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

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