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 if (symbol_type == eSymbolTypeCode) 1882 { 1883 llvm::StringRef symbol_name_ref(symbol_name); 1884 if (symbol_name_ref == "$a" || symbol_name_ref.startswith("$a.")) 1885 { 1886 // $a[.<any>]* - marks an ARM instruction sequence 1887 m_address_class_map[symbol.st_value] = eAddressClassCode; 1888 } 1889 else if (symbol_name_ref == "$b" || symbol_name_ref.startswith("$b.") || 1890 symbol_name_ref == "$t" || symbol_name_ref.startswith("$t.")) 1891 { 1892 // $b[.<any>]* - marks a THUMB BL instruction sequence 1893 // $t[.<any>]* - marks a THUMB instruction sequence 1894 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA; 1895 } 1896 else if (symbol_name_ref == "$d" || symbol_name_ref.startswith("$d.")) 1897 { 1898 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 1899 m_address_class_map[symbol.st_value] = eAddressClassData; 1900 } 1901 } 1902 1903 continue; 1904 } 1905 } 1906 else if (arch.GetMachine() == llvm::Triple::aarch64) 1907 { 1908 if (symbol.getBinding() == STB_LOCAL && symbol_name && symbol_name[0] == '$') 1909 { 1910 // These are reserved for the specification (e.g.: mapping 1911 // symbols). We don't want to add them to the symbol table. 1912 1913 if (symbol_type == eSymbolTypeCode) 1914 { 1915 llvm::StringRef symbol_name_ref(symbol_name); 1916 if (symbol_name_ref == "$x" || symbol_name_ref.startswith("$x.")) 1917 { 1918 // $x[.<any>]* - marks an A64 instruction sequence 1919 m_address_class_map[symbol.st_value] = eAddressClassCode; 1920 } 1921 else if (symbol_name_ref == "$d" || symbol_name_ref.startswith("$d.")) 1922 { 1923 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 1924 m_address_class_map[symbol.st_value] = eAddressClassData; 1925 } 1926 } 1927 1928 continue; 1929 } 1930 } 1931 1932 if (arch.GetMachine() == llvm::Triple::arm) 1933 { 1934 // THUMB functions have the lower bit of their address set. Fixup 1935 // the actual address and mark the symbol as THUMB. 1936 if (symbol_type == eSymbolTypeCode && symbol.st_value & 1) 1937 { 1938 // Substracting 1 from the address effectively unsets 1939 // the low order bit, which results in the address 1940 // actually pointing to the beginning of the symbol. 1941 // This delta will be used below in conjuction with 1942 // symbol.st_value to produce the final symbol_value 1943 // that we store in the symtab. 1944 symbol_value_offset = -1; 1945 additional_flags = ARM_ELF_SYM_IS_THUMB; 1946 } 1947 } 1948 } 1949 1950 // If the symbol section we've found has no data (SHT_NOBITS), then check the module section 1951 // list. This can happen if we're parsing the debug file and it has no .text section, for example. 1952 if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0)) 1953 { 1954 ModuleSP module_sp(GetModule()); 1955 if (module_sp) 1956 { 1957 SectionList *module_section_list = module_sp->GetSectionList(); 1958 if (module_section_list && module_section_list != section_list) 1959 { 1960 const ConstString §_name = symbol_section_sp->GetName(); 1961 lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name)); 1962 if (section_sp && section_sp->GetFileSize()) 1963 { 1964 symbol_section_sp = section_sp; 1965 } 1966 } 1967 } 1968 } 1969 1970 // symbol_value_offset may contain 0 for ARM symbols or -1 for 1971 // THUMB symbols. See above for more details. 1972 uint64_t symbol_value = symbol.st_value + symbol_value_offset; 1973 if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile) 1974 symbol_value -= symbol_section_sp->GetFileAddress(); 1975 bool is_global = symbol.getBinding() == STB_GLOBAL; 1976 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; 1977 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 1978 1979 llvm::StringRef symbol_ref(symbol_name); 1980 1981 // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily. 1982 size_t version_pos = symbol_ref.find('@'); 1983 bool has_suffix = version_pos != llvm::StringRef::npos; 1984 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); 1985 Mangled mangled(ConstString(symbol_bare), is_mangled); 1986 1987 // Now append the suffix back to mangled and unmangled names. Only do it if the 1988 // demangling was sucessful (string is not empty). 1989 if (has_suffix) 1990 { 1991 llvm::StringRef suffix = symbol_ref.substr(version_pos); 1992 1993 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); 1994 if (! mangled_name.empty()) 1995 mangled.SetMangledName( ConstString((mangled_name + suffix).str()) ); 1996 1997 llvm::StringRef demangled_name = mangled.GetDemangledName().GetStringRef(); 1998 if (! demangled_name.empty()) 1999 mangled.SetDemangledName( ConstString((demangled_name + suffix).str()) ); 2000 } 2001 2002 Symbol dc_symbol( 2003 i + start_id, // ID is the original symbol table index. 2004 mangled, 2005 symbol_type, // Type of this symbol 2006 is_global, // Is this globally visible? 2007 false, // Is this symbol debug info? 2008 false, // Is this symbol a trampoline? 2009 false, // Is this symbol artificial? 2010 AddressRange( 2011 symbol_section_sp, // Section in which this symbol is defined or null. 2012 symbol_value, // Offset in section or symbol value. 2013 symbol.st_size), // Size in bytes of this symbol. 2014 true, // Size is valid 2015 has_suffix, // Contains linker annotations? 2016 flags); // Symbol flags. 2017 symtab->AddSymbol(dc_symbol); 2018 } 2019 return i; 2020 } 2021 2022 unsigned 2023 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab) 2024 { 2025 if (symtab->GetObjectFile() != this) 2026 { 2027 // If the symbol table section is owned by a different object file, have it do the 2028 // parsing. 2029 ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 2030 return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab); 2031 } 2032 2033 // Get section list for this object file. 2034 SectionList *section_list = m_sections_ap.get(); 2035 if (!section_list) 2036 return 0; 2037 2038 user_id_t symtab_id = symtab->GetID(); 2039 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2040 assert(symtab_hdr->sh_type == SHT_SYMTAB || 2041 symtab_hdr->sh_type == SHT_DYNSYM); 2042 2043 // sh_link: section header index of associated string table. 2044 // Section ID's are ones based. 2045 user_id_t strtab_id = symtab_hdr->sh_link + 1; 2046 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 2047 2048 if (symtab && strtab) 2049 { 2050 assert (symtab->GetObjectFile() == this); 2051 assert (strtab->GetObjectFile() == this); 2052 2053 DataExtractor symtab_data; 2054 DataExtractor strtab_data; 2055 if (ReadSectionData(symtab, symtab_data) && 2056 ReadSectionData(strtab, strtab_data)) 2057 { 2058 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 2059 2060 return ParseSymbols(symbol_table, start_id, section_list, 2061 num_symbols, symtab_data, strtab_data); 2062 } 2063 } 2064 2065 return 0; 2066 } 2067 2068 size_t 2069 ObjectFileELF::ParseDynamicSymbols() 2070 { 2071 if (m_dynamic_symbols.size()) 2072 return m_dynamic_symbols.size(); 2073 2074 SectionList *section_list = GetSectionList(); 2075 if (!section_list) 2076 return 0; 2077 2078 // Find the SHT_DYNAMIC section. 2079 Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get(); 2080 if (!dynsym) 2081 return 0; 2082 assert (dynsym->GetObjectFile() == this); 2083 2084 ELFDynamic symbol; 2085 DataExtractor dynsym_data; 2086 if (ReadSectionData(dynsym, dynsym_data)) 2087 { 2088 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 2089 lldb::offset_t cursor = 0; 2090 2091 while (cursor < section_size) 2092 { 2093 if (!symbol.Parse(dynsym_data, &cursor)) 2094 break; 2095 2096 m_dynamic_symbols.push_back(symbol); 2097 } 2098 } 2099 2100 return m_dynamic_symbols.size(); 2101 } 2102 2103 const ELFDynamic * 2104 ObjectFileELF::FindDynamicSymbol(unsigned tag) 2105 { 2106 if (!ParseDynamicSymbols()) 2107 return NULL; 2108 2109 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 2110 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 2111 for ( ; I != E; ++I) 2112 { 2113 ELFDynamic *symbol = &*I; 2114 2115 if (symbol->d_tag == tag) 2116 return symbol; 2117 } 2118 2119 return NULL; 2120 } 2121 2122 unsigned 2123 ObjectFileELF::PLTRelocationType() 2124 { 2125 // DT_PLTREL 2126 // This member specifies the type of relocation entry to which the 2127 // procedure linkage table refers. The d_val member holds DT_REL or 2128 // DT_RELA, as appropriate. All relocations in a procedure linkage table 2129 // must use the same relocation. 2130 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 2131 2132 if (symbol) 2133 return symbol->d_val; 2134 2135 return 0; 2136 } 2137 2138 static unsigned 2139 ParsePLTRelocations(Symtab *symbol_table, 2140 user_id_t start_id, 2141 unsigned rel_type, 2142 const ELFHeader *hdr, 2143 const ELFSectionHeader *rel_hdr, 2144 const ELFSectionHeader *plt_hdr, 2145 const ELFSectionHeader *sym_hdr, 2146 const lldb::SectionSP &plt_section_sp, 2147 DataExtractor &rel_data, 2148 DataExtractor &symtab_data, 2149 DataExtractor &strtab_data) 2150 { 2151 ELFRelocation rel(rel_type); 2152 ELFSymbol symbol; 2153 lldb::offset_t offset = 0; 2154 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes. 2155 // So round the entsize up by the alignment if addralign is set. 2156 const elf_xword plt_entsize = plt_hdr->sh_addralign ? 2157 llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize; 2158 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2159 2160 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2161 reloc_info_fn reloc_type; 2162 reloc_info_fn reloc_symbol; 2163 2164 if (hdr->Is32Bit()) 2165 { 2166 reloc_type = ELFRelocation::RelocType32; 2167 reloc_symbol = ELFRelocation::RelocSymbol32; 2168 } 2169 else 2170 { 2171 reloc_type = ELFRelocation::RelocType64; 2172 reloc_symbol = ELFRelocation::RelocSymbol64; 2173 } 2174 2175 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 2176 unsigned i; 2177 for (i = 0; i < num_relocations; ++i) 2178 { 2179 if (rel.Parse(rel_data, &offset) == false) 2180 break; 2181 2182 if (reloc_type(rel) != slot_type) 2183 continue; 2184 2185 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 2186 uint64_t plt_index = (i + 1) * plt_entsize; 2187 2188 if (!symbol.Parse(symtab_data, &symbol_offset)) 2189 break; 2190 2191 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2192 bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false; 2193 2194 Symbol jump_symbol( 2195 i + start_id, // Symbol table index 2196 symbol_name, // symbol name. 2197 is_mangled, // is the symbol name mangled? 2198 eSymbolTypeTrampoline, // Type of this symbol 2199 false, // Is this globally visible? 2200 false, // Is this symbol debug info? 2201 true, // Is this symbol a trampoline? 2202 true, // Is this symbol artificial? 2203 plt_section_sp, // Section in which this symbol is defined or null. 2204 plt_index, // Offset in section or symbol value. 2205 plt_entsize, // Size in bytes of this symbol. 2206 true, // Size is valid 2207 false, // Contains linker annotations? 2208 0); // Symbol flags. 2209 2210 symbol_table->AddSymbol(jump_symbol); 2211 } 2212 2213 return i; 2214 } 2215 2216 unsigned 2217 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, 2218 user_id_t start_id, 2219 const ELFSectionHeaderInfo *rel_hdr, 2220 user_id_t rel_id) 2221 { 2222 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2223 2224 // The link field points to the associated symbol table. The info field 2225 // points to the section holding the plt. 2226 user_id_t symtab_id = rel_hdr->sh_link; 2227 user_id_t plt_id = rel_hdr->sh_info; 2228 2229 if (!symtab_id || !plt_id) 2230 return 0; 2231 2232 // Section ID's are ones based; 2233 symtab_id++; 2234 plt_id++; 2235 2236 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2237 if (!plt_hdr) 2238 return 0; 2239 2240 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2241 if (!sym_hdr) 2242 return 0; 2243 2244 SectionList *section_list = m_sections_ap.get(); 2245 if (!section_list) 2246 return 0; 2247 2248 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2249 if (!rel_section) 2250 return 0; 2251 2252 SectionSP plt_section_sp (section_list->FindSectionByID(plt_id)); 2253 if (!plt_section_sp) 2254 return 0; 2255 2256 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2257 if (!symtab) 2258 return 0; 2259 2260 // sh_link points to associated string table. 2261 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get(); 2262 if (!strtab) 2263 return 0; 2264 2265 DataExtractor rel_data; 2266 if (!ReadSectionData(rel_section, rel_data)) 2267 return 0; 2268 2269 DataExtractor symtab_data; 2270 if (!ReadSectionData(symtab, symtab_data)) 2271 return 0; 2272 2273 DataExtractor strtab_data; 2274 if (!ReadSectionData(strtab, strtab_data)) 2275 return 0; 2276 2277 unsigned rel_type = PLTRelocationType(); 2278 if (!rel_type) 2279 return 0; 2280 2281 return ParsePLTRelocations (symbol_table, 2282 start_id, 2283 rel_type, 2284 &m_header, 2285 rel_hdr, 2286 plt_hdr, 2287 sym_hdr, 2288 plt_section_sp, 2289 rel_data, 2290 symtab_data, 2291 strtab_data); 2292 } 2293 2294 unsigned 2295 ObjectFileELF::RelocateSection(Symtab* symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2296 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2297 DataExtractor &rel_data, DataExtractor &symtab_data, 2298 DataExtractor &debug_data, Section* rel_section) 2299 { 2300 ELFRelocation rel(rel_hdr->sh_type); 2301 lldb::addr_t offset = 0; 2302 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2303 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2304 reloc_info_fn reloc_type; 2305 reloc_info_fn reloc_symbol; 2306 2307 if (hdr->Is32Bit()) 2308 { 2309 reloc_type = ELFRelocation::RelocType32; 2310 reloc_symbol = ELFRelocation::RelocSymbol32; 2311 } 2312 else 2313 { 2314 reloc_type = ELFRelocation::RelocType64; 2315 reloc_symbol = ELFRelocation::RelocSymbol64; 2316 } 2317 2318 for (unsigned i = 0; i < num_relocations; ++i) 2319 { 2320 if (rel.Parse(rel_data, &offset) == false) 2321 break; 2322 2323 Symbol* symbol = NULL; 2324 2325 if (hdr->Is32Bit()) 2326 { 2327 switch (reloc_type(rel)) { 2328 case R_386_32: 2329 case R_386_PC32: 2330 default: 2331 assert(false && "unexpected relocation type"); 2332 } 2333 } else { 2334 switch (reloc_type(rel)) { 2335 case R_X86_64_64: 2336 { 2337 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2338 if (symbol) 2339 { 2340 addr_t value = symbol->GetAddress().GetFileAddress(); 2341 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2342 uint64_t* dst = reinterpret_cast<uint64_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset64(rel)); 2343 *dst = value + ELFRelocation::RelocAddend64(rel); 2344 } 2345 break; 2346 } 2347 case R_X86_64_32: 2348 case R_X86_64_32S: 2349 { 2350 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2351 if (symbol) 2352 { 2353 addr_t value = symbol->GetAddress().GetFileAddress(); 2354 value += ELFRelocation::RelocAddend32(rel); 2355 assert((reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || 2356 (reloc_type(rel) == R_X86_64_32S && 2357 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))); 2358 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2359 DataBufferSP& data_buffer_sp = debug_data.GetSharedDataBuffer(); 2360 uint32_t* dst = reinterpret_cast<uint32_t*>(data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel)); 2361 *dst = truncated_addr; 2362 } 2363 break; 2364 } 2365 case R_X86_64_PC32: 2366 default: 2367 assert(false && "unexpected relocation type"); 2368 } 2369 } 2370 } 2371 2372 return 0; 2373 } 2374 2375 unsigned 2376 ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, user_id_t rel_id) 2377 { 2378 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2379 2380 // Parse in the section list if needed. 2381 SectionList *section_list = GetSectionList(); 2382 if (!section_list) 2383 return 0; 2384 2385 // Section ID's are ones based. 2386 user_id_t symtab_id = rel_hdr->sh_link + 1; 2387 user_id_t debug_id = rel_hdr->sh_info + 1; 2388 2389 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2390 if (!symtab_hdr) 2391 return 0; 2392 2393 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2394 if (!debug_hdr) 2395 return 0; 2396 2397 Section *rel = section_list->FindSectionByID(rel_id).get(); 2398 if (!rel) 2399 return 0; 2400 2401 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2402 if (!symtab) 2403 return 0; 2404 2405 Section *debug = section_list->FindSectionByID(debug_id).get(); 2406 if (!debug) 2407 return 0; 2408 2409 DataExtractor rel_data; 2410 DataExtractor symtab_data; 2411 DataExtractor debug_data; 2412 2413 if (ReadSectionData(rel, rel_data) && 2414 ReadSectionData(symtab, symtab_data) && 2415 ReadSectionData(debug, debug_data)) 2416 { 2417 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr, debug_hdr, 2418 rel_data, symtab_data, debug_data, debug); 2419 } 2420 2421 return 0; 2422 } 2423 2424 Symtab * 2425 ObjectFileELF::GetSymtab() 2426 { 2427 ModuleSP module_sp(GetModule()); 2428 if (!module_sp) 2429 return NULL; 2430 2431 // We always want to use the main object file so we (hopefully) only have one cached copy 2432 // of our symtab, dynamic sections, etc. 2433 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2434 if (module_obj_file && module_obj_file != this) 2435 return module_obj_file->GetSymtab(); 2436 2437 if (m_symtab_ap.get() == NULL) 2438 { 2439 SectionList *section_list = module_sp->GetSectionList(); 2440 if (!section_list) 2441 return NULL; 2442 2443 uint64_t symbol_id = 0; 2444 lldb_private::Mutex::Locker locker(module_sp->GetMutex()); 2445 2446 m_symtab_ap.reset(new Symtab(this)); 2447 2448 // Sharable objects and dynamic executables usually have 2 distinct symbol 2449 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller 2450 // version of the symtab that only contains global symbols. The information found 2451 // in the dynsym is therefore also found in the symtab, while the reverse is not 2452 // necessarily true. 2453 Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get(); 2454 if (!symtab) 2455 { 2456 // The symtab section is non-allocable and can be stripped, so if it doesn't exist 2457 // then use the dynsym section which should always be there. 2458 symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get(); 2459 } 2460 if (symtab) 2461 symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab); 2462 2463 // DT_JMPREL 2464 // If present, this entry's d_ptr member holds the address of relocation 2465 // entries associated solely with the procedure linkage table. Separating 2466 // these relocation entries lets the dynamic linker ignore them during 2467 // process initialization, if lazy binding is enabled. If this entry is 2468 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2469 // also be present. 2470 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2471 if (symbol) 2472 { 2473 // Synthesize trampoline symbols to help navigate the PLT. 2474 addr_t addr = symbol->d_ptr; 2475 Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get(); 2476 if (reloc_section) 2477 { 2478 user_id_t reloc_id = reloc_section->GetID(); 2479 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id); 2480 assert(reloc_header); 2481 2482 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id); 2483 } 2484 } 2485 } 2486 2487 for (SectionHeaderCollIter I = m_section_headers.begin(); 2488 I != m_section_headers.end(); ++I) 2489 { 2490 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) 2491 { 2492 if (CalculateType() == eTypeObjectFile) 2493 { 2494 const char *section_name = I->section_name.AsCString(""); 2495 if (strstr(section_name, ".rela.debug") || 2496 strstr(section_name, ".rel.debug")) 2497 { 2498 const ELFSectionHeader &reloc_header = *I; 2499 user_id_t reloc_id = SectionIndex(I); 2500 RelocateDebugSections(&reloc_header, reloc_id); 2501 } 2502 } 2503 } 2504 } 2505 return m_symtab_ap.get(); 2506 } 2507 2508 Symbol * 2509 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique) 2510 { 2511 if (!m_symtab_ap.get()) 2512 return nullptr; // GetSymtab() should be called first. 2513 2514 const SectionList *section_list = GetSectionList(); 2515 if (!section_list) 2516 return nullptr; 2517 2518 if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo()) 2519 { 2520 AddressRange range; 2521 if (eh_frame->GetAddressRange (so_addr, range)) 2522 { 2523 const addr_t file_addr = range.GetBaseAddress().GetFileAddress(); 2524 Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr; 2525 if (symbol) 2526 return symbol; 2527 2528 // Note that a (stripped) symbol won't be found by GetSymtab()... 2529 lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr); 2530 if (eh_sym_section_sp.get()) 2531 { 2532 addr_t section_base = eh_sym_section_sp->GetFileAddress(); 2533 addr_t offset = file_addr - section_base; 2534 uint64_t symbol_id = m_symtab_ap->GetNumSymbols(); 2535 2536 Symbol eh_symbol( 2537 symbol_id, // Symbol table index. 2538 "???", // Symbol name. 2539 false, // Is the symbol name mangled? 2540 eSymbolTypeCode, // Type of this symbol. 2541 true, // Is this globally visible? 2542 false, // Is this symbol debug info? 2543 false, // Is this symbol a trampoline? 2544 true, // Is this symbol artificial? 2545 eh_sym_section_sp, // Section in which this symbol is defined or null. 2546 offset, // Offset in section or symbol value. 2547 range.GetByteSize(), // Size in bytes of this symbol. 2548 true, // Size is valid. 2549 false, // Contains linker annotations? 2550 0); // Symbol flags. 2551 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol)) 2552 return m_symtab_ap->SymbolAtIndex(symbol_id); 2553 } 2554 } 2555 } 2556 return nullptr; 2557 } 2558 2559 2560 bool 2561 ObjectFileELF::IsStripped () 2562 { 2563 // TODO: determine this for ELF 2564 return false; 2565 } 2566 2567 //===----------------------------------------------------------------------===// 2568 // Dump 2569 // 2570 // Dump the specifics of the runtime file container (such as any headers 2571 // segments, sections, etc). 2572 //---------------------------------------------------------------------- 2573 void 2574 ObjectFileELF::Dump(Stream *s) 2575 { 2576 DumpELFHeader(s, m_header); 2577 s->EOL(); 2578 DumpELFProgramHeaders(s); 2579 s->EOL(); 2580 DumpELFSectionHeaders(s); 2581 s->EOL(); 2582 SectionList *section_list = GetSectionList(); 2583 if (section_list) 2584 section_list->Dump(s, NULL, true, UINT32_MAX); 2585 Symtab *symtab = GetSymtab(); 2586 if (symtab) 2587 symtab->Dump(s, NULL, eSortOrderNone); 2588 s->EOL(); 2589 DumpDependentModules(s); 2590 s->EOL(); 2591 } 2592 2593 //---------------------------------------------------------------------- 2594 // DumpELFHeader 2595 // 2596 // Dump the ELF header to the specified output stream 2597 //---------------------------------------------------------------------- 2598 void 2599 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) 2600 { 2601 s->PutCString("ELF Header\n"); 2602 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2603 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", 2604 header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]); 2605 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", 2606 header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]); 2607 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", 2608 header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]); 2609 2610 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2611 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2612 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2613 s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2614 s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2615 2616 s->Printf("e_type = 0x%4.4x ", header.e_type); 2617 DumpELFHeader_e_type(s, header.e_type); 2618 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2619 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2620 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2621 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2622 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2623 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2624 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2625 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2626 s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum); 2627 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2628 s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum); 2629 s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx); 2630 } 2631 2632 //---------------------------------------------------------------------- 2633 // DumpELFHeader_e_type 2634 // 2635 // Dump an token value for the ELF header member e_type 2636 //---------------------------------------------------------------------- 2637 void 2638 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) 2639 { 2640 switch (e_type) 2641 { 2642 case ET_NONE: *s << "ET_NONE"; break; 2643 case ET_REL: *s << "ET_REL"; break; 2644 case ET_EXEC: *s << "ET_EXEC"; break; 2645 case ET_DYN: *s << "ET_DYN"; break; 2646 case ET_CORE: *s << "ET_CORE"; break; 2647 default: 2648 break; 2649 } 2650 } 2651 2652 //---------------------------------------------------------------------- 2653 // DumpELFHeader_e_ident_EI_DATA 2654 // 2655 // Dump an token value for the ELF header member e_ident[EI_DATA] 2656 //---------------------------------------------------------------------- 2657 void 2658 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data) 2659 { 2660 switch (ei_data) 2661 { 2662 case ELFDATANONE: *s << "ELFDATANONE"; break; 2663 case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break; 2664 case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break; 2665 default: 2666 break; 2667 } 2668 } 2669 2670 2671 //---------------------------------------------------------------------- 2672 // DumpELFProgramHeader 2673 // 2674 // Dump a single ELF program header to the specified output stream 2675 //---------------------------------------------------------------------- 2676 void 2677 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph) 2678 { 2679 DumpELFProgramHeader_p_type(s, ph.p_type); 2680 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr); 2681 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags); 2682 2683 DumpELFProgramHeader_p_flags(s, ph.p_flags); 2684 s->Printf(") %8.8" PRIx64, ph.p_align); 2685 } 2686 2687 //---------------------------------------------------------------------- 2688 // DumpELFProgramHeader_p_type 2689 // 2690 // Dump an token value for the ELF program header member p_type which 2691 // describes the type of the program header 2692 // ---------------------------------------------------------------------- 2693 void 2694 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) 2695 { 2696 const int kStrWidth = 15; 2697 switch (p_type) 2698 { 2699 CASE_AND_STREAM(s, PT_NULL , kStrWidth); 2700 CASE_AND_STREAM(s, PT_LOAD , kStrWidth); 2701 CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth); 2702 CASE_AND_STREAM(s, PT_INTERP , kStrWidth); 2703 CASE_AND_STREAM(s, PT_NOTE , kStrWidth); 2704 CASE_AND_STREAM(s, PT_SHLIB , kStrWidth); 2705 CASE_AND_STREAM(s, PT_PHDR , kStrWidth); 2706 CASE_AND_STREAM(s, PT_TLS , kStrWidth); 2707 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 2708 default: 2709 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 2710 break; 2711 } 2712 } 2713 2714 2715 //---------------------------------------------------------------------- 2716 // DumpELFProgramHeader_p_flags 2717 // 2718 // Dump an token value for the ELF program header member p_flags 2719 //---------------------------------------------------------------------- 2720 void 2721 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) 2722 { 2723 *s << ((p_flags & PF_X) ? "PF_X" : " ") 2724 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 2725 << ((p_flags & PF_W) ? "PF_W" : " ") 2726 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 2727 << ((p_flags & PF_R) ? "PF_R" : " "); 2728 } 2729 2730 //---------------------------------------------------------------------- 2731 // DumpELFProgramHeaders 2732 // 2733 // Dump all of the ELF program header to the specified output stream 2734 //---------------------------------------------------------------------- 2735 void 2736 ObjectFileELF::DumpELFProgramHeaders(Stream *s) 2737 { 2738 if (!ParseProgramHeaders()) 2739 return; 2740 2741 s->PutCString("Program Headers\n"); 2742 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 2743 "p_filesz p_memsz p_flags p_align\n"); 2744 s->PutCString("==== --------------- -------- -------- -------- " 2745 "-------- -------- ------------------------- --------\n"); 2746 2747 uint32_t idx = 0; 2748 for (ProgramHeaderCollConstIter I = m_program_headers.begin(); 2749 I != m_program_headers.end(); ++I, ++idx) 2750 { 2751 s->Printf("[%2u] ", idx); 2752 ObjectFileELF::DumpELFProgramHeader(s, *I); 2753 s->EOL(); 2754 } 2755 } 2756 2757 //---------------------------------------------------------------------- 2758 // DumpELFSectionHeader 2759 // 2760 // Dump a single ELF section header to the specified output stream 2761 //---------------------------------------------------------------------- 2762 void 2763 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh) 2764 { 2765 s->Printf("%8.8x ", sh.sh_name); 2766 DumpELFSectionHeader_sh_type(s, sh.sh_type); 2767 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 2768 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 2769 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size); 2770 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 2771 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 2772 } 2773 2774 //---------------------------------------------------------------------- 2775 // DumpELFSectionHeader_sh_type 2776 // 2777 // Dump an token value for the ELF section header member sh_type which 2778 // describes the type of the section 2779 //---------------------------------------------------------------------- 2780 void 2781 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) 2782 { 2783 const int kStrWidth = 12; 2784 switch (sh_type) 2785 { 2786 CASE_AND_STREAM(s, SHT_NULL , kStrWidth); 2787 CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth); 2788 CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth); 2789 CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth); 2790 CASE_AND_STREAM(s, SHT_RELA , kStrWidth); 2791 CASE_AND_STREAM(s, SHT_HASH , kStrWidth); 2792 CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth); 2793 CASE_AND_STREAM(s, SHT_NOTE , kStrWidth); 2794 CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth); 2795 CASE_AND_STREAM(s, SHT_REL , kStrWidth); 2796 CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth); 2797 CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth); 2798 CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth); 2799 CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth); 2800 CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth); 2801 CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth); 2802 default: 2803 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 2804 break; 2805 } 2806 } 2807 2808 //---------------------------------------------------------------------- 2809 // DumpELFSectionHeader_sh_flags 2810 // 2811 // Dump an token value for the ELF section header member sh_flags 2812 //---------------------------------------------------------------------- 2813 void 2814 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags) 2815 { 2816 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 2817 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 2818 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 2819 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 2820 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 2821 } 2822 2823 //---------------------------------------------------------------------- 2824 // DumpELFSectionHeaders 2825 // 2826 // Dump all of the ELF section header to the specified output stream 2827 //---------------------------------------------------------------------- 2828 void 2829 ObjectFileELF::DumpELFSectionHeaders(Stream *s) 2830 { 2831 if (!ParseSectionHeaders()) 2832 return; 2833 2834 s->PutCString("Section Headers\n"); 2835 s->PutCString("IDX name type flags " 2836 "addr offset size link info addralgn " 2837 "entsize Name\n"); 2838 s->PutCString("==== -------- ------------ -------------------------------- " 2839 "-------- -------- -------- -------- -------- -------- " 2840 "-------- ====================\n"); 2841 2842 uint32_t idx = 0; 2843 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 2844 I != m_section_headers.end(); ++I, ++idx) 2845 { 2846 s->Printf("[%2u] ", idx); 2847 ObjectFileELF::DumpELFSectionHeader(s, *I); 2848 const char* section_name = I->section_name.AsCString(""); 2849 if (section_name) 2850 *s << ' ' << section_name << "\n"; 2851 } 2852 } 2853 2854 void 2855 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) 2856 { 2857 size_t num_modules = ParseDependentModules(); 2858 2859 if (num_modules > 0) 2860 { 2861 s->PutCString("Dependent Modules:\n"); 2862 for (unsigned i = 0; i < num_modules; ++i) 2863 { 2864 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i); 2865 s->Printf(" %s\n", spec.GetFilename().GetCString()); 2866 } 2867 } 2868 } 2869 2870 bool 2871 ObjectFileELF::GetArchitecture (ArchSpec &arch) 2872 { 2873 if (!ParseHeader()) 2874 return false; 2875 2876 if (m_section_headers.empty()) 2877 { 2878 // Allow elf notes to be parsed which may affect the detected architecture. 2879 ParseSectionHeaders(); 2880 } 2881 2882 arch = m_arch_spec; 2883 return true; 2884 } 2885 2886 ObjectFile::Type 2887 ObjectFileELF::CalculateType() 2888 { 2889 switch (m_header.e_type) 2890 { 2891 case llvm::ELF::ET_NONE: 2892 // 0 - No file type 2893 return eTypeUnknown; 2894 2895 case llvm::ELF::ET_REL: 2896 // 1 - Relocatable file 2897 return eTypeObjectFile; 2898 2899 case llvm::ELF::ET_EXEC: 2900 // 2 - Executable file 2901 return eTypeExecutable; 2902 2903 case llvm::ELF::ET_DYN: 2904 // 3 - Shared object file 2905 return eTypeSharedLibrary; 2906 2907 case ET_CORE: 2908 // 4 - Core file 2909 return eTypeCoreFile; 2910 2911 default: 2912 break; 2913 } 2914 return eTypeUnknown; 2915 } 2916 2917 ObjectFile::Strata 2918 ObjectFileELF::CalculateStrata() 2919 { 2920 switch (m_header.e_type) 2921 { 2922 case llvm::ELF::ET_NONE: 2923 // 0 - No file type 2924 return eStrataUnknown; 2925 2926 case llvm::ELF::ET_REL: 2927 // 1 - Relocatable file 2928 return eStrataUnknown; 2929 2930 case llvm::ELF::ET_EXEC: 2931 // 2 - Executable file 2932 // TODO: is there any way to detect that an executable is a kernel 2933 // related executable by inspecting the program headers, section 2934 // headers, symbols, or any other flag bits??? 2935 return eStrataUser; 2936 2937 case llvm::ELF::ET_DYN: 2938 // 3 - Shared object file 2939 // TODO: is there any way to detect that an shared library is a kernel 2940 // related executable by inspecting the program headers, section 2941 // headers, symbols, or any other flag bits??? 2942 return eStrataUnknown; 2943 2944 case ET_CORE: 2945 // 4 - Core file 2946 // TODO: is there any way to detect that an core file is a kernel 2947 // related executable by inspecting the program headers, section 2948 // headers, symbols, or any other flag bits??? 2949 return eStrataUnknown; 2950 2951 default: 2952 break; 2953 } 2954 return eStrataUnknown; 2955 } 2956 2957