[Lldb-commits] [lldb] r107817 - in /lldb/trunk: lldb.xcodeproj/project.pbxproj source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp source/Plugins/ObjectFile/ELF/ObjectFileELF64.h source/Plugins/ObjectFile/ELF/elf.h source/lldb.cpp
Greg Clayton
gclayton at apple.com
Wed Jul 7 14:52:01 PDT 2010
Author: gclayton
Date: Wed Jul 7 16:52:01 2010
New Revision: 107817
URL: http://llvm.org/viewvc/llvm-project?rev=107817&view=rev
Log:
64 bit ELF support from Stephen Wilson.
Added:
lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp
lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.h
Modified:
lldb/trunk/lldb.xcodeproj/project.pbxproj
lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
lldb/trunk/source/Plugins/ObjectFile/ELF/elf.h
lldb/trunk/source/lldb.cpp
Modified: lldb/trunk/lldb.xcodeproj/project.pbxproj
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/lldb.xcodeproj/project.pbxproj?rev=107817&r1=107816&r2=107817&view=diff
==============================================================================
--- lldb/trunk/lldb.xcodeproj/project.pbxproj (original)
+++ lldb/trunk/lldb.xcodeproj/project.pbxproj Wed Jul 7 16:52:01 2010
@@ -58,6 +58,8 @@
26680336116005EF008E1FE4 /* SBBreakpointLocation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9AF16CC7114086A1007A7B3F /* SBBreakpointLocation.cpp */; };
26680337116005F1008E1FE4 /* SBBreakpoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9AF16A9C11402D5B007A7B3F /* SBBreakpoint.cpp */; };
2668035C11601108008E1FE4 /* LLDB.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 26680207115FD0ED008E1FE4 /* LLDB.framework */; };
+ 26A9641011E52C8800EE609E /* ObjectFileELF64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26A9640E11E52C8800EE609E /* ObjectFileELF64.cpp */; };
+ 26A9641111E52C8800EE609E /* ObjectFileELF64.h in Headers */ = {isa = PBXBuildFile; fileRef = 26A9640F11E52C8800EE609E /* ObjectFileELF64.h */; };
26B42B1F1187A92B0079C8C8 /* lldb-include.h in Headers */ = {isa = PBXBuildFile; fileRef = 26B42B1E1187A92B0079C8C8 /* lldb-include.h */; settings = {ATTRIBUTES = (Public, ); }; };
26B42C4D1187ABA50079C8C8 /* LLDB.h in Headers */ = {isa = PBXBuildFile; fileRef = 26B42C4C1187ABA50079C8C8 /* LLDB.h */; settings = {ATTRIBUTES = (Public, ); }; };
26D5B06511B07550009A862E /* StoppointCallbackContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26BC7E0910F1B83100F91463 /* StoppointCallbackContext.cpp */; };
@@ -545,6 +547,8 @@
26A3B4AC1181454800381BC2 /* ObjectContainerBSDArchive.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ObjectContainerBSDArchive.cpp; sourceTree = "<group>"; };
26A3B4AD1181454800381BC2 /* ObjectContainerBSDArchive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ObjectContainerBSDArchive.h; sourceTree = "<group>"; };
26A4EEB511682AAC007A372A /* LLDBWrapPython.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LLDBWrapPython.cpp; path = source/LLDBWrapPython.cpp; sourceTree = "<group>"; };
+ 26A9640E11E52C8800EE609E /* ObjectFileELF64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ObjectFileELF64.cpp; sourceTree = "<group>"; };
+ 26A9640F11E52C8800EE609E /* ObjectFileELF64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ObjectFileELF64.h; sourceTree = "<group>"; };
26B167A41123BF5500DC7B4F /* ThreadSafeValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ThreadSafeValue.h; path = include/lldb/Core/ThreadSafeValue.h; sourceTree = "<group>"; };
26B42B1E1187A92B0079C8C8 /* lldb-include.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "lldb-include.h"; path = "include/lldb/lldb-include.h"; sourceTree = "<group>"; };
26B42C4C1187ABA50079C8C8 /* LLDB.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LLDB.h; path = include/lldb/API/LLDB.h; sourceTree = "<group>"; };
@@ -1197,8 +1201,10 @@
isa = PBXGroup;
children = (
260C898410F57C5600BB2B04 /* elf.h */,
- 260C898510F57C5600BB2B04 /* ObjectFileELF.cpp */,
260C898610F57C5600BB2B04 /* ObjectFileELF.h */,
+ 260C898510F57C5600BB2B04 /* ObjectFileELF.cpp */,
+ 26A9640F11E52C8800EE609E /* ObjectFileELF64.h */,
+ 26A9640E11E52C8800EE609E /* ObjectFileELF64.cpp */,
);
path = ELF;
sourceTree = "<group>";
@@ -2190,6 +2196,7 @@
49DA743511DE6BB2006AEF7E /* IRToDWARF.h in Headers */,
49307AB211DEA4F20081F992 /* IRForTarget.h in Headers */,
4C5DBBC911E3FEC60035160F /* CommandObjectCommands.h in Headers */,
+ 26A9641111E52C8800EE609E /* ObjectFileELF64.h in Headers */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@@ -2639,6 +2646,7 @@
49DA743011DE6A5A006AEF7E /* IRToDWARF.cpp in Sources */,
49307AAE11DEA4D90081F992 /* IRForTarget.cpp in Sources */,
4C5DBBC811E3FEC60035160F /* CommandObjectCommands.cpp in Sources */,
+ 26A9641011E52C8800EE609E /* ObjectFileELF64.cpp in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
Modified: lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp?rev=107817&r1=107816&r2=107817&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp (original)
+++ lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp Wed Jul 7 16:52:01 2010
@@ -70,16 +70,22 @@
}
bool
-ObjectFileELF::MagicBytesMatch (DataBufferSP& dataSP)
+ObjectFileELF::MagicBytesMatch (DataBufferSP& data_sp)
{
- DataExtractor data(dataSP, eByteOrderHost, 4);
- const uint8_t* magic = data.PeekData(0, 4);
- if (magic != NULL)
- {
- return magic[EI_MAG0] == 0x7f
- && magic[EI_MAG1] == 'E'
- && magic[EI_MAG2] == 'L'
- && magic[EI_MAG3] == 'F';
+ if (data_sp && data_sp->GetByteSize() > EI_PAD)
+ {
+ const uint8_t* magic = data_sp->GetBytes();
+ if (magic != NULL)
+ {
+ bool have_magic = (magic[EI_MAG0] == 0x7f &&
+ magic[EI_MAG1] == 'E' &&
+ magic[EI_MAG2] == 'L' &&
+ magic[EI_MAG3] == 'F');
+
+ bool have_32bit = magic[EI_CLASS] == ELFCLASS32;
+
+ return have_magic && have_32bit;
+ }
}
return false;
}
@@ -376,7 +382,7 @@
break;
}
- switch (ELF32_ST_BIND (symbol.st_info))
+ switch (ELF_ST_BIND (symbol.st_info))
{
default:
case STT_NOTYPE:
@@ -442,7 +448,7 @@
symbol_name, // symbol name
false, // Is the symbol name mangled?
symbol_type, // type of this symbol
- ELF32_ST_BIND (symbol.st_info) == STB_GLOBAL, // Is this globally visible?
+ ELF_ST_BIND (symbol.st_info) == STB_GLOBAL, // Is this globally visible?
false, // Is this symbol debug info?
false, // Is this symbol a trampoline?
false, // Is this symbol artificial?
Added: lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp?rev=107817&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp (added)
+++ lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.cpp Wed Jul 7 16:52:01 2010
@@ -0,0 +1,1017 @@
+//===-- ObjectFileELF64.cpp ----------------------------------- -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ObjectFileELF64.h"
+
+#include <cassert>
+
+#include <algorithm>
+
+#include "lldb/Core/DataBuffer.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/FileSpecList.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/Stream.h"
+
+#define CASE_AND_STREAM(s, def, width) \
+ case def: s->Printf("%-*s", width, #def); break;
+
+using namespace lldb;
+using namespace lldb_private;
+
+void
+ObjectFileELF64::Initialize()
+{
+ PluginManager::RegisterPlugin(GetPluginNameStatic(),
+ GetPluginDescriptionStatic(),
+ CreateInstance);
+}
+
+void
+ObjectFileELF64::Terminate()
+{
+ PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+const char *
+ObjectFileELF64::GetPluginNameStatic()
+{
+ return "object-file.elf64";
+}
+
+const char *
+ObjectFileELF64::GetPluginDescriptionStatic()
+{
+ return "ELF object file reader (64-bit).";
+}
+
+ObjectFile *
+ObjectFileELF64::CreateInstance(Module *module,
+ DataBufferSP &dataSP,
+ const FileSpec *file, addr_t offset,
+ addr_t length)
+{
+ if (ObjectFileELF64::MagicBytesMatch(dataSP))
+ {
+ std::auto_ptr<ObjectFile> objfile_ap(
+ new ObjectFileELF64(module, dataSP, file, offset, length));
+ if (objfile_ap->ParseHeader())
+ return objfile_ap.release();
+ }
+ return NULL;
+}
+
+bool
+ObjectFileELF64::MagicBytesMatch(DataBufferSP& data_sp)
+{
+ if (data_sp && data_sp->GetByteSize() > EI_PAD)
+ {
+ const uint8_t* magic = data_sp->GetBytes();
+ if (magic != NULL)
+ {
+ bool have_magic = (magic[EI_MAG0] == 0x7f &&
+ magic[EI_MAG1] == 'E' &&
+ magic[EI_MAG2] == 'L' &&
+ magic[EI_MAG3] == 'F');
+
+ bool have_64bit = magic[EI_CLASS] == ELFCLASS64;
+
+ return have_magic && have_64bit;
+ }
+ }
+ return false;
+}
+
+ObjectFileELF64::ObjectFileELF64(Module* module, DataBufferSP& dataSP,
+ const FileSpec* file, addr_t offset,
+ addr_t length)
+ : ObjectFile(module, file, offset, length, dataSP),
+ m_header(),
+ m_program_headers(),
+ m_section_headers(),
+ m_sections_ap(),
+ m_symtab_ap(),
+ m_filespec_ap(),
+ m_shstr_data()
+{
+ if (file)
+ m_file = *file;
+ ::memset(&m_header, 0, sizeof(m_header));
+}
+
+
+ObjectFileELF64::~ObjectFileELF64()
+{
+}
+
+ByteOrder
+ObjectFileELF64::GetByteOrder() const
+{
+ if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
+ return eByteOrderBig;
+ if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
+ return eByteOrderLittle;
+ return eByteOrderInvalid;
+}
+
+size_t
+ObjectFileELF64::GetAddressByteSize() const
+{
+ return m_data.GetAddressByteSize();
+}
+
+unsigned
+ObjectFileELF64::SectionIndex(const SectionHeaderCollIter &I)
+{
+ return std::distance(m_section_headers.begin(), I) + 1;
+}
+
+unsigned
+ObjectFileELF64::SectionIndex(const SectionHeaderCollConstIter &I) const
+{
+ return std::distance(m_section_headers.begin(), I) + 1;
+}
+
+bool
+ObjectFileELF64::ParseHeader()
+{
+ m_data.SetAddressByteSize(8);
+ uint32_t offset = GetOffset();
+ if (m_data.GetU8(&offset, m_header.e_ident, EI_NIDENT) == NULL)
+ return false;
+
+ m_data.SetByteOrder(GetByteOrder());
+
+ // Read e_type and e_machine.
+ if (m_data.GetU16(&offset, &m_header.e_type, 2) == NULL)
+ return false;
+
+ // Read e_version.
+ if (m_data.GetU32(&offset, &m_header.e_version, 1) == NULL)
+ return false;
+
+ // Read e_entry, e_phoff and e_shoff.
+ if (m_data.GetU64(&offset, &m_header.e_entry, 3) == NULL)
+ return false;
+
+ // Read e_flags.
+ if (m_data.GetU32(&offset, &m_header.e_flags, 1) == NULL)
+ return false;
+
+ // Read e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum and e_shstrndx.
+ if (m_data.GetU16(&offset, &m_header.e_ehsize, 6) == NULL)
+ return false;
+
+ return true;
+}
+
+bool
+ObjectFileELF64::GetUUID(UUID* uuid)
+{
+ // FIXME: Return MD5 sum here. See comment in ObjectFile.h.
+ return false;
+}
+
+uint32_t
+ObjectFileELF64::GetDependentModules(FileSpecList &files)
+{
+ size_t num_modules = ParseDependentModules();
+ uint32_t num_specs = 0;
+
+ for (unsigned i = 0; i < num_modules; ++i)
+ {
+ if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i)))
+ num_specs++;
+ }
+
+ return num_specs;
+}
+
+//----------------------------------------------------------------------
+// ParseDependentModules
+//----------------------------------------------------------------------
+size_t
+ObjectFileELF64::ParseDependentModules()
+{
+ if (m_filespec_ap.get())
+ return m_filespec_ap->GetSize();
+
+ m_filespec_ap.reset(new FileSpecList());
+
+ if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
+ return 0;
+
+ // Locate the dynamic table.
+ user_id_t dynsym_id = 0;
+ user_id_t dynstr_id = 0;
+ for (SectionHeaderCollIter I = m_section_headers.begin();
+ I != m_section_headers.end(); ++I)
+ {
+ if (I->sh_type == SHT_DYNAMIC)
+ {
+ dynsym_id = SectionIndex(I);
+ dynstr_id = I->sh_link + 1; // Section ID's are 1 based.
+ break;
+ }
+ }
+
+ if (!(dynsym_id && dynstr_id))
+ return 0;
+
+ SectionList *section_list = GetSectionList();
+ if (!section_list)
+ return 0;
+
+ // Resolve and load the dynamic table entries and corresponding string
+ // table.
+ Section *dynsym = section_list->FindSectionByID(dynsym_id).get();
+ Section *dynstr = section_list->FindSectionByID(dynstr_id).get();
+ if (!(dynsym && dynstr))
+ return 0;
+
+ DataExtractor dynsym_data;
+ DataExtractor dynstr_data;
+ if (dynsym->ReadSectionDataFromObjectFile(this, dynsym_data) &&
+ dynstr->ReadSectionDataFromObjectFile(this, dynstr_data))
+ {
+ Elf64_Dyn symbol;
+ const unsigned num_syms = dynsym_data.GetByteSize() / sizeof(Elf64_Dyn);
+ unsigned offset = 0;
+
+ // The only type of entries we are concerned with are tagged DT_NEEDED,
+ // yielding the name of a required library.
+ for (unsigned i = 0; i < num_syms; ++i)
+ {
+ if (!dynsym_data.ValidOffsetForDataOfSize(offset, sizeof(Elf64_Dyn)))
+ break;
+
+ symbol.d_tag = dynsym_data.GetU64(&offset);
+ symbol.d_un.d_val = dynsym_data.GetU64(&offset);
+
+ if (symbol.d_tag != DT_NEEDED)
+ continue;
+
+ const char *lib_name = dynstr_data.PeekCStr(symbol.d_un.d_val);
+ m_filespec_ap->Append(FileSpec(lib_name));
+ }
+ }
+
+ return m_filespec_ap->GetSize();
+}
+
+//----------------------------------------------------------------------
+// ParseProgramHeaders
+//----------------------------------------------------------------------
+size_t
+ObjectFileELF64::ParseProgramHeaders()
+{
+ // We have already parsed the program headers
+ if (!m_program_headers.empty())
+ return m_program_headers.size();
+
+ // If there are no program headers to read we are done.
+ if (m_header.e_phnum == 0)
+ return 0;
+
+ m_program_headers.resize(m_header.e_phnum);
+ if (m_program_headers.size() != m_header.e_phnum)
+ return 0;
+
+ const size_t ph_size = m_header.e_phnum * m_header.e_phentsize;
+ const Elf64_Off ph_offset = m_offset + m_header.e_phoff;
+ DataBufferSP buffer_sp(m_file.ReadFileContents(ph_offset, ph_size));
+
+ if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != ph_size)
+ return 0;
+
+ DataExtractor data(buffer_sp, m_data.GetByteOrder(),
+ m_data.GetAddressByteSize());
+
+ uint32_t idx;
+ uint32_t offset;
+ for (idx = 0, offset = 0; idx < m_header.e_phnum; ++idx)
+ {
+ if (data.GetU32(&offset, &m_program_headers[idx], 8) == NULL)
+ return 0;
+ }
+
+ if (idx < m_program_headers.size())
+ m_program_headers.resize(idx);
+
+ return m_program_headers.size();
+}
+
+//----------------------------------------------------------------------
+// ParseSectionHeaders
+//----------------------------------------------------------------------
+size_t
+ObjectFileELF64::ParseSectionHeaders()
+{
+ // We have already parsed the section headers
+ if (!m_section_headers.empty())
+ return m_section_headers.size();
+
+ // If there are no section headers we are done.
+ if (m_header.e_shnum == 0)
+ return 0;
+
+ m_section_headers.resize(m_header.e_shnum);
+ if (m_section_headers.size() != m_header.e_shnum)
+ return 0;
+
+ const size_t sh_size = m_header.e_shnum * m_header.e_shentsize;
+ const Elf64_Off sh_offset = m_offset + m_header.e_shoff;
+ DataBufferSP buffer_sp(m_file.ReadFileContents(sh_offset, sh_size));
+
+ if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != sh_size)
+ return 0;
+
+ DataExtractor data(buffer_sp,
+ m_data.GetByteOrder(),
+ m_data.GetAddressByteSize());
+
+ uint32_t idx;
+ uint32_t offset;
+ for (idx = 0, offset = 0; idx < m_header.e_shnum; ++idx)
+ {
+ // Read sh_name and sh_type.
+ if (data.GetU32(&offset, &m_section_headers[idx].sh_name, 2) == NULL)
+ break;
+
+ // Read sh_flags, sh_addr, sh_offset and sh_size.
+ if (data.GetU64(&offset, &m_section_headers[idx].sh_flags, 4) == NULL)
+ break;
+
+ // Read sh_link and sh_info.
+ if (data.GetU32(&offset, &m_section_headers[idx].sh_link, 2) == NULL)
+ break;
+
+ // Read sh_addralign and sh_entsize.
+ if (data.GetU64(&offset, &m_section_headers[idx].sh_addralign, 2) == NULL)
+ break;
+ }
+ if (idx < m_section_headers.size())
+ m_section_headers.resize(idx);
+
+ return m_section_headers.size();
+}
+
+size_t
+ObjectFileELF64::GetSectionHeaderStringTable()
+{
+ if (m_shstr_data.GetByteSize() == 0)
+ {
+ if (m_header.e_shstrndx && m_header.e_shstrndx < m_section_headers.size())
+ {
+ const Elf64_Shdr &sheader = m_section_headers[m_header.e_shstrndx];
+ const size_t byte_size = sheader.sh_size;
+ const Elf64_Off offset = m_offset + sheader.sh_offset;
+ DataBufferSP buffer_sp(m_file.ReadFileContents(offset, byte_size));
+
+ if (buffer_sp.get() == NULL || buffer_sp->GetByteSize() != byte_size)
+ return 0;
+
+ m_shstr_data.SetData(buffer_sp);
+ }
+ }
+ return m_shstr_data.GetByteSize();
+}
+
+uint32_t
+ObjectFileELF64::GetSectionIndexByName(const char *name)
+{
+ if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
+ return UINT32_MAX;
+
+ // Search the collection of section headers for one with a matching name.
+ for (SectionHeaderCollIter I = m_section_headers.begin();
+ I != m_section_headers.end(); ++I)
+ {
+ const char *sectionName = m_shstr_data.PeekCStr(I->sh_name);
+
+ if (!sectionName)
+ return UINT32_MAX;
+
+ if (strcmp(name, sectionName) != 0)
+ continue;
+
+ return SectionIndex(I);
+ }
+
+ return UINT32_MAX;
+}
+
+SectionList *
+ObjectFileELF64::GetSectionList()
+{
+ if (m_sections_ap.get())
+ return m_sections_ap.get();
+
+ if (ParseSectionHeaders() && GetSectionHeaderStringTable())
+ {
+ m_sections_ap.reset(new SectionList());
+
+ for (SectionHeaderCollIter I = m_section_headers.begin();
+ I != m_section_headers.end(); ++I)
+ {
+ const Elf64_Shdr &header = *I;
+
+ ConstString name(m_shstr_data.PeekCStr(header.sh_name));
+ uint64_t size = header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
+
+ SectionSP section(new Section(
+ 0, // Parent section.
+ GetModule(), // Module to which this section belongs.
+ SectionIndex(I), // Section ID.
+ name, // Section name.
+ eSectionTypeOther, // FIXME: Fill in as appropriate.
+ header.sh_addr, // VM address.
+ header.sh_size, // VM size in bytes of this section.
+ header.sh_offset, // Offset of this section in the file.
+ size, // Size of the section as found in the file.
+ header.sh_flags)); // Flags for this section.
+
+ m_sections_ap->AddSection(section);
+ }
+ }
+
+ return m_sections_ap.get();
+}
+
+static void
+ParseSymbols(Symtab *symtab, SectionList *section_list,
+ const Elf64_Shdr &symtab_shdr,
+ const DataExtractor &symtab_data,
+ const DataExtractor &strtab_data)
+{
+ assert (sizeof(Elf64_Sym) == symtab_shdr.sh_entsize);
+ const unsigned numSymbols = symtab_data.GetByteSize() / sizeof(Elf64_Sym);
+ unsigned offset = 0;
+ Elf64_Sym symbol;
+
+ static ConstString text_section_name(".text");
+ static ConstString init_section_name(".init");
+ static ConstString fini_section_name(".fini");
+ static ConstString ctors_section_name(".ctors");
+ static ConstString dtors_section_name(".dtors");
+
+ static ConstString data_section_name(".data");
+ static ConstString rodata_section_name(".rodata");
+ static ConstString rodata1_section_name(".rodata1");
+ static ConstString data2_section_name(".data1");
+ static ConstString bss_section_name(".bss");
+
+ for (unsigned i = 0; i < numSymbols; ++i)
+ {
+ if (!symtab_data.ValidOffsetForDataOfSize(offset, sizeof(Elf64_Sym)))
+ break;
+
+ symbol.st_name = symtab_data.GetU32(&offset);
+ symbol.st_info = symtab_data.GetU8(&offset);
+ symbol.st_other = symtab_data.GetU8(&offset);
+ symbol.st_shndx = symtab_data.GetU16(&offset);
+ symbol.st_value = symtab_data.GetU64(&offset);
+ symbol.st_size = symtab_data.GetU64(&offset);
+
+ Section *symbol_section = NULL;
+ SymbolType symbol_type = eSymbolTypeInvalid;
+ Elf64_Half symbol_idx = symbol.st_shndx;
+
+ switch (symbol_idx)
+ {
+ case SHN_ABS:
+ symbol_type = eSymbolTypeAbsolute;
+ break;
+ case SHN_UNDEF:
+ symbol_type = eSymbolTypeUndefined;
+ break;
+ default:
+ symbol_section = section_list->GetSectionAtIndex(symbol_idx).get();
+ break;
+ }
+
+ switch (ELF_ST_TYPE(symbol.st_info))
+ {
+ default:
+ case STT_NOTYPE:
+ // The symbol's type is not specified.
+ break;
+
+ case STT_OBJECT:
+ // The symbol is associated with a data object, such as a variable,
+ // an array, etc.
+ symbol_type = eSymbolTypeData;
+ break;
+
+ case STT_FUNC:
+ // The symbol is associated with a function or other executable code.
+ symbol_type = eSymbolTypeCode;
+ break;
+
+ case STT_SECTION:
+ // The symbol is associated with a section. Symbol table entries of
+ // this type exist primarily for relocation and normally have
+ // STB_LOCAL binding.
+ break;
+
+ case STT_FILE:
+ // Conventionally, the symbol's name gives the name of the source
+ // file associated with the object file. A file symbol has STB_LOCAL
+ // binding, its section index is SHN_ABS, and it precedes the other
+ // STB_LOCAL symbols for the file, if it is present.
+ symbol_type = eSymbolTypeObjectFile;
+ break;
+ }
+
+ if (symbol_type == eSymbolTypeInvalid)
+ {
+ if (symbol_section)
+ {
+ const ConstString §_name = symbol_section->GetName();
+ if (sect_name == text_section_name ||
+ sect_name == init_section_name ||
+ sect_name == fini_section_name ||
+ sect_name == ctors_section_name ||
+ sect_name == dtors_section_name)
+ {
+ symbol_type = eSymbolTypeCode;
+ }
+ else if (sect_name == data_section_name ||
+ sect_name == data2_section_name ||
+ sect_name == rodata_section_name ||
+ sect_name == rodata1_section_name ||
+ sect_name == bss_section_name)
+ {
+ symbol_type = eSymbolTypeData;
+ }
+ }
+ }
+
+ uint64_t symbol_value = symbol.st_value;
+ if (symbol_section != NULL)
+ symbol_value -= symbol_section->GetFileAddress();
+ const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
+ bool is_global = ELF_ST_BIND(symbol.st_info) == STB_GLOBAL;
+ uint32_t flags = symbol.st_other << 8 | symbol.st_info;
+
+ Symbol dc_symbol(
+ i, // ID is the original symbol table index.
+ symbol_name, // symbol name.
+ false, // Is the symbol name mangled?
+ symbol_type, // type of this symbol
+ is_global, // Is this globally visible?
+ false, // Is this symbol debug info?
+ false, // Is this symbol a trampoline?
+ false, // Is this symbol artificial?
+ symbol_section, // Section in which this symbol is defined or null.
+ symbol_value, // Offset in section or symbol value.
+ symbol.st_size, // size in bytes of this symbol.
+ flags); // Symbol flags.
+ symtab->AddSymbol(dc_symbol);
+ }
+}
+
+void
+ObjectFileELF64::ParseSymbolTable(Symtab *symbol_table,
+ const Elf64_Shdr &symtab_hdr,
+ user_id_t symtab_id)
+{
+ assert(symtab_hdr.sh_type == SHT_SYMTAB ||
+ symtab_hdr.sh_type == SHT_DYNSYM);
+
+ // Parse in the section list if needed.
+ SectionList *section_list = GetSectionList();
+ if (!section_list)
+ return;
+
+ // Section ID's are ones based.
+ user_id_t strtab_id = symtab_hdr.sh_link + 1;
+
+ Section *symtab = section_list->FindSectionByID(symtab_id).get();
+ Section *strtab = section_list->FindSectionByID(strtab_id).get();
+ if (symtab && strtab)
+ {
+ DataExtractor symtab_data;
+ DataExtractor strtab_data;
+ if (symtab->ReadSectionDataFromObjectFile(this, symtab_data) &&
+ strtab->ReadSectionDataFromObjectFile(this, strtab_data))
+ {
+ ParseSymbols(symbol_table, section_list, symtab_hdr,
+ symtab_data, strtab_data);
+ }
+ }
+}
+
+Symtab *
+ObjectFileELF64::GetSymtab()
+{
+ if (m_symtab_ap.get())
+ return m_symtab_ap.get();
+
+ Symtab *symbol_table = new Symtab(this);
+ m_symtab_ap.reset(symbol_table);
+
+ if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
+ return symbol_table;
+
+ // Locate and parse all linker symbol tables.
+ for (SectionHeaderCollIter I = m_section_headers.begin();
+ I != m_section_headers.end(); ++I)
+ {
+ if (I->sh_type == SHT_SYMTAB || I->sh_type == SHT_DYNSYM)
+ {
+ const Elf64_Shdr &symtab_section = *I;
+ user_id_t section_id = SectionIndex(I);
+ ParseSymbolTable(symbol_table, symtab_section, section_id);
+ }
+ }
+
+ return symbol_table;
+}
+
+//===----------------------------------------------------------------------===//
+// Dump
+//
+// Dump the specifics of the runtime file container (such as any headers
+// segments, sections, etc).
+// ----------------------------------------------------------------------
+void
+ObjectFileELF64::Dump(Stream *s)
+{
+ DumpELFHeader(s, m_header);
+ s->EOL();
+ DumpELFProgramHeaders(s);
+ s->EOL();
+ DumpELFSectionHeaders(s);
+ s->EOL();
+ SectionList *section_list = GetSectionList();
+ if (section_list)
+ section_list->Dump(s, NULL, true);
+ Symtab *symtab = GetSymtab();
+ if (symtab)
+ symtab->Dump(s, NULL);
+ s->EOL();
+ DumpDependentModules(s);
+ s->EOL();
+}
+
+//----------------------------------------------------------------------
+// DumpELFHeader
+//
+// Dump the ELF header to the specified output stream
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFHeader(Stream *s, const Elf64_Ehdr& header)
+{
+
+ s->PutCString("ELF Header\n");
+ s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
+ s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n",
+ header.e_ident[EI_MAG1], header.e_ident[EI_MAG1]);
+ s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n",
+ header.e_ident[EI_MAG2], header.e_ident[EI_MAG2]);
+ s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n",
+ header.e_ident[EI_MAG3], header.e_ident[EI_MAG3]);
+
+ s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]);
+ s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]);
+ DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]);
+ s->Printf ("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]);
+ s->Printf ("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]);
+
+ s->Printf("e_type = 0x%4.4x ", header.e_type);
+ DumpELFHeader_e_type(s, header.e_type);
+ s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine);
+ s->Printf("e_version = 0x%8.8x\n", header.e_version);
+ s->Printf("e_entry = 0x%8.8x\n", header.e_entry);
+ s->Printf("e_phoff = 0x%8.8x\n", header.e_phoff);
+ s->Printf("e_shoff = 0x%8.8x\n", header.e_shoff);
+ s->Printf("e_flags = 0x%8.8x\n", header.e_flags);
+ s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize);
+ s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
+ s->Printf("e_phnum = 0x%4.4x\n", header.e_phnum);
+ s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
+ s->Printf("e_shnum = 0x%4.4x\n", header.e_shnum);
+ s->Printf("e_shstrndx = 0x%4.4x\n", header.e_shstrndx);
+}
+
+//----------------------------------------------------------------------
+// DumpELFHeader_e_type
+//
+// Dump an token value for the ELF header member e_type
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFHeader_e_type(Stream *s, Elf64_Half e_type)
+{
+ switch (e_type)
+ {
+ case ET_NONE: *s << "ET_NONE"; break;
+ case ET_REL: *s << "ET_REL"; break;
+ case ET_EXEC: *s << "ET_EXEC"; break;
+ case ET_DYN: *s << "ET_DYN"; break;
+ case ET_CORE: *s << "ET_CORE"; break;
+ default:
+ break;
+ }
+}
+
+//----------------------------------------------------------------------
+// DumpELFHeader_e_ident_EI_DATA
+//
+// Dump an token value for the ELF header member e_ident[EI_DATA]
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFHeader_e_ident_EI_DATA(Stream *s, unsigned char ei_data)
+{
+ switch (ei_data)
+ {
+ case ELFDATANONE: *s << "ELFDATANONE"; break;
+ case ELFDATA2LSB: *s << "ELFDATA2LSB - Little Endian"; break;
+ case ELFDATA2MSB: *s << "ELFDATA2MSB - Big Endian"; break;
+ default:
+ break;
+ }
+}
+
+
+//----------------------------------------------------------------------
+// DumpELFProgramHeader
+//
+// Dump a single ELF program header to the specified output stream
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFProgramHeader(Stream *s, const Elf64_Phdr &ph)
+{
+ DumpELFProgramHeader_p_type(s, ph.p_type);
+ s->Printf(" %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x (",
+ ph.p_offset, ph.p_vaddr, ph.p_paddr, ph.p_filesz, ph.p_memsz,
+ ph.p_flags);
+ DumpELFProgramHeader_p_flags(s, ph.p_flags);
+ s->Printf(") %8.8x", ph.p_align);
+}
+
+//----------------------------------------------------------------------
+// DumpELFProgramHeader_p_type
+//
+// Dump an token value for the ELF program header member p_type which
+// describes the type of the program header
+// ----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFProgramHeader_p_type(Stream *s, Elf64_Word p_type)
+{
+ const int kStrWidth = 10;
+ switch (p_type)
+ {
+ CASE_AND_STREAM(s, PT_NULL , kStrWidth);
+ CASE_AND_STREAM(s, PT_LOAD , kStrWidth);
+ CASE_AND_STREAM(s, PT_DYNAMIC , kStrWidth);
+ CASE_AND_STREAM(s, PT_INTERP , kStrWidth);
+ CASE_AND_STREAM(s, PT_NOTE , kStrWidth);
+ CASE_AND_STREAM(s, PT_SHLIB , kStrWidth);
+ CASE_AND_STREAM(s, PT_PHDR , kStrWidth);
+ default:
+ s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
+ break;
+ }
+}
+
+
+//----------------------------------------------------------------------
+// DumpELFProgramHeader_p_flags
+//
+// Dump an token value for the ELF program header member p_flags
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFProgramHeader_p_flags(Stream *s, Elf64_Word p_flags)
+{
+ *s << ((p_flags & PF_X) ? "PF_X" : " ")
+ << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
+ << ((p_flags & PF_W) ? "PF_W" : " ")
+ << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ')
+ << ((p_flags & PF_R) ? "PF_R" : " ");
+}
+
+//----------------------------------------------------------------------
+// DumpELFProgramHeaders
+//
+// Dump all of the ELF program header to the specified output stream
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFProgramHeaders(Stream *s)
+{
+ if (ParseProgramHeaders())
+ {
+ s->PutCString("Program Headers\n");
+ s->PutCString("IDX p_type p_offset p_vaddr p_paddr "
+ "p_filesz p_memsz p_flags p_align\n");
+ s->PutCString("==== ---------- -------- -------- -------- "
+ "-------- -------- ------------------------- --------\n");
+
+ uint32_t idx = 0;
+ for (ProgramHeaderCollConstIter I = m_program_headers.begin();
+ I != m_program_headers.end(); ++I, ++idx)
+ {
+ s->Printf("[%2u] ", idx);
+ ObjectFileELF64::DumpELFProgramHeader(s, *I);
+ s->EOL();
+ }
+ }
+}
+
+//----------------------------------------------------------------------
+// DumpELFSectionHeader
+//
+// Dump a single ELF section header to the specified output stream
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFSectionHeader(Stream *s, const Elf64_Shdr &sh)
+{
+ s->Printf("%8.8x ", sh.sh_name);
+ DumpELFSectionHeader_sh_type(s, sh.sh_type);
+ s->Printf(" %8.8x (", sh.sh_flags);
+ DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
+ s->Printf(") %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x %8.8x",
+ sh.sh_addr, sh.sh_offset, sh.sh_size, sh.sh_link, sh.sh_info,
+ sh.sh_addralign, sh.sh_entsize);
+}
+
+//----------------------------------------------------------------------
+// DumpELFSectionHeader_sh_type
+//
+// Dump an token value for the ELF section header member sh_type which
+// describes the type of the section
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFSectionHeader_sh_type(Stream *s, Elf64_Word sh_type)
+{
+ const int kStrWidth = 12;
+ switch (sh_type)
+ {
+ CASE_AND_STREAM(s, SHT_NULL , kStrWidth);
+ CASE_AND_STREAM(s, SHT_PROGBITS , kStrWidth);
+ CASE_AND_STREAM(s, SHT_SYMTAB , kStrWidth);
+ CASE_AND_STREAM(s, SHT_STRTAB , kStrWidth);
+ CASE_AND_STREAM(s, SHT_RELA , kStrWidth);
+ CASE_AND_STREAM(s, SHT_HASH , kStrWidth);
+ CASE_AND_STREAM(s, SHT_DYNAMIC , kStrWidth);
+ CASE_AND_STREAM(s, SHT_NOTE , kStrWidth);
+ CASE_AND_STREAM(s, SHT_NOBITS , kStrWidth);
+ CASE_AND_STREAM(s, SHT_REL , kStrWidth);
+ CASE_AND_STREAM(s, SHT_SHLIB , kStrWidth);
+ CASE_AND_STREAM(s, SHT_DYNSYM , kStrWidth);
+ CASE_AND_STREAM(s, SHT_LOPROC , kStrWidth);
+ CASE_AND_STREAM(s, SHT_HIPROC , kStrWidth);
+ CASE_AND_STREAM(s, SHT_LOUSER , kStrWidth);
+ CASE_AND_STREAM(s, SHT_HIUSER , kStrWidth);
+ default:
+ s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
+ break;
+ }
+}
+
+//----------------------------------------------------------------------
+// DumpELFSectionHeader_sh_flags
+//
+// Dump an token value for the ELF section header member sh_flags
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFSectionHeader_sh_flags(Stream *s, Elf64_Word sh_flags)
+{
+ *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ")
+ << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
+ << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ")
+ << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ')
+ << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " ");
+}
+
+//----------------------------------------------------------------------
+// DumpELFSectionHeaders
+//
+// Dump all of the ELF section header to the specified output stream
+//----------------------------------------------------------------------
+void
+ObjectFileELF64::DumpELFSectionHeaders(Stream *s)
+{
+ if (!(ParseSectionHeaders() && GetSectionHeaderStringTable()))
+ return;
+
+ s->PutCString("Section Headers\n");
+ s->PutCString("IDX name type flags "
+ "addr offset size link info addralgn "
+ "entsize Name\n");
+ s->PutCString("==== -------- ------------ -------------------------------- "
+ "-------- -------- -------- -------- -------- -------- "
+ "-------- ====================\n");
+
+ uint32_t idx = 0;
+ for (SectionHeaderCollConstIter I = m_section_headers.begin();
+ I != m_section_headers.end(); ++I, ++idx)
+ {
+ s->Printf("[%2u] ", idx);
+ ObjectFileELF64::DumpELFSectionHeader(s, *I);
+ const char* section_name = m_shstr_data.PeekCStr(I->sh_name);
+ if (section_name)
+ *s << ' ' << section_name << "\n";
+ }
+}
+
+void
+ObjectFileELF64::DumpDependentModules(lldb_private::Stream *s)
+{
+ size_t num_modules = ParseDependentModules();
+
+ if (num_modules > 0)
+ {
+ s->PutCString("Dependent Modules:\n");
+ for (unsigned i = 0; i < num_modules; ++i)
+ {
+ const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i);
+ s->Printf(" %s\n", spec.GetFilename().GetCString());
+ }
+ }
+}
+
+bool
+ObjectFileELF64::GetTargetTriple(ConstString &target_triple)
+{
+ static ConstString g_target_triple;
+
+ if (g_target_triple)
+ {
+ target_triple = g_target_triple;
+ return true;
+ }
+
+ std::string triple;
+ switch (m_header.e_machine)
+ {
+ default:
+ assert(false && "Unexpected machine type.");
+ break;
+ case EM_SPARC: triple.assign("sparc-"); break;
+ case EM_386: triple.assign("i386-"); break;
+ case EM_68K: triple.assign("68k-"); break;
+ case EM_88K: triple.assign("88k-"); break;
+ case EM_860: triple.assign("i860-"); break;
+ case EM_MIPS: triple.assign("mips-"); break;
+ case EM_PPC: triple.assign("powerpc-"); break;
+ case EM_PPC64: triple.assign("powerpc64-"); break;
+ case EM_ARM: triple.assign("arm-"); break;
+ case EM_X86_64: triple.assign("x86_64-"); break;
+ }
+ // TODO: determine if there is a vendor in the ELF? Default to "linux" for now
+ triple += "linux-";
+ // TODO: determine if there is an OS in the ELF? Default to "gnu" for now
+ triple += "gnu";
+ g_target_triple.SetCString(triple.c_str());
+ target_triple = g_target_triple;
+
+ return true;
+}
+
+//------------------------------------------------------------------
+// PluginInterface protocol
+//------------------------------------------------------------------
+const char *
+ObjectFileELF64::GetPluginName()
+{
+ return "ObjectFileELF64";
+}
+
+const char *
+ObjectFileELF64::GetShortPluginName()
+{
+ return GetPluginNameStatic();
+}
+
+uint32_t
+ObjectFileELF64::GetPluginVersion()
+{
+ return 1;
+}
+
+void
+ObjectFileELF64::GetPluginCommandHelp (const char *command, Stream *strm)
+{
+}
+
+Error
+ObjectFileELF64::ExecutePluginCommand (Args &command, Stream *strm)
+{
+ Error error;
+ error.SetErrorString("No plug-in commands are currently supported.");
+ return error;
+}
+
+Log *
+ObjectFileELF64::EnablePluginLogging (Stream *strm, Args &command)
+{
+ return NULL;
+}
Added: lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.h?rev=107817&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.h (added)
+++ lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF64.h Wed Jul 7 16:52:01 2010
@@ -0,0 +1,209 @@
+//===-- ObjectFileELF64.h ------------------------------------- -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_ObjectFileELF64_h_
+#define liblldb_ObjectFileELF64_h_
+
+#include <stdint.h>
+#include <vector>
+
+#include "lldb/lldb-private.h"
+#include "lldb/Core/FileSpec.h"
+#include "lldb/Symbol/ObjectFile.h"
+
+#include "elf.h"
+
+//----------------------------------------------------------------------
+// This class needs to be hidden as eventually belongs in a plugin that
+// will export the ObjectFile protocol
+//----------------------------------------------------------------------
+class ObjectFileELF64 :
+ public lldb_private::ObjectFile
+{
+public:
+ //------------------------------------------------------------------
+ // Static Functions
+ //------------------------------------------------------------------
+ static void
+ Initialize();
+
+ static void
+ Terminate();
+
+ static const char *
+ GetPluginNameStatic();
+
+ static const char *
+ GetPluginDescriptionStatic();
+
+ static lldb_private::ObjectFile *
+ CreateInstance(lldb_private::Module* module,
+ lldb::DataBufferSP& dataSP,
+ const lldb_private::FileSpec* file,
+ lldb::addr_t offset,
+ lldb::addr_t length);
+
+ static bool
+ MagicBytesMatch(lldb::DataBufferSP& dataSP);
+
+ //------------------------------------------------------------------
+ // Member Functions
+ //------------------------------------------------------------------
+ ObjectFileELF64(lldb_private::Module* module,
+ lldb::DataBufferSP& dataSP,
+ const lldb_private::FileSpec* file,
+ lldb::addr_t offset,
+ lldb::addr_t length);
+
+ virtual
+ ~ObjectFileELF64();
+
+ virtual bool
+ ParseHeader();
+
+ virtual lldb::ByteOrder
+ GetByteOrder() const;
+
+ virtual size_t
+ GetAddressByteSize() const;
+
+ virtual lldb_private::Symtab *
+ GetSymtab();
+
+ virtual lldb_private::SectionList *
+ GetSectionList();
+
+ virtual void
+ Dump(lldb_private::Stream *s);
+
+ virtual bool
+ GetTargetTriple(lldb_private::ConstString &target_triple);
+
+ virtual bool
+ GetUUID(lldb_private::UUID* uuid);
+
+ virtual uint32_t
+ GetDependentModules(lldb_private::FileSpecList& files);
+
+ //------------------------------------------------------------------
+ // PluginInterface protocol
+ //------------------------------------------------------------------
+ virtual const char *
+ GetPluginName();
+
+ virtual const char *
+ GetShortPluginName();
+
+ virtual uint32_t
+ GetPluginVersion();
+
+ virtual void
+ GetPluginCommandHelp(const char *command, lldb_private::Stream *strm);
+
+ virtual lldb_private::Error
+ ExecutePluginCommand(lldb_private::Args &command,
+ lldb_private::Stream *strm);
+
+ virtual lldb_private::Log *
+ EnablePluginLogging(lldb_private::Stream *strm,
+ lldb_private::Args &command);
+
+protected:
+ typedef std::vector<Elf64_Phdr> ProgramHeaderColl;
+ typedef ProgramHeaderColl::iterator ProgramHeaderCollIter;
+ typedef ProgramHeaderColl::const_iterator ProgramHeaderCollConstIter;
+
+ typedef std::vector<Elf64_Shdr> SectionHeaderColl;
+ typedef SectionHeaderColl::iterator SectionHeaderCollIter;
+ typedef SectionHeaderColl::const_iterator SectionHeaderCollConstIter;
+
+ Elf64_Ehdr m_header;
+ ProgramHeaderColl m_program_headers;
+ SectionHeaderColl m_section_headers;
+ mutable std::auto_ptr<lldb_private::SectionList> m_sections_ap;
+ mutable std::auto_ptr<lldb_private::Symtab> m_symtab_ap;
+ mutable std::auto_ptr<lldb_private::FileSpecList> m_filespec_ap;
+ lldb_private::DataExtractor m_shstr_data;
+
+ size_t
+ ParseSections();
+
+ size_t
+ ParseSymtab(bool minimize);
+
+private:
+ // Returns the 1 based index of a section header.
+ unsigned
+ SectionIndex(const SectionHeaderCollIter &I);
+
+ unsigned
+ SectionIndex(const SectionHeaderCollConstIter &I) const;
+
+ // ELF header dump routines
+ static void
+ DumpELFHeader(lldb_private::Stream *s, const Elf64_Ehdr& header);
+
+ static void
+ DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s,
+ unsigned char ei_data);
+
+ static void
+ DumpELFHeader_e_type(lldb_private::Stream *s, Elf64_Half e_type);
+
+ // ELF program header dump routines
+ void
+ DumpELFProgramHeaders(lldb_private::Stream *s);
+
+ static void
+ DumpELFProgramHeader(lldb_private::Stream *s, const Elf64_Phdr &ph);
+
+ static void
+ DumpELFProgramHeader_p_type(lldb_private::Stream *s, Elf64_Word p_type);
+
+ static void
+ DumpELFProgramHeader_p_flags(lldb_private::Stream *s, Elf64_Word p_flags);
+
+ // ELF section header dump routines
+ void
+ DumpELFSectionHeaders(lldb_private::Stream *s);
+
+ static void
+ DumpELFSectionHeader(lldb_private::Stream *s, const Elf64_Shdr& sh);
+
+ static void
+ DumpELFSectionHeader_sh_type(lldb_private::Stream *s, Elf64_Word sh_type);
+
+ static void
+ DumpELFSectionHeader_sh_flags(lldb_private::Stream *s, Elf64_Word sh_flags);
+
+ void
+ DumpDependentModules(lldb_private::Stream *s);
+
+ size_t
+ ParseProgramHeaders();
+
+ size_t
+ ParseSectionHeaders();
+
+ size_t
+ ParseDependentModules();
+
+ void
+ ParseSymbolTable(lldb_private::Symtab *symbol_table,
+ const Elf64_Shdr &symtab_section,
+ lldb::user_id_t symtab_id);
+
+ size_t
+ GetSectionHeaderStringTable();
+
+ uint32_t
+ GetSectionIndexByName(const char *name);
+};
+
+#endif // #ifndef liblldb_ObjectFileELF64_h_
Modified: lldb/trunk/source/Plugins/ObjectFile/ELF/elf.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/ObjectFile/ELF/elf.h?rev=107817&r1=107816&r2=107817&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/ObjectFile/ELF/elf.h (original)
+++ lldb/trunk/source/Plugins/ObjectFile/ELF/elf.h Wed Jul 7 16:52:01 2010
@@ -10,17 +10,30 @@
#ifndef __elf_h__
#define __elf_h__
+//----------------------------------------------------------------------
+// Typedefs for ELF32.
+//----------------------------------------------------------------------
typedef uint16_t Elf32_Half;
typedef uint32_t Elf32_Word;
typedef int32_t Elf32_Sword;
typedef uint32_t Elf32_Addr;
typedef uint32_t Elf32_Off;
+//----------------------------------------------------------------------
+// Typedefs for ELF64.
+//----------------------------------------------------------------------
+typedef uint16_t Elf64_Half;
+typedef uint32_t Elf64_Word;
+typedef int32_t Elf64_Sword;
+typedef uint64_t Elf64_Xword;
+typedef int64_t Elf64_Sxword;
+typedef uint64_t Elf64_Addr;
+typedef uint64_t Elf64_Off;
#define EI_NIDENT 16
//----------------------------------------------------------------------
-// ELF Header
+// ELF Headers
//----------------------------------------------------------------------
typedef struct Elf32_Ehdr_Tag
{
@@ -40,6 +53,24 @@
Elf32_Half e_shstrndx;
} Elf32_Ehdr;
+typedef struct Elf64_Ehdr_Tag
+{
+ unsigned char e_ident[EI_NIDENT];
+ Elf64_Half e_type;
+ Elf64_Half e_machine;
+ Elf64_Word e_version;
+ Elf64_Addr e_entry;
+ Elf64_Off e_phoff;
+ Elf64_Off e_shoff;
+ Elf64_Word e_flags;
+ Elf64_Half e_ehsize;
+ Elf64_Half e_phentsize;
+ Elf64_Half e_phnum;
+ Elf64_Half e_shentsize;
+ Elf64_Half e_shnum;
+ Elf64_Half e_shstrndx;
+} Elf64_Ehdr;
+
//----------------------------------------------------------------------
// e_type
//
@@ -69,6 +100,7 @@
#define EM_PPC 20 // PowerPC
#define EM_PPC64 21 // PowerPC64
#define EM_ARM 40 // ARM
+#define EM_X86_64 62 // AMD x86-64
//----------------------------------------------------------------------
@@ -83,6 +115,11 @@
#define EI_VERSION 6 // File version
#define EI_PAD 7 // Start of padding bytes
+//----------------------------------------------------------------------
+// EI_CLASS definitions
+//----------------------------------------------------------------------
+#define ELFCLASS32 1 // 32-bit object file
+#define ELFCLASS64 2 // 64-bit object file
//----------------------------------------------------------------------
// EI_DATA definitions
@@ -92,7 +129,7 @@
#define ELFDATA2MSB 2 // Big Endian
//----------------------------------------------------------------------
-// Section Header
+// Section Headers
//----------------------------------------------------------------------
typedef struct Elf32_Shdr_Tag
{
@@ -108,6 +145,20 @@
Elf32_Word sh_entsize;
} Elf32_Shdr;
+typedef struct Elf64_Shdr_Tag
+{
+ Elf64_Word sh_name;
+ Elf64_Word sh_type;
+ Elf64_Xword sh_flags;
+ Elf64_Addr sh_addr;
+ Elf64_Off sh_offset;
+ Elf64_Xword sh_size;
+ Elf64_Word sh_link;
+ Elf64_Word sh_info;
+ Elf64_Xword sh_addralign;
+ Elf64_Xword sh_entsize;
+} Elf64_Shdr;
+
//----------------------------------------------------------------------
// Section Types (sh_type)
//----------------------------------------------------------------------
@@ -149,7 +200,7 @@
//----------------------------------------------------------------------
-// Symbol Table Entry Header
+// Symbol Table Entry Headers
//----------------------------------------------------------------------
typedef struct Elf32_Sym_Tag
{
@@ -161,10 +212,23 @@
Elf32_Half st_shndx;
} Elf32_Sym;
+typedef struct Elf64_Sym_Tag
+{
+ Elf64_Word st_name;
+ unsigned char st_info;
+ unsigned char st_other;
+ Elf64_Half st_shndx;
+ Elf64_Addr st_value;
+ Elf64_Xword st_size;
+} Elf64_Sym;
-#define ELF32_ST_BIND(i) ((i)>>4)
-#define ELF32_ST_TYPE(i) ((i)&0xf)
-#define ELF32_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
+//----------------------------------------------------------------------
+// Accessors to the binding and type bits in the st_info field of a
+// symbol table entry. Valid for both 32 and 64 bit variations.
+//----------------------------------------------------------------------
+#define ELF_ST_BIND(i) ((i)>>4)
+#define ELF_ST_TYPE(i) ((i)&0xf)
+#define ELF_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
// ST_BIND
#define STB_LOCAL 0
@@ -199,10 +263,70 @@
Elf32_Sword r_addend;
} Elf32_Rela;
+typedef struct Elf64_Rel_Tag
+{
+ Elf64_Addr r_offset;
+ Elf64_Word r_info;
+} Elf64_Rel;
+
+typedef struct Elf64_Rela_Tag
+{
+ Elf64_Addr r_offset;
+ Elf64_Word r_info;
+ Elf64_Sword r_addend;
+} Elf64_Rela;
+
#define ELF32_R_SYM(i) ((i)>>8)
#define ELF32_R_TYPE(i) ((unsignedchar)(i))
#define ELF32_R_INFO(s,t) (((s)<<8)+(unsignedchar)(t))
+//----------------------------------------------------------------------
+// Dynamic Table Entry Headers
+//----------------------------------------------------------------------
+typedef struct Elf64_Dyn_Tag
+{
+ Elf64_Sxword d_tag;
+ union
+ {
+ Elf64_Xword d_val;
+ Elf64_Addr d_ptr;
+ } d_un;
+} Elf64_Dyn;
+
+#define DT_NULL 0 // Marks end of dynamic array.
+#define DT_NEEDED 1 // String table offset of needed library.
+#define DT_PLTRELSZ 2 // Size of relocation entries in PLT.
+#define DT_PLTGOT 3 // Address associated with linkage table.
+#define DT_HASH 4 // Address of symbolic hash table.
+#define DT_STRTAB 5 // Address of dynamic string table.
+#define DT_SYMTAB 6 // Address of dynamic symbol table.
+#define DT_RELA 7 // Address of relocation table (Rela entries).
+#define DT_RELASZ 8 // Size of Rela relocation table.
+#define DT_RELAENT 9 // Size of a Rela relocation entry.
+#define DT_STRSZ 10 // Total size of the string table.
+#define DT_SYMENT 11 // Size of a symbol table entry.
+#define DT_INIT 12 // Address of initialization function.
+#define DT_FINI 13 // Address of termination function.
+#define DT_SONAME 14 // String table offset of a shared objects name.
+#define DT_RPATH 15 // String table offset of library search path.
+#define DT_SYMBOLIC 16 // Changes symbol resolution algorithm.
+#define DT_REL 17 // Address of relocation table (Rel entries).
+#define DT_RELSZ 18 // Size of Rel relocation table.
+#define DT_RELENT 19 // Size of a Rel relocation entry.
+#define DT_PLTREL 20 // Type of relocation entry used for linking.
+#define DT_DEBUG 21 // Reserved for debugger.
+#define DT_TEXTREL 22 // Relocations exist for non-writable segements.
+#define DT_JMPREL 23 // Address of relocations associated with PLT.
+#define DT_BIND_NOW 24 // Process all relocations before execution.
+#define DT_INIT_ARRAY 25 // Pointer to array of initialization functions.
+#define DT_FINI_ARRAY 26 // Pointer to array of termination functions.
+#define DT_INIT_ARRAYSZ 27 // Size of DT_INIT_ARRAY.
+#define DT_FINI_ARRAYSZ 28 // Size of DT_FINI_ARRAY.
+#define DT_LOOS 0x60000000 // Start of environment specific tags.
+#define DT_HIOS 0x6FFFFFFF // End of environment specific tags.
+#define DT_LOPROC 0x70000000 // Start of processor specific tags.
+#define DT_HIPROC 0x7FFFFFFF // End of processor specific tags.
+
//----------------------------------------------------------------------
// Program Headers
@@ -219,6 +343,18 @@
Elf32_Word p_align;
} Elf32_Phdr;
+typedef struct Elf64_Phdr_Tag
+{
+ Elf64_Word p_type;
+ Elf64_Off p_offset;
+ Elf64_Addr p_vaddr;
+ Elf64_Addr p_paddr;
+ Elf64_Word p_filesz;
+ Elf64_Word p_memsz;
+ Elf64_Word p_flags;
+ Elf64_Word p_align;
+} Elf64_Phdr;
+
//----------------------------------------------------------------------
// Program Header Type (p_type)
//----------------------------------------------------------------------
Modified: lldb/trunk/source/lldb.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/lldb.cpp?rev=107817&r1=107816&r2=107817&view=diff
==============================================================================
--- lldb/trunk/source/lldb.cpp (original)
+++ lldb/trunk/source/lldb.cpp Wed Jul 7 16:52:01 2010
@@ -19,6 +19,7 @@
#include "Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h"
#include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h"
#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
+#include "Plugins/ObjectFile/ELF/ObjectFileELF64.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
#include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
@@ -55,6 +56,7 @@
DisassemblerLLVM::Initialize();
ObjectContainerBSDArchive::Initialize();
ObjectFileELF::Initialize();
+ ObjectFileELF64::Initialize();
SymbolVendorMacOSX::Initialize();
SymbolFileDWARF::Initialize();
SymbolFileDWARFDebugMap::Initialize();
@@ -84,6 +86,7 @@
DisassemblerLLVM::Terminate();
ObjectContainerBSDArchive::Terminate();
ObjectFileELF::Terminate();
+ ObjectFileELF64::Terminate();
SymbolVendorMacOSX::Terminate();
SymbolFileDWARF::Terminate();
SymbolFileDWARFDebugMap::Terminate();
More information about the lldb-commits
mailing list