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