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