diff options
Diffstat (limited to 'source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp')
| -rw-r--r-- | source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp | 1056 |
1 files changed, 1056 insertions, 0 deletions
diff --git a/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp b/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp new file mode 100644 index 000000000000..b66244813240 --- /dev/null +++ b/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp @@ -0,0 +1,1056 @@ +//===-- ObjectFilePECOFF.cpp ------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "ObjectFilePECOFF.h" +#include "WindowsMiniDump.h" + +#include "llvm/Support/COFF.h" + +#include "lldb/Core/ArchSpec.h" +#include "lldb/Core/DataBuffer.h" +#include "lldb/Host/FileSpec.h" +#include "lldb/Core/FileSpecList.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/ModuleSpec.h" +#include "lldb/Core/PluginManager.h" +#include "lldb/Core/Section.h" +#include "lldb/Core/StreamFile.h" +#include "lldb/Core/StreamString.h" +#include "lldb/Core/Timer.h" +#include "lldb/Core/UUID.h" +#include "lldb/Symbol/ObjectFile.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/SectionLoadList.h" +#include "lldb/Target/Target.h" + +#define IMAGE_DOS_SIGNATURE 0x5A4D // MZ +#define IMAGE_NT_SIGNATURE 0x00004550 // PE00 +#define OPT_HEADER_MAGIC_PE32 0x010b +#define OPT_HEADER_MAGIC_PE32_PLUS 0x020b + +using namespace lldb; +using namespace lldb_private; + +void +ObjectFilePECOFF::Initialize() +{ + PluginManager::RegisterPlugin (GetPluginNameStatic(), + GetPluginDescriptionStatic(), + CreateInstance, + CreateMemoryInstance, + GetModuleSpecifications, + SaveCore); +} + +void +ObjectFilePECOFF::Terminate() +{ + PluginManager::UnregisterPlugin (CreateInstance); +} + + +lldb_private::ConstString +ObjectFilePECOFF::GetPluginNameStatic() +{ + static ConstString g_name("pe-coff"); + return g_name; +} + +const char * +ObjectFilePECOFF::GetPluginDescriptionStatic() +{ + return "Portable Executable and Common Object File Format object file reader (32 and 64 bit)"; +} + + +ObjectFile * +ObjectFilePECOFF::CreateInstance (const lldb::ModuleSP &module_sp, + DataBufferSP& data_sp, + lldb::offset_t data_offset, + const lldb_private::FileSpec* file, + lldb::offset_t file_offset, + lldb::offset_t length) +{ + if (!data_sp) + { + data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length); + data_offset = 0; + } + + if (ObjectFilePECOFF::MagicBytesMatch(data_sp)) + { + // Update the data to contain the entire file if it doesn't already + if (data_sp->GetByteSize() < length) + data_sp = file->MemoryMapFileContentsIfLocal(file_offset, length); + std::unique_ptr<ObjectFile> objfile_ap(new ObjectFilePECOFF (module_sp, data_sp, data_offset, file, file_offset, length)); + if (objfile_ap.get() && objfile_ap->ParseHeader()) + return objfile_ap.release(); + } + return NULL; +} + +ObjectFile * +ObjectFilePECOFF::CreateMemoryInstance (const lldb::ModuleSP &module_sp, + lldb::DataBufferSP& data_sp, + const lldb::ProcessSP &process_sp, + lldb::addr_t header_addr) +{ + return NULL; +} + +size_t +ObjectFilePECOFF::GetModuleSpecifications (const lldb_private::FileSpec& file, + lldb::DataBufferSP& data_sp, + lldb::offset_t data_offset, + lldb::offset_t file_offset, + lldb::offset_t length, + lldb_private::ModuleSpecList &specs) +{ + const size_t initial_count = specs.GetSize(); + + if (ObjectFilePECOFF::MagicBytesMatch(data_sp)) + { + DataExtractor data; + data.SetData(data_sp, data_offset, length); + data.SetByteOrder(eByteOrderLittle); + + dos_header_t dos_header; + coff_header_t coff_header; + + if (ParseDOSHeader(data, dos_header)) + { + lldb::offset_t offset = dos_header.e_lfanew; + uint32_t pe_signature = data.GetU32(&offset); + if (pe_signature != IMAGE_NT_SIGNATURE) + return false; + if (ParseCOFFHeader(data, &offset, coff_header)) + { + ArchSpec spec; + if (coff_header.machine == MachineAmd64) + { + spec.SetTriple("x86_64-pc-windows"); + specs.Append(ModuleSpec(file, spec)); + } + else if (coff_header.machine == MachineX86) + { + spec.SetTriple("i386-pc-windows"); + specs.Append(ModuleSpec(file, spec)); + spec.SetTriple("i686-pc-windows"); + specs.Append(ModuleSpec(file, spec)); + } + } + } + } + + return specs.GetSize() - initial_count; +} + +bool +ObjectFilePECOFF::SaveCore(const lldb::ProcessSP &process_sp, + const lldb_private::FileSpec &outfile, + lldb_private::Error &error) +{ + return SaveMiniDump(process_sp, outfile, error); +} + + +bool +ObjectFilePECOFF::MagicBytesMatch (DataBufferSP& data_sp) +{ + DataExtractor data(data_sp, eByteOrderLittle, 4); + lldb::offset_t offset = 0; + uint16_t magic = data.GetU16 (&offset); + return magic == IMAGE_DOS_SIGNATURE; +} + + +ObjectFilePECOFF::ObjectFilePECOFF (const lldb::ModuleSP &module_sp, + DataBufferSP& data_sp, + lldb::offset_t data_offset, + const FileSpec* file, + lldb::offset_t file_offset, + lldb::offset_t length) : + ObjectFile (module_sp, file, file_offset, length, data_sp, data_offset), + m_dos_header (), + m_coff_header (), + m_coff_header_opt (), + m_sect_headers () +{ + ::memset (&m_dos_header, 0, sizeof(m_dos_header)); + ::memset (&m_coff_header, 0, sizeof(m_coff_header)); + ::memset (&m_coff_header_opt, 0, sizeof(m_coff_header_opt)); +} + + +ObjectFilePECOFF::~ObjectFilePECOFF() +{ +} + + +bool +ObjectFilePECOFF::ParseHeader () +{ + ModuleSP module_sp(GetModule()); + if (module_sp) + { + lldb_private::Mutex::Locker locker(module_sp->GetMutex()); + m_sect_headers.clear(); + m_data.SetByteOrder (eByteOrderLittle); + lldb::offset_t offset = 0; + + if (ParseDOSHeader(m_data, m_dos_header)) + { + offset = m_dos_header.e_lfanew; + uint32_t pe_signature = m_data.GetU32 (&offset); + if (pe_signature != IMAGE_NT_SIGNATURE) + return false; + if (ParseCOFFHeader(m_data, &offset, m_coff_header)) + { + if (m_coff_header.hdrsize > 0) + ParseCOFFOptionalHeader(&offset); + ParseSectionHeaders (offset); + } + return true; + } + } + return false; +} + +bool +ObjectFilePECOFF::SetLoadAddress(Target &target, addr_t value, bool value_is_offset) +{ + bool changed = false; + ModuleSP module_sp = GetModule(); + if (module_sp) + { + size_t num_loaded_sections = 0; + SectionList *section_list = GetSectionList (); + if (section_list) + { + if (!value_is_offset) + { + value -= m_image_base; + } + + const size_t num_sections = section_list->GetSize(); + size_t sect_idx = 0; + + for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) + { + // Iterate through the object file sections to find all + // of the sections that have SHF_ALLOC in their flag bits. + SectionSP section_sp (section_list->GetSectionAtIndex (sect_idx)); + if (section_sp && !section_sp->IsThreadSpecific()) + { + if (target.GetSectionLoadList().SetSectionLoadAddress (section_sp, section_sp->GetFileAddress() + value)) + ++num_loaded_sections; + } + } + changed = num_loaded_sections > 0; + } + } + return changed; +} + + +ByteOrder +ObjectFilePECOFF::GetByteOrder () const +{ + return eByteOrderLittle; +} + +bool +ObjectFilePECOFF::IsExecutable() const +{ + return (m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0; +} + +uint32_t +ObjectFilePECOFF::GetAddressByteSize () const +{ + if (m_coff_header_opt.magic == OPT_HEADER_MAGIC_PE32_PLUS) + return 8; + else if (m_coff_header_opt.magic == OPT_HEADER_MAGIC_PE32) + return 4; + return 4; +} + +//---------------------------------------------------------------------- +// NeedsEndianSwap +// +// Return true if an endian swap needs to occur when extracting data +// from this file. +//---------------------------------------------------------------------- +bool +ObjectFilePECOFF::NeedsEndianSwap() const +{ +#if defined(__LITTLE_ENDIAN__) + return false; +#else + return true; +#endif +} +//---------------------------------------------------------------------- +// ParseDOSHeader +//---------------------------------------------------------------------- +bool +ObjectFilePECOFF::ParseDOSHeader (DataExtractor &data, dos_header_t &dos_header) +{ + bool success = false; + lldb::offset_t offset = 0; + success = data.ValidOffsetForDataOfSize(0, sizeof(dos_header)); + + if (success) + { + dos_header.e_magic = data.GetU16(&offset); // Magic number + success = dos_header.e_magic == IMAGE_DOS_SIGNATURE; + + if (success) + { + dos_header.e_cblp = data.GetU16(&offset); // Bytes on last page of file + dos_header.e_cp = data.GetU16(&offset); // Pages in file + dos_header.e_crlc = data.GetU16(&offset); // Relocations + dos_header.e_cparhdr = data.GetU16(&offset); // Size of header in paragraphs + dos_header.e_minalloc = data.GetU16(&offset); // Minimum extra paragraphs needed + dos_header.e_maxalloc = data.GetU16(&offset); // Maximum extra paragraphs needed + dos_header.e_ss = data.GetU16(&offset); // Initial (relative) SS value + dos_header.e_sp = data.GetU16(&offset); // Initial SP value + dos_header.e_csum = data.GetU16(&offset); // Checksum + dos_header.e_ip = data.GetU16(&offset); // Initial IP value + dos_header.e_cs = data.GetU16(&offset); // Initial (relative) CS value + dos_header.e_lfarlc = data.GetU16(&offset); // File address of relocation table + dos_header.e_ovno = data.GetU16(&offset); // Overlay number + + dos_header.e_res[0] = data.GetU16(&offset); // Reserved words + dos_header.e_res[1] = data.GetU16(&offset); // Reserved words + dos_header.e_res[2] = data.GetU16(&offset); // Reserved words + dos_header.e_res[3] = data.GetU16(&offset); // Reserved words + + dos_header.e_oemid = data.GetU16(&offset); // OEM identifier (for e_oeminfo) + dos_header.e_oeminfo = data.GetU16(&offset); // OEM information; e_oemid specific + dos_header.e_res2[0] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[1] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[2] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[3] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[4] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[5] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[6] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[7] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[8] = data.GetU16(&offset); // Reserved words + dos_header.e_res2[9] = data.GetU16(&offset); // Reserved words + + dos_header.e_lfanew = data.GetU32(&offset); // File address of new exe header + } + } + if (!success) + memset(&dos_header, 0, sizeof(dos_header)); + return success; +} + + +//---------------------------------------------------------------------- +// ParserCOFFHeader +//---------------------------------------------------------------------- +bool +ObjectFilePECOFF::ParseCOFFHeader(DataExtractor &data, lldb::offset_t *offset_ptr, coff_header_t &coff_header) +{ + bool success = data.ValidOffsetForDataOfSize (*offset_ptr, sizeof(coff_header)); + if (success) + { + coff_header.machine = data.GetU16(offset_ptr); + coff_header.nsects = data.GetU16(offset_ptr); + coff_header.modtime = data.GetU32(offset_ptr); + coff_header.symoff = data.GetU32(offset_ptr); + coff_header.nsyms = data.GetU32(offset_ptr); + coff_header.hdrsize = data.GetU16(offset_ptr); + coff_header.flags = data.GetU16(offset_ptr); + } + if (!success) + memset(&coff_header, 0, sizeof(coff_header)); + return success; +} + +bool +ObjectFilePECOFF::ParseCOFFOptionalHeader(lldb::offset_t *offset_ptr) +{ + bool success = false; + const lldb::offset_t end_offset = *offset_ptr + m_coff_header.hdrsize; + if (*offset_ptr < end_offset) + { + success = true; + m_coff_header_opt.magic = m_data.GetU16(offset_ptr); + m_coff_header_opt.major_linker_version = m_data.GetU8 (offset_ptr); + m_coff_header_opt.minor_linker_version = m_data.GetU8 (offset_ptr); + m_coff_header_opt.code_size = m_data.GetU32(offset_ptr); + m_coff_header_opt.data_size = m_data.GetU32(offset_ptr); + m_coff_header_opt.bss_size = m_data.GetU32(offset_ptr); + m_coff_header_opt.entry = m_data.GetU32(offset_ptr); + m_coff_header_opt.code_offset = m_data.GetU32(offset_ptr); + + const uint32_t addr_byte_size = GetAddressByteSize (); + + if (*offset_ptr < end_offset) + { + if (m_coff_header_opt.magic == OPT_HEADER_MAGIC_PE32) + { + // PE32 only + m_coff_header_opt.data_offset = m_data.GetU32(offset_ptr); + } + else + m_coff_header_opt.data_offset = 0; + + if (*offset_ptr < end_offset) + { + m_coff_header_opt.image_base = m_data.GetMaxU64 (offset_ptr, addr_byte_size); + m_coff_header_opt.sect_alignment = m_data.GetU32(offset_ptr); + m_coff_header_opt.file_alignment = m_data.GetU32(offset_ptr); + m_coff_header_opt.major_os_system_version = m_data.GetU16(offset_ptr); + m_coff_header_opt.minor_os_system_version = m_data.GetU16(offset_ptr); + m_coff_header_opt.major_image_version = m_data.GetU16(offset_ptr); + m_coff_header_opt.minor_image_version = m_data.GetU16(offset_ptr); + m_coff_header_opt.major_subsystem_version = m_data.GetU16(offset_ptr); + m_coff_header_opt.minor_subsystem_version = m_data.GetU16(offset_ptr); + m_coff_header_opt.reserved1 = m_data.GetU32(offset_ptr); + m_coff_header_opt.image_size = m_data.GetU32(offset_ptr); + m_coff_header_opt.header_size = m_data.GetU32(offset_ptr); + m_coff_header_opt.checksum = m_data.GetU32(offset_ptr); + m_coff_header_opt.subsystem = m_data.GetU16(offset_ptr); + m_coff_header_opt.dll_flags = m_data.GetU16(offset_ptr); + m_coff_header_opt.stack_reserve_size = m_data.GetMaxU64 (offset_ptr, addr_byte_size); + m_coff_header_opt.stack_commit_size = m_data.GetMaxU64 (offset_ptr, addr_byte_size); + m_coff_header_opt.heap_reserve_size = m_data.GetMaxU64 (offset_ptr, addr_byte_size); + m_coff_header_opt.heap_commit_size = m_data.GetMaxU64 (offset_ptr, addr_byte_size); + m_coff_header_opt.loader_flags = m_data.GetU32(offset_ptr); + uint32_t num_data_dir_entries = m_data.GetU32(offset_ptr); + m_coff_header_opt.data_dirs.clear(); + m_coff_header_opt.data_dirs.resize(num_data_dir_entries); + uint32_t i; + for (i=0; i<num_data_dir_entries; i++) + { + m_coff_header_opt.data_dirs[i].vmaddr = m_data.GetU32(offset_ptr); + m_coff_header_opt.data_dirs[i].vmsize = m_data.GetU32(offset_ptr); + } + + m_file_offset = m_coff_header_opt.image_base; + m_image_base = m_coff_header_opt.image_base; + } + } + } + // Make sure we are on track for section data which follows + *offset_ptr = end_offset; + return success; +} + + +//---------------------------------------------------------------------- +// ParseSectionHeaders +//---------------------------------------------------------------------- +bool +ObjectFilePECOFF::ParseSectionHeaders (uint32_t section_header_data_offset) +{ + const uint32_t nsects = m_coff_header.nsects; + m_sect_headers.clear(); + + if (nsects > 0) + { + const uint32_t addr_byte_size = GetAddressByteSize (); + const size_t section_header_byte_size = nsects * sizeof(section_header_t); + DataBufferSP section_header_data_sp(m_file.ReadFileContents (section_header_data_offset, section_header_byte_size)); + DataExtractor section_header_data (section_header_data_sp, GetByteOrder(), addr_byte_size); + + lldb::offset_t offset = 0; + if (section_header_data.ValidOffsetForDataOfSize (offset, section_header_byte_size)) + { + m_sect_headers.resize(nsects); + + for (uint32_t idx = 0; idx<nsects; ++idx) + { + const void *name_data = section_header_data.GetData(&offset, 8); + if (name_data) + { + memcpy(m_sect_headers[idx].name, name_data, 8); + m_sect_headers[idx].vmsize = section_header_data.GetU32(&offset); + m_sect_headers[idx].vmaddr = section_header_data.GetU32(&offset); + m_sect_headers[idx].size = section_header_data.GetU32(&offset); + m_sect_headers[idx].offset = section_header_data.GetU32(&offset); + m_sect_headers[idx].reloff = section_header_data.GetU32(&offset); + m_sect_headers[idx].lineoff = section_header_data.GetU32(&offset); + m_sect_headers[idx].nreloc = section_header_data.GetU16(&offset); + m_sect_headers[idx].nline = section_header_data.GetU16(&offset); + m_sect_headers[idx].flags = section_header_data.GetU32(&offset); + } + } + } + } + + return m_sect_headers.empty() == false; +} + +bool +ObjectFilePECOFF::GetSectionName(std::string& sect_name, const section_header_t& sect) +{ + if (sect.name[0] == '/') + { + lldb::offset_t stroff = strtoul(§.name[1], NULL, 10); + lldb::offset_t string_file_offset = m_coff_header.symoff + (m_coff_header.nsyms * 18) + stroff; + const char *name = m_data.GetCStr (&string_file_offset); + if (name) + { + sect_name = name; + return true; + } + + return false; + } + sect_name = sect.name; + return true; +} + +//---------------------------------------------------------------------- +// GetNListSymtab +//---------------------------------------------------------------------- +Symtab * +ObjectFilePECOFF::GetSymtab() +{ + ModuleSP module_sp(GetModule()); + if (module_sp) + { + lldb_private::Mutex::Locker locker(module_sp->GetMutex()); + if (m_symtab_ap.get() == NULL) + { + SectionList *sect_list = GetSectionList(); + m_symtab_ap.reset(new Symtab(this)); + Mutex::Locker symtab_locker (m_symtab_ap->GetMutex()); + + const uint32_t num_syms = m_coff_header.nsyms; + + if (num_syms > 0 && m_coff_header.symoff > 0) + { + const uint32_t symbol_size = 18; + const uint32_t addr_byte_size = GetAddressByteSize (); + const size_t symbol_data_size = num_syms * symbol_size; + // Include the 4 bytes string table size at the end of the symbols + DataBufferSP symtab_data_sp(m_file.ReadFileContents (m_coff_header.symoff, symbol_data_size + 4)); + DataExtractor symtab_data (symtab_data_sp, GetByteOrder(), addr_byte_size); + lldb::offset_t offset = symbol_data_size; + const uint32_t strtab_size = symtab_data.GetU32 (&offset); + DataBufferSP strtab_data_sp(m_file.ReadFileContents (m_coff_header.symoff + symbol_data_size, strtab_size)); + DataExtractor strtab_data (strtab_data_sp, GetByteOrder(), addr_byte_size); + + // First 4 bytes should be zeroed after strtab_size has been read, + // because it is used as offset 0 to encode a NULL string. + uint32_t* strtab_data_start = (uint32_t*)strtab_data_sp->GetBytes(); + strtab_data_start[0] = 0; + + offset = 0; + std::string symbol_name; + Symbol *symbols = m_symtab_ap->Resize (num_syms); + for (uint32_t i=0; i<num_syms; ++i) + { + coff_symbol_t symbol; + const uint32_t symbol_offset = offset; + const char *symbol_name_cstr = NULL; + // If the first 4 bytes of the symbol string are zero, then we + // it is followed by a 4 byte string table offset. Else these + // 8 bytes contain the symbol name + if (symtab_data.GetU32 (&offset) == 0) + { + // Long string that doesn't fit into the symbol table name, + // so now we must read the 4 byte string table offset + uint32_t strtab_offset = symtab_data.GetU32 (&offset); + symbol_name_cstr = strtab_data.PeekCStr (strtab_offset); + symbol_name.assign (symbol_name_cstr); + } + else + { + // Short string that fits into the symbol table name which is 8 bytes + offset += sizeof(symbol.name) - 4; // Skip remaining + symbol_name_cstr = symtab_data.PeekCStr (symbol_offset); + if (symbol_name_cstr == NULL) + break; + symbol_name.assign (symbol_name_cstr, sizeof(symbol.name)); + } + symbol.value = symtab_data.GetU32 (&offset); + symbol.sect = symtab_data.GetU16 (&offset); + symbol.type = symtab_data.GetU16 (&offset); + symbol.storage = symtab_data.GetU8 (&offset); + symbol.naux = symtab_data.GetU8 (&offset); + symbols[i].GetMangled ().SetValue (ConstString(symbol_name.c_str())); + if ((int16_t)symbol.sect >= 1) + { + Address symbol_addr(sect_list->GetSectionAtIndex(symbol.sect-1), symbol.value); + symbols[i].GetAddressRef() = symbol_addr; + } + + if (symbol.naux > 0) + { + i += symbol.naux; + offset += symbol_size; + } + } + + } + + // Read export header + if (coff_data_dir_export_table < m_coff_header_opt.data_dirs.size() + && m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmsize > 0 && m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr > 0) + { + export_directory_entry export_table; + uint32_t data_start = m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr; + Address address(m_coff_header_opt.image_base + data_start, sect_list); + DataBufferSP symtab_data_sp(m_file.ReadFileContents(address.GetSection()->GetFileOffset() + address.GetOffset(), m_coff_header_opt.data_dirs[0].vmsize)); + DataExtractor symtab_data (symtab_data_sp, GetByteOrder(), GetAddressByteSize()); + lldb::offset_t offset = 0; + + // Read export_table header + export_table.characteristics = symtab_data.GetU32(&offset); + export_table.time_date_stamp = symtab_data.GetU32(&offset); + export_table.major_version = symtab_data.GetU16(&offset); + export_table.minor_version = symtab_data.GetU16(&offset); + export_table.name = symtab_data.GetU32(&offset); + export_table.base = symtab_data.GetU32(&offset); + export_table.number_of_functions = symtab_data.GetU32(&offset); + export_table.number_of_names = symtab_data.GetU32(&offset); + export_table.address_of_functions = symtab_data.GetU32(&offset); + export_table.address_of_names = symtab_data.GetU32(&offset); + export_table.address_of_name_ordinals = symtab_data.GetU32(&offset); + + bool has_ordinal = export_table.address_of_name_ordinals != 0; + + lldb::offset_t name_offset = export_table.address_of_names - data_start; + lldb::offset_t name_ordinal_offset = export_table.address_of_name_ordinals - data_start; + + Symbol *symbols = m_symtab_ap->Resize(export_table.number_of_names); + + std::string symbol_name; + + // Read each export table entry + for (size_t i = 0; i < export_table.number_of_names; ++i) + { + uint32_t name_ordinal = has_ordinal ? symtab_data.GetU16(&name_ordinal_offset) : i; + uint32_t name_address = symtab_data.GetU32(&name_offset); + + const char* symbol_name_cstr = symtab_data.PeekCStr(name_address - data_start); + symbol_name.assign(symbol_name_cstr); + + lldb::offset_t function_offset = export_table.address_of_functions - data_start + sizeof(uint32_t) * name_ordinal; + uint32_t function_rva = symtab_data.GetU32(&function_offset); + + Address symbol_addr(m_coff_header_opt.image_base + function_rva, sect_list); + symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str())); + symbols[i].GetAddressRef() = symbol_addr; + symbols[i].SetType(lldb::eSymbolTypeCode); + symbols[i].SetDebug(true); + } + } + } + } + return m_symtab_ap.get(); + +} + +bool +ObjectFilePECOFF::IsStripped () +{ + // TODO: determine this for COFF + return false; +} + + + +void +ObjectFilePECOFF::CreateSections (SectionList &unified_section_list) +{ + if (!m_sections_ap.get()) + { + m_sections_ap.reset(new SectionList()); + + ModuleSP module_sp(GetModule()); + if (module_sp) + { + lldb_private::Mutex::Locker locker(module_sp->GetMutex()); + const uint32_t nsects = m_sect_headers.size(); + ModuleSP module_sp (GetModule()); + for (uint32_t idx = 0; idx<nsects; ++idx) + { + std::string sect_name; + GetSectionName (sect_name, m_sect_headers[idx]); + ConstString const_sect_name (sect_name.c_str()); + static ConstString g_code_sect_name (".code"); + static ConstString g_CODE_sect_name ("CODE"); + static ConstString g_data_sect_name (".data"); + static ConstString g_DATA_sect_name ("DATA"); + static ConstString g_bss_sect_name (".bss"); + static ConstString g_BSS_sect_name ("BSS"); + static ConstString g_debug_sect_name (".debug"); + static ConstString g_reloc_sect_name (".reloc"); + static ConstString g_stab_sect_name (".stab"); + static ConstString g_stabstr_sect_name (".stabstr"); + static ConstString g_sect_name_dwarf_debug_abbrev (".debug_abbrev"); + static ConstString g_sect_name_dwarf_debug_aranges (".debug_aranges"); + static ConstString g_sect_name_dwarf_debug_frame (".debug_frame"); + static ConstString g_sect_name_dwarf_debug_info (".debug_info"); + static ConstString g_sect_name_dwarf_debug_line (".debug_line"); + static ConstString g_sect_name_dwarf_debug_loc (".debug_loc"); + static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo"); + static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames"); + static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes"); + static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges"); + static ConstString g_sect_name_dwarf_debug_str (".debug_str"); + static ConstString g_sect_name_eh_frame (".eh_frame"); + static ConstString g_sect_name_go_symtab (".gosymtab"); + SectionType section_type = eSectionTypeOther; + if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_CODE && + ((const_sect_name == g_code_sect_name) || (const_sect_name == g_CODE_sect_name))) + { + section_type = eSectionTypeCode; + } + else if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA && + ((const_sect_name == g_data_sect_name) || (const_sect_name == g_DATA_sect_name))) + { + section_type = eSectionTypeData; + } + else if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA && + ((const_sect_name == g_bss_sect_name) || (const_sect_name == g_BSS_sect_name))) + { + if (m_sect_headers[idx].size == 0) + section_type = eSectionTypeZeroFill; + else + section_type = eSectionTypeData; + } + else if (const_sect_name == g_debug_sect_name) + { + section_type = eSectionTypeDebug; + } + else if (const_sect_name == g_stabstr_sect_name) + { + section_type = eSectionTypeDataCString; + } + else if (const_sect_name == g_reloc_sect_name) + { + section_type = eSectionTypeOther; + } + else if (const_sect_name == g_sect_name_dwarf_debug_abbrev) section_type = eSectionTypeDWARFDebugAbbrev; + else if (const_sect_name == g_sect_name_dwarf_debug_aranges) section_type = eSectionTypeDWARFDebugAranges; + else if (const_sect_name == g_sect_name_dwarf_debug_frame) section_type = eSectionTypeDWARFDebugFrame; + else if (const_sect_name == g_sect_name_dwarf_debug_info) section_type = eSectionTypeDWARFDebugInfo; + else if (const_sect_name == g_sect_name_dwarf_debug_line) section_type = eSectionTypeDWARFDebugLine; + else if (const_sect_name == g_sect_name_dwarf_debug_loc) section_type = eSectionTypeDWARFDebugLoc; + else if (const_sect_name == g_sect_name_dwarf_debug_macinfo) section_type = eSectionTypeDWARFDebugMacInfo; + else if (const_sect_name == g_sect_name_dwarf_debug_pubnames) section_type = eSectionTypeDWARFDebugPubNames; + else if (const_sect_name == g_sect_name_dwarf_debug_pubtypes) section_type = eSectionTypeDWARFDebugPubTypes; + else if (const_sect_name == g_sect_name_dwarf_debug_ranges) section_type = eSectionTypeDWARFDebugRanges; + else if (const_sect_name == g_sect_name_dwarf_debug_str) section_type = eSectionTypeDWARFDebugStr; + else if (const_sect_name == g_sect_name_eh_frame) section_type = eSectionTypeEHFrame; + else if (const_sect_name == g_sect_name_go_symtab) section_type = eSectionTypeGoSymtab; + else if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_CODE) + { + section_type = eSectionTypeCode; + } + else if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA) + { + section_type = eSectionTypeData; + } + else if (m_sect_headers[idx].flags & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) + { + if (m_sect_headers[idx].size == 0) + section_type = eSectionTypeZeroFill; + else + section_type = eSectionTypeData; + } + + // Use a segment ID of the segment index shifted left by 8 so they + // never conflict with any of the sections. + SectionSP section_sp (new Section (module_sp, // Module to which this section belongs + this, // Object file to which this section belongs + idx + 1, // Section ID is the 1 based segment index shifted right by 8 bits as not to collide with any of the 256 section IDs that are possible + const_sect_name, // Name of this section + section_type, // This section is a container of other sections. + m_coff_header_opt.image_base + m_sect_headers[idx].vmaddr, // File VM address == addresses as they are found in the object file + m_sect_headers[idx].vmsize, // VM size in bytes of this section + m_sect_headers[idx].offset, // Offset to the data for this section in the file + m_sect_headers[idx].size, // Size in bytes of this section as found in the file + m_coff_header_opt.sect_alignment, // Section alignment + m_sect_headers[idx].flags)); // Flags for this section + + //section_sp->SetIsEncrypted (segment_is_encrypted); + + unified_section_list.AddSection(section_sp); + m_sections_ap->AddSection (section_sp); + } + } + } +} + +bool +ObjectFilePECOFF::GetUUID (UUID* uuid) +{ + return false; +} + +uint32_t +ObjectFilePECOFF::GetDependentModules (FileSpecList& files) +{ + return 0; +} + + +//---------------------------------------------------------------------- +// Dump +// +// Dump the specifics of the runtime file container (such as any headers +// segments, sections, etc). +//---------------------------------------------------------------------- +void +ObjectFilePECOFF::Dump(Stream *s) +{ + ModuleSP module_sp(GetModule()); + if (module_sp) + { + lldb_private::Mutex::Locker locker(module_sp->GetMutex()); + s->Printf("%p: ", static_cast<void*>(this)); + s->Indent(); + s->PutCString("ObjectFilePECOFF"); + + ArchSpec header_arch; + GetArchitecture (header_arch); + + *s << ", file = '" << m_file << "', arch = " << header_arch.GetArchitectureName() << "\n"; + + SectionList *sections = GetSectionList(); + if (sections) + sections->Dump(s, NULL, true, UINT32_MAX); + + if (m_symtab_ap.get()) + m_symtab_ap->Dump(s, NULL, eSortOrderNone); + + if (m_dos_header.e_magic) + DumpDOSHeader (s, m_dos_header); + if (m_coff_header.machine) + { + DumpCOFFHeader (s, m_coff_header); + if (m_coff_header.hdrsize) + DumpOptCOFFHeader (s, m_coff_header_opt); + } + s->EOL(); + DumpSectionHeaders(s); + s->EOL(); + } +} + +//---------------------------------------------------------------------- +// DumpDOSHeader +// +// Dump the MS-DOS header to the specified output stream +//---------------------------------------------------------------------- +void +ObjectFilePECOFF::DumpDOSHeader(Stream *s, const dos_header_t& header) +{ + s->PutCString ("MSDOS Header\n"); + s->Printf (" e_magic = 0x%4.4x\n", header.e_magic); + s->Printf (" e_cblp = 0x%4.4x\n", header.e_cblp); + s->Printf (" e_cp = 0x%4.4x\n", header.e_cp); + s->Printf (" e_crlc = 0x%4.4x\n", header.e_crlc); + s->Printf (" e_cparhdr = 0x%4.4x\n", header.e_cparhdr); + s->Printf (" e_minalloc = 0x%4.4x\n", header.e_minalloc); + s->Printf (" e_maxalloc = 0x%4.4x\n", header.e_maxalloc); + s->Printf (" e_ss = 0x%4.4x\n", header.e_ss); + s->Printf (" e_sp = 0x%4.4x\n", header.e_sp); + s->Printf (" e_csum = 0x%4.4x\n", header.e_csum); + s->Printf (" e_ip = 0x%4.4x\n", header.e_ip); + s->Printf (" e_cs = 0x%4.4x\n", header.e_cs); + s->Printf (" e_lfarlc = 0x%4.4x\n", header.e_lfarlc); + s->Printf (" e_ovno = 0x%4.4x\n", header.e_ovno); + s->Printf (" e_res[4] = { 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x }\n", + header.e_res[0], + header.e_res[1], + header.e_res[2], + header.e_res[3]); + s->Printf (" e_oemid = 0x%4.4x\n", header.e_oemid); + s->Printf (" e_oeminfo = 0x%4.4x\n", header.e_oeminfo); + s->Printf (" e_res2[10] = { 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x, 0x%4.4x }\n", + header.e_res2[0], + header.e_res2[1], + header.e_res2[2], + header.e_res2[3], + header.e_res2[4], + header.e_res2[5], + header.e_res2[6], + header.e_res2[7], + header.e_res2[8], + header.e_res2[9]); + s->Printf (" e_lfanew = 0x%8.8x\n", header.e_lfanew); +} + +//---------------------------------------------------------------------- +// DumpCOFFHeader +// +// Dump the COFF header to the specified output stream +//---------------------------------------------------------------------- +void +ObjectFilePECOFF::DumpCOFFHeader(Stream *s, const coff_header_t& header) +{ + s->PutCString ("COFF Header\n"); + s->Printf (" machine = 0x%4.4x\n", header.machine); + s->Printf (" nsects = 0x%4.4x\n", header.nsects); + s->Printf (" modtime = 0x%8.8x\n", header.modtime); + s->Printf (" symoff = 0x%8.8x\n", header.symoff); + s->Printf (" nsyms = 0x%8.8x\n", header.nsyms); + s->Printf (" hdrsize = 0x%4.4x\n", header.hdrsize); +} + +//---------------------------------------------------------------------- +// DumpOptCOFFHeader +// +// Dump the optional COFF header to the specified output stream +//---------------------------------------------------------------------- +void +ObjectFilePECOFF::DumpOptCOFFHeader(Stream *s, const coff_opt_header_t& header) +{ + s->PutCString ("Optional COFF Header\n"); + s->Printf (" magic = 0x%4.4x\n", header.magic); + s->Printf (" major_linker_version = 0x%2.2x\n", header.major_linker_version); + s->Printf (" minor_linker_version = 0x%2.2x\n", header.minor_linker_version); + s->Printf (" code_size = 0x%8.8x\n", header.code_size); + s->Printf (" data_size = 0x%8.8x\n", header.data_size); + s->Printf (" bss_size = 0x%8.8x\n", header.bss_size); + s->Printf (" entry = 0x%8.8x\n", header.entry); + s->Printf (" code_offset = 0x%8.8x\n", header.code_offset); + s->Printf (" data_offset = 0x%8.8x\n", header.data_offset); + s->Printf (" image_base = 0x%16.16" PRIx64 "\n", header.image_base); + s->Printf (" sect_alignment = 0x%8.8x\n", header.sect_alignment); + s->Printf (" file_alignment = 0x%8.8x\n", header.file_alignment); + s->Printf (" major_os_system_version = 0x%4.4x\n", header.major_os_system_version); + s->Printf (" minor_os_system_version = 0x%4.4x\n", header.minor_os_system_version); + s->Printf (" major_image_version = 0x%4.4x\n", header.major_image_version); + s->Printf (" minor_image_version = 0x%4.4x\n", header.minor_image_version); + s->Printf (" major_subsystem_version = 0x%4.4x\n", header.major_subsystem_version); + s->Printf (" minor_subsystem_version = 0x%4.4x\n", header.minor_subsystem_version); + s->Printf (" reserved1 = 0x%8.8x\n", header.reserved1); + s->Printf (" image_size = 0x%8.8x\n", header.image_size); + s->Printf (" header_size = 0x%8.8x\n", header.header_size); + s->Printf (" checksum = 0x%8.8x\n", header.checksum); + s->Printf (" subsystem = 0x%4.4x\n", header.subsystem); + s->Printf (" dll_flags = 0x%4.4x\n", header.dll_flags); + s->Printf (" stack_reserve_size = 0x%16.16" PRIx64 "\n", header.stack_reserve_size); + s->Printf (" stack_commit_size = 0x%16.16" PRIx64 "\n", header.stack_commit_size); + s->Printf (" heap_reserve_size = 0x%16.16" PRIx64 "\n", header.heap_reserve_size); + s->Printf (" heap_commit_size = 0x%16.16" PRIx64 "\n", header.heap_commit_size); + s->Printf (" loader_flags = 0x%8.8x\n", header.loader_flags); + s->Printf (" num_data_dir_entries = 0x%8.8x\n", (uint32_t)header.data_dirs.size()); + uint32_t i; + for (i=0; i<header.data_dirs.size(); i++) + { + s->Printf (" data_dirs[%2u] vmaddr = 0x%8.8x, vmsize = 0x%8.8x\n", + i, + header.data_dirs[i].vmaddr, + header.data_dirs[i].vmsize); + } +} +//---------------------------------------------------------------------- +// DumpSectionHeader +// +// Dump a single ELF section header to the specified output stream +//---------------------------------------------------------------------- +void +ObjectFilePECOFF::DumpSectionHeader(Stream *s, const section_header_t& sh) +{ + std::string name; + GetSectionName(name, sh); + s->Printf ("%-16s 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x 0x%4.4x 0x%4.4x 0x%8.8x\n", + name.c_str(), + sh.vmaddr, + sh.vmsize, + sh.offset, + sh.size, + sh.reloff, + sh.lineoff, + sh.nreloc, + sh.nline, + sh.flags); +} + + +//---------------------------------------------------------------------- +// DumpSectionHeaders +// +// Dump all of the ELF section header to the specified output stream +//---------------------------------------------------------------------- +void +ObjectFilePECOFF::DumpSectionHeaders(Stream *s) +{ + + s->PutCString ("Section Headers\n"); + s->PutCString ("IDX name vm addr vm size file off file size reloc off line off nreloc nline flags\n"); + s->PutCString ("==== ---------------- ---------- ---------- ---------- ---------- ---------- ---------- ------ ------ ----------\n"); + + uint32_t idx = 0; + SectionHeaderCollIter pos, end = m_sect_headers.end(); + + for (pos = m_sect_headers.begin(); pos != end; ++pos, ++idx) + { + s->Printf ("[%2u] ", idx); + ObjectFilePECOFF::DumpSectionHeader(s, *pos); + } +} + +bool +ObjectFilePECOFF::GetArchitecture (ArchSpec &arch) +{ + uint16_t machine = m_coff_header.machine; + switch (machine) + { + case llvm::COFF::IMAGE_FILE_MACHINE_AMD64: + case llvm::COFF::IMAGE_FILE_MACHINE_I386: + case llvm::COFF::IMAGE_FILE_MACHINE_POWERPC: + case llvm::COFF::IMAGE_FILE_MACHINE_POWERPCFP: + case llvm::COFF::IMAGE_FILE_MACHINE_ARM: + case llvm::COFF::IMAGE_FILE_MACHINE_ARMNT: + case llvm::COFF::IMAGE_FILE_MACHINE_THUMB: + arch.SetArchitecture (eArchTypeCOFF, machine, LLDB_INVALID_CPUTYPE); + return true; + default: + break; + } + return false; +} + +ObjectFile::Type +ObjectFilePECOFF::CalculateType() +{ + if (m_coff_header.machine != 0) + { + if ((m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0) + return eTypeExecutable; + else + return eTypeSharedLibrary; + } + return eTypeExecutable; +} + +ObjectFile::Strata +ObjectFilePECOFF::CalculateStrata() +{ + return eStrataUser; +} +//------------------------------------------------------------------ +// PluginInterface protocol +//------------------------------------------------------------------ +ConstString +ObjectFilePECOFF::GetPluginName() +{ + return GetPluginNameStatic(); +} + +uint32_t +ObjectFilePECOFF::GetPluginVersion() +{ + return 1; +} + |