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