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