35#include <system_error>
38using namespace object;
47 if (M.getBufferSize() <
Size) {
48 EC = object_error::unexpected_eof;
59 uintptr_t
Addr =
reinterpret_cast<uintptr_t
>(
Ptr);
62 Obj =
reinterpret_cast<const T *
>(
Addr);
69 assert(Str.size() <= 6 &&
"String too long, possible overflow.");
74 while (!Str.empty()) {
76 if (Str[0] >=
'A' && Str[0] <=
'Z')
77 CharVal = Str[0] -
'A';
78 else if (Str[0] >=
'a' && Str[0] <=
'z')
79 CharVal = Str[0] -
'a' + 26;
80 else if (Str[0] >=
'0' && Str[0] <=
'9')
81 CharVal = Str[0] -
'0' + 52;
82 else if (Str[0] ==
'+')
84 else if (Str[0] ==
'/')
93 if (
Value > std::numeric_limits<uint32_t>::max())
100template <
typename coff_symbol_type>
101const coff_symbol_type *COFFObjectFile::toSymb(
DataRefImpl Ref)
const {
102 const coff_symbol_type *
Addr =
103 reinterpret_cast<const coff_symbol_type *
>(
Ref.p);
109 reinterpret_cast<uintptr_t
>(
Addr) -
reinterpret_cast<uintptr_t
>(
base());
112 "Symbol did not point to the beginning of a symbol");
126 uintptr_t
Offset =
reinterpret_cast<uintptr_t
>(
Addr) -
127 reinterpret_cast<uintptr_t
>(SectionTable);
129 "Section did not point to the beginning of a section");
136 auto End =
reinterpret_cast<uintptr_t
>(StringTable);
140 Ref.p = std::min(
reinterpret_cast<uintptr_t
>(Symb),
End);
141 }
else if (SymbolTable32) {
144 Ref.p = std::min(
reinterpret_cast<uintptr_t
>(Symb),
End);
176 return Section.takeError();
177 Result += (*Section)->VirtualAddress;
254 Ret.p =
reinterpret_cast<uintptr_t
>(*Sec);
266 Ref.p =
reinterpret_cast<uintptr_t
>(Sec);
285 return toSec(Sec) - SectionTable;
332 if (!SectionNameOrErr) {
401 Ret.p =
reinterpret_cast<uintptr_t
>(begin);
411 Ret.p =
reinterpret_cast<uintptr_t
>(
I);
416Error COFFObjectFile::initSymbolTablePtr() {
423 if (COFFBigObjHeader)
435 const ulittle32_t *StringTableSizePtr;
438 StringTableSize = *StringTableSizePtr;
444 if (StringTableSize < 4)
448 if (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)
450 "string table missing null terminator");
457 else if (PE32PlusHeader)
467 assert(Rva <= UINT32_MAX);
473 const char *ErrorContext)
const {
476 uint32_t SectionStart = Section->VirtualAddress;
477 uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize;
478 if (SectionStart <=
Addr &&
Addr < SectionEnd) {
488 if (Section->SizeOfRawData < Section->VirtualSize &&
489 Addr >= SectionStart + Section->SizeOfRawData) {
490 return make_error<SectionStrippedError>();
493 Res =
reinterpret_cast<uintptr_t
>(
base()) + Section->PointerToRawData +
500 "RVA 0x%" PRIx32
" for %s not found",
Addr,
503 "RVA 0x%" PRIx32
" not found",
Addr);
508 const char *ErrorContext)
const {
511 uint32_t SectionStart = Section->VirtualAddress;
514 uint32_t OffsetIntoSection = RVA - SectionStart;
515 if (SectionStart <= RVA && OffsetIntoSection < Section->VirtualSize &&
516 Size <= Section->VirtualSize - OffsetIntoSection) {
517 uintptr_t Begin =
reinterpret_cast<uintptr_t
>(
base()) +
518 Section->PointerToRawData + OffsetIntoSection;
526 "RVA 0x%" PRIx32
" for %s not found", RVA,
529 "RVA 0x%" PRIx32
" not found", RVA);
536 uintptr_t IntPtr = 0;
539 const uint8_t *
Ptr =
reinterpret_cast<const uint8_t *
>(IntPtr);
540 Hint = *
reinterpret_cast<const ulittle16_t *
>(
Ptr);
551 InfoBytes,
"PDB info"))
553 if (InfoBytes.
size() <
sizeof(*PDBInfo) + 1)
556 InfoBytes = InfoBytes.
drop_front(
sizeof(*PDBInfo));
557 PDBFileName =
StringRef(
reinterpret_cast<const char *
>(InfoBytes.
data()),
560 PDBFileName = PDBFileName.
split(
'\0').first;
576Error COFFObjectFile::initImportTablePtr() {
591 uintptr_t IntPtr = 0;
596 ImportDirectory =
reinterpret_cast<
602Error COFFObjectFile::initDelayImportTablePtr() {
611 NumberOfDelayImportDirectory = DataEntry->
Size /
614 uintptr_t IntPtr = 0;
620 DelayImportDirectory =
reinterpret_cast<
626Error COFFObjectFile::initExportTablePtr() {
638 uintptr_t IntPtr = 0;
649Error COFFObjectFile::initBaseRelocPtr() {
657 uintptr_t IntPtr = 0;
667 IntPtr + DataEntry->
Size);
673Error COFFObjectFile::initDebugDirectoryPtr() {
686 "debug directory has uneven size");
688 uintptr_t IntPtr = 0;
695 DebugDirectoryBegin =
reinterpret_cast<const debug_directory *
>(IntPtr);
697 IntPtr + DataEntry->
Size);
703Error COFFObjectFile::initTLSDirectoryPtr() {
717 if (DataEntry->
Size != DirSize)
720 "TLS Directory size (%u) is not the expected size (%" PRIu64
").",
723 uintptr_t IntPtr = 0;
738Error COFFObjectFile::initLoadConfigPtr() {
747 uintptr_t IntPtr = 0;
749 "load config table"))
754 LoadConfig = (
const void *)IntPtr;
760 sizeof(
Config->CHPEMetadataPointer) &&
761 Config->CHPEMetadataPointer) {
769 CHPEMetadata =
reinterpret_cast<const chpe_metadata *
>(IntPtr);
783 "CHPE entry point ranges"))
793 "CHPE redirection metadata"))
808 std::unique_ptr<COFFObjectFile> Obj(
new COFFObjectFile(std::move(Object)));
809 if (
Error E = Obj->initialize())
811 return std::move(Obj);
816 COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr),
817 DataDirectory(nullptr), SectionTable(nullptr), SymbolTable16(nullptr),
818 SymbolTable32(nullptr), StringTable(nullptr), StringTableSize(0),
819 ImportDirectory(nullptr), DelayImportDirectory(nullptr),
820 NumberOfDelayImportDirectory(0), ExportDirectory(nullptr),
821 BaseRelocHeader(nullptr), BaseRelocEnd(nullptr),
822 DebugDirectoryBegin(nullptr), DebugDirectoryEnd(nullptr),
823 TLSDirectory32(nullptr), TLSDirectory64(nullptr) {}
833Error COFFObjectFile::initialize() {
844 bool HasPEHeader =
false;
851 if (DH->Magic[0] ==
'M' && DH->Magic[1] ==
'Z') {
852 CurPtr = DH->AddressOfNewExeHeader;
856 "incorrect PE magic");
878 COFFHeader =
nullptr;
882 COFFBigObjHeader =
nullptr;
888 EC = std::error_code();
900 const uint8_t *DataDirAddr;
913 "incorrect PE magic");
922 assert(COFFHeader || COFFBigObjHeader);
931 if (
Error E = initSymbolTablePtr()) {
934 SymbolTable16 =
nullptr;
935 SymbolTable32 =
nullptr;
936 StringTable =
nullptr;
943 "symbol table missing");
984 Ret.p =
reinterpret_cast<uintptr_t
>(StringTable);
989 if (!ImportDirectory)
991 if (ImportDirectory->
isNull())
1012 DelayImportDirectory, NumberOfDelayImportDirectory,
this));
1021 if (!ExportDirectory)
1030 Ret.p =
reinterpret_cast<uintptr_t
>(SectionTable);
1038 Ret.p =
reinterpret_cast<uintptr_t
>(SectionTable + NumSections);
1059 return "COFF-x86-64";
1063 return "COFF-ARM64";
1065 return "COFF-ARM64EC";
1067 return "COFF-ARM64X";
1069 return "COFF-<unknown arch>";
1106 assert(PE32Header || PE32PlusHeader);
1109 if (
Index >= NumEnt)
1111 return &DataDirectory[
Index];
1121 return SectionTable + (
Index - 1);
1124 "section index out of bounds");
1128 if (StringTableSize <= 4)
1131 if (
Offset >= StringTableSize)
1143 if (Symbol->Name.Offset.Zeroes == 0)
1144 return getString(Symbol->Name.Offset.Offset);
1148 return StringRef(Symbol->Name.ShortName);
1156 const uint8_t *Aux =
nullptr;
1159 if (Symbol.getNumberOfAuxSymbols() > 0) {
1161 Aux =
reinterpret_cast<const uint8_t *
>(Symbol.getRawPtr()) + SymbolSize;
1164 uintptr_t
Offset = uintptr_t(Aux) - uintptr_t(
base());
1171 "Aux Symbol data did not point to the beginning of a symbol");
1174 return ArrayRef(Aux, Symbol.getNumberOfAuxSymbols() * SymbolSize);
1179 reinterpret_cast<uintptr_t
>(Symbol.getRawPtr()) -
getSymbolTable();
1181 "Symbol did not point to the beginning of a symbol");
1192 if (
Name.starts_with(
"/")) {
1194 if (
Name.starts_with(
"//")) {
1197 "invalid section name");
1201 "invalid section name");
1203 return getString(
Offset);
1234 uintptr_t ConStart =
1239 Res =
ArrayRef(
reinterpret_cast<const uint8_t *
>(ConStart), SectionSize);
1248 Rel.
p =
reinterpret_cast<uintptr_t
>(
1254 return R->VirtualAddress;
1263 Ref.p =
reinterpret_cast<uintptr_t
>(SymbolTable16 + R->SymbolTableIndex);
1264 else if (SymbolTable32)
1265 Ref.p =
reinterpret_cast<uintptr_t
>(SymbolTable32 + R->SymbolTableIndex);
1278 return toSec(Section.getRawDataRefImpl());
1283 return toSymb<coff_symbol16>(
Ref);
1285 return toSymb<coff_symbol32>(
Ref);
1304#define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type) \
1305 case COFF::reloc_type: \
1402#undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME
1408 Result.append(Res.
begin(), Res.
end());
1412 return !DataDirectory;
1417 .
Case(
"eh_fram",
"eh_frame")
1428 if (ImportTable[
Index].isNull()) {
1430 ImportTable =
nullptr;
1442 if (Object->getBytesInAddress() == 4) {
1452 uintptr_t IntPtr = 0;
1454 cantFail(Object->getRvaPtr(RVA, IntPtr));
1460 uintptr_t IntPtr = 0;
1462 cantFail(Object->getRvaPtr(RVA, IntPtr));
1465 if (Object->getBytesInAddress() == 4) {
1466 auto *Entry =
reinterpret_cast<ulittle32_t *
>(IntPtr);
1470 auto *Entry =
reinterpret_cast<ulittle64_t *
>(IntPtr);
1510 uintptr_t IntPtr = 0;
1512 "import directory name"))
1514 Result =
StringRef(
reinterpret_cast<const char *
>(IntPtr));
1557 uintptr_t IntPtr = 0;
1559 "delay import directory name"))
1561 Result =
StringRef(
reinterpret_cast<const char *
>(IntPtr));
1567 Result = &Table[
Index];
1574 AddrIndex * (OwningObject->
is64() ? 8 : 4);
1575 uintptr_t IntPtr = 0;
1576 if (
Error E = OwningObject->
getRvaPtr(RVA, IntPtr,
"import address"))
1578 if (OwningObject->
is64())
1579 Result = *
reinterpret_cast<const ulittle64_t *
>(IntPtr);
1581 Result = *
reinterpret_cast<const ulittle32_t *
>(IntPtr);
1597 uintptr_t IntPtr = 0;
1601 Result =
StringRef(
reinterpret_cast<const char *
>(IntPtr));
1619 uintptr_t IntPtr = 0;
1621 IntPtr,
"export address"))
1633 uintptr_t IntPtr = 0;
1635 "export ordinal table"))
1637 const ulittle16_t *Start =
reinterpret_cast<const ulittle16_t *
>(IntPtr);
1641 for (
const ulittle16_t *
I = Start, *E = Start + NumEntries;
1646 "export table entry"))
1648 const ulittle32_t *NamePtr =
reinterpret_cast<const ulittle32_t *
>(IntPtr);
1650 "export symbol name"))
1652 Result =
StringRef(
reinterpret_cast<const char *
>(IntPtr));
1664 "export table missing");
1670 Result = (Begin <= RVA && RVA <
End);
1678 uintptr_t IntPtr = 0;
1679 if (
auto EC = OwningObject->
getRvaPtr(RVA, IntPtr,
"export forward target"))
1681 Result =
StringRef(
reinterpret_cast<const char *
>(IntPtr));
1687 return Entry32 ==
Other.Entry32 && Entry64 ==
Other.Entry64
1707 uintptr_t IntPtr = 0;
1708 if (
Error EC = OwningObject->
getRvaPtr(RVA, IntPtr,
"import symbol name"))
1711 Result =
StringRef(
reinterpret_cast<const char *
>(IntPtr + 2));
1746 uintptr_t IntPtr = 0;
1747 if (
Error EC = OwningObject->
getRvaPtr(RVA, IntPtr,
"import symbol ordinal"))
1749 Result = *
reinterpret_cast<const ulittle16_t *
>(IntPtr);
1767 if (
Size == Header->BlockSize) {
1773 reinterpret_cast<const uint8_t *
>(Header) +
Size);
1788 Result = Header->PageRVA + Entry[
Index].getOffset();
1792#define RETURN_IF_ERROR(Expr) \
1796 return std::move(E); \
1807 return RawDirString;
1812 return getDirStringAtOffset(Entry.Identifier.getNameOffset());
1820 Reader.setOffset(
Offset);
1822 assert(Table !=
nullptr);
1831 Reader.setOffset(
Offset);
1833 assert(Entry !=
nullptr);
1842 Reader.setOffset(
Offset);
1844 assert(Entry !=
nullptr);
1850 assert(Entry.Offset.isSubDir());
1851 return getTableAtOffset(Entry.Offset.value());
1856 assert(!Entry.Offset.isSubDir());
1857 return getDataEntryAtOffset(Entry.Offset.value());
1861 return getTableAtOffset(0);
1869 const uint8_t *TablePtr =
reinterpret_cast<const uint8_t *
>(&Table);
1871 return getTableEntryAtOffset(TableOffset +
sizeof(Table) +
1879 return Name.takeError();
1881 if (*
Name ==
".rsrc" || *
Name ==
".rsrc$01")
1885 "no resource section found");
1895 const coff_section *COFFSect = Obj->getCOFFSection(Section);
1897 Relocs.reserve(OrigRelocs.
size());
1899 Relocs.push_back(&R);
1901 return A->VirtualAddress <
B->VirtualAddress;
1913 const uint8_t *EntryPtr =
reinterpret_cast<const uint8_t *
>(&Entry);
1917 auto RelocsForOffset =
1918 std::equal_range(Relocs.begin(), Relocs.end(), &RelocTarget,
1920 return A->VirtualAddress < B->VirtualAddress;
1923 if (RelocsForOffset.first != RelocsForOffset.second) {
1928 switch (Obj->getArch()) {
1943 "unsupported architecture");
1945 if (R.Type != RVAReloc)
1947 "unexpected relocation type");
1951 return Sym.takeError();
1954 Obj->getSection(
Sym->getSectionNumber());
1956 return Section.takeError();
1961 if (
Error E = Obj->getSectionContents(*Section, Contents))
1962 return std::move(E);
1963 if (
Offset + Entry.DataSize > Contents.
size())
1965 "data outside of section");
1971 if (Obj->isRelocatableObject())
1973 "no relocation found for DataRVA");
1976 uint64_t VA = Entry.DataRVA + Obj->getImageBase();
1977 for (
const SectionRef &S : Obj->sections()) {
1978 if (VA >= S.getAddress() &&
1979 VA + Entry.DataSize <= S.getAddress() + S.getSize()) {
1984 return Contents->slice(
Offset,
Offset + Entry.DataSize);
1988 "address not found in image");
AMDGPU Mark last scratch load
#define offsetof(TYPE, MEMBER)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static imported_symbol_iterator importedSymbolEnd(uint32_t RVA, const COFFObjectFile *Object)
static uint32_t getNumberOfRelocations(const coff_section *Sec, MemoryBufferRef M, const uint8_t *base)
static Error getObject(const T *&Obj, MemoryBufferRef M, const void *Ptr, const uint64_t Size=sizeof(T))
static imported_symbol_iterator makeImportedSymbolIterator(const COFFObjectFile *Object, uintptr_t Ptr, int Index)
#define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type)
static const coff_relocation * getFirstReloc(const coff_section *Sec, MemoryBufferRef M, const uint8_t *Base)
static imported_symbol_iterator importedSymbolBegin(uint32_t RVA, const COFFObjectFile *Object)
static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Size)
#define RETURN_IF_ERROR(Expr)
static bool decodeBase64StringEntry(StringRef Str, uint32_t &Result)
static Error ignoreStrippedErrors(Error E)
Merge contiguous icmps into a memcmp
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
size_t size() const
size - Get the array size.
An implementation of BinaryStream which holds its entire data set in a single contiguous buffer.
ArrayRef< uint8_t > data() const
Provides read only access to a subclass of BinaryStream.
Error readInteger(T &Dest)
Read an integer of the specified endianness into Dest and update the stream's offset.
void setOffset(uint64_t Off)
Error readArray(ArrayRef< T > &Array, uint32_t NumElements)
Get a reference to a NumElements element array of objects of type T from the underlying stream as if ...
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
bool isA() const
Check whether one error is a subclass of another.
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
reference get()
Returns a reference to the stored T value.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
A range adaptor for a pair of iterators.
Error getType(uint8_t &Type) const
bool operator==(const BaseRelocRef &Other) const
Error getRVA(uint32_t &Result) const
static Error checkOffset(MemoryBufferRef M, uintptr_t Addr, const uint64_t Size)
const dos_header * getDOSHeader() const
uint64_t getSectionSize(DataRefImpl Sec) const override
Expected< StringRef > getSectionName(DataRefImpl Sec) const override
uint64_t getSectionIndex(DataRefImpl Sec) const override
uint32_t getSymbolAlignment(DataRefImpl Symb) const override
bool isSectionCompressed(DataRefImpl Sec) const override
void moveRelocationNext(DataRefImpl &Rel) const override
Expected< section_iterator > getSymbolSection(DataRefImpl Symb) const override
uint8_t getBytesInAddress() const override
The number of bytes used to represent an address in this object file format.
export_directory_iterator export_directory_begin() const
delay_import_directory_iterator delay_import_directory_end() const
base_reloc_iterator base_reloc_begin() const
section_iterator section_end() const override
Error getVaPtr(uint64_t VA, uintptr_t &Res) const
uint64_t getRelocationType(DataRefImpl Rel) const override
void moveSymbolNext(DataRefImpl &Symb) const override
uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override
iterator_range< delay_import_directory_iterator > delay_import_directories() const
import_directory_iterator import_directory_end() const
uint32_t getPointerToSymbolTable() const
const coff_relocation * getCOFFRelocation(const RelocationRef &Reloc) const
Expected< StringRef > getSymbolName(DataRefImpl Symb) const override
bool isDebugSection(DataRefImpl Sec) const override
iterator_range< const debug_directory * > debug_directories() const
StringRef getRelocationTypeName(uint16_t Type) const
bool isSectionBSS(DataRefImpl Sec) const override
base_reloc_iterator base_reloc_end() const
uint64_t getSectionAddress(DataRefImpl Sec) const override
Expected< uint64_t > getSymbolAddress(DataRefImpl Symb) const override
uint32_t getNumberOfSymbols() const
section_iterator section_begin() const override
Expected< SymbolRef::Type > getSymbolType(DataRefImpl Symb) const override
size_t getSymbolTableEntrySize() const
friend class ImportDirectoryEntryRef
export_directory_iterator export_directory_end() const
Error getHintName(uint32_t Rva, uint16_t &Hint, StringRef &Name) const
uintptr_t getSymbolTable() const
static Expected< std::unique_ptr< COFFObjectFile > > create(MemoryBufferRef Object)
bool isSectionVirtual(DataRefImpl Sec) const override
unsigned getSectionID(SectionRef Sec) const
relocation_iterator section_rel_begin(DataRefImpl Sec) const override
iterator_range< import_directory_iterator > import_directories() const
delay_import_directory_iterator delay_import_directory_begin() const
basic_symbol_iterator symbol_end() const override
Error getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size, ArrayRef< uint8_t > &Contents, const char *ErrorContext=nullptr) const
Given an RVA base and size, returns a valid array of bytes or an error code if the RVA and size is no...
const coff_load_configuration64 * getLoadConfig64() const
iterator_range< export_directory_iterator > export_directories() const
uint32_t getNumberOfSections() const
uint64_t getRelocationOffset(DataRefImpl Rel) const override
basic_symbol_iterator symbol_begin() const override
Triple::ArchType getArch() const override
bool isRelocatableObject() const override
True if this is a relocatable object (.o/.obj).
Expected< uint32_t > getSymbolFlags(DataRefImpl Symb) const override
Expected< const coff_section * > getSection(int32_t index) const
bool isSectionText(DataRefImpl Sec) const override
Expected< ArrayRef< uint8_t > > getSectionContents(DataRefImpl Sec) const override
const data_directory * getDataDirectory(uint32_t index) const
StringRef mapDebugSectionName(StringRef Name) const override
Maps a debug section name to a standard DWARF section name.
ArrayRef< uint8_t > getSymbolAuxData(COFFSymbolRef Symbol) const
uint64_t getImageBase() const
const coff_section * getCOFFSection(const SectionRef &Section) const
import_directory_iterator import_directory_begin() const
void moveSectionNext(DataRefImpl &Sec) const override
relocation_iterator section_rel_end(DataRefImpl Sec) const override
ArrayRef< coff_relocation > getRelocations(const coff_section *Sec) const
uint64_t getSymbolValueImpl(DataRefImpl Symb) const override
Error getRvaPtr(uint32_t Rva, uintptr_t &Res, const char *ErrorContext=nullptr) const
unsigned getSymbolSectionID(SymbolRef Sym) const
Error getDebugPDBInfo(const debug_directory *DebugDir, const codeview::DebugInfo *&Info, StringRef &PDBFileName) const
Get PDB information out of a codeview debug directory entry.
friend class ExportDirectoryEntryRef
symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override
uint64_t getSectionAlignment(DataRefImpl Sec) const override
uint32_t getSymbolIndex(COFFSymbolRef Symbol) const
uint16_t getMachine() const
COFFSymbolRef getCOFFSymbol(const DataRefImpl &Ref) const
Expected< uint64_t > getStartAddress() const override
iterator_range< base_reloc_iterator > base_relocs() const
bool isSectionData(DataRefImpl Sec) const override
StringRef getFileFormatName() const override
bool isAnyUndefined() const
bool isFileRecord() const
const coff_aux_weak_external * getWeakExternal() const
bool isSectionDefinition() const
uint8_t getComplexType() const
uint32_t getValue() const
bool isWeakExternal() const
int32_t getSectionNumber() const
bool operator==(const DelayImportDirectoryEntryRef &Other) const
imported_symbol_iterator imported_symbol_begin() const
Error getImportAddress(int AddrIndex, uint64_t &Result) const
iterator_range< imported_symbol_iterator > imported_symbols() const
imported_symbol_iterator imported_symbol_end() const
Error getDelayImportTable(const delay_import_directory_table_entry *&Result) const
Error getName(StringRef &Result) const
bool operator==(const ExportDirectoryEntryRef &Other) const
Error getDllName(StringRef &Result) const
Error getExportRVA(uint32_t &Result) const
Error getOrdinalBase(uint32_t &Result) const
Error getOrdinal(uint32_t &Result) const
Error isForwarder(bool &Result) const
Error getForwardTo(StringRef &Result) const
Error getSymbolName(StringRef &Result) const
bool operator==(const ImportDirectoryEntryRef &Other) const
imported_symbol_iterator imported_symbol_end() const
imported_symbol_iterator imported_symbol_begin() const
Error getImportLookupTableRVA(uint32_t &Result) const
Error getImportTableEntry(const coff_import_directory_table_entry *&Result) const
imported_symbol_iterator lookup_table_end() const
iterator_range< imported_symbol_iterator > lookup_table_symbols() const
iterator_range< imported_symbol_iterator > imported_symbols() const
imported_symbol_iterator lookup_table_begin() const
Error getImportAddressTableRVA(uint32_t &Result) const
Error getName(StringRef &Result) const
bool operator==(const ImportedSymbolRef &Other) const
Error getHintNameRVA(uint32_t &Result) const
Error getOrdinal(uint16_t &Result) const
Error getSymbolName(StringRef &Result) const
Error isOrdinal(bool &Result) const
This class is the base class for all object file types.
friend class RelocationRef
static Expected< std::unique_ptr< COFFObjectFile > > createCOFFObjectFile(MemoryBufferRef Object)
section_iterator_range sections() const
Expected< uint64_t > getSymbolValue(DataRefImpl Symb) const
const uint8_t * base() const
This is a value type class that represents a single relocation in the list of relocations in the obje...
DataRefImpl getRawDataRefImpl() const
Expected< const coff_resource_dir_table & > getBaseTable()
Expected< const coff_resource_dir_table & > getEntrySubDir(const coff_resource_dir_entry &Entry)
Expected< const coff_resource_data_entry & > getEntryData(const coff_resource_dir_entry &Entry)
Error load(const COFFObjectFile *O)
Expected< ArrayRef< UTF16 > > getEntryNameString(const coff_resource_dir_entry &Entry)
Expected< StringRef > getContents(const coff_resource_data_entry &Entry)
Expected< const coff_resource_dir_entry & > getTableEntry(const coff_resource_dir_table &Table, uint32_t Index)
This is a value type class that represents a single section in the list of sections in the object fil...
DataRefImpl getRawDataRefImpl() const
Expected< StringRef > getContents() const
This is a value type class that represents a single symbol in the list of symbols in the object file.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ IMAGE_FILE_MACHINE_ARM64
@ IMAGE_FILE_MACHINE_UNKNOWN
@ IMAGE_FILE_MACHINE_AMD64
@ IMAGE_FILE_MACHINE_ARM64EC
@ IMAGE_FILE_MACHINE_I386
@ IMAGE_FILE_MACHINE_ARM64X
@ IMAGE_FILE_MACHINE_ARMNT
@ IMAGE_SCN_CNT_UNINITIALIZED_DATA
@ IMAGE_SCN_CNT_INITIALIZED_DATA
@ IMAGE_DEBUG_TYPE_CODEVIEW
@ IMAGE_REL_ARM64_ADDR32NB
@ IMAGE_REL_AMD64_ADDR32NB
@ DELAY_IMPORT_DESCRIPTOR
@ IMAGE_WEAK_EXTERN_SEARCH_ALIAS
bool isReservedSectionNumber(int32_t SectionNumber)
static const char BigObjMagic[]
static const char PEMagic[]
@ IMAGE_SYM_DTYPE_FUNCTION
A function that returns a base type.
static Expected< const T * > getObject(MemoryBufferRef M, const void *Ptr, const uint64_t Size=sizeof(T))
content_iterator< ImportDirectoryEntryRef > import_directory_iterator
content_iterator< ImportedSymbolRef > imported_symbol_iterator
content_iterator< ExportDirectoryEntryRef > export_directory_iterator
content_iterator< BaseRelocRef > base_reloc_iterator
coff_tls_directory< support::little64_t > coff_tls_directory64
content_iterator< SectionRef > section_iterator
content_iterator< RelocationRef > relocation_iterator
content_iterator< BasicSymbolRef > basic_symbol_iterator
content_iterator< DelayImportDirectoryEntryRef > delay_import_directory_iterator
This is an optimization pass for GlobalISel generic memory operations.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Triple::ArchType getMachineArchType(T machine)
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
uint64_t PowerOf2Ceil(uint64_t A)
Returns the power of two which is greater than or equal to the given value.
void sort(IteratorTy Start, IteratorTy End)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
@ Ref
The access may reference the value stored in memory.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
void consumeError(Error Err)
Consume a Error without doing anything.
support::ulittle32_t ImportAddressTableRVA
support::ulittle32_t NameRVA
support::ulittle32_t ImportLookupTableRVA
64-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY64)
support::ulittle16_t Type
support::ulittle32_t VirtualAddress
support::ulittle16_t NumberOfNameEntries
support::ulittle16_t NumberOfIDEntries
support::ulittle32_t PointerToRawData
char Name[COFF::NameSize]
support::ulittle32_t VirtualSize
bool hasExtendedRelocations() const
uint32_t getAlignment() const
support::ulittle32_t Characteristics
support::ulittle32_t SizeOfRawData
support::ulittle32_t VirtualAddress
support::ulittle32_t PointerToRelocations
support::ulittle16_t NumberOfRelocations
uint8_t NumberOfAuxSymbols
support::ulittle32_t RelativeVirtualAddress
support::ulittle32_t Size
support::ulittle32_t SizeOfData
support::ulittle32_t AddressOfRawData
support::ulittle32_t DelayImportAddressTable
support::ulittle32_t Name
support::ulittle32_t OrdinalBase
support::ulittle32_t ExportAddressTableRVA
support::ulittle32_t NameRVA
support::ulittle32_t NumberOfNamePointers
support::ulittle32_t NamePointerRVA
support::ulittle32_t AddressTableEntries
support::ulittle32_t OrdinalTableRVA
uint32_t getHintNameRVA() const
uint16_t getOrdinal() const
support::ulittle32_t ExportRVA