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