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 else if (symbol.d_tag == DT_MIPS_RLD_MAP && target) 1101 { 1102 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 1103 addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target); 1104 if (dyn_base == LLDB_INVALID_ADDRESS) 1105 return Address(); 1106 Address addr; 1107 Error error; 1108 if (target->ReadPointerFromMemory(dyn_base + offset, false, error, addr)) 1109 return addr; 1110 } 1111 } 1112 1113 return Address(); 1114 } 1115 1116 lldb_private::Address 1117 ObjectFileELF::GetEntryPointAddress () 1118 { 1119 if (m_entry_point_address.IsValid()) 1120 return m_entry_point_address; 1121 1122 if (!ParseHeader() || !IsExecutable()) 1123 return m_entry_point_address; 1124 1125 SectionList *section_list = GetSectionList(); 1126 addr_t offset = m_header.e_entry; 1127 1128 if (!section_list) 1129 m_entry_point_address.SetOffset(offset); 1130 else 1131 m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list); 1132 return m_entry_point_address; 1133 } 1134 1135 //---------------------------------------------------------------------- 1136 // ParseDependentModules 1137 //---------------------------------------------------------------------- 1138 size_t 1139 ObjectFileELF::ParseDependentModules() 1140 { 1141 if (m_filespec_ap.get()) 1142 return m_filespec_ap->GetSize(); 1143 1144 m_filespec_ap.reset(new FileSpecList()); 1145 1146 if (!ParseSectionHeaders()) 1147 return 0; 1148 1149 SectionList *section_list = GetSectionList(); 1150 if (!section_list) 1151 return 0; 1152 1153 // Find the SHT_DYNAMIC section. 1154 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 1155 if (!dynsym) 1156 return 0; 1157 assert (dynsym->GetObjectFile() == this); 1158 1159 const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex (dynsym->GetID()); 1160 if (!header) 1161 return 0; 1162 // sh_link: section header index of string table used by entries in the section. 1163 Section *dynstr = section_list->FindSectionByID (header->sh_link + 1).get(); 1164 if (!dynstr) 1165 return 0; 1166 1167 DataExtractor dynsym_data; 1168 DataExtractor dynstr_data; 1169 if (ReadSectionData(dynsym, dynsym_data) && 1170 ReadSectionData(dynstr, dynstr_data)) 1171 { 1172 ELFDynamic symbol; 1173 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 1174 lldb::offset_t offset = 0; 1175 1176 // The only type of entries we are concerned with are tagged DT_NEEDED, 1177 // yielding the name of a required library. 1178 while (offset < section_size) 1179 { 1180 if (!symbol.Parse(dynsym_data, &offset)) 1181 break; 1182 1183 if (symbol.d_tag != DT_NEEDED) 1184 continue; 1185 1186 uint32_t str_index = static_cast<uint32_t>(symbol.d_val); 1187 const char *lib_name = dynstr_data.PeekCStr(str_index); 1188 m_filespec_ap->Append(FileSpec(lib_name, true)); 1189 } 1190 } 1191 1192 return m_filespec_ap->GetSize(); 1193 } 1194 1195 //---------------------------------------------------------------------- 1196 // GetProgramHeaderInfo 1197 //---------------------------------------------------------------------- 1198 size_t 1199 ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers, 1200 DataExtractor &object_data, 1201 const ELFHeader &header) 1202 { 1203 // We have already parsed the program headers 1204 if (!program_headers.empty()) 1205 return program_headers.size(); 1206 1207 // If there are no program headers to read we are done. 1208 if (header.e_phnum == 0) 1209 return 0; 1210 1211 program_headers.resize(header.e_phnum); 1212 if (program_headers.size() != header.e_phnum) 1213 return 0; 1214 1215 const size_t ph_size = header.e_phnum * header.e_phentsize; 1216 const elf_off ph_offset = header.e_phoff; 1217 DataExtractor data; 1218 if (data.SetData(object_data, ph_offset, ph_size) != ph_size) 1219 return 0; 1220 1221 uint32_t idx; 1222 lldb::offset_t offset; 1223 for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) 1224 { 1225 if (program_headers[idx].Parse(data, &offset) == false) 1226 break; 1227 } 1228 1229 if (idx < program_headers.size()) 1230 program_headers.resize(idx); 1231 1232 return program_headers.size(); 1233 1234 } 1235 1236 //---------------------------------------------------------------------- 1237 // ParseProgramHeaders 1238 //---------------------------------------------------------------------- 1239 size_t 1240 ObjectFileELF::ParseProgramHeaders() 1241 { 1242 return GetProgramHeaderInfo(m_program_headers, m_data, m_header); 1243 } 1244 1245 lldb_private::Error 1246 ObjectFileELF::RefineModuleDetailsFromNote (lldb_private::DataExtractor &data, lldb_private::ArchSpec &arch_spec, lldb_private::UUID &uuid) 1247 { 1248 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1249 Error error; 1250 1251 lldb::offset_t offset = 0; 1252 1253 while (true) 1254 { 1255 // Parse the note header. If this fails, bail out. 1256 ELFNote note = ELFNote(); 1257 if (!note.Parse(data, &offset)) 1258 { 1259 // We're done. 1260 return error; 1261 } 1262 1263 // If a tag processor handles the tag, it should set processed to true, and 1264 // the loop will assume the tag processing has moved entirely past the note's payload. 1265 // Otherwise, leave it false and the end of the loop will handle the offset properly. 1266 bool processed = false; 1267 1268 if (log) 1269 log->Printf ("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32, __FUNCTION__, note.n_name.c_str (), note.n_type); 1270 1271 // Process FreeBSD ELF notes. 1272 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) && 1273 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) && 1274 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) 1275 { 1276 // We'll consume the payload below. 1277 processed = true; 1278 1279 // Pull out the min version info. 1280 uint32_t version_info; 1281 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1282 { 1283 error.SetErrorString ("failed to read FreeBSD ABI note payload"); 1284 return error; 1285 } 1286 1287 // Convert the version info into a major/minor number. 1288 const uint32_t version_major = version_info / 100000; 1289 const uint32_t version_minor = (version_info / 1000) % 100; 1290 1291 char os_name[32]; 1292 snprintf (os_name, sizeof (os_name), "freebsd%" PRIu32 ".%" PRIu32, version_major, version_minor); 1293 1294 // Set the elf OS version to FreeBSD. Also clear the vendor. 1295 arch_spec.GetTriple ().setOSName (os_name); 1296 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1297 1298 if (log) 1299 log->Printf ("ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_major, version_minor, static_cast<uint32_t> (version_info % 1000)); 1300 } 1301 // Process GNU ELF notes. 1302 else if (note.n_name == LLDB_NT_OWNER_GNU) 1303 { 1304 switch (note.n_type) 1305 { 1306 case LLDB_NT_GNU_ABI_TAG: 1307 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) 1308 { 1309 // We'll consume the payload below. 1310 processed = true; 1311 1312 // Pull out the min OS version supporting the ABI. 1313 uint32_t version_info[4]; 1314 if (data.GetU32 (&offset, &version_info[0], note.n_descsz / 4) == nullptr) 1315 { 1316 error.SetErrorString ("failed to read GNU ABI note payload"); 1317 return error; 1318 } 1319 1320 // Set the OS per the OS field. 1321 switch (version_info[0]) 1322 { 1323 case LLDB_NT_GNU_ABI_OS_LINUX: 1324 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Linux); 1325 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1326 if (log) 1327 log->Printf ("ObjectFileELF::%s detected Linux, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1328 // 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. 1329 break; 1330 case LLDB_NT_GNU_ABI_OS_HURD: 1331 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::UnknownOS); 1332 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1333 if (log) 1334 log->Printf ("ObjectFileELF::%s detected Hurd (unsupported), min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1335 break; 1336 case LLDB_NT_GNU_ABI_OS_SOLARIS: 1337 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Solaris); 1338 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1339 if (log) 1340 log->Printf ("ObjectFileELF::%s detected Solaris, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]); 1341 break; 1342 default: 1343 if (log) 1344 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]); 1345 break; 1346 } 1347 } 1348 break; 1349 1350 case LLDB_NT_GNU_BUILD_ID_TAG: 1351 // Only bother processing this if we don't already have the uuid set. 1352 if (!uuid.IsValid()) 1353 { 1354 // We'll consume the payload below. 1355 processed = true; 1356 1357 // 16 bytes is UUID|MD5, 20 bytes is SHA1 1358 if ((note.n_descsz == 16 || note.n_descsz == 20)) 1359 { 1360 uint8_t uuidbuf[20]; 1361 if (data.GetU8 (&offset, &uuidbuf, note.n_descsz) == nullptr) 1362 { 1363 error.SetErrorString ("failed to read GNU_BUILD_ID note payload"); 1364 return error; 1365 } 1366 1367 // Save the build id as the UUID for the module. 1368 uuid.SetBytes (uuidbuf, note.n_descsz); 1369 } 1370 } 1371 break; 1372 } 1373 } 1374 // Process NetBSD ELF notes. 1375 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) && 1376 (note.n_type == LLDB_NT_NETBSD_ABI_TAG) && 1377 (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) 1378 { 1379 1380 // We'll consume the payload below. 1381 processed = true; 1382 1383 // Pull out the min version info. 1384 uint32_t version_info; 1385 if (data.GetU32 (&offset, &version_info, 1) == nullptr) 1386 { 1387 error.SetErrorString ("failed to read NetBSD ABI note payload"); 1388 return error; 1389 } 1390 1391 // Set the elf OS version to NetBSD. Also clear the vendor. 1392 arch_spec.GetTriple ().setOS (llvm::Triple::OSType::NetBSD); 1393 arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor); 1394 1395 if (log) 1396 log->Printf ("ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32, __FUNCTION__, version_info); 1397 } 1398 // Process CSR kalimba notes 1399 else if ((note.n_type == LLDB_NT_GNU_ABI_TAG) && 1400 (note.n_name == LLDB_NT_OWNER_CSR)) 1401 { 1402 // We'll consume the payload below. 1403 processed = true; 1404 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS); 1405 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::CSR); 1406 1407 // TODO At some point the description string could be processed. 1408 // It could provide a steer towards the kalimba variant which 1409 // this ELF targets. 1410 if(note.n_descsz) 1411 { 1412 const char *cstr = data.GetCStr(&offset, llvm::RoundUpToAlignment (note.n_descsz, 4)); 1413 (void)cstr; 1414 } 1415 } 1416 else if (note.n_name == LLDB_NT_OWNER_ANDROID) 1417 { 1418 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1419 arch_spec.GetTriple().setEnvironment(llvm::Triple::EnvironmentType::Android); 1420 } 1421 1422 if (!processed) 1423 offset += llvm::RoundUpToAlignment(note.n_descsz, 4); 1424 } 1425 1426 return error; 1427 } 1428 1429 1430 //---------------------------------------------------------------------- 1431 // GetSectionHeaderInfo 1432 //---------------------------------------------------------------------- 1433 size_t 1434 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 1435 lldb_private::DataExtractor &object_data, 1436 const elf::ELFHeader &header, 1437 lldb_private::UUID &uuid, 1438 std::string &gnu_debuglink_file, 1439 uint32_t &gnu_debuglink_crc, 1440 ArchSpec &arch_spec) 1441 { 1442 // Don't reparse the section headers if we already did that. 1443 if (!section_headers.empty()) 1444 return section_headers.size(); 1445 1446 // Only initialize the arch_spec to okay defaults if they're not already set. 1447 // We'll refine this with note data as we parse the notes. 1448 if (arch_spec.GetTriple ().getOS () == llvm::Triple::OSType::UnknownOS) 1449 { 1450 llvm::Triple::OSType ostype; 1451 llvm::Triple::OSType spec_ostype; 1452 const uint32_t sub_type = subTypeFromElfHeader(header); 1453 arch_spec.SetArchitecture (eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]); 1454 // 1455 // Validate if it is ok to remove GetOsFromOSABI 1456 GetOsFromOSABI (header.e_ident[EI_OSABI], ostype); 1457 spec_ostype = arch_spec.GetTriple ().getOS (); 1458 assert(spec_ostype == ostype); 1459 } 1460 1461 if (arch_spec.GetMachine() == llvm::Triple::mips || arch_spec.GetMachine() == llvm::Triple::mipsel 1462 || arch_spec.GetMachine() == llvm::Triple::mips64 || arch_spec.GetMachine() == llvm::Triple::mips64el) 1463 { 1464 switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) 1465 { 1466 case llvm::ELF::EF_MIPS_MICROMIPS: 1467 arch_spec.SetFlags (ArchSpec::eMIPSAse_micromips); 1468 break; 1469 case llvm::ELF::EF_MIPS_ARCH_ASE_M16: 1470 arch_spec.SetFlags (ArchSpec::eMIPSAse_mips16); 1471 break; 1472 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX: 1473 arch_spec.SetFlags (ArchSpec::eMIPSAse_mdmx); 1474 break; 1475 default: 1476 break; 1477 } 1478 } 1479 1480 // If there are no section headers we are done. 1481 if (header.e_shnum == 0) 1482 return 0; 1483 1484 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES)); 1485 1486 section_headers.resize(header.e_shnum); 1487 if (section_headers.size() != header.e_shnum) 1488 return 0; 1489 1490 const size_t sh_size = header.e_shnum * header.e_shentsize; 1491 const elf_off sh_offset = header.e_shoff; 1492 DataExtractor sh_data; 1493 if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size) 1494 return 0; 1495 1496 uint32_t idx; 1497 lldb::offset_t offset; 1498 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) 1499 { 1500 if (section_headers[idx].Parse(sh_data, &offset) == false) 1501 break; 1502 } 1503 if (idx < section_headers.size()) 1504 section_headers.resize(idx); 1505 1506 const unsigned strtab_idx = header.e_shstrndx; 1507 if (strtab_idx && strtab_idx < section_headers.size()) 1508 { 1509 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1510 const size_t byte_size = sheader.sh_size; 1511 const Elf64_Off offset = sheader.sh_offset; 1512 lldb_private::DataExtractor shstr_data; 1513 1514 if (shstr_data.SetData (object_data, offset, byte_size) == byte_size) 1515 { 1516 for (SectionHeaderCollIter I = section_headers.begin(); 1517 I != section_headers.end(); ++I) 1518 { 1519 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink"); 1520 const ELFSectionHeaderInfo &sheader = *I; 1521 const uint64_t section_size = sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size; 1522 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1523 1524 I->section_name = name; 1525 1526 if (arch_spec.GetMachine() == llvm::Triple::mips || arch_spec.GetMachine() == llvm::Triple::mipsel 1527 || arch_spec.GetMachine() == llvm::Triple::mips64 || arch_spec.GetMachine() == llvm::Triple::mips64el) 1528 { 1529 uint32_t arch_flags = arch_spec.GetFlags (); 1530 DataExtractor data; 1531 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) 1532 { 1533 1534 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1535 { 1536 lldb::offset_t ase_offset = 12; // MIPS ABI Flags Version: 0 1537 arch_flags |= data.GetU32 (&ase_offset); 1538 } 1539 } 1540 // Settings appropriate ArchSpec ABI Flags 1541 if (header.e_flags & llvm::ELF::EF_MIPS_ABI2) 1542 { 1543 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32; 1544 } 1545 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI_O32) 1546 { 1547 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32; 1548 } 1549 arch_spec.SetFlags (arch_flags); 1550 } 1551 1552 if (name == g_sect_name_gnu_debuglink) 1553 { 1554 DataExtractor data; 1555 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1556 { 1557 lldb::offset_t gnu_debuglink_offset = 0; 1558 gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset); 1559 gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4); 1560 data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1561 } 1562 } 1563 1564 // Process ELF note section entries. 1565 bool is_note_header = (sheader.sh_type == SHT_NOTE); 1566 1567 // The section header ".note.android.ident" is stored as a 1568 // PROGBITS type header but it is actually a note header. 1569 static ConstString g_sect_name_android_ident (".note.android.ident"); 1570 if (!is_note_header && name == g_sect_name_android_ident) 1571 is_note_header = true; 1572 1573 if (is_note_header) 1574 { 1575 // Allow notes to refine module info. 1576 DataExtractor data; 1577 if (section_size && (data.SetData (object_data, sheader.sh_offset, section_size) == section_size)) 1578 { 1579 Error error = RefineModuleDetailsFromNote (data, arch_spec, uuid); 1580 if (error.Fail ()) 1581 { 1582 if (log) 1583 log->Printf ("ObjectFileELF::%s ELF note processing failed: %s", __FUNCTION__, error.AsCString ()); 1584 } 1585 } 1586 } 1587 } 1588 1589 return section_headers.size(); 1590 } 1591 } 1592 1593 section_headers.clear(); 1594 return 0; 1595 } 1596 1597 size_t 1598 ObjectFileELF::GetProgramHeaderCount() 1599 { 1600 return ParseProgramHeaders(); 1601 } 1602 1603 const elf::ELFProgramHeader * 1604 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) 1605 { 1606 if (!id || !ParseProgramHeaders()) 1607 return NULL; 1608 1609 if (--id < m_program_headers.size()) 1610 return &m_program_headers[id]; 1611 1612 return NULL; 1613 } 1614 1615 DataExtractor 1616 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) 1617 { 1618 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id); 1619 if (segment_header == NULL) 1620 return DataExtractor(); 1621 return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz); 1622 } 1623 1624 std::string 1625 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const 1626 { 1627 size_t pos = symbol_name.find('@'); 1628 return symbol_name.substr(0, pos).str(); 1629 } 1630 1631 //---------------------------------------------------------------------- 1632 // ParseSectionHeaders 1633 //---------------------------------------------------------------------- 1634 size_t 1635 ObjectFileELF::ParseSectionHeaders() 1636 { 1637 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec); 1638 } 1639 1640 const ObjectFileELF::ELFSectionHeaderInfo * 1641 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) 1642 { 1643 if (!id || !ParseSectionHeaders()) 1644 return NULL; 1645 1646 if (--id < m_section_headers.size()) 1647 return &m_section_headers[id]; 1648 1649 return NULL; 1650 } 1651 1652 lldb::user_id_t 1653 ObjectFileELF::GetSectionIndexByName(const char* name) 1654 { 1655 if (!name || !name[0] || !ParseSectionHeaders()) 1656 return 0; 1657 for (size_t i = 1; i < m_section_headers.size(); ++i) 1658 if (m_section_headers[i].section_name == ConstString(name)) 1659 return i; 1660 return 0; 1661 } 1662 1663 void 1664 ObjectFileELF::CreateSections(SectionList &unified_section_list) 1665 { 1666 if (!m_sections_ap.get() && ParseSectionHeaders()) 1667 { 1668 m_sections_ap.reset(new SectionList()); 1669 1670 for (SectionHeaderCollIter I = m_section_headers.begin(); 1671 I != m_section_headers.end(); ++I) 1672 { 1673 const ELFSectionHeaderInfo &header = *I; 1674 1675 ConstString& name = I->section_name; 1676 const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1677 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0; 1678 1679 static ConstString g_sect_name_text (".text"); 1680 static ConstString g_sect_name_data (".data"); 1681 static ConstString g_sect_name_bss (".bss"); 1682 static ConstString g_sect_name_tdata (".tdata"); 1683 static ConstString g_sect_name_tbss (".tbss"); 1684 static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); 1685 static ConstString g_sect_name_dwarf_debug_addr (".debug_addr"); 1686 static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); 1687 static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); 1688 static ConstString g_sect_name_dwarf_debug_info (".debug_info"); 1689 static ConstString g_sect_name_dwarf_debug_line (".debug_line"); 1690 static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); 1691 static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); 1692 static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); 1693 static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); 1694 static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); 1695 static ConstString g_sect_name_dwarf_debug_str (".debug_str"); 1696 static ConstString g_sect_name_dwarf_debug_str_offsets (".debug_str_offsets"); 1697 static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo"); 1698 static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo"); 1699 static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo"); 1700 static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo"); 1701 static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo"); 1702 static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo"); 1703 static ConstString g_sect_name_eh_frame (".eh_frame"); 1704 1705 SectionType sect_type = eSectionTypeOther; 1706 1707 bool is_thread_specific = false; 1708 1709 if (name == g_sect_name_text) sect_type = eSectionTypeCode; 1710 else if (name == g_sect_name_data) sect_type = eSectionTypeData; 1711 else if (name == g_sect_name_bss) sect_type = eSectionTypeZeroFill; 1712 else if (name == g_sect_name_tdata) 1713 { 1714 sect_type = eSectionTypeData; 1715 is_thread_specific = true; 1716 } 1717 else if (name == g_sect_name_tbss) 1718 { 1719 sect_type = eSectionTypeZeroFill; 1720 is_thread_specific = true; 1721 } 1722 // .debug_abbrev – Abbreviations used in the .debug_info section 1723 // .debug_aranges – Lookup table for mapping addresses to compilation units 1724 // .debug_frame – Call frame information 1725 // .debug_info – The core DWARF information section 1726 // .debug_line – Line number information 1727 // .debug_loc – Location lists used in DW_AT_location attributes 1728 // .debug_macinfo – Macro information 1729 // .debug_pubnames – Lookup table for mapping object and function names to compilation units 1730 // .debug_pubtypes – Lookup table for mapping type names to compilation units 1731 // .debug_ranges – Address ranges used in DW_AT_ranges attributes 1732 // .debug_str – String table used in .debug_info 1733 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html 1734 // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644 1735 // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo 1736 else if (name == g_sect_name_dwarf_debug_abbrev) sect_type = eSectionTypeDWARFDebugAbbrev; 1737 else if (name == g_sect_name_dwarf_debug_addr) sect_type = eSectionTypeDWARFDebugAddr; 1738 else if (name == g_sect_name_dwarf_debug_aranges) sect_type = eSectionTypeDWARFDebugAranges; 1739 else if (name == g_sect_name_dwarf_debug_frame) sect_type = eSectionTypeDWARFDebugFrame; 1740 else if (name == g_sect_name_dwarf_debug_info) sect_type = eSectionTypeDWARFDebugInfo; 1741 else if (name == g_sect_name_dwarf_debug_line) sect_type = eSectionTypeDWARFDebugLine; 1742 else if (name == g_sect_name_dwarf_debug_loc) sect_type = eSectionTypeDWARFDebugLoc; 1743 else if (name == g_sect_name_dwarf_debug_macinfo) sect_type = eSectionTypeDWARFDebugMacInfo; 1744 else if (name == g_sect_name_dwarf_debug_pubnames) sect_type = eSectionTypeDWARFDebugPubNames; 1745 else if (name == g_sect_name_dwarf_debug_pubtypes) sect_type = eSectionTypeDWARFDebugPubTypes; 1746 else if (name == g_sect_name_dwarf_debug_ranges) sect_type = eSectionTypeDWARFDebugRanges; 1747 else if (name == g_sect_name_dwarf_debug_str) sect_type = eSectionTypeDWARFDebugStr; 1748 else if (name == g_sect_name_dwarf_debug_str_offsets) sect_type = eSectionTypeDWARFDebugStrOffsets; 1749 else if (name == g_sect_name_dwarf_debug_abbrev_dwo) sect_type = eSectionTypeDWARFDebugAbbrev; 1750 else if (name == g_sect_name_dwarf_debug_info_dwo) sect_type = eSectionTypeDWARFDebugInfo; 1751 else if (name == g_sect_name_dwarf_debug_line_dwo) sect_type = eSectionTypeDWARFDebugLine; 1752 else if (name == g_sect_name_dwarf_debug_loc_dwo) sect_type = eSectionTypeDWARFDebugLoc; 1753 else if (name == g_sect_name_dwarf_debug_str_dwo) sect_type = eSectionTypeDWARFDebugStr; 1754 else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets; 1755 else if (name == g_sect_name_eh_frame) sect_type = eSectionTypeEHFrame; 1756 1757 switch (header.sh_type) 1758 { 1759 case SHT_SYMTAB: 1760 assert (sect_type == eSectionTypeOther); 1761 sect_type = eSectionTypeELFSymbolTable; 1762 break; 1763 case SHT_DYNSYM: 1764 assert (sect_type == eSectionTypeOther); 1765 sect_type = eSectionTypeELFDynamicSymbols; 1766 break; 1767 case SHT_RELA: 1768 case SHT_REL: 1769 assert (sect_type == eSectionTypeOther); 1770 sect_type = eSectionTypeELFRelocationEntries; 1771 break; 1772 case SHT_DYNAMIC: 1773 assert (sect_type == eSectionTypeOther); 1774 sect_type = eSectionTypeELFDynamicLinkInfo; 1775 break; 1776 } 1777 1778 if (eSectionTypeOther == sect_type) 1779 { 1780 // the kalimba toolchain assumes that ELF section names are free-form. It does 1781 // support linkscripts which (can) give rise to various arbitrarily named 1782 // sections being "Code" or "Data". 1783 sect_type = kalimbaSectionType(m_header, header); 1784 } 1785 1786 const uint32_t target_bytes_size = 1787 (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type) ? 1788 m_arch_spec.GetDataByteSize() : 1789 eSectionTypeCode == sect_type ? 1790 m_arch_spec.GetCodeByteSize() : 1; 1791 1792 elf::elf_xword log2align = (header.sh_addralign==0) 1793 ? 0 1794 : llvm::Log2_64(header.sh_addralign); 1795 SectionSP section_sp (new Section(GetModule(), // Module to which this section belongs. 1796 this, // ObjectFile to which this section belongs and should read section data from. 1797 SectionIndex(I), // Section ID. 1798 name, // Section name. 1799 sect_type, // Section type. 1800 header.sh_addr, // VM address. 1801 vm_size, // VM size in bytes of this section. 1802 header.sh_offset, // Offset of this section in the file. 1803 file_size, // Size of the section as found in the file. 1804 log2align, // Alignment of the section 1805 header.sh_flags, // Flags for this section. 1806 target_bytes_size));// Number of host bytes per target byte 1807 1808 if (is_thread_specific) 1809 section_sp->SetIsThreadSpecific (is_thread_specific); 1810 m_sections_ap->AddSection(section_sp); 1811 } 1812 } 1813 1814 if (m_sections_ap.get()) 1815 { 1816 if (GetType() == eTypeDebugInfo) 1817 { 1818 static const SectionType g_sections[] = 1819 { 1820 eSectionTypeDWARFDebugAbbrev, 1821 eSectionTypeDWARFDebugAddr, 1822 eSectionTypeDWARFDebugAranges, 1823 eSectionTypeDWARFDebugFrame, 1824 eSectionTypeDWARFDebugInfo, 1825 eSectionTypeDWARFDebugLine, 1826 eSectionTypeDWARFDebugLoc, 1827 eSectionTypeDWARFDebugMacInfo, 1828 eSectionTypeDWARFDebugPubNames, 1829 eSectionTypeDWARFDebugPubTypes, 1830 eSectionTypeDWARFDebugRanges, 1831 eSectionTypeDWARFDebugStr, 1832 eSectionTypeDWARFDebugStrOffsets, 1833 eSectionTypeELFSymbolTable, 1834 }; 1835 SectionList *elf_section_list = m_sections_ap.get(); 1836 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx) 1837 { 1838 SectionType section_type = g_sections[idx]; 1839 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true)); 1840 if (section_sp) 1841 { 1842 SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true)); 1843 if (module_section_sp) 1844 unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp); 1845 else 1846 unified_section_list.AddSection (section_sp); 1847 } 1848 } 1849 } 1850 else 1851 { 1852 unified_section_list = *m_sections_ap; 1853 } 1854 } 1855 } 1856 1857 // Find the arm/aarch64 mapping symbol character in the given symbol name. Mapping symbols have the 1858 // form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping symbol prefixed by 1859 // an arbitrary string because if a symbol prefix added to each symbol in the object file with 1860 // objcopy then the mapping symbols are also prefixed. 1861 static char 1862 FindArmAarch64MappingSymbol(const char* symbol_name) 1863 { 1864 if (!symbol_name) 1865 return '\0'; 1866 1867 const char* dollar_pos = ::strchr(symbol_name, '$'); 1868 if (!dollar_pos || dollar_pos[1] == '\0') 1869 return '\0'; 1870 1871 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.') 1872 return dollar_pos[1]; 1873 return '\0'; 1874 } 1875 1876 // private 1877 unsigned 1878 ObjectFileELF::ParseSymbols (Symtab *symtab, 1879 user_id_t start_id, 1880 SectionList *section_list, 1881 const size_t num_symbols, 1882 const DataExtractor &symtab_data, 1883 const DataExtractor &strtab_data) 1884 { 1885 ELFSymbol symbol; 1886 lldb::offset_t offset = 0; 1887 1888 static ConstString text_section_name(".text"); 1889 static ConstString init_section_name(".init"); 1890 static ConstString fini_section_name(".fini"); 1891 static ConstString ctors_section_name(".ctors"); 1892 static ConstString dtors_section_name(".dtors"); 1893 1894 static ConstString data_section_name(".data"); 1895 static ConstString rodata_section_name(".rodata"); 1896 static ConstString rodata1_section_name(".rodata1"); 1897 static ConstString data2_section_name(".data1"); 1898 static ConstString bss_section_name(".bss"); 1899 static ConstString opd_section_name(".opd"); // For ppc64 1900 1901 // On Android the oatdata and the oatexec symbols in system@[email protected] covers the full 1902 // .text section what causes issues with displaying unusable symbol name to the user and very 1903 // slow unwinding speed because the instruction emulation based unwind plans try to emulate all 1904 // instructions in these symbols. Don't add these symbols to the symbol list as they have no 1905 // use for the debugger and they are causing a lot of trouble. 1906 // Filtering can't be restricted to Android because this special object file don't contain the 1907 // note section specifying the environment to Android but the custom extension and file name 1908 // makes it highly unlikely that this will collide with anything else. 1909 bool skip_oatdata_oatexec = m_file.GetFilename() == ConstString("system@[email protected]"); 1910 1911 unsigned i; 1912 for (i = 0; i < num_symbols; ++i) 1913 { 1914 if (symbol.Parse(symtab_data, &offset) == false) 1915 break; 1916 1917 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1918 1919 // No need to add non-section symbols that have no names 1920 if (symbol.getType() != STT_SECTION && 1921 (symbol_name == NULL || symbol_name[0] == '\0')) 1922 continue; 1923 1924 // Skipping oatdata and oatexec sections if it is requested. See details above the 1925 // definition of skip_oatdata_oatexec for the reasons. 1926 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || ::strcmp(symbol_name, "oatexec") == 0)) 1927 continue; 1928 1929 SectionSP symbol_section_sp; 1930 SymbolType symbol_type = eSymbolTypeInvalid; 1931 Elf64_Half symbol_idx = symbol.st_shndx; 1932 1933 switch (symbol_idx) 1934 { 1935 case SHN_ABS: 1936 symbol_type = eSymbolTypeAbsolute; 1937 break; 1938 case SHN_UNDEF: 1939 symbol_type = eSymbolTypeUndefined; 1940 break; 1941 default: 1942 symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx); 1943 break; 1944 } 1945 1946 // If a symbol is undefined do not process it further even if it has a STT type 1947 if (symbol_type != eSymbolTypeUndefined) 1948 { 1949 switch (symbol.getType()) 1950 { 1951 default: 1952 case STT_NOTYPE: 1953 // The symbol's type is not specified. 1954 break; 1955 1956 case STT_OBJECT: 1957 // The symbol is associated with a data object, such as a variable, 1958 // an array, etc. 1959 symbol_type = eSymbolTypeData; 1960 break; 1961 1962 case STT_FUNC: 1963 // The symbol is associated with a function or other executable code. 1964 symbol_type = eSymbolTypeCode; 1965 break; 1966 1967 case STT_SECTION: 1968 // The symbol is associated with a section. Symbol table entries of 1969 // this type exist primarily for relocation and normally have 1970 // STB_LOCAL binding. 1971 break; 1972 1973 case STT_FILE: 1974 // Conventionally, the symbol's name gives the name of the source 1975 // file associated with the object file. A file symbol has STB_LOCAL 1976 // binding, its section index is SHN_ABS, and it precedes the other 1977 // STB_LOCAL symbols for the file, if it is present. 1978 symbol_type = eSymbolTypeSourceFile; 1979 break; 1980 1981 case STT_GNU_IFUNC: 1982 // The symbol is associated with an indirect function. The actual 1983 // function will be resolved if it is referenced. 1984 symbol_type = eSymbolTypeResolver; 1985 break; 1986 } 1987 } 1988 1989 if (symbol_type == eSymbolTypeInvalid) 1990 { 1991 if (symbol_section_sp) 1992 { 1993 const ConstString §_name = symbol_section_sp->GetName(); 1994 if (sect_name == text_section_name || 1995 sect_name == init_section_name || 1996 sect_name == fini_section_name || 1997 sect_name == ctors_section_name || 1998 sect_name == dtors_section_name) 1999 { 2000 symbol_type = eSymbolTypeCode; 2001 } 2002 else if (sect_name == data_section_name || 2003 sect_name == data2_section_name || 2004 sect_name == rodata_section_name || 2005 sect_name == rodata1_section_name || 2006 sect_name == bss_section_name) 2007 { 2008 symbol_type = eSymbolTypeData; 2009 } 2010 } 2011 } 2012 2013 int64_t symbol_value_offset = 0; 2014 uint32_t additional_flags = 0; 2015 2016 ArchSpec arch; 2017 if (GetArchitecture(arch)) 2018 { 2019 if (arch.GetMachine() == llvm::Triple::arm) 2020 { 2021 if (symbol.getBinding() == STB_LOCAL) 2022 { 2023 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2024 if (symbol_type == eSymbolTypeCode) 2025 { 2026 switch (mapping_symbol) 2027 { 2028 case 'a': 2029 // $a[.<any>]* - marks an ARM instruction sequence 2030 m_address_class_map[symbol.st_value] = eAddressClassCode; 2031 break; 2032 case 'b': 2033 case 't': 2034 // $b[.<any>]* - marks a THUMB BL instruction sequence 2035 // $t[.<any>]* - marks a THUMB instruction sequence 2036 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 2037 break; 2038 case 'd': 2039 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2040 m_address_class_map[symbol.st_value] = eAddressClassData; 2041 break; 2042 } 2043 } 2044 if (mapping_symbol) 2045 continue; 2046 } 2047 } 2048 else if (arch.GetMachine() == llvm::Triple::aarch64) 2049 { 2050 if (symbol.getBinding() == STB_LOCAL) 2051 { 2052 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2053 if (symbol_type == eSymbolTypeCode) 2054 { 2055 switch (mapping_symbol) 2056 { 2057 case 'x': 2058 // $x[.<any>]* - marks an A64 instruction sequence 2059 m_address_class_map[symbol.st_value] = eAddressClassCode; 2060 break; 2061 case 'd': 2062 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2063 m_address_class_map[symbol.st_value] = eAddressClassData; 2064 break; 2065 } 2066 } 2067 if (mapping_symbol) 2068 continue; 2069 } 2070 } 2071 2072 if (arch.GetMachine() == llvm::Triple::arm) 2073 { 2074 if (symbol_type == eSymbolTypeCode) 2075 { 2076 if (symbol.st_value & 1) 2077 { 2078 // Subtracting 1 from the address effectively unsets 2079 // the low order bit, which results in the address 2080 // actually pointing to the beginning of the symbol. 2081 // This delta will be used below in conjunction with 2082 // symbol.st_value to produce the final symbol_value 2083 // that we store in the symtab. 2084 symbol_value_offset = -1; 2085 additional_flags = ARM_ELF_SYM_IS_THUMB; 2086 m_address_class_map[symbol.st_value^1] = eAddressClassCodeAlternateISA; 2087 } 2088 else 2089 { 2090 // This address is ARM 2091 m_address_class_map[symbol.st_value] = eAddressClassCode; 2092 } 2093 } 2094 } 2095 } 2096 2097 // symbol_value_offset may contain 0 for ARM symbols or -1 for 2098 // THUMB symbols. See above for more details. 2099 uint64_t symbol_value = symbol.st_value + symbol_value_offset; 2100 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 2101 symbol_value -= symbol_section_sp->GetFileAddress(); 2102 2103 if (symbol_section_sp) 2104 { 2105 ModuleSP module_sp(GetModule()); 2106 if (module_sp) 2107 { 2108 SectionList *module_section_list = module_sp->GetSectionList(); 2109 if (module_section_list && module_section_list != section_list) 2110 { 2111 const ConstString §_name = symbol_section_sp->GetName(); 2112 lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name)); 2113 if (section_sp && section_sp->GetFileSize()) 2114 { 2115 symbol_section_sp = section_sp; 2116 } 2117 } 2118 } 2119 } 2120 2121 bool is_global = symbol.getBinding() == STB_GLOBAL; 2122 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; 2123 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2124 2125 llvm::StringRef symbol_ref(symbol_name); 2126 2127 // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily. 2128 size_t version_pos = symbol_ref.find('@'); 2129 bool has_suffix = version_pos != llvm::StringRef::npos; 2130 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); 2131 Mangled mangled(ConstString(symbol_bare), is_mangled); 2132 2133 // Now append the suffix back to mangled and unmangled names. Only do it if the 2134 // demangling was successful (string is not empty). 2135 if (has_suffix) 2136 { 2137 llvm::StringRef suffix = symbol_ref.substr(version_pos); 2138 2139 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); 2140 if (! mangled_name.empty()) 2141 mangled.SetMangledName( ConstString((mangled_name + suffix).str()) ); 2142 2143 ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeUnknown); 2144 llvm::StringRef demangled_name = demangled.GetStringRef(); 2145 if (!demangled_name.empty()) 2146 mangled.SetDemangledName( ConstString((demangled_name + suffix).str()) ); 2147 } 2148 2149 Symbol dc_symbol( 2150 i + start_id, // ID is the original symbol table index. 2151 mangled, 2152 symbol_type, // Type of this symbol 2153 is_global, // Is this globally visible? 2154 false, // Is this symbol debug info? 2155 false, // Is this symbol a trampoline? 2156 false, // Is this symbol artificial? 2157 AddressRange( 2158 symbol_section_sp, // Section in which this symbol is defined or null. 2159 symbol_value, // Offset in section or symbol value. 2160 symbol.st_size), // Size in bytes of this symbol. 2161 symbol.st_size != 0, // Size is valid if it is not 0 2162 has_suffix, // Contains linker annotations? 2163 flags); // Symbol flags. 2164 symtab->AddSymbol(dc_symbol); 2165 } 2166 return i; 2167 } 2168 2169 unsigned 2170 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 2171 { 2172 if (symtab->GetObjectFile() != this) 2173 { 2174 // If the symbol table section is owned by a different object file, have it do the 2175 // parsing. 2176 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 2177 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 2178 } 2179 2180 // Get section list for this object file. 2181 SectionList *section_list = m_sections_ap.get(); 2182 if (!section_list) 2183 return 0; 2184 2185 user_id_t symtab_id = symtab->GetID(); 2186 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2187 assert(symtab_hdr->sh_type == SHT_SYMTAB || 2188 symtab_hdr->sh_type == SHT_DYNSYM); 2189 2190 // sh_link: section header index of associated string table. 2191 // Section ID's are ones based. 2192 user_id_t strtab_id = symtab_hdr->sh_link + 1; 2193 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 2194 2195 if (symtab && strtab) 2196 { 2197 assert (symtab->GetObjectFile() == this); 2198 assert (strtab->GetObjectFile() == this); 2199 2200 DataExtractor symtab_data; 2201 DataExtractor strtab_data; 2202 if (ReadSectionData(symtab, symtab_data) && 2203 ReadSectionData(strtab, strtab_data)) 2204 { 2205 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 2206 2207 return ParseSymbols(symbol_table, start_id, section_list, 2208 num_symbols, symtab_data, strtab_data); 2209 } 2210 } 2211 2212 return 0; 2213 } 2214 2215 size_t 2216 ObjectFileELF::ParseDynamicSymbols() 2217 { 2218 if (m_dynamic_symbols.size()) 2219 return m_dynamic_symbols.size(); 2220 2221 SectionList *section_list = GetSectionList(); 2222 if (!section_list) 2223 return 0; 2224 2225 // Find the SHT_DYNAMIC section. 2226 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 2227 if (!dynsym) 2228 return 0; 2229 assert (dynsym->GetObjectFile() == this); 2230 2231 ELFDynamic symbol; 2232 DataExtractor dynsym_data; 2233 if (ReadSectionData(dynsym, dynsym_data)) 2234 { 2235 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 2236 lldb::offset_t cursor = 0; 2237 2238 while (cursor < section_size) 2239 { 2240 if (!symbol.Parse(dynsym_data, &cursor)) 2241 break; 2242 2243 m_dynamic_symbols.push_back(symbol); 2244 } 2245 } 2246 2247 return m_dynamic_symbols.size(); 2248 } 2249 2250 const ELFDynamic * 2251 ObjectFileELF::FindDynamicSymbol(unsigned tag) 2252 { 2253 if (!ParseDynamicSymbols()) 2254 return NULL; 2255 2256 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 2257 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 2258 for ( ; I != E; ++I) 2259 { 2260 ELFDynamic *symbol = &*I; 2261 2262 if (symbol->d_tag == tag) 2263 return symbol; 2264 } 2265 2266 return NULL; 2267 } 2268 2269 unsigned 2270 ObjectFileELF::PLTRelocationType() 2271 { 2272 // DT_PLTREL 2273 // This member specifies the type of relocation entry to which the 2274 // procedure linkage table refers. The d_val member holds DT_REL or 2275 // DT_RELA, as appropriate. All relocations in a procedure linkage table 2276 // must use the same relocation. 2277 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 2278 2279 if (symbol) 2280 return symbol->d_val; 2281 2282 return 0; 2283 } 2284 2285 // Returns the size of the normal plt entries and the offset of the first normal plt entry. The 2286 // 0th entry in the plt table is usually a resolution entry which have different size in some 2287 // architectures then the rest of the plt entries. 2288 static std::pair<uint64_t, uint64_t> 2289 GetPltEntrySizeAndOffset(const ELFSectionHeader* rel_hdr, const ELFSectionHeader* plt_hdr) 2290 { 2291 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2292 2293 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 2294 // So round the entsize up by the alignment if addralign is set. 2295 elf_xword plt_entsize = plt_hdr->sh_addralign ? 2296 llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 2297 2298 if (plt_entsize == 0) 2299 { 2300 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the size of the plt 2301 // entries based on the number of entries and the size of the plt section with the 2302 // assumption that the size of the 0th entry is at least as big as the size of the normal 2303 // entries and it isn't much bigger then that. 2304 if (plt_hdr->sh_addralign) 2305 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / (num_relocations + 1) * plt_hdr->sh_addralign; 2306 else 2307 plt_entsize = plt_hdr->sh_size / (num_relocations + 1); 2308 } 2309 2310 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize; 2311 2312 return std::make_pair(plt_entsize, plt_offset); 2313 } 2314 2315 static unsigned 2316 ParsePLTRelocations(Symtab *symbol_table, 2317 user_id_t start_id, 2318 unsigned rel_type, 2319 const ELFHeader *hdr, 2320 const ELFSectionHeader *rel_hdr, 2321 const ELFSectionHeader *plt_hdr, 2322 const ELFSectionHeader *sym_hdr, 2323 const lldb::SectionSP &plt_section_sp, 2324 DataExtractor &rel_data, 2325 DataExtractor &symtab_data, 2326 DataExtractor &strtab_data) 2327 { 2328 ELFRelocation rel(rel_type); 2329 ELFSymbol symbol; 2330 lldb::offset_t offset = 0; 2331 2332 uint64_t plt_offset, plt_entsize; 2333 std::tie(plt_entsize, plt_offset) = GetPltEntrySizeAndOffset(rel_hdr, plt_hdr); 2334 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2335 2336 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2337 reloc_info_fn reloc_type; 2338 reloc_info_fn reloc_symbol; 2339 2340 if (hdr->Is32Bit()) 2341 { 2342 reloc_type = ELFRelocation::RelocType32; 2343 reloc_symbol = ELFRelocation::RelocSymbol32; 2344 } 2345 else 2346 { 2347 reloc_type = ELFRelocation::RelocType64; 2348 reloc_symbol = ELFRelocation::RelocSymbol64; 2349 } 2350 2351 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 2352 unsigned i; 2353 for (i = 0; i < num_relocations; ++i) 2354 { 2355 if (rel.Parse(rel_data, &offset) == false) 2356 break; 2357 2358 if (reloc_type(rel) != slot_type) 2359 continue; 2360 2361 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 2362 if (!symbol.Parse(symtab_data, &symbol_offset)) 2363 break; 2364 2365 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2366 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2367 uint64_t plt_index = plt_offset + i * plt_entsize; 2368 2369 Symbol jump_symbol( 2370 i + start_id, // Symbol table index 2371 symbol_name, // symbol name. 2372 is_mangled, // is the symbol name mangled? 2373 eSymbolTypeTrampoline, // Type of this symbol 2374 false, // Is this globally visible? 2375 false, // Is this symbol debug info? 2376 true, // Is this symbol a trampoline? 2377 true, // Is this symbol artificial? 2378 plt_section_sp, // Section in which this symbol is defined or null. 2379 plt_index, // Offset in section or symbol value. 2380 plt_entsize, // Size in bytes of this symbol. 2381 true, // Size is valid 2382 false, // Contains linker annotations? 2383 0); // Symbol flags. 2384 2385 symbol_table->AddSymbol(jump_symbol); 2386 } 2387 2388 return i; 2389 } 2390 2391 unsigned 2392 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 2393 user_id_t start_id, 2394 const ELFSectionHeaderInfo *rel_hdr, 2395 user_id_t rel_id) 2396 { 2397 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2398 2399 // The link field points to the associated symbol table. The info field 2400 // points to the section holding the plt. 2401 user_id_t symtab_id = rel_hdr->sh_link; 2402 user_id_t plt_id = rel_hdr->sh_info; 2403 2404 // If the link field doesn't point to the appropriate symbol name table then 2405 // try to find it by name as some compiler don't fill in the link fields. 2406 if (!symtab_id) 2407 symtab_id = GetSectionIndexByName(".dynsym"); 2408 if (!plt_id) 2409 plt_id = GetSectionIndexByName(".plt"); 2410 2411 if (!symtab_id || !plt_id) 2412 return 0; 2413 2414 // Section ID's are ones based; 2415 symtab_id++; 2416 plt_id++; 2417 2418 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2419 if (!plt_hdr) 2420 return 0; 2421 2422 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2423 if (!sym_hdr) 2424 return 0; 2425 2426 SectionList *section_list = m_sections_ap.get(); 2427 if (!section_list) 2428 return 0; 2429 2430 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2431 if (!rel_section) 2432 return 0; 2433 2434 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 2435 if (!plt_section_sp) 2436 return 0; 2437 2438 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2439 if (!symtab) 2440 return 0; 2441 2442 // sh_link points to associated string table. 2443 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 2444 if (!strtab) 2445 return 0; 2446 2447 DataExtractor rel_data; 2448 if (!ReadSectionData(rel_section, rel_data)) 2449 return 0; 2450 2451 DataExtractor symtab_data; 2452 if (!ReadSectionData(symtab, symtab_data)) 2453 return 0; 2454 2455 DataExtractor strtab_data; 2456 if (!ReadSectionData(strtab, strtab_data)) 2457 return 0; 2458 2459 unsigned rel_type = PLTRelocationType(); 2460 if (!rel_type) 2461 return 0; 2462 2463 return ParsePLTRelocations (symbol_table, 2464 start_id, 2465 rel_type, 2466 &m_header, 2467 rel_hdr, 2468 plt_hdr, 2469 sym_hdr, 2470 plt_section_sp, 2471 rel_data, 2472 symtab_data, 2473 strtab_data); 2474 } 2475 2476 unsigned 2477 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2478 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2479 DataExtractor &rel_data, DataExtractor &symtab_data, 2480 DataExtractor &debug_data, Section* rel_section) 2481 { 2482 ELFRelocation rel(rel_hdr->sh_type); 2483 lldb::addr_t offset = 0; 2484 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2485 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2486 reloc_info_fn reloc_type; 2487 reloc_info_fn reloc_symbol; 2488 2489 if (hdr->Is32Bit()) 2490 { 2491 reloc_type = ELFRelocation::RelocType32; 2492 reloc_symbol = ELFRelocation::RelocSymbol32; 2493 } 2494 else 2495 { 2496 reloc_type = ELFRelocation::RelocType64; 2497 reloc_symbol = ELFRelocation::RelocSymbol64; 2498 } 2499 2500 for (unsigned i = 0; i < num_relocations; ++i) 2501 { 2502 if (rel.Parse(rel_data, &offset) == false) 2503 break; 2504 2505 Symbol* symbol = NULL; 2506 2507 if (hdr->Is32Bit()) 2508 { 2509 switch (reloc_type(rel)) { 2510 case R_386_32: 2511 case R_386_PC32: 2512 default: 2513 assert(false && "unexpected relocation type"); 2514 } 2515 } else { 2516 switch (reloc_type(rel)) { 2517 case R_X86_64_64: 2518 { 2519 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2520 if (symbol) 2521 { 2522 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2523 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2524 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2525 *dst = value + ELFRelocation::RelocAddend64(rel); 2526 } 2527 break; 2528 } 2529 case R_X86_64_32: 2530 case R_X86_64_32S: 2531 { 2532 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2533 if (symbol) 2534 { 2535 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2536 value += ELFRelocation::RelocAddend32(rel); 2537 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2538 (reloc_type(rel) == R_X86_64_32S && 2539 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2540 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2541 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2542 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2543 *dst = truncated_addr; 2544 } 2545 break; 2546 } 2547 case R_X86_64_PC32: 2548 default: 2549 assert(false && "unexpected relocation type"); 2550 } 2551 } 2552 } 2553 2554 return 0; 2555 } 2556 2557 unsigned 2558 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2559 { 2560 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2561 2562 // Parse in the section list if needed. 2563 SectionList *section_list = GetSectionList(); 2564 if (!section_list) 2565 return 0; 2566 2567 // Section ID's are ones based. 2568 user_id_t symtab_id = rel_hdr->sh_link + 1; 2569 user_id_t debug_id = rel_hdr->sh_info + 1; 2570 2571 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2572 if (!symtab_hdr) 2573 return 0; 2574 2575 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2576 if (!debug_hdr) 2577 return 0; 2578 2579 Section *rel = section_list->FindSectionByID(rel_id).get(); 2580 if (!rel) 2581 return 0; 2582 2583 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2584 if (!symtab) 2585 return 0; 2586 2587 Section *debug = section_list->FindSectionByID(debug_id).get(); 2588 if (!debug) 2589 return 0; 2590 2591 DataExtractor rel_data; 2592 DataExtractor symtab_data; 2593 DataExtractor debug_data; 2594 2595 if (ReadSectionData(rel, rel_data) && 2596 ReadSectionData(symtab, symtab_data) && 2597 ReadSectionData(debug, debug_data)) 2598 { 2599 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2600 rel_data, symtab_data, debug_data, debug); 2601 } 2602 2603 return 0; 2604 } 2605 2606 Symtab * 2607 ObjectFileELF::GetSymtab() 2608 { 2609 ModuleSP module_sp(GetModule()); 2610 if (!module_sp) 2611 return NULL; 2612 2613 // We always want to use the main object file so we (hopefully) only have one cached copy 2614 // of our symtab, dynamic sections, etc. 2615 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2616 if (module_obj_file && module_obj_file != this) 2617 return module_obj_file->GetSymtab(); 2618 2619 if (m_symtab_ap.get() == NULL) 2620 { 2621 SectionList *section_list = module_sp->GetSectionList(); 2622 if (!section_list) 2623 return NULL; 2624 2625 uint64_t symbol_id = 0; 2626 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2627 2628 // Sharable objects and dynamic executables usually have 2 distinct symbol 2629 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2630 // version of the symtab that only contains global symbols. The information found 2631 // in the dynsym is therefore also found in the symtab, while the reverse is not 2632 // necessarily true. 2633 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2634 if (!symtab) 2635 { 2636 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2637 // then use the dynsym section which should always be there. 2638 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2639 } 2640 if (symtab) 2641 { 2642 m_symtab_ap.reset(new Symtab(symtab->GetObjectFile())); 2643 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2644 } 2645 2646 // DT_JMPREL 2647 // If present, this entry's d_ptr member holds the address of relocation 2648 // entries associated solely with the procedure linkage table. Separating 2649 // these relocation entries lets the dynamic linker ignore them during 2650 // process initialization, if lazy binding is enabled. If this entry is 2651 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2652 // also be present. 2653 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2654 if (symbol) 2655 { 2656 // Synthesize trampoline symbols to help navigate the PLT. 2657 addr_t addr = symbol->d_ptr; 2658 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2659 if (reloc_section) 2660 { 2661 user_id_t reloc_id = reloc_section->GetID(); 2662 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2663 assert(reloc_header); 2664 2665 if (m_symtab_ap == nullptr) 2666 m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile())); 2667 2668 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2669 } 2670 } 2671 2672 // If we still don't have any symtab then create an empty instance to avoid do the section 2673 // lookup next time. 2674 if (m_symtab_ap == nullptr) 2675 m_symtab_ap.reset(new Symtab(this)); 2676 2677 m_symtab_ap->CalculateSymbolSizes(); 2678 } 2679 2680 for (SectionHeaderCollIter I = m_section_headers.begin(); 2681 I != m_section_headers.end(); ++I) 2682 { 2683 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2684 { 2685 if (CalculateType() == eTypeObjectFile) 2686 { 2687 const char *section_name = I->section_name.AsCString(""); 2688 if (strstr(section_name, ".rela.debug") || 2689 strstr(section_name, ".rel.debug")) 2690 { 2691 const ELFSectionHeader &reloc_header = *I; 2692 user_id_t reloc_id = SectionIndex(I); 2693 RelocateDebugSections(&reloc_header, reloc_id); 2694 } 2695 } 2696 } 2697 } 2698 return m_symtab_ap.get(); 2699 } 2700 2701 Symbol * 2702 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2703 { 2704 if (!m_symtab_ap.get()) 2705 return nullptr; // GetSymtab() should be called first. 2706 2707 const SectionList *section_list = GetSectionList(); 2708 if (!section_list) 2709 return nullptr; 2710 2711 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2712 { 2713 AddressRange range; 2714 if (eh_frame->GetAddressRange (so_addr, range)) 2715 { 2716 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2717 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2718 if (symbol) 2719 return symbol; 2720 2721 // Note that a (stripped) symbol won't be found by GetSymtab()... 2722 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2723 if (eh_sym_section_sp.get()) 2724 { 2725 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2726 addr_t offset = file_addr - section_base; 2727 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2728 2729 Symbol eh_symbol( 2730 symbol_id, // Symbol table index. 2731 "???", // Symbol name. 2732 false, // Is the symbol name mangled? 2733 eSymbolTypeCode, // Type of this symbol. 2734 true, // Is this globally visible? 2735 false, // Is this symbol debug info? 2736 false, // Is this symbol a trampoline? 2737 true, // Is this symbol artificial? 2738 eh_sym_section_sp, // Section in which this symbol is defined or null. 2739 offset, // Offset in section or symbol value. 2740 range.GetByteSize(), // Size in bytes of this symbol. 2741 true, // Size is valid. 2742 false, // Contains linker annotations? 2743 0); // Symbol flags. 2744 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2745 return m_symtab_ap->SymbolAtIndex(symbol_id); 2746 } 2747 } 2748 } 2749 return nullptr; 2750 } 2751 2752 2753 bool 2754 ObjectFileELF::IsStripped () 2755 { 2756 // TODO: determine this for ELF 2757 return false; 2758 } 2759 2760 //===----------------------------------------------------------------------===// 2761 // Dump 2762 // 2763 // Dump the specifics of the runtime file container (such as any headers 2764 // segments, sections, etc). 2765 //---------------------------------------------------------------------- 2766 void 2767 ObjectFileELF::Dump(Stream *s) 2768 { 2769 DumpELFHeader(s, m_header); 2770 s->EOL(); 2771 DumpELFProgramHeaders(s); 2772 s->EOL(); 2773 DumpELFSectionHeaders(s); 2774 s->EOL(); 2775 SectionList *section_list = GetSectionList(); 2776 if (section_list) 2777 section_list->Dump(s, NULL, true, UINT32_MAX); 2778 Symtab *symtab = GetSymtab(); 2779 if (symtab) 2780 symtab->Dump(s, NULL, eSortOrderNone); 2781 s->EOL(); 2782 DumpDependentModules(s); 2783 s->EOL(); 2784 } 2785 2786 //---------------------------------------------------------------------- 2787 // DumpELFHeader 2788 // 2789 // Dump the ELF header to the specified output stream 2790 //---------------------------------------------------------------------- 2791 void 2792 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2793 { 2794 s->PutCString("ELF Header\n"); 2795 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2796 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2797 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2798 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2799 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2800 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2801 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2802 2803 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2804 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2805 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2806 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2807 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2808 2809 s->Printf("e_type = 0x%4.4x ", header.e_type); 2810 DumpELFHeader_e_type(s, header.e_type); 2811 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2812 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2813 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2814 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2815 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2816 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2817 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2818 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2819 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 2820 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2821 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 2822 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 2823 } 2824 2825 //---------------------------------------------------------------------- 2826 // DumpELFHeader_e_type 2827 // 2828 // Dump an token value for the ELF header member e_type 2829 //---------------------------------------------------------------------- 2830 void 2831 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 2832 { 2833 switch (e_type) 2834 { 2835 case ET_NONE: *s << "ET_NONE"; break; 2836 case ET_REL: *s << "ET_REL"; break; 2837 case ET_EXEC: *s << "ET_EXEC"; break; 2838 case ET_DYN: *s << "ET_DYN"; break; 2839 case ET_CORE: *s << "ET_CORE"; break; 2840 default: 2841 break; 2842 } 2843 } 2844 2845 //---------------------------------------------------------------------- 2846 // DumpELFHeader_e_ident_EI_DATA 2847 // 2848 // Dump an token value for the ELF header member e_ident[EI_DATA] 2849 //---------------------------------------------------------------------- 2850 void 2851 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 2852 { 2853 switch (ei_data) 2854 { 2855 case ELFDATANONE: *s << "ELFDATANONE"; break; 2856 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 2857 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 2858 default: 2859 break; 2860 } 2861 } 2862 2863 2864 //---------------------------------------------------------------------- 2865 // DumpELFProgramHeader 2866 // 2867 // Dump a single ELF program header to the specified output stream 2868 //---------------------------------------------------------------------- 2869 void 2870 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 2871 { 2872 DumpELFProgramHeader_p_type(s, ph.p_type); 2873 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 2874 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 2875 2876 DumpELFProgramHeader_p_flags(s, ph.p_flags); 2877 s->Printf(") %8.8" PRIx64, ph.p_align); 2878 } 2879 2880 //---------------------------------------------------------------------- 2881 // DumpELFProgramHeader_p_type 2882 // 2883 // Dump an token value for the ELF program header member p_type which 2884 // describes the type of the program header 2885 // ---------------------------------------------------------------------- 2886 void 2887 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 2888 { 2889 const int kStrWidth = 15; 2890 switch (p_type) 2891 { 2892 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 2893 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 2894 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 2895 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 2896 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 2897 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 2898 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 2899 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 2900 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 2901 default: 2902 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 2903 break; 2904 } 2905 } 2906 2907 2908 //---------------------------------------------------------------------- 2909 // DumpELFProgramHeader_p_flags 2910 // 2911 // Dump an token value for the ELF program header member p_flags 2912 //---------------------------------------------------------------------- 2913 void 2914 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 2915 { 2916 *s << ((p_flags & PF_X) ? "PF_X" : " ") 2917 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 2918 << ((p_flags & PF_W) ? "PF_W" : " ") 2919 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 2920 << ((p_flags & PF_R) ? "PF_R" : " "); 2921 } 2922 2923 //---------------------------------------------------------------------- 2924 // DumpELFProgramHeaders 2925 // 2926 // Dump all of the ELF program header to the specified output stream 2927 //---------------------------------------------------------------------- 2928 void 2929 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 2930 { 2931 if (!ParseProgramHeaders()) 2932 return; 2933 2934 s->PutCString("Program Headers\n"); 2935 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 2936 "p_filesz p_memsz p_flags p_align\n"); 2937 s->PutCString("==== --------------- -------- -------- -------- " 2938 "-------- -------- ------------------------- --------\n"); 2939 2940 uint32_t idx = 0; 2941 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 2942 I != m_program_headers.end(); ++I, ++idx) 2943 { 2944 s->Printf("[%2u] ", idx); 2945 ObjectFileELF::DumpELFProgramHeader(s, *I); 2946 s->EOL(); 2947 } 2948 } 2949 2950 //---------------------------------------------------------------------- 2951 // DumpELFSectionHeader 2952 // 2953 // Dump a single ELF section header to the specified output stream 2954 //---------------------------------------------------------------------- 2955 void 2956 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 2957 { 2958 s->Printf("%8.8x ", sh.sh_name); 2959 DumpELFSectionHeader_sh_type(s, sh.sh_type); 2960 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 2961 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 2962 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 2963 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 2964 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 2965 } 2966 2967 //---------------------------------------------------------------------- 2968 // DumpELFSectionHeader_sh_type 2969 // 2970 // Dump an token value for the ELF section header member sh_type which 2971 // describes the type of the section 2972 //---------------------------------------------------------------------- 2973 void 2974 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 2975 { 2976 const int kStrWidth = 12; 2977 switch (sh_type) 2978 { 2979 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 2980 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 2981 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 2982 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 2983 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 2984 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 2985 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 2986 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 2987 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 2988 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 2989 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 2990 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 2991 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 2992 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 2993 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 2994 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 2995 default: 2996 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 2997 break; 2998 } 2999 } 3000 3001 //---------------------------------------------------------------------- 3002 // DumpELFSectionHeader_sh_flags 3003 // 3004 // Dump an token value for the ELF section header member sh_flags 3005 //---------------------------------------------------------------------- 3006 void 3007 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 3008 { 3009 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 3010 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 3011 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 3012 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 3013 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 3014 } 3015 3016 //---------------------------------------------------------------------- 3017 // DumpELFSectionHeaders 3018 // 3019 // Dump all of the ELF section header to the specified output stream 3020 //---------------------------------------------------------------------- 3021 void 3022 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 3023 { 3024 if (!ParseSectionHeaders()) 3025 return; 3026 3027 s->PutCString("Section Headers\n"); 3028 s->PutCString("IDX name type flags " 3029 "addr offset size link info addralgn " 3030 "entsize Name\n"); 3031 s->PutCString("==== -------- ------------ -------------------------------- " 3032 "-------- -------- -------- -------- -------- -------- " 3033 "-------- ====================\n"); 3034 3035 uint32_t idx = 0; 3036 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 3037 I != m_section_headers.end(); ++I, ++idx) 3038 { 3039 s->Printf("[%2u] ", idx); 3040 ObjectFileELF::DumpELFSectionHeader(s, *I); 3041 const char* section_name = I->section_name.AsCString(""); 3042 if (section_name) 3043 *s << ' ' << section_name << "\n"; 3044 } 3045 } 3046 3047 void 3048 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 3049 { 3050 size_t num_modules = ParseDependentModules(); 3051 3052 if (num_modules > 0) 3053 { 3054 s->PutCString("Dependent Modules:\n"); 3055 for (unsigned i = 0; i < num_modules; ++i) 3056 { 3057 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 3058 s->Printf(" %s\n", spec.GetFilename().GetCString()); 3059 } 3060 } 3061 } 3062 3063 bool 3064 ObjectFileELF::GetArchitecture (ArchSpec &arch) 3065 { 3066 if (!ParseHeader()) 3067 return false; 3068 3069 if (m_section_headers.empty()) 3070 { 3071 // Allow elf notes to be parsed which may affect the detected architecture. 3072 ParseSectionHeaders(); 3073 } 3074 3075 arch = m_arch_spec; 3076 return true; 3077 } 3078 3079 ObjectFile::Type 3080 ObjectFileELF::CalculateType() 3081 { 3082 switch (m_header.e_type) 3083 { 3084 case llvm::ELF::ET_NONE: 3085 // 0 - No file type 3086 return eTypeUnknown; 3087 3088 case llvm::ELF::ET_REL: 3089 // 1 - Relocatable file 3090 return eTypeObjectFile; 3091 3092 case llvm::ELF::ET_EXEC: 3093 // 2 - Executable file 3094 return eTypeExecutable; 3095 3096 case llvm::ELF::ET_DYN: 3097 // 3 - Shared object file 3098 return eTypeSharedLibrary; 3099 3100 case ET_CORE: 3101 // 4 - Core file 3102 return eTypeCoreFile; 3103 3104 default: 3105 break; 3106 } 3107 return eTypeUnknown; 3108 } 3109 3110 ObjectFile::Strata 3111 ObjectFileELF::CalculateStrata() 3112 { 3113 switch (m_header.e_type) 3114 { 3115 case llvm::ELF::ET_NONE: 3116 // 0 - No file type 3117 return eStrataUnknown; 3118 3119 case llvm::ELF::ET_REL: 3120 // 1 - Relocatable file 3121 return eStrataUnknown; 3122 3123 case llvm::ELF::ET_EXEC: 3124 // 2 - Executable file 3125 // TODO: is there any way to detect that an executable is a kernel 3126 // related executable by inspecting the program headers, section 3127 // headers, symbols, or any other flag bits??? 3128 return eStrataUser; 3129 3130 case llvm::ELF::ET_DYN: 3131 // 3 - Shared object file 3132 // TODO: is there any way to detect that an shared library is a kernel 3133 // related executable by inspecting the program headers, section 3134 // headers, symbols, or any other flag bits??? 3135 return eStrataUnknown; 3136 3137 case ET_CORE: 3138 // 4 - Core file 3139 // TODO: is there any way to detect that an core file is a kernel 3140 // related executable by inspecting the program headers, section 3141 // headers, symbols, or any other flag bits??? 3142 return eStrataUnknown; 3143 3144 default: 3145 break; 3146 } 3147 return eStrataUnknown; 3148 } 3149 3150