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

   1 //===-- ObjectFileELF.cpp ------------------------------------- -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "ObjectFileELF.h"
  11
  12 #include <cassert>
  13 #include <algorithm>
  14
  15 #include "lldb/Core/ArchSpec.h"
  16 #include "lldb/Core/DataBuffer.h"
  17 #include "lldb/Core/Error.h"
  18 #include "lldb/Core/FileSpecList.h"
  19 #include "lldb/Core/Log.h"
  20 #include "lldb/Core/Module.h"
  21 #include "lldb/Core/ModuleSpec.h"
  22 #include "lldb/Core/PluginManager.h"
  23 #include "lldb/Core/Section.h"
  24 #include "lldb/Core/Stream.h"
  25 #include "lldb/Symbol/DWARFCallFrameInfo.h"
  26 #include "lldb/Symbol/SymbolContext.h"
  27 #include "lldb/Target/SectionLoadList.h"
  28 #include "lldb/Target/Target.h"
  29 #include "lldb/Host/Host.h"
  30
  31 #include "llvm/ADT/PointerUnion.h"
  32
  33 #define CASE_AND_STREAM(s, def, width)                  \
  34     case def: s->Printf("%-*s", width, #def); break;
  35
  36 using namespace lldb;
  37 using namespace lldb_private;
  38 using namespace elf;
  39 using namespace llvm::ELF;
  40
  41 namespace {
  42 //===----------------------------------------------------------------------===//
  43 /// @class ELFRelocation
  44 /// @brief Generic wrapper for ELFRel and ELFRela.
  45 ///
  46 /// This helper class allows us to parse both ELFRel and ELFRela relocation
  47 /// entries in a generic manner.
  48 class ELFRelocation
  49 {
  50 public:
  51
  52     /// Constructs an ELFRelocation entry with a personality as given by @p
  53     /// type.
  54     ///
  55     /// @param type Either DT_REL or DT_RELA.  Any other value is invalid.
  56     ELFRelocation(unsigned type);
  57
  58     ~ELFRelocation();
  59
  60     bool
  61     Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
  62
  63     static unsigned
  64     RelocType32(const ELFRelocation &rel);
  65
  66     static unsigned
  67     RelocType64(const ELFRelocation &rel);
  68
  69     static unsigned
  70     RelocSymbol32(const ELFRelocation &rel);
  71
  72     static unsigned
  73     RelocSymbol64(const ELFRelocation &rel);
  74
  75 private:
  76     typedef llvm::PointerUnion<ELFRel*, ELFRela*> RelocUnion;
  77
  78     RelocUnion reloc;
  79 };
  80
  81 ELFRelocation::ELFRelocation(unsigned type)
  82 {
  83     if (type == DT_REL)
  84         reloc = new ELFRel();
  85     else if (type == DT_RELA)
  86         reloc = new ELFRela();
  87     else {
  88         assert(false && "unexpected relocation type");
  89         reloc = static_cast<ELFRel*>(NULL);
  90     }
  91 }
  92
  93 ELFRelocation::~ELFRelocation()
  94 {
  95     if (reloc.is<ELFRel*>())
  96         delete reloc.get<ELFRel*>();
  97     else
  98         delete reloc.get<ELFRela*>();
  99 }
 100
 101 bool
 102 ELFRelocation::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
 103 {
 104     if (reloc.is<ELFRel*>())
 105         return reloc.get<ELFRel*>()->Parse(data, offset);
 106     else
 107         return reloc.get<ELFRela*>()->Parse(data, offset);
 108 }
 109
 110 unsigned
 111 ELFRelocation::RelocType32(const ELFRelocation &rel)
 112 {
 113     if (rel.reloc.is<ELFRel*>())
 114         return ELFRel::RelocType32(*rel.reloc.get<ELFRel*>());
 115     else
 116         return ELFRela::RelocType32(*rel.reloc.get<ELFRela*>());
 117 }
 118
 119 unsigned
 120 ELFRelocation::RelocType64(const ELFRelocation &rel)
 121 {
 122     if (rel.reloc.is<ELFRel*>())
 123         return ELFRel::RelocType64(*rel.reloc.get<ELFRel*>());
 124     else
 125         return ELFRela::RelocType64(*rel.reloc.get<ELFRela*>());
 126 }
 127
 128 unsigned
 129 ELFRelocation::RelocSymbol32(const ELFRelocation &rel)
 130 {
 131     if (rel.reloc.is<ELFRel*>())
 132         return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel*>());
 133     else
 134         return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela*>());
 135 }
 136
 137 unsigned
 138 ELFRelocation::RelocSymbol64(const ELFRelocation &rel)
 139 {
 140     if (rel.reloc.is<ELFRel*>())
 141         return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel*>());
 142     else
 143         return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela*>());
 144 }
 145
 146 } // end anonymous namespace
 147
 148 bool
 149 ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset)
 150 {
 151     // Read all fields.
 152     if (data.GetU32(offset, &n_namesz, 3) == NULL)
 153         return false;
 154
 155     // The name field is required to be nul-terminated, and n_namesz
 156     // includes the terminating nul in observed implementations (contrary
 157     // to the ELF-64 spec).  A special case is needed for cores generated
 158     // by some older Linux versions, which write a note named "CORE"
 159     // without a nul terminator and n_namesz = 4.
 160     if (n_namesz == 4)
 161     {
 162         char buf[4];
 163         if (data.ExtractBytes (*offset, 4, data.GetByteOrder(), buf) != 4)
 164             return false;
 165         if (strncmp (buf, "CORE", 4) == 0)
 166         {
 167             n_name = "CORE";
 168             *offset += 4;
 169             return true;
 170         }
 171     }
 172
 173     const char *cstr = data.GetCStr(offset, llvm::RoundUpToAlignment (n_namesz, 4));
 174     if (cstr == NULL)
 175     {
 176         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
 177         if (log)
 178             log->Printf("Failed to parse note name lacking nul terminator");
 179
 180         return false;
 181     }
 182     n_name = cstr;
 183     return true;
 184 }
 185
 186 //------------------------------------------------------------------
 187 // Static methods.
 188 //------------------------------------------------------------------
 189 void
 190 ObjectFileELF::Initialize()
 191 {
 192     PluginManager::RegisterPlugin(GetPluginNameStatic(),
 193                                   GetPluginDescriptionStatic(),
 194                                   CreateInstance,
 195                                   CreateMemoryInstance,
 196                                   GetModuleSpecifications);
 197 }
 198
 199 void
 200 ObjectFileELF::Terminate()
 201 {
 202     PluginManager::UnregisterPlugin(CreateInstance);
 203 }
 204
 205 lldb_private::ConstString
 206 ObjectFileELF::GetPluginNameStatic()
 207 {
 208     static ConstString g_name("elf");
 209     return g_name;
 210 }
 211
 212 const char *
 213 ObjectFileELF::GetPluginDescriptionStatic()
 214 {
 215     return "ELF object file reader.";
 216 }
 217
 218 ObjectFile *
 219 ObjectFileELF::CreateInstance (const lldb::ModuleSP &module_sp,
 220                                DataBufferSP &data_sp,
 221                                lldb::offset_t data_offset,
 222                                const lldb_private::FileSpec* file,
 223                                lldb::offset_t file_offset,
 224                                lldb::offset_t length)
 225 {
 226     if (!data_sp)
 227     {
 228         data_sp = file->MemoryMapFileContents(file_offset, length);
 229         data_offset = 0;
 230     }
 231
 232     if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset))
 233     {
 234         const uint8_t *magic = data_sp->GetBytes() + data_offset;
 235         if (ELFHeader::MagicBytesMatch(magic))
 236         {
 237             // Update the data to contain the entire file if it doesn't already
 238             if (data_sp->GetByteSize() < length) {
 239                 data_sp = file->MemoryMapFileContents(file_offset, length);
 240                 data_offset = 0;
 241                 magic = data_sp->GetBytes();
 242             }
 243             unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
 244             if (address_size == 4 || address_size == 8)
 245             {
 246                 std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(module_sp, data_sp, data_offset, file, file_offset, length));
 247                 ArchSpec spec;
 248                 if (objfile_ap->GetArchitecture(spec) &&
 249                     objfile_ap->SetModulesArchitecture(spec))
 250                     return objfile_ap.release();
 251             }
 252         }
 253     }
 254     return NULL;
 255 }
 256
 257
 258 ObjectFile*
 259 ObjectFileELF::CreateMemoryInstance (const lldb::ModuleSP &module_sp,
 260                                      DataBufferSP& data_sp,
 261                                      const lldb::ProcessSP &process_sp,
 262                                      lldb::addr_t header_addr)
 263 {
 264     return NULL;
 265 }
 266
 267 bool
 268 ObjectFileELF::MagicBytesMatch (DataBufferSP& data_sp,
 269                                   lldb::addr_t data_offset,
 270                                   lldb::addr_t data_length)
 271 {
 272     if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset))
 273     {
 274         const uint8_t *magic = data_sp->GetBytes() + data_offset;
 275         return ELFHeader::MagicBytesMatch(magic);
 276     }
 277     return false;
 278 }
 279
 280 /*
 281  * crc function from http://svnweb.freebsd.org/base/head/sys/libkern/crc32.c
 282  *
 283  *   COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
 284  *   code or tables extracted from it, as desired without restriction.
 285  */
 286 static uint32_t
 287 calc_gnu_debuglink_crc32(const void *buf, size_t size)
 288 {
 289     static const uint32_t g_crc32_tab[] =
 290     {
 291         0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
 292         0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
 293         0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
 294         0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
 295         0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 296         0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
 297         0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
 298         0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
 299         0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
 300         0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 301         0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
 302         0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
 303         0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
 304         0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
 305         0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 306         0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
 307         0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
 308         0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
 309         0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
 310         0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 311         0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
 312         0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
 313         0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
 314         0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
 315         0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 316         0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
 317         0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
 318         0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
 319         0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
 320         0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 321         0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
 322         0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
 323         0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
 324         0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
 325         0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 326         0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
 327         0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
 328         0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
 329         0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
 330         0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 331         0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
 332         0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 333         0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
 334     };
 335     const uint8_t *p = (const uint8_t *)buf;
 336     uint32_t crc;
 337
 338     crc = ~0U;
 339     while (size--)
 340         crc = g_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
 341     return crc ^ ~0U;
 342 }
 343
 344 size_t
 345 ObjectFileELF::GetModuleSpecifications (const lldb_private::FileSpec& file,
 346                                         lldb::DataBufferSP& data_sp,
 347                                         lldb::offset_t data_offset,
 348                                         lldb::offset_t file_offset,
 349                                         lldb::offset_t length,
 350                                         lldb_private::ModuleSpecList &specs)
 351 {
 352     const size_t initial_count = specs.GetSize();
 353
 354     if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
 355     {
 356         DataExtractor data;
 357         data.SetData(data_sp);
 358         elf::ELFHeader header;
 359         if (header.Parse(data, &data_offset))
 360         {
 361             if (data_sp)
 362             {
 363                 ModuleSpec spec;
 364                 spec.GetFileSpec() = file;
 365                 spec.GetArchitecture().SetArchitecture(eArchTypeELF,
 366                                                        header.e_machine,
 367                                                        LLDB_INVALID_CPUTYPE);
 368                 if (spec.GetArchitecture().IsValid())
 369                 {
 370                     // We could parse the ABI tag information (in .note, .notes, or .note.ABI-tag) to get the
 371                     // machine information. However, this info isn't guaranteed to exist or be correct. Details:
 372                     //  http://refspecs.linuxfoundation.org/LSB_1.2.0/gLSB/noteabitag.html
 373                     // Instead of passing potentially incorrect information down the pipeline, grab
 374                     // the host information and use it.
 375                     spec.GetArchitecture().GetTriple().setOSName (Host::GetOSString().GetCString());
 376                     spec.GetArchitecture().GetTriple().setVendorName(Host::GetVendorString().GetCString());
 377
 378                     // Try to get the UUID from the section list. Usually that's at the end, so
 379                     // map the file in if we don't have it already.
 380                     size_t section_header_end = header.e_shoff + header.e_shnum * header.e_shentsize;
 381                     if (section_header_end > data_sp->GetByteSize())
 382                     {
 383                         data_sp = file.MemoryMapFileContents (file_offset, section_header_end);
 384                         data.SetData(data_sp);
 385                     }
 386
 387                     uint32_t gnu_debuglink_crc = 0;
 388                     std::string gnu_debuglink_file;
 389                     SectionHeaderColl section_headers;
 390                     lldb_private::UUID &uuid = spec.GetUUID();
 391                     GetSectionHeaderInfo(section_headers, data, header, uuid, gnu_debuglink_file, gnu_debuglink_crc);
 392
 393                     if (!uuid.IsValid())
 394                     {
 395                         if (!gnu_debuglink_crc)
 396                         {
 397                             // Need to map entire file into memory to calculate the crc.
 398                             data_sp = file.MemoryMapFileContents (file_offset, SIZE_MAX);
 399                             data.SetData(data_sp);
 400                             gnu_debuglink_crc = calc_gnu_debuglink_crc32 (data.GetDataStart(), data.GetByteSize());
 401                         }
 402                         if (gnu_debuglink_crc)
 403                         {
 404                             // Use 4 bytes of crc from the .gnu_debuglink section.
 405                             uint32_t uuidt[4] = { gnu_debuglink_crc, 0, 0, 0 };
 406                             uuid.SetBytes (uuidt, sizeof(uuidt));
 407                         }
 408                     }
 409
 410                     specs.Append(spec);
 411                 }
 412             }
 413         }
 414     }
 415
 416     return specs.GetSize() - initial_count;
 417 }
 418
 419 //------------------------------------------------------------------
 420 // PluginInterface protocol
 421 //------------------------------------------------------------------
 422 lldb_private::ConstString
 423 ObjectFileELF::GetPluginName()
 424 {
 425     return GetPluginNameStatic();
 426 }
 427
 428 uint32_t
 429 ObjectFileELF::GetPluginVersion()
 430 {
 431     return m_plugin_version;
 432 }
 433 //------------------------------------------------------------------
 434 // ObjectFile protocol
 435 //------------------------------------------------------------------
 436
 437 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp,
 438                               DataBufferSP& data_sp,
 439                               lldb::offset_t data_offset,
 440                               const FileSpec* file,
 441                               lldb::offset_t file_offset,
 442                               lldb::offset_t length) :
 443     ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
 444     m_header(),
 445     m_program_headers(),
 446     m_section_headers(),
 447     m_filespec_ap()
 448 {
 449     if (file)
 450         m_file = *file;
 451     ::memset(&m_header, 0, sizeof(m_header));
 452     m_gnu_debuglink_crc = 0;
 453     m_gnu_debuglink_file.clear();
 454 }
 455
 456 ObjectFileELF::~ObjectFileELF()
 457 {
 458 }
 459
 460 bool
 461 ObjectFileELF::IsExecutable() const
 462 {
 463     return m_header.e_entry != 0;
 464 }
 465
 466 bool
 467 ObjectFileELF::SetLoadAddress (Target &target,
 468                                lldb::addr_t value,
 469                                bool value_is_offset)
 470 {
 471     ModuleSP module_sp = GetModule();
 472     if (module_sp)
 473     {
 474         size_t num_loaded_sections = 0;
 475         SectionList *section_list = GetSectionList ();
 476         if (section_list)
 477         {
 478             if (value_is_offset)
 479             {
 480                 const size_t num_sections = section_list->GetSize();
 481                 size_t sect_idx = 0;
 482
 483                 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx)
 484                 {
 485                     // Iterate through the object file sections to find all
 486                     // of the sections that have SHF_ALLOC in their flag bits.
 487                     SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx));
 488                     // if (section_sp && !section_sp->IsThreadSpecific())
 489                     if (section_sp && section_sp->Test(SHF_ALLOC))
 490                     {
 491                         if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress() + value))
 492                             ++num_loaded_sections;
 493                     }
 494                 }
 495                 return num_loaded_sections > 0;
 496             }
 497             else
 498             {
 499                 // Not sure how to slide an ELF file given the base address
 500                 // of the ELF file in memory
 501             }
 502         }
 503     }
 504     return false; // If it changed
 505 }
 506
 507 ByteOrder
 508 ObjectFileELF::GetByteOrder() const
 509 {
 510     if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
 511         return eByteOrderBig;
 512     if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
 513         return eByteOrderLittle;
 514     return eByteOrderInvalid;
 515 }
 516
 517 uint32_t
 518 ObjectFileELF::GetAddressByteSize() const
 519 {
 520     return m_data.GetAddressByteSize();
 521 }
 522
 523 size_t
 524 ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I)
 525 {
 526     return std::distance(m_section_headers.begin(), I) + 1u;
 527 }
 528
 529 size_t
 530 ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const
 531 {
 532     return std::distance(m_section_headers.begin(), I) + 1u;
 533 }
 534
 535 bool
 536 ObjectFileELF::ParseHeader()
 537 {
 538     lldb::offset_t offset = 0;
 539     return m_header.Parse(m_data, &offset);
 540 }
 541
 542 bool
 543 ObjectFileELF::GetUUID(lldb_private::UUID* uuid)
 544 {
 545     // Need to parse the section list to get the UUIDs, so make sure that's been done.
 546     if (!ParseSectionHeaders())
 547         return false;
 548
 549     if (m_uuid.IsValid())
 550     {
 551         // We have the full build id uuid.
 552         *uuid = m_uuid;
 553         return true;
 554     }
 555     else
 556     {
 557         if (!m_gnu_debuglink_crc)
 558             m_gnu_debuglink_crc = calc_gnu_debuglink_crc32 (m_data.GetDataStart(), m_data.GetByteSize());
 559         if (m_gnu_debuglink_crc)
 560         {
 561             // Use 4 bytes of crc from the .gnu_debuglink section.
 562             uint32_t uuidt[4] = { m_gnu_debuglink_crc, 0, 0, 0 };
 563             uuid->SetBytes (uuidt, sizeof(uuidt));
 564             return true;
 565         }
 566     }
 567
 568     return false;
 569 }
 570
 571 lldb_private::FileSpecList
 572 ObjectFileELF::GetDebugSymbolFilePaths()
 573 {
 574     FileSpecList file_spec_list;
 575
 576     if (!m_gnu_debuglink_file.empty())
 577     {
 578         FileSpec file_spec (m_gnu_debuglink_file.c_str(), false);
 579         file_spec_list.Append (file_spec);
 580     }
 581     return file_spec_list;
 582 }
 583
 584 uint32_t
 585 ObjectFileELF::GetDependentModules(FileSpecList &files)
 586 {
 587     size_t num_modules = ParseDependentModules();
 588     uint32_t num_specs = 0;
 589
 590     for (unsigned i = 0; i < num_modules; ++i)
 591     {
 592         if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i)))
 593             num_specs++;
 594     }
 595
 596     return num_specs;
 597 }
 598
 599 Address
 600 ObjectFileELF::GetImageInfoAddress(Target *target)
 601 {
 602     if (!ParseDynamicSymbols())
 603         return Address();
 604
 605     SectionList *section_list = GetSectionList();
 606     if (!section_list)
 607         return Address();
 608
 609     // Find the SHT_DYNAMIC (.dynamic) section.
 610     SectionSP dynsym_section_sp (section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true));
 611     if (!dynsym_section_sp)
 612         return Address();
 613     assert (dynsym_section_sp->GetObjectFile() == this);
 614
 615     user_id_t dynsym_id = dynsym_section_sp->GetID();
 616     const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id);
 617     if (!dynsym_hdr)
 618         return Address();
 619
 620     for (size_t i = 0; i < m_dynamic_symbols.size(); ++i)
 621     {
 622         ELFDynamic &symbol = m_dynamic_symbols[i];
 623
 624         if (symbol.d_tag == DT_DEBUG)
 625         {
 626             // Compute the offset as the number of previous entries plus the
 627             // size of d_tag.
 628             addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
 629             return Address(dynsym_section_sp, offset);
 630         }
 631         else if (symbol.d_tag == DT_MIPS_RLD_MAP && target)
 632         {
 633             addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
 634             addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
 635             if (dyn_base == LLDB_INVALID_ADDRESS)
 636                 return Address();
 637             Address addr;
 638             Error error;
 639             if (target->ReadPointerFromMemory(dyn_base + offset, false, error, addr))
 640                 return addr;
 641         }
 642     }
 643
 644     return Address();
 645 }
 646
 647 lldb_private::Address
 648 ObjectFileELF::GetEntryPointAddress ()
 649 {
 650     if (m_entry_point_address.IsValid())
 651         return m_entry_point_address;
 652
 653     if (!ParseHeader() || !IsExecutable())
 654         return m_entry_point_address;
 655
 656     SectionList *section_list = GetSectionList();
 657     addr_t offset = m_header.e_entry;
 658
 659     if (!section_list)
 660         m_entry_point_address.SetOffset(offset);
 661     else
 662         m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list);
 663     return m_entry_point_address;
 664 }
 665
 666 //----------------------------------------------------------------------
 667 // ParseDependentModules
 668 //----------------------------------------------------------------------
 669 size_t
 670 ObjectFileELF::ParseDependentModules()
 671 {
 672     if (m_filespec_ap.get())
 673         return m_filespec_ap->GetSize();
 674
 675     m_filespec_ap.reset(new FileSpecList());
 676
 677     if (!ParseSectionHeaders())
 678         return 0;
 679
 680     SectionList *section_list = GetSectionList();
 681     if (!section_list)
 682         return 0;
 683
 684     // Find the SHT_DYNAMIC section.
 685     Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get();
 686     if (!dynsym)
 687         return 0;
 688     assert (dynsym->GetObjectFile() == this);
 689
 690     const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex (dynsym->GetID());
 691     if (!header)
 692         return 0;
 693     // sh_link: section header index of string table used by entries in the section.
 694     Section *dynstr = section_list->FindSectionByID (header->sh_link + 1).get();
 695     if (!dynstr)
 696         return 0;
 697
 698     DataExtractor dynsym_data;
 699     DataExtractor dynstr_data;
 700     if (ReadSectionData(dynsym, dynsym_data) &&
 701         ReadSectionData(dynstr, dynstr_data))
 702     {
 703         ELFDynamic symbol;
 704         const lldb::offset_t section_size = dynsym_data.GetByteSize();
 705         lldb::offset_t offset = 0;
 706
 707         // The only type of entries we are concerned with are tagged DT_NEEDED,
 708         // yielding the name of a required library.
 709         while (offset < section_size)
 710         {
 711             if (!symbol.Parse(dynsym_data, &offset))
 712                 break;
 713
 714             if (symbol.d_tag != DT_NEEDED)
 715                 continue;
 716
 717             uint32_t str_index = static_cast<uint32_t>(symbol.d_val);
 718             const char *lib_name = dynstr_data.PeekCStr(str_index);
 719             m_filespec_ap->Append(FileSpec(lib_name, true));
 720         }
 721     }
 722
 723     return m_filespec_ap->GetSize();
 724 }
 725
 726 //----------------------------------------------------------------------
 727 // ParseProgramHeaders
 728 //----------------------------------------------------------------------
 729 size_t
 730 ObjectFileELF::ParseProgramHeaders()
 731 {
 732     // We have already parsed the program headers
 733     if (!m_program_headers.empty())
 734         return m_program_headers.size();
 735
 736     // If there are no program headers to read we are done.
 737     if (m_header.e_phnum == 0)
 738         return 0;
 739
 740     m_program_headers.resize(m_header.e_phnum);
 741     if (m_program_headers.size() != m_header.e_phnum)
 742         return 0;
 743
 744     const size_t ph_size = m_header.e_phnum * m_header.e_phentsize;
 745     const elf_off ph_offset = m_header.e_phoff;
 746     DataExtractor data;
 747     if (GetData (ph_offset, ph_size, data) != ph_size)
 748         return 0;
 749
 750     uint32_t idx;
 751     lldb::offset_t offset;
 752     for (idx = 0, offset = 0; idx < m_header.e_phnum; ++idx)
 753     {
 754         if (m_program_headers[idx].Parse(data, &offset) == false)
 755             break;
 756     }
 757
 758     if (idx < m_program_headers.size())
 759         m_program_headers.resize(idx);
 760
 761     return m_program_headers.size();
 762 }
 763
 764 static bool
 765 ParseNoteGNUBuildID(DataExtractor &data, lldb_private::UUID &uuid)
 766 {
 767     // Try to parse the note section (ie .note.gnu.build-id|.notes|.note|...) and get the build id.
 768     // BuildID documentation: https://fedoraproject.org/wiki/Releases/FeatureBuildId
 769     lldb::offset_t offset = 0;
 770     static const uint32_t g_gnu_build_id = 3; // NT_GNU_BUILD_ID from elf.h
 771
 772     while (true)
 773     {
 774         ELFNote note = ELFNote();
 775         if (!note.Parse(data, &offset))
 776             return false;
 777
 778         // 16 bytes is UUID|MD5, 20 bytes is SHA1
 779         if (note.n_name == "GNU" && (note.n_type == g_gnu_build_id) &&
 780             (note.n_descsz == 16 || note.n_descsz == 20))
 781         {
 782             uint8_t uuidbuf[20];
 783             if (data.GetU8 (&offset, &uuidbuf, note.n_descsz) == NULL)
 784                 return false;
 785             uuid.SetBytes (uuidbuf, note.n_descsz);
 786             return true;
 787         }
 788         offset += llvm::RoundUpToAlignment(note.n_descsz, 4);
 789     }
 790     return false;
 791 }
 792
 793 //----------------------------------------------------------------------
 794 // GetSectionHeaderInfo
 795 //----------------------------------------------------------------------
 796 size_t
 797 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
 798                                     lldb_private::DataExtractor &object_data,
 799                                     const elf::ELFHeader &header,
 800                                     lldb_private::UUID &uuid,
 801                                     std::string &gnu_debuglink_file,
 802                                     uint32_t &gnu_debuglink_crc)
 803 {
 804     // We have already parsed the section headers
 805     if (!section_headers.empty())
 806         return section_headers.size();
 807
 808     // If there are no section headers we are done.
 809     if (header.e_shnum == 0)
 810         return 0;
 811
 812     section_headers.resize(header.e_shnum);
 813     if (section_headers.size() != header.e_shnum)
 814         return 0;
 815
 816     const size_t sh_size = header.e_shnum * header.e_shentsize;
 817     const elf_off sh_offset = header.e_shoff;
 818     DataExtractor sh_data;
 819     if (sh_data.SetData (object_data, sh_offset, sh_size) != sh_size)
 820         return 0;
 821
 822     uint32_t idx;
 823     lldb::offset_t offset;
 824     for (idx = 0, offset = 0; idx < header.e_shnum; ++idx)
 825     {
 826         if (section_headers[idx].Parse(sh_data, &offset) == false)
 827             break;
 828     }
 829     if (idx < section_headers.size())
 830         section_headers.resize(idx);
 831
 832     const unsigned strtab_idx = header.e_shstrndx;
 833     if (strtab_idx && strtab_idx < section_headers.size())
 834     {
 835         const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx];
 836         const size_t byte_size = sheader.sh_size;
 837         const Elf64_Off offset = sheader.sh_offset;
 838         lldb_private::DataExtractor shstr_data;
 839
 840         if (shstr_data.SetData (object_data, offset, byte_size) == byte_size)
 841         {
 842             for (SectionHeaderCollIter I = section_headers.begin();
 843                  I != section_headers.end(); ++I)
 844             {
 845                 static ConstString g_sect_name_gnu_debuglink (".gnu_debuglink");
 846                 const ELFSectionHeaderInfo &header = *I;
 847                 const uint64_t section_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
 848                 ConstString name(shstr_data.PeekCStr(I->sh_name));
 849
 850                 I->section_name = name;
 851
 852                 if (name == g_sect_name_gnu_debuglink)
 853                 {
 854                     DataExtractor data;
 855                     if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size))
 856                     {
 857                         lldb::offset_t gnu_debuglink_offset = 0;
 858                         gnu_debuglink_file = data.GetCStr (&gnu_debuglink_offset);
 859                         gnu_debuglink_offset = llvm::RoundUpToAlignment (gnu_debuglink_offset, 4);
 860                         data.GetU32 (&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
 861                     }
 862                 }
 863
 864                 if (header.sh_type == SHT_NOTE && !uuid.IsValid())
 865                 {
 866                     DataExtractor data;
 867                     if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size))
 868                     {
 869                         ParseNoteGNUBuildID (data, uuid);
 870                     }
 871                 }
 872             }
 873
 874             return section_headers.size();
 875         }
 876     }
 877
 878     section_headers.clear();
 879     return 0;
 880 }
 881
 882 size_t
 883 ObjectFileELF::GetProgramHeaderCount()
 884 {
 885     return ParseProgramHeaders();
 886 }
 887
 888 const elf::ELFProgramHeader *
 889 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id)
 890 {
 891     if (!id || !ParseProgramHeaders())
 892         return NULL;
 893
 894     if (--id < m_program_headers.size())
 895         return &m_program_headers[id];
 896
 897     return NULL;
 898 }
 899
 900 DataExtractor
 901 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id)
 902 {
 903     const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id);
 904     if (segment_header == NULL)
 905         return DataExtractor();
 906     return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz);
 907 }
 908
 909 //----------------------------------------------------------------------
 910 // ParseSectionHeaders
 911 //----------------------------------------------------------------------
 912 size_t
 913 ObjectFileELF::ParseSectionHeaders()
 914 {
 915     return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc);
 916 }
 917
 918 const ObjectFileELF::ELFSectionHeaderInfo *
 919 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id)
 920 {
 921     if (!id || !ParseSectionHeaders())
 922         return NULL;
 923
 924     if (--id < m_section_headers.size())
 925         return &m_section_headers[id];
 926
 927     return NULL;
 928 }
 929
 930 void
 931 ObjectFileELF::CreateSections(SectionList &unified_section_list)
 932 {
 933     if (!m_sections_ap.get() && ParseSectionHeaders())
 934     {
 935         m_sections_ap.reset(new SectionList());
 936
 937         for (SectionHeaderCollIter I = m_section_headers.begin();
 938              I != m_section_headers.end(); ++I)
 939         {
 940             const ELFSectionHeaderInfo &header = *I;
 941
 942             ConstString& name = I->section_name;
 943             const uint64_t file_size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
 944             const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0;
 945
 946             static ConstString g_sect_name_text (".text");
 947             static ConstString g_sect_name_data (".data");
 948             static ConstString g_sect_name_bss (".bss");
 949             static ConstString g_sect_name_tdata (".tdata");
 950             static ConstString g_sect_name_tbss (".tbss");
 951             static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev");
 952             static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges");
 953             static ConstString g_sect_name_dwarf_debug_frame (".debug_frame");
 954             static ConstString g_sect_name_dwarf_debug_info (".debug_info");
 955             static ConstString g_sect_name_dwarf_debug_line (".debug_line");
 956             static ConstString g_sect_name_dwarf_debug_loc (".debug_loc");
 957             static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo");
 958             static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames");
 959             static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes");
 960             static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges");
 961             static ConstString g_sect_name_dwarf_debug_str (".debug_str");
 962             static ConstString g_sect_name_eh_frame (".eh_frame");
 963
 964             SectionType sect_type = eSectionTypeOther;
 965
 966             bool is_thread_specific = false;
 967
 968             if      (name == g_sect_name_text)                  sect_type = eSectionTypeCode;
 969             else if (name == g_sect_name_data)                  sect_type = eSectionTypeData;
 970             else if (name == g_sect_name_bss)                   sect_type = eSectionTypeZeroFill;
 971             else if (name == g_sect_name_tdata)
 972             {
 973                 sect_type = eSectionTypeData;
 974                 is_thread_specific = true;
 975             }
 976             else if (name == g_sect_name_tbss)
 977             {
 978                 sect_type = eSectionTypeZeroFill;
 979                 is_thread_specific = true;
 980             }
 981             // .debug_abbrev – Abbreviations used in the .debug_info section
 982             // .debug_aranges – Lookup table for mapping addresses to compilation units
 983             // .debug_frame – Call frame information
 984             // .debug_info – The core DWARF information section
 985             // .debug_line – Line number information
 986             // .debug_loc – Location lists used in DW_AT_location attributes
 987             // .debug_macinfo – Macro information
 988             // .debug_pubnames – Lookup table for mapping object and function names to compilation units
 989             // .debug_pubtypes – Lookup table for mapping type names to compilation units
 990             // .debug_ranges – Address ranges used in DW_AT_ranges attributes
 991             // .debug_str – String table used in .debug_info
 992             // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html
 993             // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644
 994             // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo
 995             else if (name == g_sect_name_dwarf_debug_abbrev)    sect_type = eSectionTypeDWARFDebugAbbrev;
 996             else if (name == g_sect_name_dwarf_debug_aranges)   sect_type = eSectionTypeDWARFDebugAranges;
 997             else if (name == g_sect_name_dwarf_debug_frame)     sect_type = eSectionTypeDWARFDebugFrame;
 998             else if (name == g_sect_name_dwarf_debug_info)      sect_type = eSectionTypeDWARFDebugInfo;
 999             else if (name == g_sect_name_dwarf_debug_line)      sect_type = eSectionTypeDWARFDebugLine;
1000             else if (name == g_sect_name_dwarf_debug_loc)       sect_type = eSectionTypeDWARFDebugLoc;
1001             else if (name == g_sect_name_dwarf_debug_macinfo)   sect_type = eSectionTypeDWARFDebugMacInfo;
1002             else if (name == g_sect_name_dwarf_debug_pubnames)  sect_type = eSectionTypeDWARFDebugPubNames;
1003             else if (name == g_sect_name_dwarf_debug_pubtypes)  sect_type = eSectionTypeDWARFDebugPubTypes;
1004             else if (name == g_sect_name_dwarf_debug_ranges)    sect_type = eSectionTypeDWARFDebugRanges;
1005             else if (name == g_sect_name_dwarf_debug_str)       sect_type = eSectionTypeDWARFDebugStr;
1006             else if (name == g_sect_name_eh_frame)              sect_type = eSectionTypeEHFrame;
1007
1008             switch (header.sh_type)
1009             {
1010                 case SHT_SYMTAB:
1011                     assert (sect_type == eSectionTypeOther);
1012                     sect_type = eSectionTypeELFSymbolTable;
1013                     break;
1014                 case SHT_DYNSYM:
1015                     assert (sect_type == eSectionTypeOther);
1016                     sect_type = eSectionTypeELFDynamicSymbols;
1017                     break;
1018                 case SHT_RELA:
1019                 case SHT_REL:
1020                     assert (sect_type == eSectionTypeOther);
1021                     sect_type = eSectionTypeELFRelocationEntries;
1022                     break;
1023                 case SHT_DYNAMIC:
1024                     assert (sect_type == eSectionTypeOther);
1025                     sect_type = eSectionTypeELFDynamicLinkInfo;
1026                     break;
1027             }
1028
1029             SectionSP section_sp (new Section(GetModule(),        // Module to which this section belongs.
1030                                               this,               // ObjectFile to which this section belongs and should read section data from.
1031                                               SectionIndex(I),    // Section ID.
1032                                               name,               // Section name.
1033                                               sect_type,          // Section type.
1034                                               header.sh_addr,     // VM address.
1035                                               vm_size,            // VM size in bytes of this section.
1036                                               header.sh_offset,   // Offset of this section in the file.
1037                                               file_size,          // Size of the section as found in the file.
1038                                               header.sh_flags));  // Flags for this section.
1039
1040             if (is_thread_specific)
1041                 section_sp->SetIsThreadSpecific (is_thread_specific);
1042             m_sections_ap->AddSection(section_sp);
1043         }
1044     }
1045
1046     if (m_sections_ap.get())
1047     {
1048         if (GetType() == eTypeDebugInfo)
1049         {
1050             static const SectionType g_sections[] =
1051             {
1052                 eSectionTypeDWARFDebugAranges,
1053                 eSectionTypeDWARFDebugInfo,
1054                 eSectionTypeDWARFDebugAbbrev,
1055                 eSectionTypeDWARFDebugFrame,
1056                 eSectionTypeDWARFDebugLine,
1057                 eSectionTypeDWARFDebugStr,
1058                 eSectionTypeDWARFDebugLoc,
1059                 eSectionTypeDWARFDebugMacInfo,
1060                 eSectionTypeDWARFDebugPubNames,
1061                 eSectionTypeDWARFDebugPubTypes,
1062                 eSectionTypeDWARFDebugRanges,
1063                 eSectionTypeELFSymbolTable,
1064             };
1065             SectionList *elf_section_list = m_sections_ap.get();
1066             for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]); ++idx)
1067             {
1068                 SectionType section_type = g_sections[idx];
1069                 SectionSP section_sp (elf_section_list->FindSectionByType (section_type, true));
1070                 if (section_sp)
1071                 {
1072                     SectionSP module_section_sp (unified_section_list.FindSectionByType (section_type, true));
1073                     if (module_section_sp)
1074                         unified_section_list.ReplaceSection (module_section_sp->GetID(), section_sp);
1075                     else
1076                         unified_section_list.AddSection (section_sp);
1077                 }
1078             }
1079         }
1080         else
1081         {
1082             unified_section_list = *m_sections_ap;
1083         }
1084     }
1085 }
1086
1087 // private
1088 unsigned
1089 ObjectFileELF::ParseSymbols (Symtab *symtab,
1090                              user_id_t start_id,
1091                              SectionList *section_list,
1092                              const size_t num_symbols,
1093                              const DataExtractor &symtab_data,
1094                              const DataExtractor &strtab_data)
1095 {
1096     ELFSymbol symbol;
1097     lldb::offset_t offset = 0;
1098
1099     static ConstString text_section_name(".text");
1100     static ConstString init_section_name(".init");
1101     static ConstString fini_section_name(".fini");
1102     static ConstString ctors_section_name(".ctors");
1103     static ConstString dtors_section_name(".dtors");
1104
1105     static ConstString data_section_name(".data");
1106     static ConstString rodata_section_name(".rodata");
1107     static ConstString rodata1_section_name(".rodata1");
1108     static ConstString data2_section_name(".data1");
1109     static ConstString bss_section_name(".bss");
1110
1111     //StreamFile strm(stdout, false);
1112     unsigned i;
1113     for (i = 0; i < num_symbols; ++i)
1114     {
1115         if (symbol.Parse(symtab_data, &offset) == false)
1116             break;
1117
1118         const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
1119
1120         // No need to add symbols that have no names
1121         if (symbol_name == NULL || symbol_name[0] == '\0')
1122             continue;
1123
1124         //symbol.Dump (&strm, i, &strtab_data, section_list);
1125
1126         SectionSP symbol_section_sp;
1127         SymbolType symbol_type = eSymbolTypeInvalid;
1128         Elf64_Half symbol_idx = symbol.st_shndx;
1129
1130         switch (symbol_idx)
1131         {
1132         case SHN_ABS:
1133             symbol_type = eSymbolTypeAbsolute;
1134             break;
1135         case SHN_UNDEF:
1136             symbol_type = eSymbolTypeUndefined;
1137             break;
1138         default:
1139             symbol_section_sp = section_list->GetSectionAtIndex(symbol_idx);
1140             break;
1141         }
1142
1143         // If a symbol is undefined do not process it further even if it has a STT type
1144         if (symbol_type != eSymbolTypeUndefined)
1145         {
1146             switch (symbol.getType())
1147             {
1148             default:
1149             case STT_NOTYPE:
1150                 // The symbol's type is not specified.
1151                 break;
1152
1153             case STT_OBJECT:
1154                 // The symbol is associated with a data object, such as a variable,
1155                 // an array, etc.
1156                 symbol_type = eSymbolTypeData;
1157                 break;
1158
1159             case STT_FUNC:
1160                 // The symbol is associated with a function or other executable code.
1161                 symbol_type = eSymbolTypeCode;
1162                 break;
1163
1164             case STT_SECTION:
1165                 // The symbol is associated with a section. Symbol table entries of
1166                 // this type exist primarily for relocation and normally have
1167                 // STB_LOCAL binding.
1168                 break;
1169
1170             case STT_FILE:
1171                 // Conventionally, the symbol's name gives the name of the source
1172                 // file associated with the object file. A file symbol has STB_LOCAL
1173                 // binding, its section index is SHN_ABS, and it precedes the other
1174                 // STB_LOCAL symbols for the file, if it is present.
1175                 symbol_type = eSymbolTypeSourceFile;
1176                 break;
1177
1178             case STT_GNU_IFUNC:
1179                 // The symbol is associated with an indirect function. The actual
1180                 // function will be resolved if it is referenced.
1181                 symbol_type = eSymbolTypeResolver;
1182                 break;
1183             }
1184         }
1185
1186         if (symbol_type == eSymbolTypeInvalid)
1187         {
1188             if (symbol_section_sp)
1189             {
1190                 const ConstString &sect_name = symbol_section_sp->GetName();
1191                 if (sect_name == text_section_name ||
1192                     sect_name == init_section_name ||
1193                     sect_name == fini_section_name ||
1194                     sect_name == ctors_section_name ||
1195                     sect_name == dtors_section_name)
1196                 {
1197                     symbol_type = eSymbolTypeCode;
1198                 }
1199                 else if (sect_name == data_section_name ||
1200                          sect_name == data2_section_name ||
1201                          sect_name == rodata_section_name ||
1202                          sect_name == rodata1_section_name ||
1203                          sect_name == bss_section_name)
1204                 {
1205                     symbol_type = eSymbolTypeData;
1206                 }
1207             }
1208         }
1209
1210         // If the symbol section we've found has no data (SHT_NOBITS), then check the module section
1211         // list. This can happen if we're parsing the debug file and it has no .text section, for example.
1212         if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0))
1213         {
1214             ModuleSP module_sp(GetModule());
1215             if (module_sp)
1216             {
1217                 SectionList *module_section_list = module_sp->GetSectionList();
1218                 if (module_section_list && module_section_list != section_list)
1219                 {
1220                     const ConstString &sect_name = symbol_section_sp->GetName();
1221                     lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name));
1222                     if (section_sp && section_sp->GetFileSize())
1223                     {
1224                         symbol_section_sp = section_sp;
1225                     }
1226                 }
1227             }
1228         }
1229
1230         uint64_t symbol_value = symbol.st_value;
1231         if (symbol_section_sp)
1232             symbol_value -= symbol_section_sp->GetFileAddress();
1233         bool is_global = symbol.getBinding() == STB_GLOBAL;
1234         uint32_t flags = symbol.st_other << 8 | symbol.st_info;
1235         bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
1236         Symbol dc_symbol(
1237             i + start_id,       // ID is the original symbol table index.
1238             symbol_name,        // Symbol name.
1239             is_mangled,         // Is the symbol name mangled?
1240             symbol_type,        // Type of this symbol
1241             is_global,          // Is this globally visible?
1242             false,              // Is this symbol debug info?
1243             false,              // Is this symbol a trampoline?
1244             false,              // Is this symbol artificial?
1245             symbol_section_sp,  // Section in which this symbol is defined or null.
1246             symbol_value,       // Offset in section or symbol value.
1247             symbol.st_size,     // Size in bytes of this symbol.
1248             true,               // Size is valid
1249             flags);             // Symbol flags.
1250         symtab->AddSymbol(dc_symbol);
1251     }
1252
1253     return i;
1254 }
1255
1256 unsigned
1257 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab)
1258 {
1259     if (symtab->GetObjectFile() != this)
1260     {
1261         // If the symbol table section is owned by a different object file, have it do the
1262         // parsing.
1263         ObjectFileELF *obj_file_elf = static_cast<ObjectFileELF *>(symtab->GetObjectFile());
1264         return obj_file_elf->ParseSymbolTable (symbol_table, start_id, symtab);
1265     }
1266
1267     // Get section list for this object file.
1268     SectionList *section_list = m_sections_ap.get();
1269     if (!section_list)
1270         return 0;
1271
1272     user_id_t symtab_id = symtab->GetID();
1273     const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
1274     assert(symtab_hdr->sh_type == SHT_SYMTAB ||
1275            symtab_hdr->sh_type == SHT_DYNSYM);
1276
1277     // sh_link: section header index of associated string table.
1278     // Section ID's are ones based.
1279     user_id_t strtab_id = symtab_hdr->sh_link + 1;
1280     Section *strtab = section_list->FindSectionByID(strtab_id).get();
1281
1282     unsigned num_symbols = 0;
1283     if (symtab && strtab)
1284     {
1285         assert (symtab->GetObjectFile() == this);
1286         assert (strtab->GetObjectFile() == this);
1287
1288         DataExtractor symtab_data;
1289         DataExtractor strtab_data;
1290         if (ReadSectionData(symtab, symtab_data) &&
1291             ReadSectionData(strtab, strtab_data))
1292         {
1293             size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize;
1294
1295             num_symbols = ParseSymbols(symbol_table, start_id,
1296                                        section_list, num_symbols,
1297                                        symtab_data, strtab_data);
1298         }
1299     }
1300
1301     return num_symbols;
1302 }
1303
1304 size_t
1305 ObjectFileELF::ParseDynamicSymbols()
1306 {
1307     if (m_dynamic_symbols.size())
1308         return m_dynamic_symbols.size();
1309
1310     SectionList *section_list = GetSectionList();
1311     if (!section_list)
1312         return 0;
1313
1314     // Find the SHT_DYNAMIC section.
1315     Section *dynsym = section_list->FindSectionByType (eSectionTypeELFDynamicLinkInfo, true).get();
1316     if (!dynsym)
1317         return 0;
1318     assert (dynsym->GetObjectFile() == this);
1319
1320     ELFDynamic symbol;
1321     DataExtractor dynsym_data;
1322     if (ReadSectionData(dynsym, dynsym_data))
1323     {
1324         const lldb::offset_t section_size = dynsym_data.GetByteSize();
1325         lldb::offset_t cursor = 0;
1326
1327         while (cursor < section_size)
1328         {
1329             if (!symbol.Parse(dynsym_data, &cursor))
1330                 break;
1331
1332             m_dynamic_symbols.push_back(symbol);
1333         }
1334     }
1335
1336     return m_dynamic_symbols.size();
1337 }
1338
1339 const ELFDynamic *
1340 ObjectFileELF::FindDynamicSymbol(unsigned tag)
1341 {
1342     if (!ParseDynamicSymbols())
1343         return NULL;
1344
1345     DynamicSymbolCollIter I = m_dynamic_symbols.begin();
1346     DynamicSymbolCollIter E = m_dynamic_symbols.end();
1347     for ( ; I != E; ++I)
1348     {
1349         ELFDynamic *symbol = &*I;
1350
1351         if (symbol->d_tag == tag)
1352             return symbol;
1353     }
1354
1355     return NULL;
1356 }
1357
1358 unsigned
1359 ObjectFileELF::PLTRelocationType()
1360 {
1361     // DT_PLTREL
1362     //  This member specifies the type of relocation entry to which the
1363     //  procedure linkage table refers. The d_val member holds DT_REL or
1364     //  DT_RELA, as appropriate. All relocations in a procedure linkage table
1365     //  must use the same relocation.
1366     const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL);
1367
1368     if (symbol)
1369         return symbol->d_val;
1370
1371     return 0;
1372 }
1373
1374 static unsigned
1375 ParsePLTRelocations(Symtab *symbol_table,
1376                     user_id_t start_id,
1377                     unsigned rel_type,
1378                     const ELFHeader *hdr,
1379                     const ELFSectionHeader *rel_hdr,
1380                     const ELFSectionHeader *plt_hdr,
1381                     const ELFSectionHeader *sym_hdr,
1382                     const lldb::SectionSP &plt_section_sp,
1383                     DataExtractor &rel_data,
1384                     DataExtractor &symtab_data,
1385                     DataExtractor &strtab_data)
1386 {
1387     ELFRelocation rel(rel_type);
1388     ELFSymbol symbol;
1389     lldb::offset_t offset = 0;
1390     // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16 bytes.
1391     // So round the entsize up by the alignment if addralign is set.
1392     const elf_xword plt_entsize = plt_hdr->sh_addralign ?
1393         llvm::RoundUpToAlignment (plt_hdr->sh_entsize, plt_hdr->sh_addralign) : plt_hdr->sh_entsize;
1394     const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
1395
1396     typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
1397     reloc_info_fn reloc_type;
1398     reloc_info_fn reloc_symbol;
1399
1400     if (hdr->Is32Bit())
1401     {
1402         reloc_type = ELFRelocation::RelocType32;
1403         reloc_symbol = ELFRelocation::RelocSymbol32;
1404     }
1405     else
1406     {
1407         reloc_type = ELFRelocation::RelocType64;
1408         reloc_symbol = ELFRelocation::RelocSymbol64;
1409     }
1410
1411     unsigned slot_type = hdr->GetRelocationJumpSlotType();
1412     unsigned i;
1413     for (i = 0; i < num_relocations; ++i)
1414     {
1415         if (rel.Parse(rel_data, &offset) == false)
1416             break;
1417
1418         if (reloc_type(rel) != slot_type)
1419             continue;
1420
1421         lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize;
1422         uint64_t plt_index = (i + 1) * plt_entsize;
1423
1424         if (!symbol.Parse(symtab_data, &symbol_offset))
1425             break;
1426
1427         const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
1428         bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
1429
1430         Symbol jump_symbol(
1431             i + start_id,    // Symbol table index
1432             symbol_name,     // symbol name.
1433             is_mangled,      // is the symbol name mangled?
1434             eSymbolTypeTrampoline, // Type of this symbol
1435             false,           // Is this globally visible?
1436             false,           // Is this symbol debug info?
1437             true,            // Is this symbol a trampoline?
1438             true,            // Is this symbol artificial?
1439             plt_section_sp,  // Section in which this symbol is defined or null.
1440             plt_index,       // Offset in section or symbol value.
1441             plt_entsize,     // Size in bytes of this symbol.
1442             true,            // Size is valid
1443             0);              // Symbol flags.
1444
1445         symbol_table->AddSymbol(jump_symbol);
1446     }
1447
1448     return i;
1449 }
1450
1451 unsigned
1452 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table,
1453                                       user_id_t start_id,
1454                                       const ELFSectionHeaderInfo *rel_hdr,
1455                                       user_id_t rel_id)
1456 {
1457     assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
1458
1459     // The link field points to the associated symbol table. The info field
1460     // points to the section holding the plt.
1461     user_id_t symtab_id = rel_hdr->sh_link;
1462     user_id_t plt_id = rel_hdr->sh_info;
1463
1464     if (!symtab_id || !plt_id)
1465         return 0;
1466
1467     // Section ID's are ones based;
1468     symtab_id++;
1469     plt_id++;
1470
1471     const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id);
1472     if (!plt_hdr)
1473         return 0;
1474
1475     const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id);
1476     if (!sym_hdr)
1477         return 0;
1478
1479     SectionList *section_list = m_sections_ap.get();
1480     if (!section_list)
1481         return 0;
1482
1483     Section *rel_section = section_list->FindSectionByID(rel_id).get();
1484     if (!rel_section)
1485         return 0;
1486
1487     SectionSP plt_section_sp (section_list->FindSectionByID(plt_id));
1488     if (!plt_section_sp)
1489         return 0;
1490
1491     Section *symtab = section_list->FindSectionByID(symtab_id).get();
1492     if (!symtab)
1493         return 0;
1494
1495     // sh_link points to associated string table.
1496     Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get();
1497     if (!strtab)
1498         return 0;
1499
1500     DataExtractor rel_data;
1501     if (!ReadSectionData(rel_section, rel_data))
1502         return 0;
1503
1504     DataExtractor symtab_data;
1505     if (!ReadSectionData(symtab, symtab_data))
1506         return 0;
1507
1508     DataExtractor strtab_data;
1509     if (!ReadSectionData(strtab, strtab_data))
1510         return 0;
1511
1512     unsigned rel_type = PLTRelocationType();
1513     if (!rel_type)
1514         return 0;
1515
1516     return ParsePLTRelocations (symbol_table,
1517                                 start_id,
1518                                 rel_type,
1519                                 &m_header,
1520                                 rel_hdr,
1521                                 plt_hdr,
1522                                 sym_hdr,
1523                                 plt_section_sp,
1524                                 rel_data,
1525                                 symtab_data,
1526                                 strtab_data);
1527 }
1528
1529 Symtab *
1530 ObjectFileELF::GetSymtab()
1531 {
1532     ModuleSP module_sp(GetModule());
1533     if (!module_sp)
1534         return NULL;
1535
1536     // We always want to use the main object file so we (hopefully) only have one cached copy
1537     // of our symtab, dynamic sections, etc.
1538     ObjectFile *module_obj_file = module_sp->GetObjectFile();
1539     if (module_obj_file && module_obj_file != this)
1540         return module_obj_file->GetSymtab();
1541
1542     if (m_symtab_ap.get() == NULL)
1543     {
1544         SectionList *section_list = GetSectionList();
1545         if (!section_list)
1546             return NULL;
1547
1548         uint64_t symbol_id = 0;
1549         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
1550
1551         m_symtab_ap.reset(new Symtab(this));
1552
1553         // Sharable objects and dynamic executables usually have 2 distinct symbol
1554         // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller
1555         // version of the symtab that only contains global symbols. The information found
1556         // in the dynsym is therefore also found in the symtab, while the reverse is not
1557         // necessarily true.
1558         Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get();
1559         if (!symtab)
1560         {
1561             // The symtab section is non-allocable and can be stripped, so if it doesn't exist
1562             // then use the dynsym section which should always be there.
1563             symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get();
1564         }
1565         if (symtab)
1566             symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab);
1567
1568         // DT_JMPREL
1569         //      If present, this entry's d_ptr member holds the address of relocation
1570         //      entries associated solely with the procedure linkage table. Separating
1571         //      these relocation entries lets the dynamic linker ignore them during
1572         //      process initialization, if lazy binding is enabled. If this entry is
1573         //      present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
1574         //      also be present.
1575         const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
1576         if (symbol)
1577         {
1578             // Synthesize trampoline symbols to help navigate the PLT.
1579             addr_t addr = symbol->d_ptr;
1580             Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get();
1581             if (reloc_section)
1582             {
1583                 user_id_t reloc_id = reloc_section->GetID();
1584                 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id);
1585                 assert(reloc_header);
1586
1587                 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id);
1588             }
1589         }
1590     }
1591     return m_symtab_ap.get();
1592 }
1593
1594 Symbol *
1595 ObjectFileELF::ResolveSymbolForAddress(const Address& so_addr, bool verify_unique)
1596 {
1597     if (!m_symtab_ap.get())
1598         return nullptr; // GetSymtab() should be called first.
1599
1600     const SectionList *section_list = GetSectionList();
1601     if (!section_list)
1602         return nullptr;
1603
1604     if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo())
1605     {
1606         AddressRange range;
1607         if (eh_frame->GetAddressRange (so_addr, range))
1608         {
1609             const addr_t file_addr = range.GetBaseAddress().GetFileAddress();
1610             Symbol * symbol = verify_unique ? m_symtab_ap->FindSymbolContainingFileAddress(file_addr) : nullptr;
1611             if (symbol)
1612                 return symbol;
1613
1614             // Note that a (stripped) symbol won't be found by GetSymtab()...
1615             lldb::SectionSP eh_sym_section_sp = section_list->FindSectionContainingFileAddress(file_addr);
1616             if (eh_sym_section_sp.get())
1617             {
1618                 addr_t section_base = eh_sym_section_sp->GetFileAddress();
1619                 addr_t offset = file_addr - section_base;
1620                 uint64_t symbol_id = m_symtab_ap->GetNumSymbols();
1621
1622                 Symbol eh_symbol(
1623                         symbol_id,            // Symbol table index.
1624                         "???",                // Symbol name.
1625                         false,                // Is the symbol name mangled?
1626                         eSymbolTypeCode,      // Type of this symbol.
1627                         true,                 // Is this globally visible?
1628                         false,                // Is this symbol debug info?
1629                         false,                // Is this symbol a trampoline?
1630                         true,                 // Is this symbol artificial?
1631                         eh_sym_section_sp,    // Section in which this symbol is defined or null.
1632                         offset,               // Offset in section or symbol value.
1633                         range.GetByteSize(),  // Size in bytes of this symbol.
1634                         true,                 // Size is valid.
1635                         0);                   // Symbol flags.
1636                 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol))
1637                     return m_symtab_ap->SymbolAtIndex(symbol_id);
1638             }
1639         }
1640     }
1641     return nullptr;
1642 }
1643
1644
1645 bool
1646 ObjectFileELF::IsStripped ()
1647 {
1648     // TODO: determine this for ELF
1649     return false;
1650 }
1651
1652 //===----------------------------------------------------------------------===//
1653 // Dump
1654 //
1655 // Dump the specifics of the runtime file container (such as any headers
1656 // segments, sections, etc).
1657 //----------------------------------------------------------------------
1658 void
1659 ObjectFileELF::Dump(Stream *s)
1660 {
1661     DumpELFHeader(s, m_header);
1662     s->EOL();
1663     DumpELFProgramHeaders(s);
1664     s->EOL();
1665     DumpELFSectionHeaders(s);
1666     s->EOL();
1667     SectionList *section_list = GetSectionList();
1668     if (section_list)
1669         section_list->Dump(s, NULL, true, UINT32_MAX);
1670     Symtab *symtab = GetSymtab();
1671     if (symtab)
1672         symtab->Dump(s, NULL, eSortOrderNone);
1673     s->EOL();
1674     DumpDependentModules(s);
1675     s->EOL();
1676 }
1677
1678 //----------------------------------------------------------------------
1679 // DumpELFHeader
1680 //
1681 // Dump the ELF header to the specified output stream
1682 //----------------------------------------------------------------------
1683 void
1684 ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header)
1685 {
1686     s->PutCString("ELF Header\n");
1687     s->Printf("e_ident[EI_MAG0   ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
1688     s->Printf("e_ident[EI_MAG1   ] = 0x%2.2x '%c'\n",
1689               header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]);
1690     s->Printf("e_ident[EI_MAG2   ] = 0x%2.2x '%c'\n",
1691               header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]);
1692     s->Printf("e_ident[EI_MAG3   ] = 0x%2.2x '%c'\n",
1693               header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]);
1694
1695     s->Printf("e_ident[EI_CLASS  ] = 0x%2.2x\n", header.e_ident[EI_CLASS]);
1696     s->Printf("e_ident[EI_DATA   ] = 0x%2.2x ", header.e_ident[EI_DATA]);
1697     DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]);
1698     s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]);
1699     s->Printf ("e_ident[EI_PAD    ] = 0x%2.2x\n", header.e_ident[EI_PAD]);
1700
1701     s->Printf("e_type      = 0x%4.4x ", header.e_type);
1702     DumpELFHeader_e_type(s, header.e_type);
1703     s->Printf("\ne_machine   = 0x%4.4x\n", header.e_machine);
1704     s->Printf("e_version   = 0x%8.8x\n", header.e_version);
1705     s->Printf("e_entry     = 0x%8.8" PRIx64 "\n", header.e_entry);
1706     s->Printf("e_phoff     = 0x%8.8" PRIx64 "\n", header.e_phoff);
1707     s->Printf("e_shoff     = 0x%8.8" PRIx64 "\n", header.e_shoff);
1708     s->Printf("e_flags     = 0x%8.8x\n", header.e_flags);
1709     s->Printf("e_ehsize    = 0x%4.4x\n", header.e_ehsize);
1710     s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
1711     s->Printf("e_phnum     = 0x%4.4x\n", header.e_phnum);
1712     s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
1713     s->Printf("e_shnum     = 0x%4.4x\n", header.e_shnum);
1714     s->Printf("e_shstrndx  = 0x%4.4x\n", header.e_shstrndx);
1715 }
1716
1717 //----------------------------------------------------------------------
1718 // DumpELFHeader_e_type
1719 //
1720 // Dump an token value for the ELF header member e_type
1721 //----------------------------------------------------------------------
1722 void
1723 ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type)
1724 {
1725     switch (e_type)
1726     {
1727     case ET_NONE:   *s << "ET_NONE"; break;
1728     case ET_REL:    *s << "ET_REL"; break;
1729     case ET_EXEC:   *s << "ET_EXEC"; break;
1730     case ET_DYN:    *s << "ET_DYN"; break;
1731     case ET_CORE:   *s << "ET_CORE"; break;
1732     default:
1733         break;
1734     }
1735 }
1736
1737 //----------------------------------------------------------------------
1738 // DumpELFHeader_e_ident_EI_DATA
1739 //
1740 // Dump an token value for the ELF header member e_ident[EI_DATA]
1741 //----------------------------------------------------------------------
1742 void
1743 ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data)
1744 {
1745     switch (ei_data)
1746     {
1747     case ELFDATANONE:   *s << "ELFDATANONE"; break;
1748     case ELFDATA2LSB:   *s << "ELFDATA2LSB - Little Endian"; break;
1749     case ELFDATA2MSB:   *s << "ELFDATA2MSB - Big Endian"; break;
1750     default:
1751         break;
1752     }
1753 }
1754
1755
1756 //----------------------------------------------------------------------
1757 // DumpELFProgramHeader
1758 //
1759 // Dump a single ELF program header to the specified output stream
1760 //----------------------------------------------------------------------
1761 void
1762 ObjectFileELF::DumpELFProgramHeader(Stream *s, const ELFProgramHeader &ph)
1763 {
1764     DumpELFProgramHeader_p_type(s, ph.p_type);
1765     s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, ph.p_vaddr, ph.p_paddr);
1766     s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, ph.p_flags);
1767
1768     DumpELFProgramHeader_p_flags(s, ph.p_flags);
1769     s->Printf(") %8.8" PRIx64, ph.p_align);
1770 }
1771
1772 //----------------------------------------------------------------------
1773 // DumpELFProgramHeader_p_type
1774 //
1775 // Dump an token value for the ELF program header member p_type which
1776 // describes the type of the program header
1777 // ----------------------------------------------------------------------
1778 void
1779 ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type)
1780 {
1781     const int kStrWidth = 15;
1782     switch (p_type)
1783     {
1784     CASE_AND_STREAM(s, PT_NULL        , kStrWidth);
1785     CASE_AND_STREAM(s, PT_LOAD        , kStrWidth);
1786     CASE_AND_STREAM(s, PT_DYNAMIC     , kStrWidth);
1787     CASE_AND_STREAM(s, PT_INTERP      , kStrWidth);
1788     CASE_AND_STREAM(s, PT_NOTE        , kStrWidth);
1789     CASE_AND_STREAM(s, PT_SHLIB       , kStrWidth);
1790     CASE_AND_STREAM(s, PT_PHDR        , kStrWidth);
1791     CASE_AND_STREAM(s, PT_TLS         , kStrWidth);
1792     CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth);
1793     default:
1794         s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
1795         break;
1796     }
1797 }
1798
1799
1800 //----------------------------------------------------------------------
1801 // DumpELFProgramHeader_p_flags
1802 //
1803 // Dump an token value for the ELF program header member p_flags
1804 //----------------------------------------------------------------------
1805 void
1806 ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags)
1807 {
1808     *s  << ((p_flags & PF_X) ? "PF_X" : "    ")
1809         << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
1810         << ((p_flags & PF_W) ? "PF_W" : "    ")
1811         << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ')
1812         << ((p_flags & PF_R) ? "PF_R" : "    ");
1813 }
1814
1815 //----------------------------------------------------------------------
1816 // DumpELFProgramHeaders
1817 //
1818 // Dump all of the ELF program header to the specified output stream
1819 //----------------------------------------------------------------------
1820 void
1821 ObjectFileELF::DumpELFProgramHeaders(Stream *s)
1822 {
1823     if (ParseProgramHeaders())
1824     {
1825         s->PutCString("Program Headers\n");
1826         s->PutCString("IDX  p_type          p_offset p_vaddr  p_paddr  "
1827                       "p_filesz p_memsz  p_flags                   p_align\n");
1828         s->PutCString("==== --------------- -------- -------- -------- "
1829                       "-------- -------- ------------------------- --------\n");
1830
1831         uint32_t idx = 0;
1832         for (ProgramHeaderCollConstIter I = m_program_headers.begin();
1833              I != m_program_headers.end(); ++I, ++idx)
1834         {
1835             s->Printf("[%2u] ", idx);
1836             ObjectFileELF::DumpELFProgramHeader(s, *I);
1837             s->EOL();
1838         }
1839     }
1840 }
1841
1842 //----------------------------------------------------------------------
1843 // DumpELFSectionHeader
1844 //
1845 // Dump a single ELF section header to the specified output stream
1846 //----------------------------------------------------------------------
1847 void
1848 ObjectFileELF::DumpELFSectionHeader(Stream *s, const ELFSectionHeaderInfo &sh)
1849 {
1850     s->Printf("%8.8x ", sh.sh_name);
1851     DumpELFSectionHeader_sh_type(s, sh.sh_type);
1852     s->Printf(" %8.8" PRIx64 " (", sh.sh_flags);
1853     DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
1854     s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, sh.sh_offset, sh.sh_size);
1855     s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info);
1856     s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize);
1857 }
1858
1859 //----------------------------------------------------------------------
1860 // DumpELFSectionHeader_sh_type
1861 //
1862 // Dump an token value for the ELF section header member sh_type which
1863 // describes the type of the section
1864 //----------------------------------------------------------------------
1865 void
1866 ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type)
1867 {
1868     const int kStrWidth = 12;
1869     switch (sh_type)
1870     {
1871     CASE_AND_STREAM(s, SHT_NULL     , kStrWidth);
1872     CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth);
1873     CASE_AND_STREAM(s, SHT_SYMTAB   , kStrWidth);
1874     CASE_AND_STREAM(s, SHT_STRTAB   , kStrWidth);
1875     CASE_AND_STREAM(s, SHT_RELA     , kStrWidth);
1876     CASE_AND_STREAM(s, SHT_HASH     , kStrWidth);
1877     CASE_AND_STREAM(s, SHT_DYNAMIC  , kStrWidth);
1878     CASE_AND_STREAM(s, SHT_NOTE     , kStrWidth);
1879     CASE_AND_STREAM(s, SHT_NOBITS   , kStrWidth);
1880     CASE_AND_STREAM(s, SHT_REL      , kStrWidth);
1881     CASE_AND_STREAM(s, SHT_SHLIB    , kStrWidth);
1882     CASE_AND_STREAM(s, SHT_DYNSYM   , kStrWidth);
1883     CASE_AND_STREAM(s, SHT_LOPROC   , kStrWidth);
1884     CASE_AND_STREAM(s, SHT_HIPROC   , kStrWidth);
1885     CASE_AND_STREAM(s, SHT_LOUSER   , kStrWidth);
1886     CASE_AND_STREAM(s, SHT_HIUSER   , kStrWidth);
1887     default:
1888         s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
1889         break;
1890     }
1891 }
1892
1893 //----------------------------------------------------------------------
1894 // DumpELFSectionHeader_sh_flags
1895 //
1896 // Dump an token value for the ELF section header member sh_flags
1897 //----------------------------------------------------------------------
1898 void
1899 ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, elf_xword sh_flags)
1900 {
1901     *s  << ((sh_flags & SHF_WRITE) ? "WRITE" : "     ")
1902         << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
1903         << ((sh_flags & SHF_ALLOC) ? "ALLOC" : "     ")
1904         << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ')
1905         << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : "         ");
1906 }
1907
1908 //----------------------------------------------------------------------
1909 // DumpELFSectionHeaders
1910 //
1911 // Dump all of the ELF section header to the specified output stream
1912 //----------------------------------------------------------------------
1913 void
1914 ObjectFileELF::DumpELFSectionHeaders(Stream *s)
1915 {
1916     if (!ParseSectionHeaders())
1917         return;
1918
1919     s->PutCString("Section Headers\n");
1920     s->PutCString("IDX  name     type         flags                            "
1921                   "addr     offset   size     link     info     addralgn "
1922                   "entsize  Name\n");
1923     s->PutCString("==== -------- ------------ -------------------------------- "
1924                   "-------- -------- -------- -------- -------- -------- "
1925                   "-------- ====================\n");
1926
1927     uint32_t idx = 0;
1928     for (SectionHeaderCollConstIter I = m_section_headers.begin();
1929          I != m_section_headers.end(); ++I, ++idx)
1930     {
1931         s->Printf("[%2u] ", idx);
1932         ObjectFileELF::DumpELFSectionHeader(s, *I);
1933         const char* section_name = I->section_name.AsCString("");
1934         if (section_name)
1935             *s << ' ' << section_name << "\n";
1936     }
1937 }
1938
1939 void
1940 ObjectFileELF::DumpDependentModules(lldb_private::Stream *s)
1941 {
1942     size_t num_modules = ParseDependentModules();
1943
1944     if (num_modules > 0)
1945     {
1946         s->PutCString("Dependent Modules:\n");
1947         for (unsigned i = 0; i < num_modules; ++i)
1948         {
1949             const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i);
1950             s->Printf("   %s\n", spec.GetFilename().GetCString());
1951         }
1952     }
1953 }
1954
1955 bool
1956 ObjectFileELF::GetArchitecture (ArchSpec &arch)
1957 {
1958     if (!ParseHeader())
1959         return false;
1960
1961     arch.SetArchitecture (eArchTypeELF, m_header.e_machine, LLDB_INVALID_CPUTYPE);
1962     arch.GetTriple().setOSName (Host::GetOSString().GetCString());
1963     arch.GetTriple().setVendorName(Host::GetVendorString().GetCString());
1964     return true;
1965 }
1966
1967 ObjectFile::Type
1968 ObjectFileELF::CalculateType()
1969 {
1970     switch (m_header.e_type)
1971     {
1972         case llvm::ELF::ET_NONE:
1973             // 0 - No file type
1974             return eTypeUnknown;
1975
1976         case llvm::ELF::ET_REL:
1977             // 1 - Relocatable file
1978             return eTypeObjectFile;
1979
1980         case llvm::ELF::ET_EXEC:
1981             // 2 - Executable file
1982             return eTypeExecutable;
1983
1984         case llvm::ELF::ET_DYN:
1985             // 3 - Shared object file
1986             return eTypeSharedLibrary;
1987
1988         case ET_CORE:
1989             // 4 - Core file
1990             return eTypeCoreFile;
1991
1992         default:
1993             break;
1994     }
1995     return eTypeUnknown;
1996 }
1997
1998 ObjectFile::Strata
1999 ObjectFileELF::CalculateStrata()
2000 {
2001     switch (m_header.e_type)
2002     {
2003         case llvm::ELF::ET_NONE:
2004             // 0 - No file type
2005             return eStrataUnknown;
2006
2007         case llvm::ELF::ET_REL:
2008             // 1 - Relocatable file
2009             return eStrataUnknown;
2010
2011         case llvm::ELF::ET_EXEC:
2012             // 2 - Executable file
2013             // TODO: is there any way to detect that an executable is a kernel
2014             // related executable by inspecting the program headers, section
2015             // headers, symbols, or any other flag bits???
2016             return eStrataUser;
2017
2018         case llvm::ELF::ET_DYN:
2019             // 3 - Shared object file
2020             // TODO: is there any way to detect that an shared library is a kernel
2021             // related executable by inspecting the program headers, section
2022             // headers, symbols, or any other flag bits???
2023             return eStrataUnknown;
2024
2025         case ET_CORE:
2026             // 4 - Core file
2027             // TODO: is there any way to detect that an core file is a kernel
2028             // related executable by inspecting the program headers, section
2029             // headers, symbols, or any other flag bits???
2030             return eStrataUnknown;
2031
2032         default:
2033             break;
2034     }
2035     return eStrataUnknown;
2036 }
2037