contrib/llvm-project/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

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