contrib/llvm/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

   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 <algorithm>
  13 #include <cassert>
  14 #include <unordered_map>
  15
  16 #include "lldb/Core/FileSpecList.h"
  17 #include "lldb/Core/Module.h"
  18 #include "lldb/Core/ModuleSpec.h"
  19 #include "lldb/Core/PluginManager.h"
  20 #include "lldb/Core/Section.h"
  21 #include "lldb/Symbol/DWARFCallFrameInfo.h"
  22 #include "lldb/Symbol/SymbolContext.h"
  23 #include "lldb/Target/SectionLoadList.h"
  24 #include "lldb/Target/Target.h"
  25 #include "lldb/Utility/ArchSpec.h"
  26 #include "lldb/Utility/DataBufferHeap.h"
  27 #include "lldb/Utility/Log.h"
  28 #include "lldb/Utility/Status.h"
  29 #include "lldb/Utility/Stream.h"
  30 #include "lldb/Utility/Timer.h"
  31
  32 #include "llvm/ADT/PointerUnion.h"
  33 #include "llvm/ADT/StringRef.h"
  34 #include "llvm/Object/Decompressor.h"
  35 #include "llvm/Support/ARMBuildAttributes.h"
  36 #include "llvm/Support/MathExtras.h"
  37 #include "llvm/Support/MemoryBuffer.h"
  38 #include "llvm/Support/MipsABIFlags.h"
  39
  40 #define CASE_AND_STREAM(s, def, width)                                         \
  41   case def:                                                                    \
  42     s->Printf("%-*s", width, #def);                                            \
  43     break;
  44
  45 using namespace lldb;
  46 using namespace lldb_private;
  47 using namespace elf;
  48 using namespace llvm::ELF;
  49
  50 namespace {
  51
  52 // ELF note owner definitions
  53 const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD";
  54 const char *const LLDB_NT_OWNER_GNU = "GNU";
  55 const char *const LLDB_NT_OWNER_NETBSD = "NetBSD";
  56 const char *const LLDB_NT_OWNER_OPENBSD = "OpenBSD";
  57 const char *const LLDB_NT_OWNER_CSR = "csr";
  58 const char *const LLDB_NT_OWNER_ANDROID = "Android";
  59 const char *const LLDB_NT_OWNER_CORE = "CORE";
  60 const char *const LLDB_NT_OWNER_LINUX = "LINUX";
  61
  62 // ELF note type definitions
  63 const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01;
  64 const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4;
  65
  66 const elf_word LLDB_NT_GNU_ABI_TAG = 0x01;
  67 const elf_word LLDB_NT_GNU_ABI_SIZE = 16;
  68
  69 const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03;
  70
  71 const elf_word LLDB_NT_NETBSD_ABI_TAG = 0x01;
  72 const elf_word LLDB_NT_NETBSD_ABI_SIZE = 4;
  73
  74 // GNU ABI note OS constants
  75 const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00;
  76 const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01;
  77 const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02;
  78
  79 // LLDB_NT_OWNER_CORE and LLDB_NT_OWNER_LINUX note contants
  80 #define NT_PRSTATUS 1
  81 #define NT_PRFPREG 2
  82 #define NT_PRPSINFO 3
  83 #define NT_TASKSTRUCT 4
  84 #define NT_AUXV 6
  85 #define NT_SIGINFO 0x53494749
  86 #define NT_FILE 0x46494c45
  87 #define NT_PRXFPREG 0x46e62b7f
  88 #define NT_PPC_VMX 0x100
  89 #define NT_PPC_SPE 0x101
  90 #define NT_PPC_VSX 0x102
  91 #define NT_386_TLS 0x200
  92 #define NT_386_IOPERM 0x201
  93 #define NT_X86_XSTATE 0x202
  94 #define NT_S390_HIGH_GPRS 0x300
  95 #define NT_S390_TIMER 0x301
  96 #define NT_S390_TODCMP 0x302
  97 #define NT_S390_TODPREG 0x303
  98 #define NT_S390_CTRS 0x304
  99 #define NT_S390_PREFIX 0x305
 100 #define NT_S390_LAST_BREAK 0x306
 101 #define NT_S390_SYSTEM_CALL 0x307
 102 #define NT_S390_TDB 0x308
 103 #define NT_S390_VXRS_LOW 0x309
 104 #define NT_S390_VXRS_HIGH 0x30a
 105 #define NT_ARM_VFP 0x400
 106 #define NT_ARM_TLS 0x401
 107 #define NT_ARM_HW_BREAK 0x402
 108 #define NT_ARM_HW_WATCH 0x403
 109 #define NT_ARM_SYSTEM_CALL 0x404
 110 #define NT_METAG_CBUF 0x500
 111 #define NT_METAG_RPIPE 0x501
 112 #define NT_METAG_TLS 0x502
 113
 114 //===----------------------------------------------------------------------===//
 115 /// @class ELFRelocation
 116 /// Generic wrapper for ELFRel and ELFRela.
 117 ///
 118 /// This helper class allows us to parse both ELFRel and ELFRela relocation
 119 /// entries in a generic manner.
 120 class ELFRelocation {
 121 public:
 122   /// Constructs an ELFRelocation entry with a personality as given by @p
 123   /// type.
 124   ///
 125   /// @param type Either DT_REL or DT_RELA.  Any other value is invalid.
 126   ELFRelocation(unsigned type);
 127
 128   ~ELFRelocation();
 129
 130   bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
 131
 132   static unsigned RelocType32(const ELFRelocation &rel);
 133
 134   static unsigned RelocType64(const ELFRelocation &rel);
 135
 136   static unsigned RelocSymbol32(const ELFRelocation &rel);
 137
 138   static unsigned RelocSymbol64(const ELFRelocation &rel);
 139
 140   static unsigned RelocOffset32(const ELFRelocation &rel);
 141
 142   static unsigned RelocOffset64(const ELFRelocation &rel);
 143
 144   static unsigned RelocAddend32(const ELFRelocation &rel);
 145
 146   static unsigned RelocAddend64(const ELFRelocation &rel);
 147
 148 private:
 149   typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion;
 150
 151   RelocUnion reloc;
 152 };
 153
 154 ELFRelocation::ELFRelocation(unsigned type) {
 155   if (type == DT_REL || type == SHT_REL)
 156     reloc = new ELFRel();
 157   else if (type == DT_RELA || type == SHT_RELA)
 158     reloc = new ELFRela();
 159   else {
 160     assert(false && "unexpected relocation type");
 161     reloc = static_cast<ELFRel *>(NULL);
 162   }
 163 }
 164
 165 ELFRelocation::~ELFRelocation() {
 166   if (reloc.is<ELFRel *>())
 167     delete reloc.get<ELFRel *>();
 168   else
 169     delete reloc.get<ELFRela *>();
 170 }
 171
 172 bool ELFRelocation::Parse(const lldb_private::DataExtractor &data,
 173                           lldb::offset_t *offset) {
 174   if (reloc.is<ELFRel *>())
 175     return reloc.get<ELFRel *>()->Parse(data, offset);
 176   else
 177     return reloc.get<ELFRela *>()->Parse(data, offset);
 178 }
 179
 180 unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) {
 181   if (rel.reloc.is<ELFRel *>())
 182     return ELFRel::RelocType32(*rel.reloc.get<ELFRel *>());
 183   else
 184     return ELFRela::RelocType32(*rel.reloc.get<ELFRela *>());
 185 }
 186
 187 unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) {
 188   if (rel.reloc.is<ELFRel *>())
 189     return ELFRel::RelocType64(*rel.reloc.get<ELFRel *>());
 190   else
 191     return ELFRela::RelocType64(*rel.reloc.get<ELFRela *>());
 192 }
 193
 194 unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) {
 195   if (rel.reloc.is<ELFRel *>())
 196     return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel *>());
 197   else
 198     return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela *>());
 199 }
 200
 201 unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) {
 202   if (rel.reloc.is<ELFRel *>())
 203     return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel *>());
 204   else
 205     return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela *>());
 206 }
 207
 208 unsigned ELFRelocation::RelocOffset32(const ELFRelocation &rel) {
 209   if (rel.reloc.is<ELFRel *>())
 210     return rel.reloc.get<ELFRel *>()->r_offset;
 211   else
 212     return rel.reloc.get<ELFRela *>()->r_offset;
 213 }
 214
 215 unsigned ELFRelocation::RelocOffset64(const ELFRelocation &rel) {
 216   if (rel.reloc.is<ELFRel *>())
 217     return rel.reloc.get<ELFRel *>()->r_offset;
 218   else
 219     return rel.reloc.get<ELFRela *>()->r_offset;
 220 }
 221
 222 unsigned ELFRelocation::RelocAddend32(const ELFRelocation &rel) {
 223   if (rel.reloc.is<ELFRel *>())
 224     return 0;
 225   else
 226     return rel.reloc.get<ELFRela *>()->r_addend;
 227 }
 228
 229 unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) {
 230   if (rel.reloc.is<ELFRel *>())
 231     return 0;
 232   else
 233     return rel.reloc.get<ELFRela *>()->r_addend;
 234 }
 235
 236 } // end anonymous namespace
 237
 238 bool ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) {
 239   // Read all fields.
 240   if (data.GetU32(offset, &n_namesz, 3) == NULL)
 241     return false;
 242
 243   // The name field is required to be nul-terminated, and n_namesz includes the
 244   // terminating nul in observed implementations (contrary to the ELF-64 spec).
 245   // A special case is needed for cores generated by some older Linux versions,
 246   // which write a note named "CORE" without a nul terminator and n_namesz = 4.
 247   if (n_namesz == 4) {
 248     char buf[4];
 249     if (data.ExtractBytes(*offset, 4, data.GetByteOrder(), buf) != 4)
 250       return false;
 251     if (strncmp(buf, "CORE", 4) == 0) {
 252       n_name = "CORE";
 253       *offset += 4;
 254       return true;
 255     }
 256   }
 257
 258   const char *cstr = data.GetCStr(offset, llvm::alignTo(n_namesz, 4));
 259   if (cstr == NULL) {
 260     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS));
 261     if (log)
 262       log->Printf("Failed to parse note name lacking nul terminator");
 263
 264     return false;
 265   }
 266   n_name = cstr;
 267   return true;
 268 }
 269
 270 static uint32_t kalimbaVariantFromElfFlags(const elf::elf_word e_flags) {
 271   const uint32_t dsp_rev = e_flags & 0xFF;
 272   uint32_t kal_arch_variant = LLDB_INVALID_CPUTYPE;
 273   switch (dsp_rev) {
 274   // TODO(mg11) Support more variants
 275   case 10:
 276     kal_arch_variant = llvm::Triple::KalimbaSubArch_v3;
 277     break;
 278   case 14:
 279     kal_arch_variant = llvm::Triple::KalimbaSubArch_v4;
 280     break;
 281   case 17:
 282   case 20:
 283     kal_arch_variant = llvm::Triple::KalimbaSubArch_v5;
 284     break;
 285   default:
 286     break;
 287   }
 288   return kal_arch_variant;
 289 }
 290
 291 static uint32_t mipsVariantFromElfFlags (const elf::ELFHeader &header) {
 292   const uint32_t mips_arch = header.e_flags & llvm::ELF::EF_MIPS_ARCH;
 293   uint32_t endian = header.e_ident[EI_DATA];
 294   uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown;
 295   uint32_t fileclass = header.e_ident[EI_CLASS];
 296
 297   // If there aren't any elf flags available (e.g core elf file) then return
 298   // default
 299   // 32 or 64 bit arch (without any architecture revision) based on object file's class.
 300   if (header.e_type == ET_CORE) {
 301     switch (fileclass) {
 302     case llvm::ELF::ELFCLASS32:
 303       return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
 304                                      : ArchSpec::eMIPSSubType_mips32;
 305     case llvm::ELF::ELFCLASS64:
 306       return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
 307                                      : ArchSpec::eMIPSSubType_mips64;
 308     default:
 309       return arch_variant;
 310     }
 311   }
 312
 313   switch (mips_arch) {
 314   case llvm::ELF::EF_MIPS_ARCH_1:
 315   case llvm::ELF::EF_MIPS_ARCH_2:
 316   case llvm::ELF::EF_MIPS_ARCH_32:
 317     return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
 318                                    : ArchSpec::eMIPSSubType_mips32;
 319   case llvm::ELF::EF_MIPS_ARCH_32R2:
 320     return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el
 321                                    : ArchSpec::eMIPSSubType_mips32r2;
 322   case llvm::ELF::EF_MIPS_ARCH_32R6:
 323     return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el
 324                                    : ArchSpec::eMIPSSubType_mips32r6;
 325   case llvm::ELF::EF_MIPS_ARCH_3:
 326   case llvm::ELF::EF_MIPS_ARCH_4:
 327   case llvm::ELF::EF_MIPS_ARCH_5:
 328   case llvm::ELF::EF_MIPS_ARCH_64:
 329     return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
 330                                    : ArchSpec::eMIPSSubType_mips64;
 331   case llvm::ELF::EF_MIPS_ARCH_64R2:
 332     return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r2el
 333                                    : ArchSpec::eMIPSSubType_mips64r2;
 334   case llvm::ELF::EF_MIPS_ARCH_64R6:
 335     return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r6el
 336                                    : ArchSpec::eMIPSSubType_mips64r6;
 337   default:
 338     break;
 339   }
 340
 341   return arch_variant;
 342 }
 343
 344 static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) {
 345   if (header.e_machine == llvm::ELF::EM_MIPS)
 346     return mipsVariantFromElfFlags(header);
 347
 348   return llvm::ELF::EM_CSR_KALIMBA == header.e_machine
 349              ? kalimbaVariantFromElfFlags(header.e_flags)
 350              : LLDB_INVALID_CPUTYPE;
 351 }
 352
 353 //! The kalimba toolchain identifies a code section as being
 354 //! one with the SHT_PROGBITS set in the section sh_type and the top
 355 //! bit in the 32-bit address field set.
 356 static lldb::SectionType
 357 kalimbaSectionType(const elf::ELFHeader &header,
 358                    const elf::ELFSectionHeader &sect_hdr) {
 359   if (llvm::ELF::EM_CSR_KALIMBA != header.e_machine) {
 360     return eSectionTypeOther;
 361   }
 362
 363   if (llvm::ELF::SHT_NOBITS == sect_hdr.sh_type) {
 364     return eSectionTypeZeroFill;
 365   }
 366
 367   if (llvm::ELF::SHT_PROGBITS == sect_hdr.sh_type) {
 368     const lldb::addr_t KAL_CODE_BIT = 1 << 31;
 369     return KAL_CODE_BIT & sect_hdr.sh_addr ? eSectionTypeCode
 370                                            : eSectionTypeData;
 371   }
 372
 373   return eSectionTypeOther;
 374 }
 375
 376 // Arbitrary constant used as UUID prefix for core files.
 377 const uint32_t ObjectFileELF::g_core_uuid_magic(0xE210C);
 378
 379 //------------------------------------------------------------------
 380 // Static methods.
 381 //------------------------------------------------------------------
 382 void ObjectFileELF::Initialize() {
 383   PluginManager::RegisterPlugin(GetPluginNameStatic(),
 384                                 GetPluginDescriptionStatic(), CreateInstance,
 385                                 CreateMemoryInstance, GetModuleSpecifications);
 386 }
 387
 388 void ObjectFileELF::Terminate() {
 389   PluginManager::UnregisterPlugin(CreateInstance);
 390 }
 391
 392 lldb_private::ConstString ObjectFileELF::GetPluginNameStatic() {
 393   static ConstString g_name("elf");
 394   return g_name;
 395 }
 396
 397 const char *ObjectFileELF::GetPluginDescriptionStatic() {
 398   return "ELF object file reader.";
 399 }
 400
 401 ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
 402                                           DataBufferSP &data_sp,
 403                                           lldb::offset_t data_offset,
 404                                           const lldb_private::FileSpec *file,
 405                                           lldb::offset_t file_offset,
 406                                           lldb::offset_t length) {
 407   if (!data_sp) {
 408     data_sp = MapFileData(*file, length, file_offset);
 409     if (!data_sp)
 410       return nullptr;
 411     data_offset = 0;
 412   }
 413
 414   assert(data_sp);
 415
 416   if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
 417     return nullptr;
 418
 419   const uint8_t *magic = data_sp->GetBytes() + data_offset;
 420   if (!ELFHeader::MagicBytesMatch(magic))
 421     return nullptr;
 422
 423   // Update the data to contain the entire file if it doesn't already
 424   if (data_sp->GetByteSize() < length) {
 425     data_sp = MapFileData(*file, length, file_offset);
 426     if (!data_sp)
 427       return nullptr;
 428     data_offset = 0;
 429     magic = data_sp->GetBytes();
 430   }
 431
 432   unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
 433   if (address_size == 4 || address_size == 8) {
 434     std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(
 435         module_sp, data_sp, data_offset, file, file_offset, length));
 436     ArchSpec spec;
 437     if (objfile_ap->GetArchitecture(spec) &&
 438         objfile_ap->SetModulesArchitecture(spec))
 439       return objfile_ap.release();
 440   }
 441
 442   return NULL;
 443 }
 444
 445 ObjectFile *ObjectFileELF::CreateMemoryInstance(
 446     const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
 447     const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
 448   if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
 449     const uint8_t *magic = data_sp->GetBytes();
 450     if (ELFHeader::MagicBytesMatch(magic)) {
 451       unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
 452       if (address_size == 4 || address_size == 8) {
 453         std::unique_ptr<ObjectFileELF> objfile_ap(
 454             new ObjectFileELF(module_sp, data_sp, process_sp, header_addr));
 455         ArchSpec spec;
 456         if (objfile_ap->GetArchitecture(spec) &&
 457             objfile_ap->SetModulesArchitecture(spec))
 458           return objfile_ap.release();
 459       }
 460     }
 461   }
 462   return NULL;
 463 }
 464
 465 bool ObjectFileELF::MagicBytesMatch(DataBufferSP &data_sp,
 466                                     lldb::addr_t data_offset,
 467                                     lldb::addr_t data_length) {
 468   if (data_sp &&
 469       data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
 470     const uint8_t *magic = data_sp->GetBytes() + data_offset;
 471     return ELFHeader::MagicBytesMatch(magic);
 472   }
 473   return false;
 474 }
 475
 476 /*
 477  * crc function from http://svnweb.freebsd.org/base/head/sys/libkern/crc32.c
 478  *
 479  *   COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
 480  *   code or tables extracted from it, as desired without restriction.
 481  */
 482 static uint32_t calc_crc32(uint32_t crc, const void *buf, size_t size) {
 483   static const uint32_t g_crc32_tab[] = {
 484       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
 485       0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
 486       0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
 487       0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
 488       0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 489       0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
 490       0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
 491       0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
 492       0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
 493       0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 494       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
 495       0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
 496       0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
 497       0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
 498       0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 499       0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
 500       0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
 501       0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
 502       0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
 503       0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 504       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
 505       0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
 506       0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
 507       0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
 508       0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 509       0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
 510       0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
 511       0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
 512       0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
 513       0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 514       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
 515       0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
 516       0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
 517       0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
 518       0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 519       0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
 520       0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
 521       0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
 522       0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
 523       0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 524       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
 525       0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 526       0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
 527   const uint8_t *p = (const uint8_t *)buf;
 528
 529   crc = crc ^ ~0U;
 530   while (size--)
 531     crc = g_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
 532   return crc ^ ~0U;
 533 }
 534
 535 static uint32_t calc_gnu_debuglink_crc32(const void *buf, size_t size) {
 536   return calc_crc32(0U, buf, size);
 537 }
 538
 539 uint32_t ObjectFileELF::CalculateELFNotesSegmentsCRC32(
 540     const ProgramHeaderColl &program_headers, DataExtractor &object_data) {
 541   typedef ProgramHeaderCollConstIter Iter;
 542
 543   uint32_t core_notes_crc = 0;
 544
 545   for (Iter I = program_headers.begin(); I != program_headers.end(); ++I) {
 546     if (I->p_type == llvm::ELF::PT_NOTE) {
 547       const elf_off ph_offset = I->p_offset;
 548       const size_t ph_size = I->p_filesz;
 549
 550       DataExtractor segment_data;
 551       if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) {
 552         // The ELF program header contained incorrect data, probably corefile
 553         // is incomplete or corrupted.
 554         break;
 555       }
 556
 557       core_notes_crc = calc_crc32(core_notes_crc, segment_data.GetDataStart(),
 558                                   segment_data.GetByteSize());
 559     }
 560   }
 561
 562   return core_notes_crc;
 563 }
 564
 565 static const char *OSABIAsCString(unsigned char osabi_byte) {
 566 #define _MAKE_OSABI_CASE(x)                                                    \
 567   case x:                                                                      \
 568     return #x
 569   switch (osabi_byte) {
 570     _MAKE_OSABI_CASE(ELFOSABI_NONE);
 571     _MAKE_OSABI_CASE(ELFOSABI_HPUX);
 572     _MAKE_OSABI_CASE(ELFOSABI_NETBSD);
 573     _MAKE_OSABI_CASE(ELFOSABI_GNU);
 574     _MAKE_OSABI_CASE(ELFOSABI_HURD);
 575     _MAKE_OSABI_CASE(ELFOSABI_SOLARIS);
 576     _MAKE_OSABI_CASE(ELFOSABI_AIX);
 577     _MAKE_OSABI_CASE(ELFOSABI_IRIX);
 578     _MAKE_OSABI_CASE(ELFOSABI_FREEBSD);
 579     _MAKE_OSABI_CASE(ELFOSABI_TRU64);
 580     _MAKE_OSABI_CASE(ELFOSABI_MODESTO);
 581     _MAKE_OSABI_CASE(ELFOSABI_OPENBSD);
 582     _MAKE_OSABI_CASE(ELFOSABI_OPENVMS);
 583     _MAKE_OSABI_CASE(ELFOSABI_NSK);
 584     _MAKE_OSABI_CASE(ELFOSABI_AROS);
 585     _MAKE_OSABI_CASE(ELFOSABI_FENIXOS);
 586     _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI);
 587     _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX);
 588     _MAKE_OSABI_CASE(ELFOSABI_ARM);
 589     _MAKE_OSABI_CASE(ELFOSABI_STANDALONE);
 590   default:
 591     return "<unknown-osabi>";
 592   }
 593 #undef _MAKE_OSABI_CASE
 594 }
 595
 596 //
 597 // WARNING : This function is being deprecated
 598 // It's functionality has moved to ArchSpec::SetArchitecture This function is
 599 // only being kept to validate the move.
 600 //
 601 // TODO : Remove this function
 602 static bool GetOsFromOSABI(unsigned char osabi_byte,
 603                            llvm::Triple::OSType &ostype) {
 604   switch (osabi_byte) {
 605   case ELFOSABI_AIX:
 606     ostype = llvm::Triple::OSType::AIX;
 607     break;
 608   case ELFOSABI_FREEBSD:
 609     ostype = llvm::Triple::OSType::FreeBSD;
 610     break;
 611   case ELFOSABI_GNU:
 612     ostype = llvm::Triple::OSType::Linux;
 613     break;
 614   case ELFOSABI_NETBSD:
 615     ostype = llvm::Triple::OSType::NetBSD;
 616     break;
 617   case ELFOSABI_OPENBSD:
 618     ostype = llvm::Triple::OSType::OpenBSD;
 619     break;
 620   case ELFOSABI_SOLARIS:
 621     ostype = llvm::Triple::OSType::Solaris;
 622     break;
 623   default:
 624     ostype = llvm::Triple::OSType::UnknownOS;
 625   }
 626   return ostype != llvm::Triple::OSType::UnknownOS;
 627 }
 628
 629 size_t ObjectFileELF::GetModuleSpecifications(
 630     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
 631     lldb::offset_t data_offset, lldb::offset_t file_offset,
 632     lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
 633   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
 634
 635   const size_t initial_count = specs.GetSize();
 636
 637   if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
 638     DataExtractor data;
 639     data.SetData(data_sp);
 640     elf::ELFHeader header;
 641     lldb::offset_t header_offset = data_offset;
 642     if (header.Parse(data, &header_offset)) {
 643       if (data_sp) {
 644         ModuleSpec spec(file);
 645
 646         const uint32_t sub_type = subTypeFromElfHeader(header);
 647         spec.GetArchitecture().SetArchitecture(
 648             eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]);
 649
 650         if (spec.GetArchitecture().IsValid()) {
 651           llvm::Triple::OSType ostype;
 652           llvm::Triple::VendorType vendor;
 653           llvm::Triple::OSType spec_ostype =
 654               spec.GetArchitecture().GetTriple().getOS();
 655
 656           if (log)
 657             log->Printf("ObjectFileELF::%s file '%s' module OSABI: %s",
 658                         __FUNCTION__, file.GetPath().c_str(),
 659                         OSABIAsCString(header.e_ident[EI_OSABI]));
 660
 661           // SetArchitecture should have set the vendor to unknown
 662           vendor = spec.GetArchitecture().GetTriple().getVendor();
 663           assert(vendor == llvm::Triple::UnknownVendor);
 664           UNUSED_IF_ASSERT_DISABLED(vendor);
 665
 666           //
 667           // Validate it is ok to remove GetOsFromOSABI
 668           GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
 669           assert(spec_ostype == ostype);
 670           if (spec_ostype != llvm::Triple::OSType::UnknownOS) {
 671             if (log)
 672               log->Printf("ObjectFileELF::%s file '%s' set ELF module OS type "
 673                           "from ELF header OSABI.",
 674                           __FUNCTION__, file.GetPath().c_str());
 675           }
 676
 677           data_sp = MapFileData(file, -1, file_offset);
 678           if (data_sp)
 679             data.SetData(data_sp);
 680           // In case there is header extension in the section #0, the header we
 681           // parsed above could have sentinel values for e_phnum, e_shnum, and
 682           // e_shstrndx.  In this case we need to reparse the header with a
 683           // bigger data source to get the actual values.
 684           if (header.HasHeaderExtension()) {
 685             lldb::offset_t header_offset = data_offset;
 686             header.Parse(data, &header_offset);
 687           }
 688
 689           uint32_t gnu_debuglink_crc = 0;
 690           std::string gnu_debuglink_file;
 691           SectionHeaderColl section_headers;
 692           lldb_private::UUID &uuid = spec.GetUUID();
 693
 694           GetSectionHeaderInfo(section_headers, data, header, uuid,
 695                                gnu_debuglink_file, gnu_debuglink_crc,
 696                                spec.GetArchitecture());
 697
 698           llvm::Triple &spec_triple = spec.GetArchitecture().GetTriple();
 699
 700           if (log)
 701             log->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
 702                         "(architecture %s)",
 703                         __FUNCTION__, file.GetPath().c_str(),
 704                         spec_triple.getTriple().c_str(),
 705                         spec.GetArchitecture().GetArchitectureName());
 706
 707           if (!uuid.IsValid()) {
 708             uint32_t core_notes_crc = 0;
 709
 710             if (!gnu_debuglink_crc) {
 711               static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
 712               lldb_private::Timer scoped_timer(
 713                   func_cat,
 714                   "Calculating module crc32 %s with size %" PRIu64 " KiB",
 715                   file.GetLastPathComponent().AsCString(),
 716                   (file.GetByteSize() - file_offset) / 1024);
 717
 718               // For core files - which usually don't happen to have a
 719               // gnu_debuglink, and are pretty bulky - calculating whole
 720               // contents crc32 would be too much of luxury.  Thus we will need
 721               // to fallback to something simpler.
 722               if (header.e_type == llvm::ELF::ET_CORE) {
 723                 ProgramHeaderColl program_headers;
 724                 GetProgramHeaderInfo(program_headers, data, header);
 725
 726                 core_notes_crc =
 727                     CalculateELFNotesSegmentsCRC32(program_headers, data);
 728               } else {
 729                 gnu_debuglink_crc = calc_gnu_debuglink_crc32(
 730                     data.GetDataStart(), data.GetByteSize());
 731               }
 732             }
 733             using u32le = llvm::support::ulittle32_t;
 734             if (gnu_debuglink_crc) {
 735               // Use 4 bytes of crc from the .gnu_debuglink section.
 736               u32le data(gnu_debuglink_crc);
 737               uuid = UUID::fromData(&data, sizeof(data));
 738             } else if (core_notes_crc) {
 739               // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make
 740               // it look different form .gnu_debuglink crc followed by 4 bytes
 741               // of note segments crc.
 742               u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
 743               uuid = UUID::fromData(data, sizeof(data));
 744             }
 745           }
 746
 747           specs.Append(spec);
 748         }
 749       }
 750     }
 751   }
 752
 753   return specs.GetSize() - initial_count;
 754 }
 755
 756 //------------------------------------------------------------------
 757 // PluginInterface protocol
 758 //------------------------------------------------------------------
 759 lldb_private::ConstString ObjectFileELF::GetPluginName() {
 760   return GetPluginNameStatic();
 761 }
 762
 763 uint32_t ObjectFileELF::GetPluginVersion() { return m_plugin_version; }
 764 //------------------------------------------------------------------
 765 // ObjectFile protocol
 766 //------------------------------------------------------------------
 767
 768 ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
 769                              DataBufferSP &data_sp, lldb::offset_t data_offset,
 770                              const FileSpec *file, lldb::offset_t file_offset,
 771                              lldb::offset_t length)
 772     : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
 773       m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0),
 774       m_program_headers(), m_section_headers(), m_dynamic_symbols(),
 775       m_filespec_ap(), m_entry_point_address(), m_arch_spec() {
 776   if (file)
 777     m_file = *file;
 778   ::memset(&m_header, 0, sizeof(m_header));
 779 }
 780
 781 ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
 782                              DataBufferSP &header_data_sp,
 783                              const lldb::ProcessSP &process_sp,
 784                              addr_t header_addr)
 785     : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
 786       m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0),
 787       m_program_headers(), m_section_headers(), m_dynamic_symbols(),
 788       m_filespec_ap(), m_entry_point_address(), m_arch_spec() {
 789   ::memset(&m_header, 0, sizeof(m_header));
 790 }
 791
 792 ObjectFileELF::~ObjectFileELF() {}
 793
 794 bool ObjectFileELF::IsExecutable() const {
 795   return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0);
 796 }
 797
 798 bool ObjectFileELF::SetLoadAddress(Target &target, lldb::addr_t value,
 799                                    bool value_is_offset) {
 800   ModuleSP module_sp = GetModule();
 801   if (module_sp) {
 802     size_t num_loaded_sections = 0;
 803     SectionList *section_list = GetSectionList();
 804     if (section_list) {
 805       if (!value_is_offset) {
 806         bool found_offset = false;
 807         for (size_t i = 1, count = GetProgramHeaderCount(); i <= count; ++i) {
 808           const elf::ELFProgramHeader *header = GetProgramHeaderByIndex(i);
 809           if (header == nullptr)
 810             continue;
 811
 812           if (header->p_type != PT_LOAD || header->p_offset != 0)
 813             continue;
 814
 815           value = value - header->p_vaddr;
 816           found_offset = true;
 817           break;
 818         }
 819         if (!found_offset)
 820           return false;
 821       }
 822
 823       const size_t num_sections = section_list->GetSize();
 824       size_t sect_idx = 0;
 825
 826       for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
 827         // Iterate through the object file sections to find all of the sections
 828         // that have SHF_ALLOC in their flag bits.
 829         SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
 830         if (section_sp && section_sp->Test(SHF_ALLOC)) {
 831           lldb::addr_t load_addr = section_sp->GetFileAddress();
 832           // We don't want to update the load address of a section with type
 833           // eSectionTypeAbsoluteAddress as they already have the absolute load
 834           // address already specified
 835           if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
 836             load_addr += value;
 837
 838           // On 32-bit systems the load address have to fit into 4 bytes. The
 839           // rest of the bytes are the overflow from the addition.
 840           if (GetAddressByteSize() == 4)
 841             load_addr &= 0xFFFFFFFF;
 842
 843           if (target.GetSectionLoadList().SetSectionLoadAddress(section_sp,
 844                                                                 load_addr))
 845             ++num_loaded_sections;
 846         }
 847       }
 848       return num_loaded_sections > 0;
 849     }
 850   }
 851   return false;
 852 }
 853
 854 ByteOrder ObjectFileELF::GetByteOrder() const {
 855   if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
 856     return eByteOrderBig;
 857   if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
 858     return eByteOrderLittle;
 859   return eByteOrderInvalid;
 860 }
 861
 862 uint32_t ObjectFileELF::GetAddressByteSize() const {
 863   return m_data.GetAddressByteSize();
 864 }
 865
 866 AddressClass ObjectFileELF::GetAddressClass(addr_t file_addr) {
 867   Symtab *symtab = GetSymtab();
 868   if (!symtab)
 869     return AddressClass::eUnknown;
 870
 871   // The address class is determined based on the symtab. Ask it from the
 872   // object file what contains the symtab information.
 873   ObjectFile *symtab_objfile = symtab->GetObjectFile();
 874   if (symtab_objfile != nullptr && symtab_objfile != this)
 875     return symtab_objfile->GetAddressClass(file_addr);
 876
 877   auto res = ObjectFile::GetAddressClass(file_addr);
 878   if (res != AddressClass::eCode)
 879     return res;
 880
 881   auto ub = m_address_class_map.upper_bound(file_addr);
 882   if (ub == m_address_class_map.begin()) {
 883     // No entry in the address class map before the address. Return default
 884     // address class for an address in a code section.
 885     return AddressClass::eCode;
 886   }
 887
 888   // Move iterator to the address class entry preceding address
 889   --ub;
 890
 891   return ub->second;
 892 }
 893
 894 size_t ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) {
 895   return std::distance(m_section_headers.begin(), I) + 1u;
 896 }
 897
 898 size_t ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const {
 899   return std::distance(m_section_headers.begin(), I) + 1u;
 900 }
 901
 902 bool ObjectFileELF::ParseHeader() {
 903   lldb::offset_t offset = 0;
 904   return m_header.Parse(m_data, &offset);
 905 }
 906
 907 bool ObjectFileELF::GetUUID(lldb_private::UUID *uuid) {
 908   // Need to parse the section list to get the UUIDs, so make sure that's been
 909   // done.
 910   if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile)
 911     return false;
 912
 913   using u32le = llvm::support::ulittle32_t;
 914   if (m_uuid.IsValid()) {
 915     // We have the full build id uuid.
 916     *uuid = m_uuid;
 917     return true;
 918   } else if (GetType() == ObjectFile::eTypeCoreFile) {
 919     uint32_t core_notes_crc = 0;
 920
 921     if (!ParseProgramHeaders())
 922       return false;
 923
 924     core_notes_crc = CalculateELFNotesSegmentsCRC32(m_program_headers, m_data);
 925
 926     if (core_notes_crc) {
 927       // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it look
 928       // different form .gnu_debuglink crc - followed by 4 bytes of note
 929       // segments crc.
 930       u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
 931       m_uuid = UUID::fromData(data, sizeof(data));
 932     }
 933   } else {
 934     if (!m_gnu_debuglink_crc)
 935       m_gnu_debuglink_crc =
 936           calc_gnu_debuglink_crc32(m_data.GetDataStart(), m_data.GetByteSize());
 937     if (m_gnu_debuglink_crc) {
 938       // Use 4 bytes of crc from the .gnu_debuglink section.
 939       u32le data(m_gnu_debuglink_crc);
 940       m_uuid = UUID::fromData(&data, sizeof(data));
 941     }
 942   }
 943
 944   if (m_uuid.IsValid()) {
 945     *uuid = m_uuid;
 946     return true;
 947   }
 948
 949   return false;
 950 }
 951
 952 lldb_private::FileSpecList ObjectFileELF::GetDebugSymbolFilePaths() {
 953   FileSpecList file_spec_list;
 954
 955   if (!m_gnu_debuglink_file.empty()) {
 956     FileSpec file_spec(m_gnu_debuglink_file, false);
 957     file_spec_list.Append(file_spec);
 958   }
 959   return file_spec_list;
 960 }
 961
 962 uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) {
 963   size_t num_modules = ParseDependentModules();
 964   uint32_t num_specs = 0;
 965
 966   for (unsigned i = 0; i < num_modules; ++i) {
 967     if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i)))
 968       num_specs++;
 969   }
 970
 971   return num_specs;
 972 }
 973
 974 Address ObjectFileELF::GetImageInfoAddress(Target *target) {
 975   if (!ParseDynamicSymbols())
 976     return Address();
 977
 978   SectionList *section_list = GetSectionList();
 979   if (!section_list)
 980     return Address();
 981
 982   // Find the SHT_DYNAMIC (.dynamic) section.
 983   SectionSP dynsym_section_sp(
 984       section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true));
 985   if (!dynsym_section_sp)
 986     return Address();
 987   assert(dynsym_section_sp->GetObjectFile() == this);
 988
 989   user_id_t dynsym_id = dynsym_section_sp->GetID();
 990   const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id);
 991   if (!dynsym_hdr)
 992     return Address();
 993
 994   for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) {
 995     ELFDynamic &symbol = m_dynamic_symbols[i];
 996
 997     if (symbol.d_tag == DT_DEBUG) {
 998       // Compute the offset as the number of previous entries plus the size of
 999       // d_tag.
1000       addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
1001       return Address(dynsym_section_sp, offset);
1002     }
1003     // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP
1004     // exists in non-PIE.
1005     else if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
1006               symbol.d_tag == DT_MIPS_RLD_MAP_REL) &&
1007              target) {
1008       addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
1009       addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
1010       if (dyn_base == LLDB_INVALID_ADDRESS)
1011         return Address();
1012
1013       Status error;
1014       if (symbol.d_tag == DT_MIPS_RLD_MAP) {
1015         // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer.
1016         Address addr;
1017         if (target->ReadPointerFromMemory(dyn_base + offset, false, error,
1018                                           addr))
1019           return addr;
1020       }
1021       if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) {
1022         // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer,
1023         // relative to the address of the tag.
1024         uint64_t rel_offset;
1025         rel_offset = target->ReadUnsignedIntegerFromMemory(
1026             dyn_base + offset, false, GetAddressByteSize(), UINT64_MAX, error);
1027         if (error.Success() && rel_offset != UINT64_MAX) {
1028           Address addr;
1029           addr_t debug_ptr_address =
1030               dyn_base + (offset - GetAddressByteSize()) + rel_offset;
1031           addr.SetOffset(debug_ptr_address);
1032           return addr;
1033         }
1034       }
1035     }
1036   }
1037
1038   return Address();
1039 }
1040
1041 lldb_private::Address ObjectFileELF::GetEntryPointAddress() {
1042   if (m_entry_point_address.IsValid())
1043     return m_entry_point_address;
1044
1045   if (!ParseHeader() || !IsExecutable())
1046     return m_entry_point_address;
1047
1048   SectionList *section_list = GetSectionList();
1049   addr_t offset = m_header.e_entry;
1050
1051   if (!section_list)
1052     m_entry_point_address.SetOffset(offset);
1053   else
1054     m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list);
1055   return m_entry_point_address;
1056 }
1057
1058 //----------------------------------------------------------------------
1059 // ParseDependentModules
1060 //----------------------------------------------------------------------
1061 size_t ObjectFileELF::ParseDependentModules() {
1062   if (m_filespec_ap.get())
1063     return m_filespec_ap->GetSize();
1064
1065   m_filespec_ap.reset(new FileSpecList());
1066
1067   if (!ParseSectionHeaders())
1068     return 0;
1069
1070   SectionList *section_list = GetSectionList();
1071   if (!section_list)
1072     return 0;
1073
1074   // Find the SHT_DYNAMIC section.
1075   Section *dynsym =
1076       section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
1077           .get();
1078   if (!dynsym)
1079     return 0;
1080   assert(dynsym->GetObjectFile() == this);
1081
1082   const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex(dynsym->GetID());
1083   if (!header)
1084     return 0;
1085   // sh_link: section header index of string table used by entries in the
1086   // section.
1087   Section *dynstr = section_list->FindSectionByID(header->sh_link + 1).get();
1088   if (!dynstr)
1089     return 0;
1090
1091   DataExtractor dynsym_data;
1092   DataExtractor dynstr_data;
1093   if (ReadSectionData(dynsym, dynsym_data) &&
1094       ReadSectionData(dynstr, dynstr_data)) {
1095     ELFDynamic symbol;
1096     const lldb::offset_t section_size = dynsym_data.GetByteSize();
1097     lldb::offset_t offset = 0;
1098
1099     // The only type of entries we are concerned with are tagged DT_NEEDED,
1100     // yielding the name of a required library.
1101     while (offset < section_size) {
1102       if (!symbol.Parse(dynsym_data, &offset))
1103         break;
1104
1105       if (symbol.d_tag != DT_NEEDED)
1106         continue;
1107
1108       uint32_t str_index = static_cast<uint32_t>(symbol.d_val);
1109       const char *lib_name = dynstr_data.PeekCStr(str_index);
1110       m_filespec_ap->Append(FileSpec(lib_name, true));
1111     }
1112   }
1113
1114   return m_filespec_ap->GetSize();
1115 }
1116
1117 //----------------------------------------------------------------------
1118 // GetProgramHeaderInfo
1119 //----------------------------------------------------------------------
1120 size_t ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
1121                                            DataExtractor &object_data,
1122                                            const ELFHeader &header) {
1123   // We have already parsed the program headers
1124   if (!program_headers.empty())
1125     return program_headers.size();
1126
1127   // If there are no program headers to read we are done.
1128   if (header.e_phnum == 0)
1129     return 0;
1130
1131   program_headers.resize(header.e_phnum);
1132   if (program_headers.size() != header.e_phnum)
1133     return 0;
1134
1135   const size_t ph_size = header.e_phnum * header.e_phentsize;
1136   const elf_off ph_offset = header.e_phoff;
1137   DataExtractor data;
1138   if (data.SetData(object_data, ph_offset, ph_size) != ph_size)
1139     return 0;
1140
1141   uint32_t idx;
1142   lldb::offset_t offset;
1143   for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) {
1144     if (program_headers[idx].Parse(data, &offset) == false)
1145       break;
1146   }
1147
1148   if (idx < program_headers.size())
1149     program_headers.resize(idx);
1150
1151   return program_headers.size();
1152 }
1153
1154 //----------------------------------------------------------------------
1155 // ParseProgramHeaders
1156 //----------------------------------------------------------------------
1157 size_t ObjectFileELF::ParseProgramHeaders() {
1158   return GetProgramHeaderInfo(m_program_headers, m_data, m_header);
1159 }
1160
1161 lldb_private::Status
1162 ObjectFileELF::RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
1163                                            lldb_private::ArchSpec &arch_spec,
1164                                            lldb_private::UUID &uuid) {
1165   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
1166   Status error;
1167
1168   lldb::offset_t offset = 0;
1169
1170   while (true) {
1171     // Parse the note header.  If this fails, bail out.
1172     const lldb::offset_t note_offset = offset;
1173     ELFNote note = ELFNote();
1174     if (!note.Parse(data, &offset)) {
1175       // We're done.
1176       return error;
1177     }
1178
1179     if (log)
1180       log->Printf("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32,
1181                   __FUNCTION__, note.n_name.c_str(), note.n_type);
1182
1183     // Process FreeBSD ELF notes.
1184     if ((note.n_name == LLDB_NT_OWNER_FREEBSD) &&
1185         (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) &&
1186         (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) {
1187       // Pull out the min version info.
1188       uint32_t version_info;
1189       if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1190         error.SetErrorString("failed to read FreeBSD ABI note payload");
1191         return error;
1192       }
1193
1194       // Convert the version info into a major/minor number.
1195       const uint32_t version_major = version_info / 100000;
1196       const uint32_t version_minor = (version_info / 1000) % 100;
1197
1198       char os_name[32];
1199       snprintf(os_name, sizeof(os_name), "freebsd%" PRIu32 ".%" PRIu32,
1200                version_major, version_minor);
1201
1202       // Set the elf OS version to FreeBSD.  Also clear the vendor.
1203       arch_spec.GetTriple().setOSName(os_name);
1204       arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1205
1206       if (log)
1207         log->Printf("ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32
1208                     ".%" PRIu32,
1209                     __FUNCTION__, version_major, version_minor,
1210                     static_cast<uint32_t>(version_info % 1000));
1211     }
1212     // Process GNU ELF notes.
1213     else if (note.n_name == LLDB_NT_OWNER_GNU) {
1214       switch (note.n_type) {
1215       case LLDB_NT_GNU_ABI_TAG:
1216         if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) {
1217           // Pull out the min OS version supporting the ABI.
1218           uint32_t version_info[4];
1219           if (data.GetU32(&offset, &version_info[0], note.n_descsz / 4) ==
1220               nullptr) {
1221             error.SetErrorString("failed to read GNU ABI note payload");
1222             return error;
1223           }
1224
1225           // Set the OS per the OS field.
1226           switch (version_info[0]) {
1227           case LLDB_NT_GNU_ABI_OS_LINUX:
1228             arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1229             arch_spec.GetTriple().setVendor(
1230                 llvm::Triple::VendorType::UnknownVendor);
1231             if (log)
1232               log->Printf(
1233                   "ObjectFileELF::%s detected Linux, min version %" PRIu32
1234                   ".%" PRIu32 ".%" PRIu32,
1235                   __FUNCTION__, version_info[1], version_info[2],
1236                   version_info[3]);
1237             // FIXME we have the minimal version number, we could be propagating
1238             // that.  version_info[1] = OS Major, version_info[2] = OS Minor,
1239             // version_info[3] = Revision.
1240             break;
1241           case LLDB_NT_GNU_ABI_OS_HURD:
1242             arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1243             arch_spec.GetTriple().setVendor(
1244                 llvm::Triple::VendorType::UnknownVendor);
1245             if (log)
1246               log->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
1247                           "version %" PRIu32 ".%" PRIu32 ".%" PRIu32,
1248                           __FUNCTION__, version_info[1], version_info[2],
1249                           version_info[3]);
1250             break;
1251           case LLDB_NT_GNU_ABI_OS_SOLARIS:
1252             arch_spec.GetTriple().setOS(llvm::Triple::OSType::Solaris);
1253             arch_spec.GetTriple().setVendor(
1254                 llvm::Triple::VendorType::UnknownVendor);
1255             if (log)
1256               log->Printf(
1257                   "ObjectFileELF::%s detected Solaris, min version %" PRIu32
1258                   ".%" PRIu32 ".%" PRIu32,
1259                   __FUNCTION__, version_info[1], version_info[2],
1260                   version_info[3]);
1261             break;
1262           default:
1263             if (log)
1264               log->Printf(
1265                   "ObjectFileELF::%s unrecognized OS in note, id %" PRIu32
1266                   ", min version %" PRIu32 ".%" PRIu32 ".%" PRIu32,
1267                   __FUNCTION__, version_info[0], version_info[1],
1268                   version_info[2], version_info[3]);
1269             break;
1270           }
1271         }
1272         break;
1273
1274       case LLDB_NT_GNU_BUILD_ID_TAG:
1275         // Only bother processing this if we don't already have the uuid set.
1276         if (!uuid.IsValid()) {
1277           // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a
1278           // build-id of a different length. Accept it as long as it's at least
1279           // 4 bytes as it will be better than our own crc32.
1280           if (note.n_descsz >= 4) {
1281             if (const uint8_t *buf = data.PeekData(offset, note.n_descsz)) {
1282               // Save the build id as the UUID for the module.
1283               uuid = UUID::fromData(buf, note.n_descsz);
1284             } else {
1285               error.SetErrorString("failed to read GNU_BUILD_ID note payload");
1286               return error;
1287             }
1288           }
1289         }
1290         break;
1291       }
1292       if (arch_spec.IsMIPS() &&
1293           arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1294         // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux platform
1295         arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1296     }
1297     // Process NetBSD ELF notes.
1298     else if ((note.n_name == LLDB_NT_OWNER_NETBSD) &&
1299              (note.n_type == LLDB_NT_NETBSD_ABI_TAG) &&
1300              (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) {
1301       // Pull out the min version info.
1302       uint32_t version_info;
1303       if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1304         error.SetErrorString("failed to read NetBSD ABI note payload");
1305         return error;
1306       }
1307
1308       // Set the elf OS version to NetBSD.  Also clear the vendor.
1309       arch_spec.GetTriple().setOS(llvm::Triple::OSType::NetBSD);
1310       arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1311
1312       if (log)
1313         log->Printf(
1314             "ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32,
1315             __FUNCTION__, version_info);
1316     }
1317     // Process OpenBSD ELF notes.
1318     else if (note.n_name == LLDB_NT_OWNER_OPENBSD) {
1319       // Set the elf OS version to OpenBSD.  Also clear the vendor.
1320       arch_spec.GetTriple().setOS(llvm::Triple::OSType::OpenBSD);
1321       arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1322     }
1323     // Process CSR kalimba notes
1324     else if ((note.n_type == LLDB_NT_GNU_ABI_TAG) &&
1325              (note.n_name == LLDB_NT_OWNER_CSR)) {
1326       arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1327       arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::CSR);
1328
1329       // TODO At some point the description string could be processed.
1330       // It could provide a steer towards the kalimba variant which this ELF
1331       // targets.
1332       if (note.n_descsz) {
1333         const char *cstr =
1334             data.GetCStr(&offset, llvm::alignTo(note.n_descsz, 4));
1335         (void)cstr;
1336       }
1337     } else if (note.n_name == LLDB_NT_OWNER_ANDROID) {
1338       arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1339       arch_spec.GetTriple().setEnvironment(
1340           llvm::Triple::EnvironmentType::Android);
1341     } else if (note.n_name == LLDB_NT_OWNER_LINUX) {
1342       // This is sometimes found in core files and usually contains extended
1343       // register info
1344       arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1345     } else if (note.n_name == LLDB_NT_OWNER_CORE) {
1346       // Parse the NT_FILE to look for stuff in paths to shared libraries As
1347       // the contents look like this in a 64 bit ELF core file: count     =
1348       // 0x000000000000000a (10) page_size = 0x0000000000001000 (4096) Index
1349       // start              end                file_ofs           path =====
1350       // ------------------ ------------------ ------------------
1351       // ------------------------------------- [  0] 0x0000000000400000
1352       // 0x0000000000401000 0x0000000000000000 /tmp/a.out [  1]
1353       // 0x0000000000600000 0x0000000000601000 0x0000000000000000 /tmp/a.out [
1354       // 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001 /tmp/a.out
1355       // [  3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000
1356       // /lib/x86_64-linux-gnu/libc-2.19.so [  4] 0x00007fa79cba8000
1357       // 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux-
1358       // gnu/libc-2.19.so [  5] 0x00007fa79cda7000 0x00007fa79cdab000
1359       // 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so [  6]
1360       // 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be /lib/x86_64
1361       // -linux-gnu/libc-2.19.so [  7] 0x00007fa79cdb2000 0x00007fa79cdd5000
1362       // 0x0000000000000000 /lib/x86_64-linux-gnu/ld-2.19.so [  8]
1363       // 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022 /lib/x86_64
1364       // -linux-gnu/ld-2.19.so [  9] 0x00007fa79cfd5000 0x00007fa79cfd6000
1365       // 0x0000000000000023 /lib/x86_64-linux-gnu/ld-2.19.so In the 32 bit ELFs
1366       // the count, page_size, start, end, file_ofs are uint32_t For reference:
1367       // see readelf source code (in binutils).
1368       if (note.n_type == NT_FILE) {
1369         uint64_t count = data.GetAddress(&offset);
1370         const char *cstr;
1371         data.GetAddress(&offset); // Skip page size
1372         offset += count * 3 *
1373                   data.GetAddressByteSize(); // Skip all start/end/file_ofs
1374         for (size_t i = 0; i < count; ++i) {
1375           cstr = data.GetCStr(&offset);
1376           if (cstr == nullptr) {
1377             error.SetErrorStringWithFormat("ObjectFileELF::%s trying to read "
1378                                            "at an offset after the end "
1379                                            "(GetCStr returned nullptr)",
1380                                            __FUNCTION__);
1381             return error;
1382           }
1383           llvm::StringRef path(cstr);
1384           if (path.contains("/lib/x86_64-linux-gnu") || path.contains("/lib/i386-linux-gnu")) {
1385             arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1386             break;
1387           }
1388         }
1389         if (arch_spec.IsMIPS() &&
1390             arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1391           // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing for some
1392           // cases (e.g. compile with -nostdlib) Hence set OS to Linux
1393           arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1394       }
1395     }
1396
1397     // Calculate the offset of the next note just in case "offset" has been
1398     // used to poke at the contents of the note data
1399     offset = note_offset + note.GetByteSize();
1400   }
1401
1402   return error;
1403 }
1404
1405 void ObjectFileELF::ParseARMAttributes(DataExtractor &data, uint64_t length,
1406                                        ArchSpec &arch_spec) {
1407   lldb::offset_t Offset = 0;
1408
1409   uint8_t FormatVersion = data.GetU8(&Offset);
1410   if (FormatVersion != llvm::ARMBuildAttrs::Format_Version)
1411     return;
1412
1413   Offset = Offset + sizeof(uint32_t); // Section Length
1414   llvm::StringRef VendorName = data.GetCStr(&Offset);
1415
1416   if (VendorName != "aeabi")
1417     return;
1418
1419   if (arch_spec.GetTriple().getEnvironment() ==
1420       llvm::Triple::UnknownEnvironment)
1421     arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);
1422
1423   while (Offset < length) {
1424     uint8_t Tag = data.GetU8(&Offset);
1425     uint32_t Size = data.GetU32(&Offset);
1426
1427     if (Tag != llvm::ARMBuildAttrs::File || Size == 0)
1428       continue;
1429
1430     while (Offset < length) {
1431       uint64_t Tag = data.GetULEB128(&Offset);
1432       switch (Tag) {
1433       default:
1434         if (Tag < 32)
1435           data.GetULEB128(&Offset);
1436         else if (Tag % 2 == 0)
1437           data.GetULEB128(&Offset);
1438         else
1439           data.GetCStr(&Offset);
1440
1441         break;
1442
1443       case llvm::ARMBuildAttrs::CPU_raw_name:
1444       case llvm::ARMBuildAttrs::CPU_name:
1445         data.GetCStr(&Offset);
1446
1447         break;
1448
1449       case llvm::ARMBuildAttrs::ABI_VFP_args: {
1450         uint64_t VFPArgs = data.GetULEB128(&Offset);
1451
1452         if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) {
1453           if (arch_spec.GetTriple().getEnvironment() ==
1454                   llvm::Triple::UnknownEnvironment ||
1455               arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABIHF)
1456             arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);
1457
1458           arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
1459         } else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) {
1460           if (arch_spec.GetTriple().getEnvironment() ==
1461                   llvm::Triple::UnknownEnvironment ||
1462               arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABI)
1463             arch_spec.GetTriple().setEnvironment(llvm::Triple::EABIHF);
1464
1465           arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
1466         }
1467
1468         break;
1469       }
1470       }
1471     }
1472   }
1473 }
1474
1475 //----------------------------------------------------------------------
1476 // GetSectionHeaderInfo
1477 //----------------------------------------------------------------------
1478 size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
1479                                            DataExtractor &object_data,
1480                                            const elf::ELFHeader &header,
1481                                            lldb_private::UUID &uuid,
1482                                            std::string &gnu_debuglink_file,
1483                                            uint32_t &gnu_debuglink_crc,
1484                                            ArchSpec &arch_spec) {
1485   // Don't reparse the section headers if we already did that.
1486   if (!section_headers.empty())
1487     return section_headers.size();
1488
1489   // Only initialize the arch_spec to okay defaults if they're not already set.
1490   // We'll refine this with note data as we parse the notes.
1491   if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
1492     llvm::Triple::OSType ostype;
1493     llvm::Triple::OSType spec_ostype;
1494     const uint32_t sub_type = subTypeFromElfHeader(header);
1495     arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type,
1496                               header.e_ident[EI_OSABI]);
1497
1498     // Validate if it is ok to remove GetOsFromOSABI. Note, that now the OS is
1499     // determined based on EI_OSABI flag and the info extracted from ELF notes
1500     // (see RefineModuleDetailsFromNote). However in some cases that still
1501     // might be not enough: for example a shared library might not have any
1502     // notes at all and have EI_OSABI flag set to System V, as result the OS
1503     // will be set to UnknownOS.
1504     GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
1505     spec_ostype = arch_spec.GetTriple().getOS();
1506     assert(spec_ostype == ostype);
1507     UNUSED_IF_ASSERT_DISABLED(spec_ostype);
1508   }
1509
1510   if (arch_spec.GetMachine() == llvm::Triple::mips ||
1511       arch_spec.GetMachine() == llvm::Triple::mipsel ||
1512       arch_spec.GetMachine() == llvm::Triple::mips64 ||
1513       arch_spec.GetMachine() == llvm::Triple::mips64el) {
1514     switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) {
1515     case llvm::ELF::EF_MIPS_MICROMIPS:
1516       arch_spec.SetFlags(ArchSpec::eMIPSAse_micromips);
1517       break;
1518     case llvm::ELF::EF_MIPS_ARCH_ASE_M16:
1519       arch_spec.SetFlags(ArchSpec::eMIPSAse_mips16);
1520       break;
1521     case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX:
1522       arch_spec.SetFlags(ArchSpec::eMIPSAse_mdmx);
1523       break;
1524     default:
1525       break;
1526     }
1527   }
1528
1529   if (arch_spec.GetMachine() == llvm::Triple::arm ||
1530       arch_spec.GetMachine() == llvm::Triple::thumb) {
1531     if (header.e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT)
1532       arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
1533     else if (header.e_flags & llvm::ELF::EF_ARM_VFP_FLOAT)
1534       arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
1535   }
1536
1537   // If there are no section headers we are done.
1538   if (header.e_shnum == 0)
1539     return 0;
1540
1541   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
1542
1543   section_headers.resize(header.e_shnum);
1544   if (section_headers.size() != header.e_shnum)
1545     return 0;
1546
1547   const size_t sh_size = header.e_shnum * header.e_shentsize;
1548   const elf_off sh_offset = header.e_shoff;
1549   DataExtractor sh_data;
1550   if (sh_data.SetData(object_data, sh_offset, sh_size) != sh_size)
1551     return 0;
1552
1553   uint32_t idx;
1554   lldb::offset_t offset;
1555   for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) {
1556     if (section_headers[idx].Parse(sh_data, &offset) == false)
1557       break;
1558   }
1559   if (idx < section_headers.size())
1560     section_headers.resize(idx);
1561
1562   const unsigned strtab_idx = header.e_shstrndx;
1563   if (strtab_idx && strtab_idx < section_headers.size()) {
1564     const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx];
1565     const size_t byte_size = sheader.sh_size;
1566     const Elf64_Off offset = sheader.sh_offset;
1567     lldb_private::DataExtractor shstr_data;
1568
1569     if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) {
1570       for (SectionHeaderCollIter I = section_headers.begin();
1571            I != section_headers.end(); ++I) {
1572         static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink");
1573         const ELFSectionHeaderInfo &sheader = *I;
1574         const uint64_t section_size =
1575             sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size;
1576         ConstString name(shstr_data.PeekCStr(I->sh_name));
1577
1578         I->section_name = name;
1579
1580         if (arch_spec.IsMIPS()) {
1581           uint32_t arch_flags = arch_spec.GetFlags();
1582           DataExtractor data;
1583           if (sheader.sh_type == SHT_MIPS_ABIFLAGS) {
1584
1585             if (section_size && (data.SetData(object_data, sheader.sh_offset,
1586                                               section_size) == section_size)) {
1587               // MIPS ASE Mask is at offset 12 in MIPS.abiflags section
1588               lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0
1589               arch_flags |= data.GetU32(&offset);
1590
1591               // The floating point ABI is at offset 7
1592               offset = 7;
1593               switch (data.GetU8(&offset)) {
1594               case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
1595                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_ANY;
1596                 break;
1597               case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
1598                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_DOUBLE;
1599                 break;
1600               case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
1601                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SINGLE;
1602                 break;
1603               case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
1604                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT;
1605                 break;
1606               case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
1607                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_OLD_64;
1608                 break;
1609               case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
1610                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_XX;
1611                 break;
1612               case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
1613                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64;
1614                 break;
1615               case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
1616                 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64A;
1617                 break;
1618               }
1619             }
1620           }
1621           // Settings appropriate ArchSpec ABI Flags
1622           switch (header.e_flags & llvm::ELF::EF_MIPS_ABI) {
1623           case llvm::ELF::EF_MIPS_ABI_O32:
1624             arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32;
1625             break;
1626           case EF_MIPS_ABI_O64:
1627             arch_flags |= lldb_private::ArchSpec::eMIPSABI_O64;
1628             break;
1629           case EF_MIPS_ABI_EABI32:
1630             arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI32;
1631             break;
1632           case EF_MIPS_ABI_EABI64:
1633             arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI64;
1634             break;
1635           default:
1636             // ABI Mask doesn't cover N32 and N64 ABI.
1637             if (header.e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64)
1638               arch_flags |= lldb_private::ArchSpec::eMIPSABI_N64;
1639             else if (header.e_flags & llvm::ELF::EF_MIPS_ABI2)
1640               arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32;
1641             break;
1642           }
1643           arch_spec.SetFlags(arch_flags);
1644         }
1645
1646         if (arch_spec.GetMachine() == llvm::Triple::arm ||
1647             arch_spec.GetMachine() == llvm::Triple::thumb) {
1648           DataExtractor data;
1649
1650           if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
1651               data.SetData(object_data, sheader.sh_offset, section_size) == section_size)
1652             ParseARMAttributes(data, section_size, arch_spec);
1653         }
1654
1655         if (name == g_sect_name_gnu_debuglink) {
1656           DataExtractor data;
1657           if (section_size && (data.SetData(object_data, sheader.sh_offset,
1658                                             section_size) == section_size)) {
1659             lldb::offset_t gnu_debuglink_offset = 0;
1660             gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset);
1661             gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
1662             data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
1663           }
1664         }
1665
1666         // Process ELF note section entries.
1667         bool is_note_header = (sheader.sh_type == SHT_NOTE);
1668
1669         // The section header ".note.android.ident" is stored as a
1670         // PROGBITS type header but it is actually a note header.
1671         static ConstString g_sect_name_android_ident(".note.android.ident");
1672         if (!is_note_header && name == g_sect_name_android_ident)
1673           is_note_header = true;
1674
1675         if (is_note_header) {
1676           // Allow notes to refine module info.
1677           DataExtractor data;
1678           if (section_size && (data.SetData(object_data, sheader.sh_offset,
1679                                             section_size) == section_size)) {
1680             Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid);
1681             if (error.Fail()) {
1682               if (log)
1683                 log->Printf("ObjectFileELF::%s ELF note processing failed: %s",
1684                             __FUNCTION__, error.AsCString());
1685             }
1686           }
1687         }
1688       }
1689
1690       // Make any unknown triple components to be unspecified unknowns.
1691       if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor)
1692         arch_spec.GetTriple().setVendorName(llvm::StringRef());
1693       if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS)
1694         arch_spec.GetTriple().setOSName(llvm::StringRef());
1695
1696       return section_headers.size();
1697     }
1698   }
1699
1700   section_headers.clear();
1701   return 0;
1702 }
1703
1704 size_t ObjectFileELF::GetProgramHeaderCount() { return ParseProgramHeaders(); }
1705
1706 const elf::ELFProgramHeader *
1707 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) {
1708   if (!id || !ParseProgramHeaders())
1709     return NULL;
1710
1711   if (--id < m_program_headers.size())
1712     return &m_program_headers[id];
1713
1714   return NULL;
1715 }
1716
1717 DataExtractor ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) {
1718   const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id);
1719   if (segment_header == NULL)
1720     return DataExtractor();
1721   return DataExtractor(m_data, segment_header->p_offset,
1722                        segment_header->p_filesz);
1723 }
1724
1725 llvm::StringRef
1726 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
1727   size_t pos = symbol_name.find('@');
1728   return symbol_name.substr(0, pos);
1729 }
1730
1731 //----------------------------------------------------------------------
1732 // ParseSectionHeaders
1733 //----------------------------------------------------------------------
1734 size_t ObjectFileELF::ParseSectionHeaders() {
1735   return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid,
1736                               m_gnu_debuglink_file, m_gnu_debuglink_crc,
1737                               m_arch_spec);
1738 }
1739
1740 const ObjectFileELF::ELFSectionHeaderInfo *
1741 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) {
1742   if (!id || !ParseSectionHeaders())
1743     return NULL;
1744
1745   if (--id < m_section_headers.size())
1746     return &m_section_headers[id];
1747
1748   return NULL;
1749 }
1750
1751 lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
1752   if (!name || !name[0] || !ParseSectionHeaders())
1753     return 0;
1754   for (size_t i = 1; i < m_section_headers.size(); ++i)
1755     if (m_section_headers[i].section_name == ConstString(name))
1756       return i;
1757   return 0;
1758 }
1759
1760 void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
1761   if (!m_sections_ap.get() && ParseSectionHeaders()) {
1762     m_sections_ap.reset(new SectionList());
1763
1764     // Object files frequently have 0 for every section address, meaning we
1765     // need to compute synthetic addresses in order for "file addresses" from
1766     // different sections to not overlap
1767     bool synthaddrs = (CalculateType() == ObjectFile::Type::eTypeObjectFile);
1768     uint64_t nextaddr = 0;
1769
1770     for (SectionHeaderCollIter I = m_section_headers.begin();
1771          I != m_section_headers.end(); ++I) {
1772       const ELFSectionHeaderInfo &header = *I;
1773
1774       ConstString &name = I->section_name;
1775       const uint64_t file_size =
1776           header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
1777       const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0;
1778
1779       static ConstString g_sect_name_text(".text");
1780       static ConstString g_sect_name_data(".data");
1781       static ConstString g_sect_name_bss(".bss");
1782       static ConstString g_sect_name_tdata(".tdata");
1783       static ConstString g_sect_name_tbss(".tbss");
1784       static ConstString g_sect_name_dwarf_debug_abbrev(".debug_abbrev");
1785       static ConstString g_sect_name_dwarf_debug_addr(".debug_addr");
1786       static ConstString g_sect_name_dwarf_debug_aranges(".debug_aranges");
1787       static ConstString g_sect_name_dwarf_debug_cu_index(".debug_cu_index");
1788       static ConstString g_sect_name_dwarf_debug_frame(".debug_frame");
1789       static ConstString g_sect_name_dwarf_debug_info(".debug_info");
1790       static ConstString g_sect_name_dwarf_debug_line(".debug_line");
1791       static ConstString g_sect_name_dwarf_debug_loc(".debug_loc");
1792       static ConstString g_sect_name_dwarf_debug_macinfo(".debug_macinfo");
1793       static ConstString g_sect_name_dwarf_debug_macro(".debug_macro");
1794       static ConstString g_sect_name_dwarf_debug_names(".debug_names");
1795       static ConstString g_sect_name_dwarf_debug_pubnames(".debug_pubnames");
1796       static ConstString g_sect_name_dwarf_debug_pubtypes(".debug_pubtypes");
1797       static ConstString g_sect_name_dwarf_debug_ranges(".debug_ranges");
1798       static ConstString g_sect_name_dwarf_debug_str(".debug_str");
1799       static ConstString g_sect_name_dwarf_debug_str_offsets(
1800           ".debug_str_offsets");
1801       static ConstString g_sect_name_dwarf_debug_abbrev_dwo(
1802           ".debug_abbrev.dwo");
1803       static ConstString g_sect_name_dwarf_debug_info_dwo(".debug_info.dwo");
1804       static ConstString g_sect_name_dwarf_debug_line_dwo(".debug_line.dwo");
1805       static ConstString g_sect_name_dwarf_debug_macro_dwo(".debug_macro.dwo");
1806       static ConstString g_sect_name_dwarf_debug_loc_dwo(".debug_loc.dwo");
1807       static ConstString g_sect_name_dwarf_debug_str_dwo(".debug_str.dwo");
1808       static ConstString g_sect_name_dwarf_debug_str_offsets_dwo(
1809           ".debug_str_offsets.dwo");
1810       static ConstString g_sect_name_dwarf_debug_types(".debug_types");
1811       static ConstString g_sect_name_eh_frame(".eh_frame");
1812       static ConstString g_sect_name_arm_exidx(".ARM.exidx");
1813       static ConstString g_sect_name_arm_extab(".ARM.extab");
1814       static ConstString g_sect_name_go_symtab(".gosymtab");
1815       static ConstString g_sect_name_dwarf_gnu_debugaltlink(".gnu_debugaltlink");
1816
1817       SectionType sect_type = eSectionTypeOther;
1818
1819       bool is_thread_specific = false;
1820
1821       if (name == g_sect_name_text)
1822         sect_type = eSectionTypeCode;
1823       else if (name == g_sect_name_data)
1824         sect_type = eSectionTypeData;
1825       else if (name == g_sect_name_bss)
1826         sect_type = eSectionTypeZeroFill;
1827       else if (name == g_sect_name_tdata) {
1828         sect_type = eSectionTypeData;
1829         is_thread_specific = true;
1830       } else if (name == g_sect_name_tbss) {
1831         sect_type = eSectionTypeZeroFill;
1832         is_thread_specific = true;
1833       }
1834       // .debug_abbrev – Abbreviations used in the .debug_info section
1835       // .debug_aranges – Lookup table for mapping addresses to compilation
1836       // units .debug_frame – Call frame information .debug_info – The core
1837       // DWARF information section .debug_line – Line number information
1838       // .debug_loc – Location lists used in DW_AT_location attributes
1839       // .debug_macinfo – Macro information .debug_pubnames – Lookup table
1840       // for mapping object and function names to compilation units
1841       // .debug_pubtypes – Lookup table for mapping type names to compilation
1842       // units .debug_ranges – Address ranges used in DW_AT_ranges attributes
1843       // .debug_str – String table used in .debug_info MISSING?
1844       // .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section,
1845       // http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html MISSING?
1846       // .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build
1847       // /gdb-add-index?pathrev=144644 MISSING? .debug_types - Type
1848       // descriptions from DWARF 4? See
1849       // http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo
1850       else if (name == g_sect_name_dwarf_debug_abbrev)
1851         sect_type = eSectionTypeDWARFDebugAbbrev;
1852       else if (name == g_sect_name_dwarf_debug_addr)
1853         sect_type = eSectionTypeDWARFDebugAddr;
1854       else if (name == g_sect_name_dwarf_debug_aranges)
1855         sect_type = eSectionTypeDWARFDebugAranges;
1856       else if (name == g_sect_name_dwarf_debug_cu_index)
1857         sect_type = eSectionTypeDWARFDebugCuIndex;
1858       else if (name == g_sect_name_dwarf_debug_frame)
1859         sect_type = eSectionTypeDWARFDebugFrame;
1860       else if (name == g_sect_name_dwarf_debug_info)
1861         sect_type = eSectionTypeDWARFDebugInfo;
1862       else if (name == g_sect_name_dwarf_debug_line)
1863         sect_type = eSectionTypeDWARFDebugLine;
1864       else if (name == g_sect_name_dwarf_debug_loc)
1865         sect_type = eSectionTypeDWARFDebugLoc;
1866       else if (name == g_sect_name_dwarf_debug_macinfo)
1867         sect_type = eSectionTypeDWARFDebugMacInfo;
1868       else if (name == g_sect_name_dwarf_debug_macro)
1869         sect_type = eSectionTypeDWARFDebugMacro;
1870       else if (name == g_sect_name_dwarf_debug_names)
1871         sect_type = eSectionTypeDWARFDebugNames;
1872       else if (name == g_sect_name_dwarf_debug_pubnames)
1873         sect_type = eSectionTypeDWARFDebugPubNames;
1874       else if (name == g_sect_name_dwarf_debug_pubtypes)
1875         sect_type = eSectionTypeDWARFDebugPubTypes;
1876       else if (name == g_sect_name_dwarf_debug_ranges)
1877         sect_type = eSectionTypeDWARFDebugRanges;
1878       else if (name == g_sect_name_dwarf_debug_str)
1879         sect_type = eSectionTypeDWARFDebugStr;
1880       else if (name == g_sect_name_dwarf_debug_types)
1881         sect_type = eSectionTypeDWARFDebugTypes;
1882       else if (name == g_sect_name_dwarf_debug_str_offsets)
1883         sect_type = eSectionTypeDWARFDebugStrOffsets;
1884       else if (name == g_sect_name_dwarf_debug_abbrev_dwo)
1885         sect_type = eSectionTypeDWARFDebugAbbrev;
1886       else if (name == g_sect_name_dwarf_debug_info_dwo)
1887         sect_type = eSectionTypeDWARFDebugInfo;
1888       else if (name == g_sect_name_dwarf_debug_line_dwo)
1889         sect_type = eSectionTypeDWARFDebugLine;
1890       else if (name == g_sect_name_dwarf_debug_macro_dwo)
1891         sect_type = eSectionTypeDWARFDebugMacro;
1892       else if (name == g_sect_name_dwarf_debug_loc_dwo)
1893         sect_type = eSectionTypeDWARFDebugLoc;
1894       else if (name == g_sect_name_dwarf_debug_str_dwo)
1895         sect_type = eSectionTypeDWARFDebugStr;
1896       else if (name == g_sect_name_dwarf_debug_str_offsets_dwo)
1897         sect_type = eSectionTypeDWARFDebugStrOffsets;
1898       else if (name == g_sect_name_eh_frame)
1899         sect_type = eSectionTypeEHFrame;
1900       else if (name == g_sect_name_arm_exidx)
1901         sect_type = eSectionTypeARMexidx;
1902       else if (name == g_sect_name_arm_extab)
1903         sect_type = eSectionTypeARMextab;
1904       else if (name == g_sect_name_go_symtab)
1905         sect_type = eSectionTypeGoSymtab;
1906       else if (name == g_sect_name_dwarf_gnu_debugaltlink)
1907         sect_type = eSectionTypeDWARFGNUDebugAltLink;
1908
1909       const uint32_t permissions =
1910           ((header.sh_flags & SHF_ALLOC) ? ePermissionsReadable : 0u) |
1911           ((header.sh_flags & SHF_WRITE) ? ePermissionsWritable : 0u) |
1912           ((header.sh_flags & SHF_EXECINSTR) ? ePermissionsExecutable : 0u);
1913       switch (header.sh_type) {
1914       case SHT_SYMTAB:
1915         assert(sect_type == eSectionTypeOther);
1916         sect_type = eSectionTypeELFSymbolTable;
1917         break;
1918       case SHT_DYNSYM:
1919         assert(sect_type == eSectionTypeOther);
1920         sect_type = eSectionTypeELFDynamicSymbols;
1921         break;
1922       case SHT_RELA:
1923       case SHT_REL:
1924         assert(sect_type == eSectionTypeOther);
1925         sect_type = eSectionTypeELFRelocationEntries;
1926         break;
1927       case SHT_DYNAMIC:
1928         assert(sect_type == eSectionTypeOther);
1929         sect_type = eSectionTypeELFDynamicLinkInfo;
1930         break;
1931       }
1932
1933       if (eSectionTypeOther == sect_type) {
1934         // the kalimba toolchain assumes that ELF section names are free-form.
1935         // It does support linkscripts which (can) give rise to various
1936         // arbitrarily named sections being "Code" or "Data".
1937         sect_type = kalimbaSectionType(m_header, header);
1938       }
1939
1940       // In common case ELF code section can have arbitrary name (for example,
1941       // we can specify it using section attribute for particular function) so
1942       // assume that section is a code section if it has SHF_EXECINSTR flag set
1943       // and has SHT_PROGBITS type.
1944       if (eSectionTypeOther == sect_type &&
1945           llvm::ELF::SHT_PROGBITS == header.sh_type &&
1946           (header.sh_flags & SHF_EXECINSTR)) {
1947         sect_type = eSectionTypeCode;
1948       }
1949
1950       const uint32_t target_bytes_size =
1951           (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type)
1952               ? m_arch_spec.GetDataByteSize()
1953               : eSectionTypeCode == sect_type ? m_arch_spec.GetCodeByteSize()
1954                                               : 1;
1955       elf::elf_xword log2align =
1956           (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign);
1957
1958       uint64_t addr = header.sh_addr;
1959
1960       if ((header.sh_flags & SHF_ALLOC) && synthaddrs) {
1961           nextaddr =
1962               (nextaddr + header.sh_addralign - 1) & ~(header.sh_addralign - 1);
1963           addr = nextaddr;
1964           nextaddr += vm_size;
1965       }
1966
1967       SectionSP section_sp(new Section(
1968           GetModule(), // Module to which this section belongs.
1969           this, // ObjectFile to which this section belongs and should read
1970                 // section data from.
1971           SectionIndex(I),     // Section ID.
1972           name,                // Section name.
1973           sect_type,           // Section type.
1974           addr,                // VM address.
1975           vm_size,             // VM size in bytes of this section.
1976           header.sh_offset,    // Offset of this section in the file.
1977           file_size,           // Size of the section as found in the file.
1978           log2align,           // Alignment of the section
1979           header.sh_flags,     // Flags for this section.
1980           target_bytes_size)); // Number of host bytes per target byte
1981
1982       section_sp->SetPermissions(permissions);
1983       if (is_thread_specific)
1984         section_sp->SetIsThreadSpecific(is_thread_specific);
1985       m_sections_ap->AddSection(section_sp);
1986     }
1987   }
1988
1989   // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the
1990   // unified section list.
1991   if (GetType() != eTypeDebugInfo)
1992     unified_section_list = *m_sections_ap;
1993 }
1994
1995 // Find the arm/aarch64 mapping symbol character in the given symbol name.
1996 // Mapping symbols have the form of "$<char>[.<any>]*". Additionally we
1997 // recognize cases when the mapping symbol prefixed by an arbitrary string
1998 // because if a symbol prefix added to each symbol in the object file with
1999 // objcopy then the mapping symbols are also prefixed.
2000 static char FindArmAarch64MappingSymbol(const char *symbol_name) {
2001   if (!symbol_name)
2002     return '\0';
2003
2004   const char *dollar_pos = ::strchr(symbol_name, '$');
2005   if (!dollar_pos || dollar_pos[1] == '\0')
2006     return '\0';
2007
2008   if (dollar_pos[2] == '\0' || dollar_pos[2] == '.')
2009     return dollar_pos[1];
2010   return '\0';
2011 }
2012
2013 #define STO_MIPS_ISA (3 << 6)
2014 #define STO_MICROMIPS (2 << 6)
2015 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS)
2016
2017 // private
2018 unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
2019                                      SectionList *section_list,
2020                                      const size_t num_symbols,
2021                                      const DataExtractor &symtab_data,
2022                                      const DataExtractor &strtab_data) {
2023   ELFSymbol symbol;
2024   lldb::offset_t offset = 0;
2025
2026   static ConstString text_section_name(".text");
2027   static ConstString init_section_name(".init");
2028   static ConstString fini_section_name(".fini");
2029   static ConstString ctors_section_name(".ctors");
2030   static ConstString dtors_section_name(".dtors");
2031
2032   static ConstString data_section_name(".data");
2033   static ConstString rodata_section_name(".rodata");
2034   static ConstString rodata1_section_name(".rodata1");
2035   static ConstString data2_section_name(".data1");
2036   static ConstString bss_section_name(".bss");
2037   static ConstString opd_section_name(".opd"); // For ppc64
2038
2039   // On Android the oatdata and the oatexec symbols in the oat and odex files
2040   // covers the full .text section what causes issues with displaying unusable
2041   // symbol name to the user and very slow unwinding speed because the
2042   // instruction emulation based unwind plans try to emulate all instructions
2043   // in these symbols. Don't add these symbols to the symbol list as they have
2044   // no use for the debugger and they are causing a lot of trouble. Filtering
2045   // can't be restricted to Android because this special object file don't
2046   // contain the note section specifying the environment to Android but the
2047   // custom extension and file name makes it highly unlikely that this will
2048   // collide with anything else.
2049   ConstString file_extension = m_file.GetFileNameExtension();
2050   bool skip_oatdata_oatexec = file_extension == ConstString(".oat") ||
2051                               file_extension == ConstString(".odex");
2052
2053   ArchSpec arch;
2054   GetArchitecture(arch);
2055   ModuleSP module_sp(GetModule());
2056   SectionList *module_section_list =
2057       module_sp ? module_sp->GetSectionList() : nullptr;
2058
2059   // Local cache to avoid doing a FindSectionByName for each symbol. The "const
2060   // char*" key must came from a ConstString object so they can be compared by
2061   // pointer
2062   std::unordered_map<const char *, lldb::SectionSP> section_name_to_section;
2063
2064   unsigned i;
2065   for (i = 0; i < num_symbols; ++i) {
2066     if (symbol.Parse(symtab_data, &offset) == false)
2067       break;
2068
2069     const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2070     if (!symbol_name)
2071       symbol_name = "";
2072
2073     // No need to add non-section symbols that have no names
2074     if (symbol.getType() != STT_SECTION &&
2075         (symbol_name == nullptr || symbol_name[0] == '\0'))
2076       continue;
2077
2078     // Skipping oatdata and oatexec sections if it is requested. See details
2079     // above the definition of skip_oatdata_oatexec for the reasons.
2080     if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 ||
2081                                  ::strcmp(symbol_name, "oatexec") == 0))
2082       continue;
2083
2084     SectionSP symbol_section_sp;
2085     SymbolType symbol_type = eSymbolTypeInvalid;
2086     Elf64_Half section_idx = symbol.st_shndx;
2087
2088     switch (section_idx) {
2089     case SHN_ABS:
2090       symbol_type = eSymbolTypeAbsolute;
2091       break;
2092     case SHN_UNDEF:
2093       symbol_type = eSymbolTypeUndefined;
2094       break;
2095     default:
2096       symbol_section_sp = section_list->GetSectionAtIndex(section_idx);
2097       break;
2098     }
2099
2100     // If a symbol is undefined do not process it further even if it has a STT
2101     // type
2102     if (symbol_type != eSymbolTypeUndefined) {
2103       switch (symbol.getType()) {
2104       default:
2105       case STT_NOTYPE:
2106         // The symbol's type is not specified.
2107         break;
2108
2109       case STT_OBJECT:
2110         // The symbol is associated with a data object, such as a variable, an
2111         // array, etc.
2112         symbol_type = eSymbolTypeData;
2113         break;
2114
2115       case STT_FUNC:
2116         // The symbol is associated with a function or other executable code.
2117         symbol_type = eSymbolTypeCode;
2118         break;
2119
2120       case STT_SECTION:
2121         // The symbol is associated with a section. Symbol table entries of
2122         // this type exist primarily for relocation and normally have STB_LOCAL
2123         // binding.
2124         break;
2125
2126       case STT_FILE:
2127         // Conventionally, the symbol's name gives the name of the source file
2128         // associated with the object file. A file symbol has STB_LOCAL
2129         // binding, its section index is SHN_ABS, and it precedes the other
2130         // STB_LOCAL symbols for the file, if it is present.
2131         symbol_type = eSymbolTypeSourceFile;
2132         break;
2133
2134       case STT_GNU_IFUNC:
2135         // The symbol is associated with an indirect function. The actual
2136         // function will be resolved if it is referenced.
2137         symbol_type = eSymbolTypeResolver;
2138         break;
2139       }
2140     }
2141
2142     if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) {
2143       if (symbol_section_sp) {
2144         const ConstString &sect_name = symbol_section_sp->GetName();
2145         if (sect_name == text_section_name || sect_name == init_section_name ||
2146             sect_name == fini_section_name || sect_name == ctors_section_name ||
2147             sect_name == dtors_section_name) {
2148           symbol_type = eSymbolTypeCode;
2149         } else if (sect_name == data_section_name ||
2150                    sect_name == data2_section_name ||
2151                    sect_name == rodata_section_name ||
2152                    sect_name == rodata1_section_name ||
2153                    sect_name == bss_section_name) {
2154           symbol_type = eSymbolTypeData;
2155         }
2156       }
2157     }
2158
2159     int64_t symbol_value_offset = 0;
2160     uint32_t additional_flags = 0;
2161
2162     if (arch.IsValid()) {
2163       if (arch.GetMachine() == llvm::Triple::arm) {
2164         if (symbol.getBinding() == STB_LOCAL) {
2165           char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2166           if (symbol_type == eSymbolTypeCode) {
2167             switch (mapping_symbol) {
2168             case 'a':
2169               // $a[.<any>]* - marks an ARM instruction sequence
2170               m_address_class_map[symbol.st_value] = AddressClass::eCode;
2171               break;
2172             case 'b':
2173             case 't':
2174               // $b[.<any>]* - marks a THUMB BL instruction sequence
2175               // $t[.<any>]* - marks a THUMB instruction sequence
2176               m_address_class_map[symbol.st_value] =
2177                   AddressClass::eCodeAlternateISA;
2178               break;
2179             case 'd':
2180               // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2181               m_address_class_map[symbol.st_value] = AddressClass::eData;
2182               break;
2183             }
2184           }
2185           if (mapping_symbol)
2186             continue;
2187         }
2188       } else if (arch.GetMachine() == llvm::Triple::aarch64) {
2189         if (symbol.getBinding() == STB_LOCAL) {
2190           char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2191           if (symbol_type == eSymbolTypeCode) {
2192             switch (mapping_symbol) {
2193             case 'x':
2194               // $x[.<any>]* - marks an A64 instruction sequence
2195               m_address_class_map[symbol.st_value] = AddressClass::eCode;
2196               break;
2197             case 'd':
2198               // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2199               m_address_class_map[symbol.st_value] = AddressClass::eData;
2200               break;
2201             }
2202           }
2203           if (mapping_symbol)
2204             continue;
2205         }
2206       }
2207
2208       if (arch.GetMachine() == llvm::Triple::arm) {
2209         if (symbol_type == eSymbolTypeCode) {
2210           if (symbol.st_value & 1) {
2211             // Subtracting 1 from the address effectively unsets the low order
2212             // bit, which results in the address actually pointing to the
2213             // beginning of the symbol. This delta will be used below in
2214             // conjunction with symbol.st_value to produce the final
2215             // symbol_value that we store in the symtab.
2216             symbol_value_offset = -1;
2217             m_address_class_map[symbol.st_value ^ 1] =
2218                 AddressClass::eCodeAlternateISA;
2219           } else {
2220             // This address is ARM
2221             m_address_class_map[symbol.st_value] = AddressClass::eCode;
2222           }
2223         }
2224       }
2225
2226       /*
2227        * MIPS:
2228        * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for
2229        * MIPS).
2230        * This allows processor to switch between microMIPS and MIPS without any
2231        * need
2232        * for special mode-control register. However, apart from .debug_line,
2233        * none of
2234        * the ELF/DWARF sections set the ISA bit (for symbol or section). Use
2235        * st_other
2236        * flag to check whether the symbol is microMIPS and then set the address
2237        * class
2238        * accordingly.
2239       */
2240       const llvm::Triple::ArchType llvm_arch = arch.GetMachine();
2241       if (llvm_arch == llvm::Triple::mips ||
2242           llvm_arch == llvm::Triple::mipsel ||
2243           llvm_arch == llvm::Triple::mips64 ||
2244           llvm_arch == llvm::Triple::mips64el) {
2245         if (IS_MICROMIPS(symbol.st_other))
2246           m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
2247         else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) {
2248           symbol.st_value = symbol.st_value & (~1ull);
2249           m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
2250         } else {
2251           if (symbol_type == eSymbolTypeCode)
2252             m_address_class_map[symbol.st_value] = AddressClass::eCode;
2253           else if (symbol_type == eSymbolTypeData)
2254             m_address_class_map[symbol.st_value] = AddressClass::eData;
2255           else
2256             m_address_class_map[symbol.st_value] = AddressClass::eUnknown;
2257         }
2258       }
2259     }
2260
2261     // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB
2262     // symbols. See above for more details.
2263     uint64_t symbol_value = symbol.st_value + symbol_value_offset;
2264
2265     if (symbol_section_sp == nullptr && section_idx == SHN_ABS &&
2266         symbol.st_size != 0) {
2267       // We don't have a section for a symbol with non-zero size. Create a new
2268       // section for it so the address range covered by the symbol is also
2269       // covered by the module (represented through the section list). It is
2270       // needed so module lookup for the addresses covered by this symbol will
2271       // be successfull. This case happens for absolute symbols.
2272       ConstString fake_section_name(std::string(".absolute.") + symbol_name);
2273       symbol_section_sp =
2274           std::make_shared<Section>(module_sp, this, SHN_ABS, fake_section_name,
2275                                     eSectionTypeAbsoluteAddress, symbol_value,
2276                                     symbol.st_size, 0, 0, 0, SHF_ALLOC);
2277
2278       module_section_list->AddSection(symbol_section_sp);
2279       section_list->AddSection(symbol_section_sp);
2280     }
2281
2282     if (symbol_section_sp &&
2283         CalculateType() != ObjectFile::Type::eTypeObjectFile)
2284       symbol_value -= symbol_section_sp->GetFileAddress();
2285
2286     if (symbol_section_sp && module_section_list &&
2287         module_section_list != section_list) {
2288       const ConstString &sect_name = symbol_section_sp->GetName();
2289       auto section_it = section_name_to_section.find(sect_name.GetCString());
2290       if (section_it == section_name_to_section.end())
2291         section_it =
2292             section_name_to_section
2293                 .emplace(sect_name.GetCString(),
2294                          module_section_list->FindSectionByName(sect_name))
2295                 .first;
2296       if (section_it->second)
2297         symbol_section_sp = section_it->second;
2298     }
2299
2300     bool is_global = symbol.getBinding() == STB_GLOBAL;
2301     uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags;
2302     bool is_mangled = (symbol_name[0] == '_' && symbol_name[1] == 'Z');
2303
2304     llvm::StringRef symbol_ref(symbol_name);
2305
2306     // Symbol names may contain @VERSION suffixes. Find those and strip them
2307     // temporarily.
2308     size_t version_pos = symbol_ref.find('@');
2309     bool has_suffix = version_pos != llvm::StringRef::npos;
2310     llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
2311     Mangled mangled(ConstString(symbol_bare), is_mangled);
2312
2313     // Now append the suffix back to mangled and unmangled names. Only do it if
2314     // the demangling was successful (string is not empty).
2315     if (has_suffix) {
2316       llvm::StringRef suffix = symbol_ref.substr(version_pos);
2317
2318       llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
2319       if (!mangled_name.empty())
2320         mangled.SetMangledName(ConstString((mangled_name + suffix).str()));
2321
2322       ConstString demangled =
2323           mangled.GetDemangledName(lldb::eLanguageTypeUnknown);
2324       llvm::StringRef demangled_name = demangled.GetStringRef();
2325       if (!demangled_name.empty())
2326         mangled.SetDemangledName(ConstString((demangled_name + suffix).str()));
2327     }
2328
2329     // In ELF all symbol should have a valid size but it is not true for some
2330     // function symbols coming from hand written assembly. As none of the
2331     // function symbol should have 0 size we try to calculate the size for
2332     // these symbols in the symtab with saying that their original size is not
2333     // valid.
2334     bool symbol_size_valid =
2335         symbol.st_size != 0 || symbol.getType() != STT_FUNC;
2336
2337     Symbol dc_symbol(
2338         i + start_id, // ID is the original symbol table index.
2339         mangled,
2340         symbol_type,                    // Type of this symbol
2341         is_global,                      // Is this globally visible?
2342         false,                          // Is this symbol debug info?
2343         false,                          // Is this symbol a trampoline?
2344         false,                          // Is this symbol artificial?
2345         AddressRange(symbol_section_sp, // Section in which this symbol is
2346                                         // defined or null.
2347                      symbol_value,      // Offset in section or symbol value.
2348                      symbol.st_size),   // Size in bytes of this symbol.
2349         symbol_size_valid,              // Symbol size is valid
2350         has_suffix,                     // Contains linker annotations?
2351         flags);                         // Symbol flags.
2352     symtab->AddSymbol(dc_symbol);
2353   }
2354   return i;
2355 }
2356
2357 unsigned ObjectFileELF::ParseSymbolTable(Symtab *symbol_table,
2358                                          user_id_t start_id,
2359                                          lldb_private::Section *symtab) {
2360   if (symtab->GetObjectFile() != this) {
2361     // If the symbol table section is owned by a different object file, have it
2362     // do the parsing.
2363     ObjectFileELF *obj_file_elf =
2364         static_cast<ObjectFileELF *>(symtab->GetObjectFile());
2365     return obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab);
2366   }
2367
2368   // Get section list for this object file.
2369   SectionList *section_list = m_sections_ap.get();
2370   if (!section_list)
2371     return 0;
2372
2373   user_id_t symtab_id = symtab->GetID();
2374   const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2375   assert(symtab_hdr->sh_type == SHT_SYMTAB ||
2376          symtab_hdr->sh_type == SHT_DYNSYM);
2377
2378   // sh_link: section header index of associated string table. Section ID's are
2379   // ones based.
2380   user_id_t strtab_id = symtab_hdr->sh_link + 1;
2381   Section *strtab = section_list->FindSectionByID(strtab_id).get();
2382
2383   if (symtab && strtab) {
2384     assert(symtab->GetObjectFile() == this);
2385     assert(strtab->GetObjectFile() == this);
2386
2387     DataExtractor symtab_data;
2388     DataExtractor strtab_data;
2389     if (ReadSectionData(symtab, symtab_data) &&
2390         ReadSectionData(strtab, strtab_data)) {
2391       size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize;
2392
2393       return ParseSymbols(symbol_table, start_id, section_list, num_symbols,
2394                           symtab_data, strtab_data);
2395     }
2396   }
2397
2398   return 0;
2399 }
2400
2401 size_t ObjectFileELF::ParseDynamicSymbols() {
2402   if (m_dynamic_symbols.size())
2403     return m_dynamic_symbols.size();
2404
2405   SectionList *section_list = GetSectionList();
2406   if (!section_list)
2407     return 0;
2408
2409   // Find the SHT_DYNAMIC section.
2410   Section *dynsym =
2411       section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
2412           .get();
2413   if (!dynsym)
2414     return 0;
2415   assert(dynsym->GetObjectFile() == this);
2416
2417   ELFDynamic symbol;
2418   DataExtractor dynsym_data;
2419   if (ReadSectionData(dynsym, dynsym_data)) {
2420     const lldb::offset_t section_size = dynsym_data.GetByteSize();
2421     lldb::offset_t cursor = 0;
2422
2423     while (cursor < section_size) {
2424       if (!symbol.Parse(dynsym_data, &cursor))
2425         break;
2426
2427       m_dynamic_symbols.push_back(symbol);
2428     }
2429   }
2430
2431   return m_dynamic_symbols.size();
2432 }
2433
2434 const ELFDynamic *ObjectFileELF::FindDynamicSymbol(unsigned tag) {
2435   if (!ParseDynamicSymbols())
2436     return NULL;
2437
2438   DynamicSymbolCollIter I = m_dynamic_symbols.begin();
2439   DynamicSymbolCollIter E = m_dynamic_symbols.end();
2440   for (; I != E; ++I) {
2441     ELFDynamic *symbol = &*I;
2442
2443     if (symbol->d_tag == tag)
2444       return symbol;
2445   }
2446
2447   return NULL;
2448 }
2449
2450 unsigned ObjectFileELF::PLTRelocationType() {
2451   // DT_PLTREL
2452   //  This member specifies the type of relocation entry to which the
2453   //  procedure linkage table refers. The d_val member holds DT_REL or
2454   //  DT_RELA, as appropriate. All relocations in a procedure linkage table
2455   //  must use the same relocation.
2456   const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL);
2457
2458   if (symbol)
2459     return symbol->d_val;
2460
2461   return 0;
2462 }
2463
2464 // Returns the size of the normal plt entries and the offset of the first
2465 // normal plt entry. The 0th entry in the plt table is usually a resolution
2466 // entry which have different size in some architectures then the rest of the
2467 // plt entries.
2468 static std::pair<uint64_t, uint64_t>
2469 GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr,
2470                          const ELFSectionHeader *plt_hdr) {
2471   const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2472
2473   // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are
2474   // 16 bytes. So round the entsize up by the alignment if addralign is set.
2475   elf_xword plt_entsize =
2476       plt_hdr->sh_addralign
2477           ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign)
2478           : plt_hdr->sh_entsize;
2479
2480   // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly.
2481   // PLT entries relocation code in general requires multiple instruction and
2482   // should be greater than 4 bytes in most cases. Try to guess correct size
2483   // just in case.
2484   if (plt_entsize <= 4) {
2485     // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the
2486     // size of the plt entries based on the number of entries and the size of
2487     // the plt section with the assumption that the size of the 0th entry is at
2488     // least as big as the size of the normal entries and it isn't much bigger
2489     // then that.
2490     if (plt_hdr->sh_addralign)
2491       plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign /
2492                     (num_relocations + 1) * plt_hdr->sh_addralign;
2493     else
2494       plt_entsize = plt_hdr->sh_size / (num_relocations + 1);
2495   }
2496
2497   elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize;
2498
2499   return std::make_pair(plt_entsize, plt_offset);
2500 }
2501
2502 static unsigned ParsePLTRelocations(
2503     Symtab *symbol_table, user_id_t start_id, unsigned rel_type,
2504     const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2505     const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr,
2506     const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data,
2507     DataExtractor &symtab_data, DataExtractor &strtab_data) {
2508   ELFRelocation rel(rel_type);
2509   ELFSymbol symbol;
2510   lldb::offset_t offset = 0;
2511
2512   uint64_t plt_offset, plt_entsize;
2513   std::tie(plt_entsize, plt_offset) =
2514       GetPltEntrySizeAndOffset(rel_hdr, plt_hdr);
2515   const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2516
2517   typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2518   reloc_info_fn reloc_type;
2519   reloc_info_fn reloc_symbol;
2520
2521   if (hdr->Is32Bit()) {
2522     reloc_type = ELFRelocation::RelocType32;
2523     reloc_symbol = ELFRelocation::RelocSymbol32;
2524   } else {
2525     reloc_type = ELFRelocation::RelocType64;
2526     reloc_symbol = ELFRelocation::RelocSymbol64;
2527   }
2528
2529   unsigned slot_type = hdr->GetRelocationJumpSlotType();
2530   unsigned i;
2531   for (i = 0; i < num_relocations; ++i) {
2532     if (rel.Parse(rel_data, &offset) == false)
2533       break;
2534
2535     if (reloc_type(rel) != slot_type)
2536       continue;
2537
2538     lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize;
2539     if (!symbol.Parse(symtab_data, &symbol_offset))
2540       break;
2541
2542     const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2543     bool is_mangled =
2544         symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
2545     uint64_t plt_index = plt_offset + i * plt_entsize;
2546
2547     Symbol jump_symbol(
2548         i + start_id,          // Symbol table index
2549         symbol_name,           // symbol name.
2550         is_mangled,            // is the symbol name mangled?
2551         eSymbolTypeTrampoline, // Type of this symbol
2552         false,                 // Is this globally visible?
2553         false,                 // Is this symbol debug info?
2554         true,                  // Is this symbol a trampoline?
2555         true,                  // Is this symbol artificial?
2556         plt_section_sp, // Section in which this symbol is defined or null.
2557         plt_index,      // Offset in section or symbol value.
2558         plt_entsize,    // Size in bytes of this symbol.
2559         true,           // Size is valid
2560         false,          // Contains linker annotations?
2561         0);             // Symbol flags.
2562
2563     symbol_table->AddSymbol(jump_symbol);
2564   }
2565
2566   return i;
2567 }
2568
2569 unsigned
2570 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id,
2571                                       const ELFSectionHeaderInfo *rel_hdr,
2572                                       user_id_t rel_id) {
2573   assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
2574
2575   // The link field points to the associated symbol table.
2576   user_id_t symtab_id = rel_hdr->sh_link;
2577
2578   // If the link field doesn't point to the appropriate symbol name table then
2579   // try to find it by name as some compiler don't fill in the link fields.
2580   if (!symtab_id)
2581     symtab_id = GetSectionIndexByName(".dynsym");
2582
2583   // Get PLT section.  We cannot use rel_hdr->sh_info, since current linkers
2584   // point that to the .got.plt or .got section instead of .plt.
2585   user_id_t plt_id = GetSectionIndexByName(".plt");
2586
2587   if (!symtab_id || !plt_id)
2588     return 0;
2589
2590   // Section ID's are ones based;
2591   symtab_id++;
2592   plt_id++;
2593
2594   const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id);
2595   if (!plt_hdr)
2596     return 0;
2597
2598   const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id);
2599   if (!sym_hdr)
2600     return 0;
2601
2602   SectionList *section_list = m_sections_ap.get();
2603   if (!section_list)
2604     return 0;
2605
2606   Section *rel_section = section_list->FindSectionByID(rel_id).get();
2607   if (!rel_section)
2608     return 0;
2609
2610   SectionSP plt_section_sp(section_list->FindSectionByID(plt_id));
2611   if (!plt_section_sp)
2612     return 0;
2613
2614   Section *symtab = section_list->FindSectionByID(symtab_id).get();
2615   if (!symtab)
2616     return 0;
2617
2618   // sh_link points to associated string table.
2619   Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get();
2620   if (!strtab)
2621     return 0;
2622
2623   DataExtractor rel_data;
2624   if (!ReadSectionData(rel_section, rel_data))
2625     return 0;
2626
2627   DataExtractor symtab_data;
2628   if (!ReadSectionData(symtab, symtab_data))
2629     return 0;
2630
2631   DataExtractor strtab_data;
2632   if (!ReadSectionData(strtab, strtab_data))
2633     return 0;
2634
2635   unsigned rel_type = PLTRelocationType();
2636   if (!rel_type)
2637     return 0;
2638
2639   return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header,
2640                              rel_hdr, plt_hdr, sym_hdr, plt_section_sp,
2641                              rel_data, symtab_data, strtab_data);
2642 }
2643
2644 unsigned ObjectFileELF::ApplyRelocations(
2645     Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2646     const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr,
2647     DataExtractor &rel_data, DataExtractor &symtab_data,
2648     DataExtractor &debug_data, Section *rel_section) {
2649   ELFRelocation rel(rel_hdr->sh_type);
2650   lldb::addr_t offset = 0;
2651   const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2652   typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2653   reloc_info_fn reloc_type;
2654   reloc_info_fn reloc_symbol;
2655
2656   if (hdr->Is32Bit()) {
2657     reloc_type = ELFRelocation::RelocType32;
2658     reloc_symbol = ELFRelocation::RelocSymbol32;
2659   } else {
2660     reloc_type = ELFRelocation::RelocType64;
2661     reloc_symbol = ELFRelocation::RelocSymbol64;
2662   }
2663
2664   for (unsigned i = 0; i < num_relocations; ++i) {
2665     if (rel.Parse(rel_data, &offset) == false)
2666       break;
2667
2668     Symbol *symbol = NULL;
2669
2670     if (hdr->Is32Bit()) {
2671       switch (reloc_type(rel)) {
2672       case R_386_32:
2673       case R_386_PC32:
2674       default:
2675         // FIXME: This asserts with this input:
2676         //
2677         // foo.cpp
2678         // int main(int argc, char **argv) { return 0; }
2679         //
2680         // clang++.exe --target=i686-unknown-linux-gnu -g -c foo.cpp -o foo.o
2681         //
2682         // and running this on the foo.o module.
2683         assert(false && "unexpected relocation type");
2684       }
2685     } else {
2686       switch (reloc_type(rel)) {
2687       case R_X86_64_64: {
2688         symbol = symtab->FindSymbolByID(reloc_symbol(rel));
2689         if (symbol) {
2690           addr_t value = symbol->GetAddressRef().GetFileAddress();
2691           DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2692           uint64_t *dst = reinterpret_cast<uint64_t *>(
2693               data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
2694               ELFRelocation::RelocOffset64(rel));
2695           *dst = value + ELFRelocation::RelocAddend64(rel);
2696         }
2697         break;
2698       }
2699       case R_X86_64_32:
2700       case R_X86_64_32S: {
2701         symbol = symtab->FindSymbolByID(reloc_symbol(rel));
2702         if (symbol) {
2703           addr_t value = symbol->GetAddressRef().GetFileAddress();
2704           value += ELFRelocation::RelocAddend32(rel);
2705           assert(
2706               (reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) ||
2707               (reloc_type(rel) == R_X86_64_32S &&
2708                ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN)));
2709           uint32_t truncated_addr = (value & 0xFFFFFFFF);
2710           DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2711           uint32_t *dst = reinterpret_cast<uint32_t *>(
2712               data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
2713               ELFRelocation::RelocOffset32(rel));
2714           *dst = truncated_addr;
2715         }
2716         break;
2717       }
2718       case R_X86_64_PC32:
2719       default:
2720         assert(false && "unexpected relocation type");
2721       }
2722     }
2723   }
2724
2725   return 0;
2726 }
2727
2728 unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
2729                                               user_id_t rel_id,
2730                                               lldb_private::Symtab *thetab) {
2731   assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
2732
2733   // Parse in the section list if needed.
2734   SectionList *section_list = GetSectionList();
2735   if (!section_list)
2736     return 0;
2737
2738   // Section ID's are ones based.
2739   user_id_t symtab_id = rel_hdr->sh_link + 1;
2740   user_id_t debug_id = rel_hdr->sh_info + 1;
2741
2742   const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2743   if (!symtab_hdr)
2744     return 0;
2745
2746   const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id);
2747   if (!debug_hdr)
2748     return 0;
2749
2750   Section *rel = section_list->FindSectionByID(rel_id).get();
2751   if (!rel)
2752     return 0;
2753
2754   Section *symtab = section_list->FindSectionByID(symtab_id).get();
2755   if (!symtab)
2756     return 0;
2757
2758   Section *debug = section_list->FindSectionByID(debug_id).get();
2759   if (!debug)
2760     return 0;
2761
2762   DataExtractor rel_data;
2763   DataExtractor symtab_data;
2764   DataExtractor debug_data;
2765
2766   if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) &&
2767       GetData(symtab->GetFileOffset(), symtab->GetFileSize(), symtab_data) &&
2768       GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) {
2769     ApplyRelocations(thetab, &m_header, rel_hdr, symtab_hdr, debug_hdr,
2770                      rel_data, symtab_data, debug_data, debug);
2771   }
2772
2773   return 0;
2774 }
2775
2776 Symtab *ObjectFileELF::GetSymtab() {
2777   ModuleSP module_sp(GetModule());
2778   if (!module_sp)
2779     return NULL;
2780
2781   // We always want to use the main object file so we (hopefully) only have one
2782   // cached copy of our symtab, dynamic sections, etc.
2783   ObjectFile *module_obj_file = module_sp->GetObjectFile();
2784   if (module_obj_file && module_obj_file != this)
2785     return module_obj_file->GetSymtab();
2786
2787   if (m_symtab_ap.get() == NULL) {
2788     SectionList *section_list = module_sp->GetSectionList();
2789     if (!section_list)
2790       return NULL;
2791
2792     uint64_t symbol_id = 0;
2793     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
2794
2795     // Sharable objects and dynamic executables usually have 2 distinct symbol
2796     // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
2797     // smaller version of the symtab that only contains global symbols. The
2798     // information found in the dynsym is therefore also found in the symtab,
2799     // while the reverse is not necessarily true.
2800     Section *symtab =
2801         section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
2802     if (!symtab) {
2803       // The symtab section is non-allocable and can be stripped, so if it
2804       // doesn't exist then use the dynsym section which should always be
2805       // there.
2806       symtab =
2807           section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
2808               .get();
2809     }
2810     if (symtab) {
2811       m_symtab_ap.reset(new Symtab(symtab->GetObjectFile()));
2812       symbol_id += ParseSymbolTable(m_symtab_ap.get(), symbol_id, symtab);
2813     }
2814
2815     // DT_JMPREL
2816     //      If present, this entry's d_ptr member holds the address of
2817     //      relocation
2818     //      entries associated solely with the procedure linkage table.
2819     //      Separating
2820     //      these relocation entries lets the dynamic linker ignore them during
2821     //      process initialization, if lazy binding is enabled. If this entry is
2822     //      present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
2823     //      also be present.
2824     const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
2825     if (symbol) {
2826       // Synthesize trampoline symbols to help navigate the PLT.
2827       addr_t addr = symbol->d_ptr;
2828       Section *reloc_section =
2829           section_list->FindSectionContainingFileAddress(addr).get();
2830       if (reloc_section) {
2831         user_id_t reloc_id = reloc_section->GetID();
2832         const ELFSectionHeaderInfo *reloc_header =
2833             GetSectionHeaderByIndex(reloc_id);
2834         assert(reloc_header);
2835
2836         if (m_symtab_ap == nullptr)
2837           m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile()));
2838
2839         ParseTrampolineSymbols(m_symtab_ap.get(), symbol_id, reloc_header,
2840                                reloc_id);
2841       }
2842     }
2843
2844     DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo();
2845     if (eh_frame) {
2846       if (m_symtab_ap == nullptr)
2847         m_symtab_ap.reset(new Symtab(this));
2848       ParseUnwindSymbols(m_symtab_ap.get(), eh_frame);
2849     }
2850
2851     // If we still don't have any symtab then create an empty instance to avoid
2852     // do the section lookup next time.
2853     if (m_symtab_ap == nullptr)
2854       m_symtab_ap.reset(new Symtab(this));
2855
2856     m_symtab_ap->CalculateSymbolSizes();
2857   }
2858
2859   return m_symtab_ap.get();
2860 }
2861
2862 void ObjectFileELF::RelocateSection(lldb_private::Section *section)
2863 {
2864   static const char *debug_prefix = ".debug";
2865
2866   // Set relocated bit so we stop getting called, regardless of whether we
2867   // actually relocate.
2868   section->SetIsRelocated(true);
2869
2870   // We only relocate in ELF relocatable files
2871   if (CalculateType() != eTypeObjectFile)
2872     return;
2873
2874   const char *section_name = section->GetName().GetCString();
2875   // Can't relocate that which can't be named
2876   if (section_name == nullptr)
2877     return;
2878
2879   // We don't relocate non-debug sections at the moment
2880   if (strncmp(section_name, debug_prefix, strlen(debug_prefix)))
2881     return;
2882
2883   // Relocation section names to look for
2884   std::string needle = std::string(".rel") + section_name;
2885   std::string needlea = std::string(".rela") + section_name;
2886
2887   for (SectionHeaderCollIter I = m_section_headers.begin();
2888        I != m_section_headers.end(); ++I) {
2889     if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
2890       const char *hay_name = I->section_name.GetCString();
2891       if (hay_name == nullptr)
2892         continue;
2893       if (needle == hay_name || needlea == hay_name) {
2894         const ELFSectionHeader &reloc_header = *I;
2895         user_id_t reloc_id = SectionIndex(I);
2896         RelocateDebugSections(&reloc_header, reloc_id, GetSymtab());
2897         break;
2898       }
2899     }
2900   }
2901 }
2902
2903 void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
2904                                        DWARFCallFrameInfo *eh_frame) {
2905   SectionList *section_list = GetSectionList();
2906   if (!section_list)
2907     return;
2908
2909   // First we save the new symbols into a separate list and add them to the
2910   // symbol table after we colleced all symbols we want to add. This is
2911   // neccessary because adding a new symbol invalidates the internal index of
2912   // the symtab what causing the next lookup to be slow because it have to
2913   // recalculate the index first.
2914   std::vector<Symbol> new_symbols;
2915
2916   eh_frame->ForEachFDEEntries([this, symbol_table, section_list, &new_symbols](
2917       lldb::addr_t file_addr, uint32_t size, dw_offset_t) {
2918     Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);
2919     if (symbol) {
2920       if (!symbol->GetByteSizeIsValid()) {
2921         symbol->SetByteSize(size);
2922         symbol->SetSizeIsSynthesized(true);
2923       }
2924     } else {
2925       SectionSP section_sp =
2926           section_list->FindSectionContainingFileAddress(file_addr);
2927       if (section_sp) {
2928         addr_t offset = file_addr - section_sp->GetFileAddress();
2929         const char *symbol_name = GetNextSyntheticSymbolName().GetCString();
2930         uint64_t symbol_id = symbol_table->GetNumSymbols();
2931         Symbol eh_symbol(
2932             symbol_id,       // Symbol table index.
2933             symbol_name,     // Symbol name.
2934             false,           // Is the symbol name mangled?
2935             eSymbolTypeCode, // Type of this symbol.
2936             true,            // Is this globally visible?
2937             false,           // Is this symbol debug info?
2938             false,           // Is this symbol a trampoline?
2939             true,            // Is this symbol artificial?
2940             section_sp,      // Section in which this symbol is defined or null.
2941             offset,          // Offset in section or symbol value.
2942             0,     // Size:          Don't specify the size as an FDE can
2943             false, // Size is valid: cover multiple symbols.
2944             false, // Contains linker annotations?
2945             0);    // Symbol flags.
2946         new_symbols.push_back(eh_symbol);
2947       }
2948     }
2949     return true;
2950   });
2951
2952   for (const Symbol &s : new_symbols)
2953     symbol_table->AddSymbol(s);
2954 }
2955
2956 bool ObjectFileELF::IsStripped() {
2957   // TODO: determine this for ELF
2958   return false;
2959 }
2960
2961 //===----------------------------------------------------------------------===//
2962 // Dump
2963 //
2964 // Dump the specifics of the runtime file container (such as any headers
2965 // segments, sections, etc).
2966 //----------------------------------------------------------------------
2967 void ObjectFileELF::Dump(Stream *s) {
2968   ModuleSP module_sp(GetModule());
2969   if (!module_sp) {
2970     return;
2971   }
2972
2973   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
2974   s->Printf("%p: ", static_cast<void *>(this));
2975   s->Indent();
2976   s->PutCString("ObjectFileELF");
2977
2978   ArchSpec header_arch;
2979   GetArchitecture(header_arch);
2980
2981   *s << ", file = '" << m_file
2982      << "', arch = " << header_arch.GetArchitectureName() << "\n";
2983
2984   DumpELFHeader(s, m_header);
2985   s->EOL();
2986   DumpELFProgramHeaders(s);
2987   s->EOL();
2988   DumpELFSectionHeaders(s);
2989   s->EOL();
2990   SectionList *section_list = GetSectionList();
2991   if (section_list)
2992     section_list->Dump(s, NULL, true, UINT32_MAX);
2993   Symtab *symtab = GetSymtab();
2994   if (symtab)
2995     symtab->Dump(s, NULL, eSortOrderNone);
2996   s->EOL();
2997   DumpDependentModules(s);
2998   s->EOL();
2999 }
3000
3001 //----------------------------------------------------------------------
3002 // DumpELFHeader
3003 //
3004 // Dump the ELF header to the specified output stream
3005 //----------------------------------------------------------------------
3006 void ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) {
3007   s->PutCString("ELF Header\n");
3008   s->Printf("e_ident[EI_MAG0   ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
3009   s->Printf("e_ident[EI_MAG1   ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG1],
3010             header.e_ident[EI_MAG1]);
3011   s->Printf("e_ident[EI_MAG2   ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2],
3012             header.e_ident[EI_MAG2]);
3013   s->Printf("e_ident[EI_MAG3   ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3],
3014             header.e_ident[EI_MAG3]);
3015
3016   s->Printf("e_ident[EI_CLASS  ] = 0x%2.2x\n", header.e_ident[EI_CLASS]);
3017   s->Printf("e_ident[EI_DATA   ] = 0x%2.2x ", header.e_ident[EI_DATA]);
3018   DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]);
3019   s->Printf("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]);
3020   s->Printf("e_ident[EI_PAD    ] = 0x%2.2x\n", header.e_ident[EI_PAD]);
3021
3022   s->Printf("e_type      = 0x%4.4x ", header.e_type);
3023   DumpELFHeader_e_type(s, header.e_type);
3024   s->Printf("\ne_machine   = 0x%4.4x\n", header.e_machine);
3025   s->Printf("e_version   = 0x%8.8x\n", header.e_version);
3026   s->Printf("e_entry     = 0x%8.8" PRIx64 "\n", header.e_entry);
3027   s->Printf("e_phoff     = 0x%8.8" PRIx64 "\n", header.e_phoff);
3028   s->Printf("e_shoff     = 0x%8.8" PRIx64 "\n", header.e_shoff);
3029   s->Printf("e_flags     = 0x%8.8x\n", header.e_flags);
3030   s->Printf("e_ehsize    = 0x%4.4x\n", header.e_ehsize);
3031   s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
3032   s->Printf("e_phnum     = 0x%8.8x\n", header.e_phnum);
3033   s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
3034   s->Printf("e_shnum     = 0x%8.8x\n", header.e_shnum);
3035   s->Printf("e_shstrndx  = 0x%8.8x\n", header.e_shstrndx);
3036 }
3037
3038 //----------------------------------------------------------------------
3039 // DumpELFHeader_e_type
3040 //
3041 // Dump an token value for the ELF header member e_type
3042 //----------------------------------------------------------------------
3043 void ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) {
3044   switch (e_type) {
3045   case ET_NONE:
3046     *s << "ET_NONE";
3047     break;
3048   case ET_REL:
3049     *s << "ET_REL";
3050     break;
3051   case ET_EXEC:
3052     *s << "ET_EXEC";
3053     break;
3054   case ET_DYN:
3055     *s << "ET_DYN";
3056     break;
3057   case ET_CORE:
3058     *s << "ET_CORE";
3059     break;
3060   default:
3061     break;
3062   }
3063 }
3064
3065 //----------------------------------------------------------------------
3066 // DumpELFHeader_e_ident_EI_DATA
3067 //
3068 // Dump an token value for the ELF header member e_ident[EI_DATA]
3069 //----------------------------------------------------------------------
3070 void ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s,
3071                                                   unsigned char ei_data) {
3072   switch (ei_data) {
3073   case ELFDATANONE:
3074     *s << "ELFDATANONE";
3075     break;
3076   case ELFDATA2LSB:
3077     *s << "ELFDATA2LSB - Little Endian";
3078     break;
3079   case ELFDATA2MSB:
3080     *s << "ELFDATA2MSB - Big Endian";
3081     break;
3082   default:
3083     break;
3084   }
3085 }
3086
3087 //----------------------------------------------------------------------
3088 // DumpELFProgramHeader
3089 //
3090 // Dump a single ELF program header to the specified output stream
3091 //----------------------------------------------------------------------
3092 void ObjectFileELF::DumpELFProgramHeader(Stream *s,
3093                                          const ELFProgramHeader &ph) {
3094   DumpELFProgramHeader_p_type(s, ph.p_type);
3095   s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset,
3096             ph.p_vaddr, ph.p_paddr);
3097   s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz,
3098             ph.p_flags);
3099
3100   DumpELFProgramHeader_p_flags(s, ph.p_flags);
3101   s->Printf(") %8.8" PRIx64, ph.p_align);
3102 }
3103
3104 //----------------------------------------------------------------------
3105 // DumpELFProgramHeader_p_type
3106 //
3107 // Dump an token value for the ELF program header member p_type which describes
3108 // the type of the program header
3109 // ----------------------------------------------------------------------
3110 void ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) {
3111   const int kStrWidth = 15;
3112   switch (p_type) {
3113     CASE_AND_STREAM(s, PT_NULL, kStrWidth);
3114     CASE_AND_STREAM(s, PT_LOAD, kStrWidth);
3115     CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth);
3116     CASE_AND_STREAM(s, PT_INTERP, kStrWidth);
3117     CASE_AND_STREAM(s, PT_NOTE, kStrWidth);
3118     CASE_AND_STREAM(s, PT_SHLIB, kStrWidth);
3119     CASE_AND_STREAM(s, PT_PHDR, kStrWidth);
3120     CASE_AND_STREAM(s, PT_TLS, kStrWidth);
3121     CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth);
3122   default:
3123     s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
3124     break;
3125   }
3126 }
3127
3128 //----------------------------------------------------------------------
3129 // DumpELFProgramHeader_p_flags
3130 //
3131 // Dump an token value for the ELF program header member p_flags
3132 //----------------------------------------------------------------------
3133 void ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) {
3134   *s << ((p_flags & PF_X) ? "PF_X" : "    ")
3135      << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
3136      << ((p_flags & PF_W) ? "PF_W" : "    ")
3137      << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ')
3138      << ((p_flags & PF_R) ? "PF_R" : "    ");
3139 }
3140
3141 //----------------------------------------------------------------------
3142 // DumpELFProgramHeaders
3143 //
3144 // Dump all of the ELF program header to the specified output stream
3145 //----------------------------------------------------------------------
3146 void ObjectFileELF::DumpELFProgramHeaders(Stream *s) {
3147   if (!ParseProgramHeaders())
3148     return;
3149
3150   s->PutCString("Program Headers\n");
3151   s->PutCString("IDX  p_type          p_offset p_vaddr  p_paddr  "
3152                 "p_filesz p_memsz  p_flags                   p_align\n");
3153   s->PutCString("==== --------------- -------- -------- -------- "
3154                 "-------- -------- ------------------------- --------\n");
3155
3156   uint32_t idx = 0;
3157   for (ProgramHeaderCollConstIter I = m_program_headers.begin();
3158        I != m_program_headers.end(); ++I, ++idx) {
3159     s->Printf("[%2u] ", idx);
3160     ObjectFileELF::DumpELFProgramHeader(s, *I);
3161     s->EOL();
3162   }
3163 }
3164
3165 //----------------------------------------------------------------------
3166 // DumpELFSectionHeader
3167 //
3168 // Dump a single ELF section header to the specified output stream
3169 //----------------------------------------------------------------------
3170 void ObjectFileELF::DumpELFSectionHeader(Stream *s,
3171                                          const ELFSectionHeaderInfo &sh) {
3172   s->Printf("%8.8x ", sh.sh_name);
3173   DumpELFSectionHeader_sh_type(s, sh.sh_type);
3174   s->Printf(" %8.8" PRIx64 " (", sh.sh_flags);
3175   DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
3176   s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr,
3177             sh.sh_offset, sh.sh_size);
3178   s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info);
3179   s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize);
3180 }
3181
3182 //----------------------------------------------------------------------
3183 // DumpELFSectionHeader_sh_type
3184 //
3185 // Dump an token value for the ELF section header member sh_type which
3186 // describes the type of the section
3187 //----------------------------------------------------------------------
3188 void ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) {
3189   const int kStrWidth = 12;
3190   switch (sh_type) {
3191     CASE_AND_STREAM(s, SHT_NULL, kStrWidth);
3192     CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth);
3193     CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth);
3194     CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth);
3195     CASE_AND_STREAM(s, SHT_RELA, kStrWidth);
3196     CASE_AND_STREAM(s, SHT_HASH, kStrWidth);
3197     CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth);
3198     CASE_AND_STREAM(s, SHT_NOTE, kStrWidth);
3199     CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth);
3200     CASE_AND_STREAM(s, SHT_REL, kStrWidth);
3201     CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth);
3202     CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth);
3203     CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth);
3204     CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth);
3205     CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth);
3206     CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth);
3207   default:
3208     s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
3209     break;
3210   }
3211 }
3212
3213 //----------------------------------------------------------------------
3214 // DumpELFSectionHeader_sh_flags
3215 //
3216 // Dump an token value for the ELF section header member sh_flags
3217 //----------------------------------------------------------------------
3218 void ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s,
3219                                                   elf_xword sh_flags) {
3220   *s << ((sh_flags & SHF_WRITE) ? "WRITE" : "     ")
3221      << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
3222      << ((sh_flags & SHF_ALLOC) ? "ALLOC" : "     ")
3223      << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ')
3224      << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : "         ");
3225 }
3226
3227 //----------------------------------------------------------------------
3228 // DumpELFSectionHeaders
3229 //
3230 // Dump all of the ELF section header to the specified output stream
3231 //----------------------------------------------------------------------
3232 void ObjectFileELF::DumpELFSectionHeaders(Stream *s) {
3233   if (!ParseSectionHeaders())
3234     return;
3235
3236   s->PutCString("Section Headers\n");
3237   s->PutCString("IDX  name     type         flags                            "
3238                 "addr     offset   size     link     info     addralgn "
3239                 "entsize  Name\n");
3240   s->PutCString("==== -------- ------------ -------------------------------- "
3241                 "-------- -------- -------- -------- -------- -------- "
3242                 "-------- ====================\n");
3243
3244   uint32_t idx = 0;
3245   for (SectionHeaderCollConstIter I = m_section_headers.begin();
3246        I != m_section_headers.end(); ++I, ++idx) {
3247     s->Printf("[%2u] ", idx);
3248     ObjectFileELF::DumpELFSectionHeader(s, *I);
3249     const char *section_name = I->section_name.AsCString("");
3250     if (section_name)
3251       *s << ' ' << section_name << "\n";
3252   }
3253 }
3254
3255 void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) {
3256   size_t num_modules = ParseDependentModules();
3257
3258   if (num_modules > 0) {
3259     s->PutCString("Dependent Modules:\n");
3260     for (unsigned i = 0; i < num_modules; ++i) {
3261       const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i);
3262       s->Printf("   %s\n", spec.GetFilename().GetCString());
3263     }
3264   }
3265 }
3266
3267 bool ObjectFileELF::GetArchitecture(ArchSpec &arch) {
3268   if (!ParseHeader())
3269     return false;
3270
3271   if (m_section_headers.empty()) {
3272     // Allow elf notes to be parsed which may affect the detected architecture.
3273     ParseSectionHeaders();
3274   }
3275
3276   if (CalculateType() == eTypeCoreFile &&
3277       m_arch_spec.TripleOSIsUnspecifiedUnknown()) {
3278     // Core files don't have section headers yet they have PT_NOTE program
3279     // headers that might shed more light on the architecture
3280     if (ParseProgramHeaders()) {
3281       for (size_t i = 1, count = GetProgramHeaderCount(); i <= count; ++i) {
3282         const elf::ELFProgramHeader *header = GetProgramHeaderByIndex(i);
3283         if (header && header->p_type == PT_NOTE && header->p_offset != 0 &&
3284             header->p_filesz > 0) {
3285           DataExtractor data;
3286           if (data.SetData(m_data, header->p_offset, header->p_filesz) ==
3287               header->p_filesz) {
3288             lldb_private::UUID uuid;
3289             RefineModuleDetailsFromNote(data, m_arch_spec, uuid);
3290           }
3291         }
3292       }
3293     }
3294   }
3295   arch = m_arch_spec;
3296   return true;
3297 }
3298
3299 ObjectFile::Type ObjectFileELF::CalculateType() {
3300   switch (m_header.e_type) {
3301   case llvm::ELF::ET_NONE:
3302     // 0 - No file type
3303     return eTypeUnknown;
3304
3305   case llvm::ELF::ET_REL:
3306     // 1 - Relocatable file
3307     return eTypeObjectFile;
3308
3309   case llvm::ELF::ET_EXEC:
3310     // 2 - Executable file
3311     return eTypeExecutable;
3312
3313   case llvm::ELF::ET_DYN:
3314     // 3 - Shared object file
3315     return eTypeSharedLibrary;
3316
3317   case ET_CORE:
3318     // 4 - Core file
3319     return eTypeCoreFile;
3320
3321   default:
3322     break;
3323   }
3324   return eTypeUnknown;
3325 }
3326
3327 ObjectFile::Strata ObjectFileELF::CalculateStrata() {
3328   switch (m_header.e_type) {
3329   case llvm::ELF::ET_NONE:
3330     // 0 - No file type
3331     return eStrataUnknown;
3332
3333   case llvm::ELF::ET_REL:
3334     // 1 - Relocatable file
3335     return eStrataUnknown;
3336
3337   case llvm::ELF::ET_EXEC:
3338     // 2 - Executable file
3339     // TODO: is there any way to detect that an executable is a kernel
3340     // related executable by inspecting the program headers, section headers,
3341     // symbols, or any other flag bits???
3342     return eStrataUser;
3343
3344   case llvm::ELF::ET_DYN:
3345     // 3 - Shared object file
3346     // TODO: is there any way to detect that an shared library is a kernel
3347     // related executable by inspecting the program headers, section headers,
3348     // symbols, or any other flag bits???
3349     return eStrataUnknown;
3350
3351   case ET_CORE:
3352     // 4 - Core file
3353     // TODO: is there any way to detect that an core file is a kernel
3354     // related executable by inspecting the program headers, section headers,
3355     // symbols, or any other flag bits???
3356     return eStrataUnknown;
3357
3358   default:
3359     break;
3360   }
3361   return eStrataUnknown;
3362 }
3363
3364 size_t ObjectFileELF::ReadSectionData(Section *section,
3365                        lldb::offset_t section_offset, void *dst,
3366                        size_t dst_len) {
3367   // If some other objectfile owns this data, pass this to them.
3368   if (section->GetObjectFile() != this)
3369     return section->GetObjectFile()->ReadSectionData(section, section_offset,
3370                                                      dst, dst_len);
3371
3372   if (!section->Test(SHF_COMPRESSED))
3373     return ObjectFile::ReadSectionData(section, section_offset, dst, dst_len);
3374
3375   // For compressed sections we need to read to full data to be able to
3376   // decompress.
3377   DataExtractor data;
3378   ReadSectionData(section, data);
3379   return data.CopyData(section_offset, dst_len, dst);
3380 }
3381
3382 size_t ObjectFileELF::ReadSectionData(Section *section,
3383                                       DataExtractor &section_data) {
3384   // If some other objectfile owns this data, pass this to them.
3385   if (section->GetObjectFile() != this)
3386     return section->GetObjectFile()->ReadSectionData(section, section_data);
3387
3388   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES);
3389
3390   size_t result = ObjectFile::ReadSectionData(section, section_data);
3391   if (result == 0 || !section->Test(SHF_COMPRESSED))
3392     return result;
3393
3394   auto Decompressor = llvm::object::Decompressor::create(
3395       section->GetName().GetStringRef(),
3396       {reinterpret_cast<const char *>(section_data.GetDataStart()),
3397        size_t(section_data.GetByteSize())},
3398       GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8);
3399   if (!Decompressor) {
3400     LLDB_LOG_ERROR(log, Decompressor.takeError(),
3401                    "Unable to initialize decompressor for section {0}",
3402                    section->GetName());
3403     return result;
3404   }
3405   auto buffer_sp =
3406       std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0);
3407   if (auto Error = Decompressor->decompress(
3408           {reinterpret_cast<char *>(buffer_sp->GetBytes()),
3409            size_t(buffer_sp->GetByteSize())})) {
3410     LLDB_LOG_ERROR(log, std::move(Error), "Decompression of section {0} failed",
3411                    section->GetName());
3412     return result;
3413   }
3414   section_data.SetData(buffer_sp);
3415   return buffer_sp->GetByteSize();
3416 }
3417
3418 bool ObjectFileELF::AnySegmentHasPhysicalAddress() {
3419   size_t header_count = ParseProgramHeaders();
3420   for (size_t i = 1; i <= header_count; ++i) {
3421     auto header = GetProgramHeaderByIndex(i);
3422     if (header->p_paddr != 0)
3423       return true;
3424   }
3425   return false;
3426 }
3427
3428 std::vector<ObjectFile::LoadableData>
3429 ObjectFileELF::GetLoadableData(Target &target) {
3430   // Create a list of loadable data from loadable segments, using physical
3431   // addresses if they aren't all null
3432   std::vector<LoadableData> loadables;
3433   size_t header_count = ParseProgramHeaders();
3434   bool should_use_paddr = AnySegmentHasPhysicalAddress();
3435   for (size_t i = 1; i <= header_count; ++i) {
3436     LoadableData loadable;
3437     auto header = GetProgramHeaderByIndex(i);
3438     if (header->p_type != llvm::ELF::PT_LOAD)
3439       continue;
3440     loadable.Dest = should_use_paddr ? header->p_paddr : header->p_vaddr;
3441     if (loadable.Dest == LLDB_INVALID_ADDRESS)
3442       continue;
3443     if (header->p_filesz == 0)
3444       continue;
3445     auto segment_data = GetSegmentDataByIndex(i);
3446     loadable.Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(),
3447                                                 segment_data.GetByteSize());
3448     loadables.push_back(loadable);
3449   }
3450   return loadables;
3451 }