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