CbC/CbC_llvm: lib/Object/COFFObjectFile.cpp comparison

comparison lib/Object/COFFObjectFile.cpp @ 95:afa8332a0e37 LLVM3.8

LLVM 3.8

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Tue, 13 Oct 2015 17:48:58 +0900
parents	60c9769439b8
children	7d135dc70f03

comparison

equal deleted inserted replaced

-:f3e34b893a5f
+:afa8332a0e37
 #include "llvm/Object/COFF.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
 #include <limits>
 if (Addr + Size < Addr || Addr + Size < Size ||
 Addr + Size > uintptr_t(M.getBufferEnd()) ||
 Addr < uintptr_t(M.getBufferStart())) {
 return object_error::unexpected_eof;
 }
-return object_error::success;
+return std::error_code();
 }
 // Sets Obj unless any bytes in [addr, addr + size) fall outsize of m.
 // Returns unexpected_eof if error.
 template <typename T>
 const uint64_t Size = sizeof(T)) {
 uintptr_t Addr = uintptr_t(Ptr);
 if (std::error_code EC = checkOffset(M, Addr, Size))
 return EC;
 Obj = reinterpret_cast<const T *>(Addr);
-return object_error::success;
+return std::error_code();
 }
 // Decode a string table entry in base 64 (//AAAAAA). Expects \arg Str without
 // prefixed slashes.
 static bool decodeBase64StringEntry(StringRef Str, uint32_t &Result) {
 } else {
 llvm_unreachable("no symbol table pointer!");
 }
 }
-std::error_code COFFObjectFile::getSymbolName(DataRefImpl Ref,
+ErrorOr<StringRef> COFFObjectFile::getSymbolName(DataRefImpl Ref) const {
-StringRef &Result) const {
 COFFSymbolRef Symb = getCOFFSymbol(Ref);
-return getSymbolName(Symb, Result);
+StringRef Result;
-}
+std::error_code EC = getSymbolName(Symb, Result);
+if (EC)
-std::error_code COFFObjectFile::getSymbolAddress(DataRefImpl Ref,
+return EC;
-uint64_t &Result) const {
+return Result;
-COFFSymbolRef Symb = getCOFFSymbol(Ref);
+}
-if (Symb.isAnyUndefined()) {
+uint64_t COFFObjectFile::getSymbolValueImpl(DataRefImpl Ref) const {
-Result = UnknownAddressOrSize;
+return getCOFFSymbol(Ref).getValue();
-return object_error::success;
+}
-}
-if (Symb.isCommon()) {
+ErrorOr<uint64_t> COFFObjectFile::getSymbolAddress(DataRefImpl Ref) const {
-Result = UnknownAddressOrSize;
+uint64_t Result = getSymbolValue(Ref);
-return object_error::success;
-}
-int32_t SectionNumber = Symb.getSectionNumber();
-if (!COFF::isReservedSectionNumber(SectionNumber)) {
-const coff_section *Section = nullptr;
-if (std::error_code EC = getSection(SectionNumber, Section))
-return EC;
-Result = Section->VirtualAddress + Symb.getValue();
-return object_error::success;
-}
-Result = Symb.getValue();
-return object_error::success;
-}
-std::error_code COFFObjectFile::getSymbolType(DataRefImpl Ref,
-SymbolRef::Type &Result) const {
 COFFSymbolRef Symb = getCOFFSymbol(Ref);
 int32_t SectionNumber = Symb.getSectionNumber();
-Result = SymbolRef::ST_Other;
+if (Symb.isAnyUndefined() || Symb.isCommon() ||
-if (Symb.isAnyUndefined()) {
+COFF::isReservedSectionNumber(SectionNumber))
-Result = SymbolRef::ST_Unknown;
+return Result;
-} else if (Symb.isFunctionDefinition()) {
-Result = SymbolRef::ST_Function;
+const coff_section *Section = nullptr;
-} else if (Symb.isCommon()) {
+if (std::error_code EC = getSection(SectionNumber, Section))
-Result = SymbolRef::ST_Data;
+return EC;
-} else if (Symb.isFileRecord()) {
+Result += Section->VirtualAddress;
-Result = SymbolRef::ST_File;
-} else if (SectionNumber == COFF::IMAGE_SYM_DEBUG) {
+// The section VirtualAddress does not include ImageBase, and we want to
-Result = SymbolRef::ST_Debug;
+// return virtual addresses.
-} else if (!COFF::isReservedSectionNumber(SectionNumber)) {
+Result += getImageBase();
-const coff_section *Section = nullptr;
-if (std::error_code EC = getSection(SectionNumber, Section))
+return Result;
-return EC;
+}
-uint32_t Characteristics = Section->Characteristics;
-if (Characteristics & COFF::IMAGE_SCN_CNT_CODE)
+SymbolRef::Type COFFObjectFile::getSymbolType(DataRefImpl Ref) const {
-Result = SymbolRef::ST_Function;
+COFFSymbolRef Symb = getCOFFSymbol(Ref);
-else if (Characteristics & (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+int32_t SectionNumber = Symb.getSectionNumber();
-COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA))
-Result = SymbolRef::ST_Data;
+if (Symb.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION)
-}
+return SymbolRef::ST_Function;
-return object_error::success;
+if (Symb.isAnyUndefined())
+return SymbolRef::ST_Unknown;
+if (Symb.isCommon())
+return SymbolRef::ST_Data;
+if (Symb.isFileRecord())
+return SymbolRef::ST_File;
+// TODO: perhaps we need a new symbol type ST_Section.
+if (SectionNumber == COFF::IMAGE_SYM_DEBUG || Symb.isSectionDefinition())
+return SymbolRef::ST_Debug;
+if (!COFF::isReservedSectionNumber(SectionNumber))
+return SymbolRef::ST_Data;
+return SymbolRef::ST_Other;
 }
 uint32_t COFFObjectFile::getSymbolFlags(DataRefImpl Ref) const {
 COFFSymbolRef Symb = getCOFFSymbol(Ref);
 uint32_t Result = SymbolRef::SF_None;
 Result |= SymbolRef::SF_Undefined;
 return Result;
 }
-std::error_code COFFObjectFile::getSymbolSize(DataRefImpl Ref,
+uint64_t COFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Ref) const {
-uint64_t &Result) const {
 COFFSymbolRef Symb = getCOFFSymbol(Ref);
+return Symb.getValue();
-if (Symb.isAnyUndefined()) {
+}
-Result = UnknownAddressOrSize;
-return object_error::success;
+ErrorOr<section_iterator>
-}
+COFFObjectFile::getSymbolSection(DataRefImpl Ref) const {
-if (Symb.isCommon()) {
-Result = Symb.getValue();
-return object_error::success;
-}
-// Let's attempt to get the size of the symbol by looking at the address of
-// the symbol after the symbol in question.
-uint64_t SymbAddr;
-if (std::error_code EC = getSymbolAddress(Ref, SymbAddr))
-return EC;
-int32_t SectionNumber = Symb.getSectionNumber();
-if (COFF::isReservedSectionNumber(SectionNumber)) {
-// Absolute and debug symbols aren't sorted in any interesting way.
-Result = 0;
-return object_error::success;
-}
-const section_iterator SecEnd = section_end();
-uint64_t AfterAddr = UnknownAddressOrSize;
-for (const symbol_iterator &SymbI : symbols()) {
-section_iterator SecI = SecEnd;
-if (std::error_code EC = SymbI->getSection(SecI))
-return EC;
-// Check the symbol's section, skip it if it's in the wrong section.
-// First, make sure it is in any section.
-if (SecI == SecEnd)
-continue;
-// Second, make sure it is in the same section as the symbol in question.
-if (!sectionContainsSymbol(SecI->getRawDataRefImpl(), Ref))
-continue;
-uint64_t Addr;
-if (std::error_code EC = SymbI->getAddress(Addr))
-return EC;
-// We want to compare our symbol in question with the closest possible
-// symbol that comes after.
-if (AfterAddr > Addr && Addr > SymbAddr)
-AfterAddr = Addr;
-}
-if (AfterAddr == UnknownAddressOrSize) {
-// No symbol comes after this one, assume that everything after our symbol
-// is part of it.
-const coff_section *Section = nullptr;
-if (std::error_code EC = getSection(SectionNumber, Section))
-return EC;
-Result = Section->SizeOfRawData - Symb.getValue();
-} else {
-// Take the difference between our symbol and the symbol that comes after
-// our symbol.
-Result = AfterAddr - SymbAddr;
-}
-return object_error::success;
-}
-std::error_code
-COFFObjectFile::getSymbolSection(DataRefImpl Ref,
-section_iterator &Result) const {
 COFFSymbolRef Symb = getCOFFSymbol(Ref);
-if (COFF::isReservedSectionNumber(Symb.getSectionNumber())) {
+if (COFF::isReservedSectionNumber(Symb.getSectionNumber()))
-Result = section_end();
+return section_end();
-} else {
+const coff_section *Sec = nullptr;
-const coff_section *Sec = nullptr;
+if (std::error_code EC = getSection(Symb.getSectionNumber(), Sec))
-if (std::error_code EC = getSection(Symb.getSectionNumber(), Sec))
+return EC;
-return EC;
+DataRefImpl Ret;
-DataRefImpl Ref;
+Ret.p = reinterpret_cast<uintptr_t>(Sec);
-Ref.p = reinterpret_cast<uintptr_t>(Sec);
+return section_iterator(SectionRef(Ret, this));
-Result = section_iterator(SectionRef(Ref, this));
+}
-}
-return object_error::success;
+unsigned COFFObjectFile::getSymbolSectionID(SymbolRef Sym) const {
+COFFSymbolRef Symb = getCOFFSymbol(Sym.getRawDataRefImpl());
+return Symb.getSectionNumber();
 }
 void COFFObjectFile::moveSectionNext(DataRefImpl &Ref) const {
 const coff_section *Sec = toSec(Ref);
 Sec += 1;
 return getSectionName(Sec, Result);
 }
 uint64_t COFFObjectFile::getSectionAddress(DataRefImpl Ref) const {
 const coff_section *Sec = toSec(Ref);
-return Sec->VirtualAddress;
+uint64_t Result = Sec->VirtualAddress;
+// The section VirtualAddress does not include ImageBase, and we want to
+// return virtual addresses.
+Result += getImageBase();
+return Result;
 }
 uint64_t COFFObjectFile::getSectionSize(DataRefImpl Ref) const {
 return getSectionSize(toSec(Ref));
 }
 return Sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
 }
 bool COFFObjectFile::isSectionBSS(DataRefImpl Ref) const {
 const coff_section *Sec = toSec(Ref);
-return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
+const uint32_t BssFlags = COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
+COFF::IMAGE_SCN_MEM_READ |
+COFF::IMAGE_SCN_MEM_WRITE;
+return (Sec->Characteristics & BssFlags) == BssFlags;
+}
+unsigned COFFObjectFile::getSectionID(SectionRef Sec) const {
+uintptr_t Offset =
+uintptr_t(Sec.getRawDataRefImpl().p) - uintptr_t(SectionTable);
+assert((Offset % sizeof(coff_section)) == 0);
+return (Offset / sizeof(coff_section)) + 1;
 }
 bool COFFObjectFile::isSectionVirtual(DataRefImpl Ref) const {
 const coff_section *Sec = toSec(Ref);
-return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
+// In COFF, a virtual section won't have any in-file
-}
+// content, so the file pointer to the content will be zero.
+return Sec->PointerToRawData == 0;
-bool COFFObjectFile::sectionContainsSymbol(DataRefImpl SecRef,
-DataRefImpl SymbRef) const {
-const coff_section *Sec = toSec(SecRef);
-COFFSymbolRef Symb = getCOFFSymbol(SymbRef);
-int32_t SecNumber = (Sec - SectionTable) + 1;
-return SecNumber == Symb.getSectionNumber();
 }
 static uint32_t getNumberOfRelocations(const coff_section *Sec,
 MemoryBufferRef M, const uint8_t *base) {
 // The field for the number of relocations in COFF section table is only
 }
 relocation_iterator COFFObjectFile::section_rel_begin(DataRefImpl Ref) const {
 const coff_section *Sec = toSec(Ref);
 const coff_relocation *begin = getFirstReloc(Sec, Data, base());
+if (begin && Sec->VirtualAddress != 0)
+report_fatal_error("Sections with relocations should have an address of 0");
 DataRefImpl Ret;
 Ret.p = reinterpret_cast<uintptr_t>(begin);
 return relocation_iterator(RelocationRef(Ret, this));
 }
 StringTableSize = 4;
 // Check that the string table is null terminated if has any in it.
 if (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)
 return  object_error::parse_failed;
-return object_error::success;
+return std::error_code();
+}
+uint64_t COFFObjectFile::getImageBase() const {
+if (PE32Header)
+return PE32Header->ImageBase;
+else if (PE32PlusHeader)
+return PE32PlusHeader->ImageBase;
+// This actually comes up in practice.
+return 0;
 }
 // Returns the file offset for the given VA.
 std::error_code COFFObjectFile::getVaPtr(uint64_t Addr, uintptr_t &Res) const {
-uint64_t ImageBase = PE32Header ? (uint64_t)PE32Header->ImageBase
+uint64_t ImageBase = getImageBase();
-: (uint64_t)PE32PlusHeader->ImageBase;
 uint64_t Rva = Addr - ImageBase;
 assert(Rva <= UINT32_MAX);
 return getRvaPtr((uint32_t)Rva, Res);
 }
 uint32_t SectionStart = Section->VirtualAddress;
 uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize;
 if (SectionStart <= Addr && Addr < SectionEnd) {
 uint32_t Offset = Addr - SectionStart;
 Res = uintptr_t(base()) + Section->PointerToRawData + Offset;
-return object_error::success;
+return std::error_code();
 }
 }
 return object_error::parse_failed;
 }
 if (std::error_code EC = getRvaPtr(Rva, IntPtr))
 return EC;
 const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr);
 Hint = *reinterpret_cast<const ulittle16_t *>(Ptr);
 Name = StringRef(reinterpret_cast<const char *>(Ptr + 2));
-return object_error::success;
+return std::error_code();
 }
 // Find the import table.
 std::error_code COFFObjectFile::initImportTablePtr() {
 // First, we get the RVA of the import table. If the file lacks a pointer to
 // the import table, do nothing.
 const data_directory *DataEntry;
 if (getDataDirectory(COFF::IMPORT_TABLE, DataEntry))
-return object_error::success;
+return std::error_code();
 // Do nothing if the pointer to import table is NULL.
 if (DataEntry->RelativeVirtualAddress == 0)
-return object_error::success;
+return std::error_code();
 uint32_t ImportTableRva = DataEntry->RelativeVirtualAddress;
 // -1 because the last entry is the null entry.
 NumberOfImportDirectory = DataEntry->Size /
 sizeof(import_directory_table_entry) - 1;
 uintptr_t IntPtr = 0;
 if (std::error_code EC = getRvaPtr(ImportTableRva, IntPtr))
 return EC;
 ImportDirectory = reinterpret_cast<
 const import_directory_table_entry *>(IntPtr);
-return object_error::success;
+return std::error_code();
 }
 // Initializes DelayImportDirectory and NumberOfDelayImportDirectory.
 std::error_code COFFObjectFile::initDelayImportTablePtr() {
 const data_directory *DataEntry;
 if (getDataDirectory(COFF::DELAY_IMPORT_DESCRIPTOR, DataEntry))
-return object_error::success;
+return std::error_code();
 if (DataEntry->RelativeVirtualAddress == 0)
-return object_error::success;
+return std::error_code();
 uint32_t RVA = DataEntry->RelativeVirtualAddress;
 NumberOfDelayImportDirectory = DataEntry->Size /
 sizeof(delay_import_directory_table_entry) - 1;
 uintptr_t IntPtr = 0;
 if (std::error_code EC = getRvaPtr(RVA, IntPtr))
 return EC;
 DelayImportDirectory = reinterpret_cast<
 const delay_import_directory_table_entry *>(IntPtr);
-return object_error::success;
+return std::error_code();
 }
 // Find the export table.
 std::error_code COFFObjectFile::initExportTablePtr() {
 // First, we get the RVA of the export table. If the file lacks a pointer to
 // the export table, do nothing.
 const data_directory *DataEntry;
 if (getDataDirectory(COFF::EXPORT_TABLE, DataEntry))
-return object_error::success;
+return std::error_code();
 // Do nothing if the pointer to export table is NULL.
 if (DataEntry->RelativeVirtualAddress == 0)
-return object_error::success;
+return std::error_code();
 uint32_t ExportTableRva = DataEntry->RelativeVirtualAddress;
 uintptr_t IntPtr = 0;
 if (std::error_code EC = getRvaPtr(ExportTableRva, IntPtr))
 return EC;
 ExportDirectory =
 reinterpret_cast<const export_directory_table_entry *>(IntPtr);
-return object_error::success;
+return std::error_code();
 }
 std::error_code COFFObjectFile::initBaseRelocPtr() {
 const data_directory *DataEntry;
 if (getDataDirectory(COFF::BASE_RELOCATION_TABLE, DataEntry))
-return object_error::success;
+return std::error_code();
 if (DataEntry->RelativeVirtualAddress == 0)
-return object_error::success;
+return std::error_code();
 uintptr_t IntPtr = 0;
 if (std::error_code EC = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr))
 return EC;
 BaseRelocHeader = reinterpret_cast<const coff_base_reloc_block_header *>(
 IntPtr);
 BaseRelocEnd = reinterpret_cast<coff_base_reloc_block_header *>(
 IntPtr + DataEntry->Size);
-return object_error::success;
+return std::error_code();
 }
 COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
 : ObjectFile(Binary::ID_COFF, Object), COFFHeader(nullptr),
 COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr),
 }
 }
 if (COFFHeader) {
 // The prior checkSize call may have failed.  This isn't a hard error
 // because we were just trying to sniff out bigobj.
-EC = object_error::success;
+EC = std::error_code();
 CurPtr += sizeof(coff_file_header);
 if (COFFHeader->isImportLibrary())
 return;
 }
 // Initialize the pointer to the base relocation table.
 if ((EC = initBaseRelocPtr()))
 return;
-EC = object_error::success;
+EC = std::error_code();
 }
 basic_symbol_iterator COFFObjectFile::symbol_begin_impl() const {
 DataRefImpl Ret;
 Ret.p = getSymbolTable();
 return "COFF-i386";
 case COFF::IMAGE_FILE_MACHINE_AMD64:
 return "COFF-x86-64";
 case COFF::IMAGE_FILE_MACHINE_ARMNT:
 return "COFF-ARM";
+case COFF::IMAGE_FILE_MACHINE_ARM64:
+return "COFF-ARM64";
 default:
 return "COFF-<unknown arch>";
 }
 }
 return Triple::x86;
 case COFF::IMAGE_FILE_MACHINE_AMD64:
 return Triple::x86_64;
 case COFF::IMAGE_FILE_MACHINE_ARMNT:
 return Triple::thumb;
+case COFF::IMAGE_FILE_MACHINE_ARM64:
+return Triple::aarch64;
 default:
 return Triple::UnknownArch;
 }
 }
 return make_range(base_reloc_begin(), base_reloc_end());
 }
 std::error_code COFFObjectFile::getPE32Header(const pe32_header *&Res) const {
 Res = PE32Header;
-return object_error::success;
+return std::error_code();
 }
 std::error_code
 COFFObjectFile::getPE32PlusHeader(const pe32plus_header *&Res) const {
 Res = PE32PlusHeader;
-return object_error::success;
+return std::error_code();
 }
 std::error_code
 COFFObjectFile::getDataDirectory(uint32_t Index,
 const data_directory *&Res) const {
 if (Index >= NumEnt) {
 Res = nullptr;
 return object_error::parse_failed;
 }
 Res = &DataDirectory[Index];
-return object_error::success;
+return std::error_code();
 }
 std::error_code COFFObjectFile::getSection(int32_t Index,
 const coff_section *&Result) const {
 Result = nullptr;
 if (COFF::isReservedSectionNumber(Index))
-return object_error::success;
+return std::error_code();
 if (static_cast<uint32_t>(Index) <= getNumberOfSections()) {
 // We already verified the section table data, so no need to check again.
 Result = SectionTable + (Index - 1);
-return object_error::success;
+return std::error_code();
 }
 return object_error::parse_failed;
 }
 std::error_code COFFObjectFile::getString(uint32_t Offset,
 // Tried to get a string from an empty string table.
 return object_error::parse_failed;
 if (Offset >= StringTableSize)
 return object_error::unexpected_eof;
 Result = StringRef(StringTable + Offset);
-return object_error::success;
+return std::error_code();
 }
 std::error_code COFFObjectFile::getSymbolName(COFFSymbolRef Symbol,
 StringRef &Res) const {
+return getSymbolName(Symbol.getGeneric(), Res);
+}
+std::error_code COFFObjectFile::getSymbolName(const coff_symbol_generic *Symbol,
+StringRef &Res) const {
 // Check for string table entry. First 4 bytes are 0.
-if (Symbol.getStringTableOffset().Zeroes == 0) {
+if (Symbol->Name.Offset.Zeroes == 0) {
-uint32_t Offset = Symbol.getStringTableOffset().Offset;
+if (std::error_code EC = getString(Symbol->Name.Offset.Offset, Res))
-if (std::error_code EC = getString(Offset, Res))
 return EC;
-return object_error::success;
+return std::error_code();
 }
-if (Symbol.getShortName()[COFF::NameSize - 1] == 0)
+if (Symbol->Name.ShortName[COFF::NameSize - 1] == 0)
 // Null terminated, let ::strlen figure out the length.
-Res = StringRef(Symbol.getShortName());
+Res = StringRef(Symbol->Name.ShortName);
 else
 // Not null terminated, use all 8 bytes.
-Res = StringRef(Symbol.getShortName(), COFF::NameSize);
+Res = StringRef(Symbol->Name.ShortName, COFF::NameSize);
-return object_error::success;
+return std::error_code();
 }
 ArrayRef<uint8_t>
 COFFObjectFile::getSymbolAuxData(COFFSymbolRef Symbol) const {
 const uint8_t *Aux = nullptr;
 if (std::error_code EC = getString(Offset, Name))
 return EC;
 }
 Res = Name;
-return object_error::success;
+return std::error_code();
 }
 uint64_t COFFObjectFile::getSectionSize(const coff_section *Sec) const {
 // SizeOfRawData and VirtualSize change what they represent depending on
 // whether or not we have an executable image.
 //
 // For object files, SizeOfRawData contains the size of section's data;
-// VirtualSize is always zero.
+// VirtualSize should be zero but isn't due to buggy COFF writers.
 //
 // For executables, SizeOfRawData *must* be a multiple of FileAlignment; the
 // actual section size is in VirtualSize.  It is possible for VirtualSize to
 // be greater than SizeOfRawData; the contents past that point should be
 // considered to be zero.
-uint32_t SectionSize;
+if (getDOSHeader())
-if (Sec->VirtualSize)
+return std::min(Sec->VirtualSize, Sec->SizeOfRawData);
-SectionSize = std::min(Sec->VirtualSize, Sec->SizeOfRawData);
+return Sec->SizeOfRawData;
-else
-SectionSize = Sec->SizeOfRawData;
-return SectionSize;
 }
 std::error_code
 COFFObjectFile::getSectionContents(const coff_section *Sec,
 ArrayRef<uint8_t> &Res) const {
 uintptr_t ConStart = uintptr_t(base()) + Sec->PointerToRawData;
 uint32_t SectionSize = getSectionSize(Sec);
 if (checkOffset(Data, ConStart, SectionSize))
 return object_error::parse_failed;
 Res = makeArrayRef(reinterpret_cast<const uint8_t *>(ConStart), SectionSize);
-return object_error::success;
+return std::error_code();
 }
 const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const {
 return reinterpret_cast<const coff_relocation*>(Rel.p);
 }
 void COFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
 Rel.p = reinterpret_cast<uintptr_t>(
 reinterpret_cast<const coff_relocation*>(Rel.p) + 1);
 }
-std::error_code COFFObjectFile::getRelocationAddress(DataRefImpl Rel,
+uint64_t COFFObjectFile::getRelocationOffset(DataRefImpl Rel) const {
-uint64_t &Res) const {
-report_fatal_error("getRelocationAddress not implemented in COFFObjectFile");
-}
-std::error_code COFFObjectFile::getRelocationOffset(DataRefImpl Rel,
-uint64_t &Res) const {
 const coff_relocation *R = toRel(Rel);
-const support::ulittle32_t *VirtualAddressPtr;
+return R->VirtualAddress;
-if (std::error_code EC =
-getObject(VirtualAddressPtr, Data, &R->VirtualAddress))
-return EC;
-Res = *VirtualAddressPtr;
-return object_error::success;
 }
 symbol_iterator COFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
 const coff_relocation *R = toRel(Rel);
 DataRefImpl Ref;
 else
 llvm_unreachable("no symbol table pointer!");
 return symbol_iterator(SymbolRef(Ref, this));
 }
-std::error_code COFFObjectFile::getRelocationType(DataRefImpl Rel,
+uint64_t COFFObjectFile::getRelocationType(DataRefImpl Rel) const {
-uint64_t &Res) const {
 const coff_relocation* R = toRel(Rel);
-Res = R->Type;
+return R->Type;
-return object_error::success;
 }
 const coff_section *
 COFFObjectFile::getCOFFSection(const SectionRef &Section) const {
 return toSec(Section.getRawDataRefImpl());
 const coff_relocation *
 COFFObjectFile::getCOFFRelocation(const RelocationRef &Reloc) const {
 return toRel(Reloc.getRawDataRefImpl());
 }
+iterator_range<const coff_relocation *>
+COFFObjectFile::getRelocations(const coff_section *Sec) const {
+const coff_relocation *I = getFirstReloc(Sec, Data, base());
+const coff_relocation *E = I;
+if (I)
+E += getNumberOfRelocations(Sec, Data, base());
+return make_range(I, E);
+}
 #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type)                           \
 case COFF::reloc_type:                                                       \
 Res = #reloc_type;                                                         \
 break;
-std::error_code
+void COFFObjectFile::getRelocationTypeName(
-COFFObjectFile::getRelocationTypeName(DataRefImpl Rel,
+DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
-SmallVectorImpl<char> &Result) const {
 const coff_relocation *Reloc = toRel(Rel);
 StringRef Res;
 switch (getMachine()) {
 case COFF::IMAGE_FILE_MACHINE_AMD64:
 switch (Reloc->Type) {
 break;
 default:
 Res = "Unknown";
 }
 Result.append(Res.begin(), Res.end());
-return object_error::success;
 }
 #undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME
-std::error_code
-COFFObjectFile::getRelocationValueString(DataRefImpl Rel,
-SmallVectorImpl<char> &Result) const {
-const coff_relocation *Reloc = toRel(Rel);
-DataRefImpl Sym;
-ErrorOr<COFFSymbolRef> Symb = getSymbol(Reloc->SymbolTableIndex);
-if (std::error_code EC = Symb.getError())
-return EC;
-Sym.p = reinterpret_cast<uintptr_t>(Symb->getRawPtr());
-StringRef SymName;
-if (std::error_code EC = getSymbolName(Sym, SymName))
-return EC;
-Result.append(SymName.begin(), SymName.end());
-return object_error::success;
-}
 bool COFFObjectFile::isRelocatableObject() const {
 return !DataDirectory;
 }
 }
 std::error_code ImportDirectoryEntryRef::getImportTableEntry(
 const import_directory_table_entry *&Result) const {
 Result = ImportTable + Index;
-return object_error::success;
+return std::error_code();
 }
 static imported_symbol_iterator
 makeImportedSymbolIterator(const COFFObjectFile *Object,
 uintptr_t Ptr, int Index) {
 uintptr_t IntPtr = 0;
 if (std::error_code EC =
 OwningObject->getRvaPtr(ImportTable[Index].NameRVA, IntPtr))
 return EC;
 Result = StringRef(reinterpret_cast<const char *>(IntPtr));
-return object_error::success;
+return std::error_code();
 }
 std::error_code
 ImportDirectoryEntryRef::getImportLookupTableRVA(uint32_t  &Result) const {
 Result = ImportTable[Index].ImportLookupTableRVA;
-return object_error::success;
+return std::error_code();
 }
 std::error_code
 ImportDirectoryEntryRef::getImportAddressTableRVA(uint32_t &Result) const {
 Result = ImportTable[Index].ImportAddressTableRVA;
-return object_error::success;
+return std::error_code();
 }
 std::error_code ImportDirectoryEntryRef::getImportLookupEntry(
 const import_lookup_table_entry32 *&Result) const {
 uintptr_t IntPtr = 0;
 uint32_t RVA = ImportTable[Index].ImportLookupTableRVA;
 if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr))
 return EC;
 Result = reinterpret_cast<const import_lookup_table_entry32 *>(IntPtr);
-return object_error::success;
+return std::error_code();
 }
 bool DelayImportDirectoryEntryRef::
 operator==(const DelayImportDirectoryEntryRef &Other) const {
 return Table == Other.Table && Index == Other.Index;
 std::error_code DelayImportDirectoryEntryRef::getName(StringRef &Result) const {
 uintptr_t IntPtr = 0;
 if (std::error_code EC = OwningObject->getRvaPtr(Table[Index].Name, IntPtr))
 return EC;
 Result = StringRef(reinterpret_cast<const char *>(IntPtr));
-return object_error::success;
+return std::error_code();
 }
 std::error_code DelayImportDirectoryEntryRef::
 getDelayImportTable(const delay_import_directory_table_entry *&Result) const {
 Result = Table;
-return object_error::success;
+return std::error_code();
 }
 std::error_code DelayImportDirectoryEntryRef::
 getImportAddress(int AddrIndex, uint64_t &Result) const {
 uint32_t RVA = Table[Index].DelayImportAddressTable +
 return EC;
 if (OwningObject->is64())
 Result = *reinterpret_cast<const ulittle64_t *>(IntPtr);
 else
 Result = *reinterpret_cast<const ulittle32_t *>(IntPtr);
-return object_error::success;
+return std::error_code();
 }
 bool ExportDirectoryEntryRef::
 operator==(const ExportDirectoryEntryRef &Other) const {
 return ExportTable == Other.ExportTable && Index == Other.Index;
 uintptr_t IntPtr = 0;
 if (std::error_code EC =
 OwningObject->getRvaPtr(ExportTable->NameRVA, IntPtr))
 return EC;
 Result = StringRef(reinterpret_cast<const char *>(IntPtr));
-return object_error::success;
+return std::error_code();
 }
 // Returns the starting ordinal number.
 std::error_code
 ExportDirectoryEntryRef::getOrdinalBase(uint32_t &Result) const {
 Result = ExportTable->OrdinalBase;
-return object_error::success;
+return std::error_code();
 }
 // Returns the export ordinal of the current export symbol.
 std::error_code ExportDirectoryEntryRef::getOrdinal(uint32_t &Result) const {
 Result = ExportTable->OrdinalBase + Index;
-return object_error::success;
+return std::error_code();
 }
 // Returns the address of the current export symbol.
 std::error_code ExportDirectoryEntryRef::getExportRVA(uint32_t &Result) const {
 uintptr_t IntPtr = 0;
 OwningObject->getRvaPtr(ExportTable->ExportAddressTableRVA, IntPtr))
 return EC;
 const export_address_table_entry *entry =
 reinterpret_cast<const export_address_table_entry *>(IntPtr);
 Result = entry[Index].ExportRVA;
-return object_error::success;
+return std::error_code();
 }
 // Returns the name of the current export symbol. If the symbol is exported only
 // by ordinal, the empty string is set as a result.
 std::error_code
 return EC;
 const ulittle32_t *NamePtr = reinterpret_cast<const ulittle32_t *>(IntPtr);
 if (std::error_code EC = OwningObject->getRvaPtr(NamePtr[Offset], IntPtr))
 return EC;
 Result = StringRef(reinterpret_cast<const char *>(IntPtr));
-return object_error::success;
+return std::error_code();
 }
 Result = "";
-return object_error::success;
+return std::error_code();
 }
 bool ImportedSymbolRef::
 operator==(const ImportedSymbolRef &Other) const {
 return Entry32 == Other.Entry32 && Entry64 == Other.Entry64
 ImportedSymbolRef::getSymbolName(StringRef &Result) const {
 uint32_t RVA;
 if (Entry32) {
 // If a symbol is imported only by ordinal, it has no name.
 if (Entry32[Index].isOrdinal())
-return object_error::success;
+return std::error_code();
 RVA = Entry32[Index].getHintNameRVA();
 } else {
 if (Entry64[Index].isOrdinal())
-return object_error::success;
+return std::error_code();
 RVA = Entry64[Index].getHintNameRVA();
 }
 uintptr_t IntPtr = 0;
 if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr))
 return EC;
 // +2 because the first two bytes is hint.
 Result = StringRef(reinterpret_cast<const char *>(IntPtr + 2));
-return object_error::success;
+return std::error_code();
 }
 std::error_code ImportedSymbolRef::getOrdinal(uint16_t &Result) const {
 uint32_t RVA;
 if (Entry32) {
 if (Entry32[Index].isOrdinal()) {
 Result = Entry32[Index].getOrdinal();
-return object_error::success;
+return std::error_code();
 }
 RVA = Entry32[Index].getHintNameRVA();
 } else {
 if (Entry64[Index].isOrdinal()) {
 Result = Entry64[Index].getOrdinal();
-return object_error::success;
+return std::error_code();
 }
 RVA = Entry64[Index].getHintNameRVA();
 }
 uintptr_t IntPtr = 0;
 if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr))
 return EC;
 Result = *reinterpret_cast<const ulittle16_t *>(IntPtr);
-return object_error::success;
+return std::error_code();
 }
 ErrorOr<std::unique_ptr<COFFObjectFile>>
 ObjectFile::createCOFFObjectFile(MemoryBufferRef Object) {
 std::error_code EC;
 }
 std::error_code BaseRelocRef::getType(uint8_t &Type) const {
 auto *Entry = reinterpret_cast<const coff_base_reloc_block_entry *>(Header + 1);
 Type = Entry[Index].getType();
-return object_error::success;
+return std::error_code();
 }
 std::error_code BaseRelocRef::getRVA(uint32_t &Result) const {
 auto *Entry = reinterpret_cast<const coff_base_reloc_block_entry *>(Header + 1);
 Result = Header->PageRVA + Entry[Index].getOffset();
-return object_error::success;
+return std::error_code();
 }

Mercurial > hg > CbC > CbC_llvm

comparison lib/Object/COFFObjectFile.cpp @ 95:afa8332a0e37 LLVM3.8