Merge lldb r188801 to contrib/llvm/tools/lldb/

1 files changed, 465 insertions, 0 deletions

diff --git a/contrib/llvm/tools/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.cpp b/contrib/llvm/tools/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.cpp
new file mode 100644
index 0000000..a63a01d
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.cpp
@@ -0,0 +1,465 @@
+//===-- ELFHeader.cpp ----------------------------------------- -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstring>
+
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/Stream.h"
+
+#include "ELFHeader.h"
+
+using namespace elf;
+using namespace lldb;
+using namespace llvm::ELF;
+
+//------------------------------------------------------------------------------
+// Static utility functions.
+//
+// GetMaxU64 and GetMaxS64 wrap the similarly named methods from DataExtractor
+// with error handling code and provide for parsing a sequence of values.
+static bool
+GetMaxU64(const lldb_private::DataExtractor &data,
+          lldb::offset_t *offset,
+          uint64_t *value,
+          uint32_t byte_size)
+{
+    const lldb::offset_t saved_offset = *offset;
+    *value = data.GetMaxU64(offset, byte_size);
+    return *offset != saved_offset;
+}
+
+static bool
+GetMaxU64(const lldb_private::DataExtractor &data, 
+          lldb::offset_t *offset,
+          uint64_t *value,
+          uint32_t byte_size,
+          uint32_t count) 
+{
+    lldb::offset_t saved_offset = *offset;
+
+    for (uint32_t i = 0; i < count; ++i, ++value)
+    {
+        if (GetMaxU64(data, offset, value, byte_size) == false) 
+        {
+            *offset = saved_offset;
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool
+GetMaxS64(const lldb_private::DataExtractor &data, 
+          lldb::offset_t *offset,
+          int64_t *value,
+          uint32_t byte_size)
+{
+    const lldb::offset_t saved_offset = *offset;
+    *value = data.GetMaxS64(offset, byte_size);
+    return *offset != saved_offset;
+}
+
+static bool
+GetMaxS64(const lldb_private::DataExtractor &data, 
+          lldb::offset_t *offset,
+          int64_t *value,
+          uint32_t byte_size,
+          uint32_t count) 
+{
+    lldb::offset_t saved_offset = *offset;
+
+    for (uint32_t i = 0; i < count; ++i, ++value)
+    {
+        if (GetMaxS64(data, offset, value, byte_size) == false) 
+        {
+            *offset = saved_offset;
+            return false;
+        }
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFHeader
+
+ELFHeader::ELFHeader()
+{
+    memset(this, 0, sizeof(ELFHeader)); 
+}
+
+ByteOrder
+ELFHeader::GetByteOrder() const 
+{
+    if (e_ident[EI_DATA] == ELFDATA2MSB)
+        return eByteOrderBig;
+    if (e_ident[EI_DATA] == ELFDATA2LSB)
+        return eByteOrderLittle;
+    return eByteOrderInvalid;
+}
+
+bool
+ELFHeader::Parse(lldb_private::DataExtractor &data, lldb::offset_t *offset) 
+{
+    // Read e_ident.  This provides byte order and address size info.
+    if (data.GetU8(offset, &e_ident, EI_NIDENT) == NULL)
+        return false;
+
+    const unsigned byte_size = Is32Bit() ? 4 : 8;
+    data.SetByteOrder(GetByteOrder());
+    data.SetAddressByteSize(byte_size);
+
+    // Read e_type and e_machine.
+    if (data.GetU16(offset, &e_type, 2) == NULL)
+        return false;
+
+    // Read e_version.
+    if (data.GetU32(offset, &e_version, 1) == NULL)
+        return false;
+
+    // Read e_entry, e_phoff and e_shoff.
+    if (GetMaxU64(data, offset, &e_entry, byte_size, 3) == false)
+        return false;
+
+    // Read e_flags.
+    if (data.GetU32(offset, &e_flags, 1) == NULL)
+        return false;
+
+    // Read e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum and
+    // e_shstrndx.
+    if (data.GetU16(offset, &e_ehsize, 6) == NULL)
+        return false;
+
+    return true;
+}
+
+bool
+ELFHeader::MagicBytesMatch(const uint8_t *magic)
+{
+    return memcmp(magic, ElfMagic, strlen(ElfMagic)) == 0;
+}
+
+unsigned
+ELFHeader::AddressSizeInBytes(const uint8_t *magic)
+{
+    unsigned address_size = 0;
+
+    switch (magic[EI_CLASS]) 
+    {
+    case ELFCLASS32:
+        address_size = 4;
+        break;
+            
+    case ELFCLASS64:
+        address_size = 8;
+        break;
+    }
+    return address_size;
+}
+
+unsigned
+ELFHeader::GetRelocationJumpSlotType() const
+{
+    unsigned slot = 0;
+
+    switch (e_machine)
+    {
+    default:
+        assert(false && "architecture not supported");
+        break;
+    case EM_386:
+    case EM_486:
+        slot = R_386_JUMP_SLOT;
+        break;
+    case EM_X86_64:
+        slot = R_X86_64_JUMP_SLOT;
+        break;
+    case EM_ARM:
+        slot = R_ARM_JUMP_SLOT;
+        break;
+    }
+
+    return slot;
+}
+
+//------------------------------------------------------------------------------
+// ELFSectionHeader
+
+ELFSectionHeader::ELFSectionHeader() 
+{
+    memset(this, 0, sizeof(ELFSectionHeader));
+}
+
+bool
+ELFSectionHeader::Parse(const lldb_private::DataExtractor &data,
+                        lldb::offset_t *offset)
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+
+    // Read sh_name and sh_type.
+    if (data.GetU32(offset, &sh_name, 2) == NULL)
+        return false;
+
+    // Read sh_flags.
+    if (GetMaxU64(data, offset, &sh_flags, byte_size) == false)
+        return false;
+
+    // Read sh_addr, sh_off and sh_size.
+    if (GetMaxU64(data, offset, &sh_addr, byte_size, 3) == false)
+        return false;
+
+    // Read sh_link and sh_info.
+    if (data.GetU32(offset, &sh_link, 2) == NULL)
+        return false;
+
+    // Read sh_addralign and sh_entsize.
+    if (GetMaxU64(data, offset, &sh_addralign, byte_size, 2) == false)
+        return false;
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFSymbol
+
+ELFSymbol::ELFSymbol() 
+{
+    memset(this, 0, sizeof(ELFSymbol));
+}
+
+#define ENUM_TO_CSTR(e) case e: return #e
+
+const char *
+ELFSymbol::bindingToCString(unsigned char binding)
+{
+    switch (binding)
+    {
+    ENUM_TO_CSTR(STB_LOCAL);
+    ENUM_TO_CSTR(STB_GLOBAL);
+    ENUM_TO_CSTR(STB_WEAK);
+    ENUM_TO_CSTR(STB_LOOS);
+    ENUM_TO_CSTR(STB_HIOS);
+    ENUM_TO_CSTR(STB_LOPROC);
+    ENUM_TO_CSTR(STB_HIPROC);
+    }
+    return "";
+}
+
+const char *
+ELFSymbol::typeToCString(unsigned char type)
+{
+    switch (type)
+    {
+    ENUM_TO_CSTR(STT_NOTYPE);
+    ENUM_TO_CSTR(STT_OBJECT);
+    ENUM_TO_CSTR(STT_FUNC);
+    ENUM_TO_CSTR(STT_SECTION);
+    ENUM_TO_CSTR(STT_FILE);
+    ENUM_TO_CSTR(STT_COMMON);
+    ENUM_TO_CSTR(STT_TLS);
+    ENUM_TO_CSTR(STT_LOOS);
+    ENUM_TO_CSTR(STT_HIOS);
+    ENUM_TO_CSTR(STT_GNU_IFUNC);
+    ENUM_TO_CSTR(STT_LOPROC);
+    ENUM_TO_CSTR(STT_HIPROC);
+    }
+    return "";
+}
+
+const char *
+ELFSymbol::sectionIndexToCString (elf_half shndx,
+                                  const lldb_private::SectionList *section_list)
+{
+    switch (shndx)
+    {
+    ENUM_TO_CSTR(SHN_UNDEF);
+    ENUM_TO_CSTR(SHN_LOPROC);
+    ENUM_TO_CSTR(SHN_HIPROC);
+    ENUM_TO_CSTR(SHN_LOOS);
+    ENUM_TO_CSTR(SHN_HIOS);
+    ENUM_TO_CSTR(SHN_ABS);
+    ENUM_TO_CSTR(SHN_COMMON);
+    ENUM_TO_CSTR(SHN_XINDEX);
+    default:
+        {
+            const lldb_private::Section *section = section_list->GetSectionAtIndex(shndx).get();
+            if (section)
+                return section->GetName().AsCString("");
+        }
+        break;
+    }
+    return "";
+}
+
+void
+ELFSymbol::Dump (lldb_private::Stream *s,
+                 uint32_t idx,
+                 const lldb_private::DataExtractor *strtab_data,
+                 const lldb_private::SectionList *section_list)
+{
+    s->Printf("[%3u] 0x%16.16" PRIx64 " 0x%16.16" PRIx64 " 0x%8.8x 0x%2.2x (%-10s %-13s) 0x%2.2x 0x%4.4x (%-10s) %s\n",
+              idx,
+              st_value,
+              st_size,
+              st_name,
+              st_info,
+              bindingToCString (getBinding()),
+              typeToCString (getType()),
+              st_other,
+              st_shndx,
+              sectionIndexToCString (st_shndx, section_list),
+              strtab_data ? strtab_data->PeekCStr(st_name) : "");
+}
+
+bool
+ELFSymbol::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+    const bool parsing_32 = byte_size == 4;
+
+    // Read st_name.
+    if (data.GetU32(offset, &st_name, 1) == NULL)
+        return false;
+
+    if (parsing_32) 
+    {
+        // Read st_value and st_size.
+        if (GetMaxU64(data, offset, &st_value, byte_size, 2) == false)
+            return false;
+
+        // Read st_info and st_other.
+        if (data.GetU8(offset, &st_info, 2) == NULL)
+            return false;
+            
+        // Read st_shndx.
+        if (data.GetU16(offset, &st_shndx, 1) == NULL)
+            return false;
+    }
+    else 
+    {
+        // Read st_info and st_other.
+        if (data.GetU8(offset, &st_info, 2) == NULL)
+            return false;
+            
+        // Read st_shndx.
+        if (data.GetU16(offset, &st_shndx, 1) == NULL)
+            return false;
+
+        // Read st_value and st_size.
+        if (data.GetU64(offset, &st_value, 2) == NULL)
+            return false;
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFProgramHeader
+
+ELFProgramHeader::ELFProgramHeader() 
+{
+    memset(this, 0, sizeof(ELFProgramHeader));
+}
+
+bool
+ELFProgramHeader::Parse(const lldb_private::DataExtractor &data, 
+                        lldb::offset_t *offset)
+{
+    const uint32_t byte_size = data.GetAddressByteSize();
+    const bool parsing_32 = byte_size == 4;
+
+    // Read p_type;
+    if (data.GetU32(offset, &p_type, 1) == NULL)
+        return false;
+
+    if (parsing_32) {
+        // Read p_offset, p_vaddr, p_paddr, p_filesz and p_memsz.
+        if (GetMaxU64(data, offset, &p_offset, byte_size, 5) == false)
+            return false;
+
+        // Read p_flags.
+        if (data.GetU32(offset, &p_flags, 1) == NULL)
+            return false;
+
+        // Read p_align.
+        if (GetMaxU64(data, offset, &p_align, byte_size) == false)
+            return false;
+    }
+    else {
+        // Read p_flags.
+        if (data.GetU32(offset, &p_flags, 1) == NULL)
+            return false;
+
+        // Read p_offset, p_vaddr, p_paddr, p_filesz, p_memsz and p_align.
+        if (GetMaxU64(data, offset, &p_offset, byte_size, 6) == false)
+            return false;
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFDynamic
+
+ELFDynamic::ELFDynamic() 
+{ 
+    memset(this, 0, sizeof(ELFDynamic)); 
+}
+
+bool
+ELFDynamic::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+    return GetMaxS64(data, offset, &d_tag, byte_size, 2);
+}
+
+//------------------------------------------------------------------------------
+// ELFRel
+
+ELFRel::ELFRel()
+{
+    memset(this, 0, sizeof(ELFRel));
+}
+
+bool
+ELFRel::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+
+    // Read r_offset and r_info.
+    if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false)
+        return false;
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+// ELFRela
+
+ELFRela::ELFRela()
+{
+    memset(this, 0, sizeof(ELFRela));
+}
+
+bool
+ELFRela::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
+{
+    const unsigned byte_size = data.GetAddressByteSize();
+
+    // Read r_offset and r_info.
+    if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false)
+        return false;
+
+    // Read r_addend;
+    if (GetMaxS64(data, offset, &r_addend, byte_size) == false)
+        return false;
+
+    return true;
+}
+
+