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