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