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