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