27 using namespace object;
44 const uint64_t Size) {
45 if (Addr + Size < Addr || Addr + Size < Size ||
50 return std::error_code();
58 const uint64_t Size =
sizeof(
T)) {
59 uintptr_t Addr = uintptr_t(Ptr);
60 if (std::error_code EC =
checkOffset(M, Addr, Size))
62 Obj =
reinterpret_cast<const T *
>(Addr);
63 return std::error_code();
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] ==
'/')
89 Value = (Value * 64) + CharVal;
93 if (Value > std::numeric_limits<uint32_t>::max())
96 Result =
static_cast<uint32_t
>(Value);
100 template <
typename coff_symbol_type>
101 const coff_symbol_type *COFFObjectFile::toSymb(
DataRefImpl Ref)
const {
102 const coff_symbol_type *Addr =
103 reinterpret_cast<const coff_symbol_type *
>(Ref.
p);
108 uintptr_t Offset = uintptr_t(Addr) - uintptr_t(
base());
111 "Symbol did not point to the beginning of a symbol");
125 uintptr_t Offset = uintptr_t(Addr) - uintptr_t(SectionTable);
127 "Section did not point to the beginning of a section");
134 auto End =
reinterpret_cast<uintptr_t
>(StringTable);
138 Ref.
p =
std::min(reinterpret_cast<uintptr_t>(Symb), End);
139 }
else if (SymbolTable32) {
142 Ref.
p =
std::min(reinterpret_cast<uintptr_t>(Symb), End);
171 if (std::error_code EC =
getSection(SectionNumber, Section))
244 Ref.
p =
reinterpret_cast<uintptr_t
>(Sec);
247 return std::error_code();
258 Ref.
p =
reinterpret_cast<uintptr_t
>(Sec);
287 return uint64_t(1) << (((Sec->
Characteristics & 0x00F00000) >> 20) - 1);
330 if (
getObject(FirstReloc, M, reinterpret_cast<const coff_relocation*>(
362 Ret.
p =
reinterpret_cast<uintptr_t
>(
begin);
372 Ret.
p =
reinterpret_cast<uintptr_t
>(
I);
377 std::error_code COFFObjectFile::initSymbolTablePtr() {
384 if (COFFBigObjHeader)
395 const uint8_t *StringTableAddr =
base() + StringTableOffset;
397 if (std::error_code EC =
getObject(StringTableSizePtr,
Data, StringTableAddr))
399 StringTableSize = *StringTableSizePtr;
400 if (std::error_code EC =
401 getObject(StringTable,
Data, StringTableAddr, StringTableSize))
406 if (StringTableSize < 4)
410 if (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)
412 return std::error_code();
417 uint64_t ImageBase = PE32Header ? (uint64_t)PE32Header->
ImageBase
419 uint64_t Rva = Addr - ImageBase;
420 assert(Rva <= UINT32_MAX);
430 if (SectionStart <= Addr && Addr < SectionEnd) {
431 uint32_t Offset = Addr - SectionStart;
433 return std::error_code();
443 uintptr_t IntPtr = 0;
444 if (std::error_code EC =
getRvaPtr(Rva, IntPtr))
446 const uint8_t *Ptr =
reinterpret_cast<const uint8_t *
>(IntPtr);
447 Hint = *
reinterpret_cast<const ulittle16_t *
>(Ptr);
448 Name =
StringRef(reinterpret_cast<const char *>(Ptr + 2));
449 return std::error_code();
453 std::error_code COFFObjectFile::initImportTablePtr() {
458 return std::error_code();
462 return std::error_code();
466 NumberOfImportDirectory = DataEntry->
Size /
471 uintptr_t IntPtr = 0;
472 if (std::error_code EC =
getRvaPtr(ImportTableRva, IntPtr))
474 ImportDirectory =
reinterpret_cast<
476 return std::error_code();
480 std::error_code COFFObjectFile::initDelayImportTablePtr() {
483 return std::error_code();
485 return std::error_code();
488 NumberOfDelayImportDirectory = DataEntry->
Size /
491 uintptr_t IntPtr = 0;
492 if (std::error_code EC =
getRvaPtr(RVA, IntPtr))
494 DelayImportDirectory =
reinterpret_cast<
496 return std::error_code();
500 std::error_code COFFObjectFile::initExportTablePtr() {
505 return std::error_code();
509 return std::error_code();
512 uintptr_t IntPtr = 0;
513 if (std::error_code EC =
getRvaPtr(ExportTableRva, IntPtr))
517 return std::error_code();
520 std::error_code COFFObjectFile::initBaseRelocPtr() {
523 return std::error_code();
525 return std::error_code();
527 uintptr_t IntPtr = 0;
533 IntPtr + DataEntry->
Size);
534 return std::error_code();
539 COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr),
540 DataDirectory(nullptr), SectionTable(nullptr), SymbolTable16(nullptr),
541 SymbolTable32(nullptr), StringTable(nullptr), StringTableSize(0),
542 ImportDirectory(nullptr), NumberOfImportDirectory(0),
543 DelayImportDirectory(nullptr), NumberOfDelayImportDirectory(0),
544 ExportDirectory(nullptr), BaseRelocHeader(nullptr),
545 BaseRelocEnd(nullptr) {
555 bool HasPEHeader =
false;
562 if (
DH->Magic[0] ==
'M' &&
DH->Magic[1] ==
'Z') {
563 CurPtr =
DH->AddressOfNewExeHeader;
589 COFFHeader =
nullptr;
593 COFFBigObjHeader =
nullptr;
599 EC = std::error_code();
611 const uint8_t *DataDirAddr;
612 uint64_t DataDirSize;
626 if ((EC =
getObject(DataDirectory,
Data, DataDirAddr, DataDirSize)))
637 if ((EC = initSymbolTablePtr()))
648 if ((EC = initImportTablePtr()))
650 if ((EC = initDelayImportTablePtr()))
654 if ((EC = initExportTablePtr()))
658 if ((EC = initBaseRelocPtr()))
661 EC = std::error_code();
673 Ret.
p =
reinterpret_cast<uintptr_t
>(StringTable);
697 DelayImportDirectory, NumberOfDelayImportDirectory,
this));
706 if (!ExportDirectory)
715 Ret.
p =
reinterpret_cast<uintptr_t
>(SectionTable);
723 Ret.
p =
reinterpret_cast<uintptr_t
>(SectionTable + NumSections);
744 return "COFF-x86-64";
748 return "COFF-<unknown arch>";
787 return std::error_code();
792 Res = PE32PlusHeader;
793 return std::error_code();
800 if (!DataDirectory) {
804 assert(PE32Header || PE32PlusHeader);
807 if (Index >= NumEnt) {
811 Res = &DataDirectory[Index];
812 return std::error_code();
819 return std::error_code();
822 Result = SectionTable + (Index - 1);
823 return std::error_code();
828 std::error_code COFFObjectFile::getString(uint32_t Offset,
830 if (StringTableSize <= 4)
833 if (Offset >= StringTableSize)
835 Result =
StringRef(StringTable + Offset);
836 return std::error_code();
850 return std::error_code();
859 return std::error_code();
864 const uint8_t *Aux =
nullptr;
869 Aux =
reinterpret_cast<const uint8_t *
>(Symbol.
getRawPtr()) + SymbolSize;
872 uintptr_t Offset = uintptr_t(Aux) - uintptr_t(
base());
879 "Aux Symbol data did not point to the beginning of a symbol");
905 if (std::error_code EC = getString(Offset, Name))
910 return std::error_code();
935 "BSS sections don't have contents!");
943 Res =
makeArrayRef(reinterpret_cast<const uint8_t *>(ConStart), SectionSize);
944 return std::error_code();
952 Rel.
p =
reinterpret_cast<uintptr_t
>(
968 else if (SymbolTable32)
987 return toSymb<coff_symbol16>(Ref);
989 return toSymb<coff_symbol32>(Ref);
1011 #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type) \
1012 case COFF::reloc_type: \
1013 Res = #reloc_type; \
1022 switch (Reloc->
Type) {
1045 switch (Reloc->
Type) {
1066 switch (Reloc->
Type) {
1088 #undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME
1091 return !DataDirectory;
1096 return ImportTable == Other.ImportTable && Index == Other.Index;
1105 Result = ImportTable + Index;
1106 return std::error_code();
1111 uintptr_t Ptr,
int Index) {
1112 if (Object->getBytesInAddress() == 4) {
1122 uintptr_t IntPtr = 0;
1123 Object->getRvaPtr(RVA, IntPtr);
1129 uintptr_t IntPtr = 0;
1130 Object->getRvaPtr(RVA, IntPtr);
1133 if (Object->getBytesInAddress() == 4) {
1134 auto *Entry =
reinterpret_cast<ulittle32_t *
>(IntPtr);
1138 auto *Entry =
reinterpret_cast<ulittle64_t *
>(IntPtr);
1163 uintptr_t IntPtr = 0;
1164 if (std::error_code EC =
1167 Result =
StringRef(reinterpret_cast<const char *>(IntPtr));
1168 return std::error_code();
1174 return std::error_code();
1180 return std::error_code();
1185 uintptr_t IntPtr = 0;
1187 if (std::error_code EC = OwningObject->
getRvaPtr(RVA, IntPtr))
1190 return std::error_code();
1195 return Table == Other.Table && Index == Other.Index;
1220 uintptr_t IntPtr = 0;
1221 if (std::error_code EC = OwningObject->
getRvaPtr(Table[Index].
Name, IntPtr))
1223 Result =
StringRef(reinterpret_cast<const char *>(IntPtr));
1224 return std::error_code();
1230 return std::error_code();
1236 AddrIndex * (OwningObject->
is64() ? 8 : 4);
1237 uintptr_t IntPtr = 0;
1238 if (std::error_code EC = OwningObject->
getRvaPtr(RVA, IntPtr))
1240 if (OwningObject->
is64())
1241 Result = *reinterpret_cast<const ulittle64_t *>(IntPtr);
1243 Result = *
reinterpret_cast<const ulittle32_t *
>(IntPtr);
1244 return std::error_code();
1249 return ExportTable == Other.ExportTable && Index == Other.Index;
1259 uintptr_t IntPtr = 0;
1260 if (std::error_code EC =
1263 Result =
StringRef(reinterpret_cast<const char *>(IntPtr));
1264 return std::error_code();
1271 return std::error_code();
1277 return std::error_code();
1282 uintptr_t IntPtr = 0;
1283 if (std::error_code EC =
1289 return std::error_code();
1296 uintptr_t IntPtr = 0;
1297 if (std::error_code EC =
1304 for (
const ulittle16_t *
I = Start, *E = Start + NumEntries;
1305 I < E; ++
I, ++Offset) {
1308 if (std::error_code EC =
1312 if (std::error_code EC = OwningObject->
getRvaPtr(NamePtr[Offset], IntPtr))
1314 Result =
StringRef(reinterpret_cast<const char *>(IntPtr));
1315 return std::error_code();
1318 return std::error_code();
1323 return Entry32 == Other.Entry32 && Entry64 == Other.Entry64
1324 && Index == Other.Index;
1336 if (Entry32[Index].isOrdinal())
1337 return std::error_code();
1340 if (Entry64[Index].isOrdinal())
1341 return std::error_code();
1344 uintptr_t IntPtr = 0;
1345 if (std::error_code EC = OwningObject->
getRvaPtr(RVA, IntPtr))
1348 Result =
StringRef(reinterpret_cast<const char *>(IntPtr + 2));
1349 return std::error_code();
1355 if (Entry32[Index].isOrdinal()) {
1357 return std::error_code();
1361 if (Entry64[Index].isOrdinal()) {
1363 return std::error_code();
1367 uintptr_t IntPtr = 0;
1368 if (std::error_code EC = OwningObject->
getRvaPtr(RVA, IntPtr))
1370 Result = *
reinterpret_cast<const ulittle16_t *
>(IntPtr);
1371 return std::error_code();
1380 return std::move(Ret);
1384 return Header == Other.Header && Index == Other.Index;
1390 uint32_t Size =
sizeof(*Header) +
1398 reinterpret_cast<const uint8_t *
>(Header) + Size);
1407 Type = Entry[Index].
getType();
1408 return std::error_code();
1413 Result = Header->
PageRVA + Entry[Index].getOffset();
1414 return std::error_code();
std::error_code getRVA(uint32_t &Result) const
uint32_t getNumberOfSections() const
std::enable_if< std::numeric_limits< T >::is_signed, bool >::type getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
bool operator==(const ImportDirectoryEntryRef &Other) const
static uint32_t getNumberOfRelocations(const coff_section *Sec, MemoryBufferRef M, const uint8_t *base)
Represents either an error or a value T.
support::ulittle32_t ImportAddressTableRVA
section_iterator section_begin() const override
ErrorOr< StringRef > getSymbolName(DataRefImpl Symb) const override
DataRefImpl getRawDataRefImpl() const
size_t size() const
size - Get the string size.
iterator_range< imported_symbol_iterator > imported_symbols() const
support::ulittle32_t Name
support::ulittle32_t OrdinalBase
const void * getRawPtr() const
std::error_code getDelayImportTable(const delay_import_directory_table_entry *&Result) const
COFFObjectFile(MemoryBufferRef Object, std::error_code &EC)
uint64_t getRelocationOffset(DataRefImpl Rel) const override
bool hasExtendedRelocations() const
std::error_code getImportAddress(int AddrIndex, uint64_t &Result) const
imported_symbol_iterator imported_symbol_begin() const
const uint8_t * base() const
support::ulittle32_t VirtualAddress
import_directory_iterator import_directory_end() const
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
void moveSectionNext(DataRefImpl &Sec) const override
static std::error_code getObject(const T *&Obj, MemoryBufferRef M, const void *Ptr, const uint64_t Size=sizeof(T))
void moveRelocationNext(DataRefImpl &Rel) const override
static ErrorOr< std::unique_ptr< COFFObjectFile > > createCOFFObjectFile(MemoryBufferRef Object)
StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
This class is the base class for all object file types.
static const coff_relocation * getFirstReloc(const coff_section *Sec, MemoryBufferRef M, const uint8_t *Base)
support::ulittle32_t PointerToRelocations
const_iterator begin(StringRef path)
Get begin iterator over path.
const char * getBufferStart() const
uint32_t getValue() const
union llvm::object::coff_symbol_generic::@91 Name
DataRefImpl getRawDataRefImpl() const
std::error_code getImportAddressTableRVA(uint32_t &Result) const
std::error_code getSectionContents(DataRefImpl Sec, StringRef &Res) const override
uint64_t getSymbolValueImpl(DataRefImpl Symb) const override
const coff_section * getCOFFSection(const SectionRef &Section) const
std::error_code getSectionName(DataRefImpl Sec, StringRef &Res) const override
std::error_code getRvaPtr(uint32_t Rva, uintptr_t &Res) const
static const char BigObjMagic[]
aarch64 collect AArch64 Collect Linker Optimization Hint(LOH)"
support::ulittle32_t DelayImportAddressTable
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
uint8_t getBytesInAddress() const override
The number of bytes used to represent an address in this object file format.
char ShortName[COFF::NameSize]
support::ulittle32_t NameRVA
uint16_t getOrdinal() const
friend class ExportDirectoryEntryRef
uint64_t getSectionAlignment(DataRefImpl Sec) const override
char Name[COFF::NameSize]
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is a value type class that represents a single relocation in the list of relocations in the obje...
bool operator==(const ExportDirectoryEntryRef &Other) const
iterator_range< base_reloc_iterator > base_relocs() const
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
std::error_code getOrdinal(uint32_t &Result) const
content_iterator< ImportedSymbolRef > imported_symbol_iterator
static imported_symbol_iterator importedSymbolBegin(uint32_t RVA, const COFFObjectFile *Object)
iterator_range< import_directory_iterator > import_directories() const
support::ulittle32_t ImportLookupTableRVA
bool isReservedSectionNumber(int32_t SectionNumber)
support::ulittle32_t VirtualSize
#define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type)
support::ulittle32_t NameRVA
std::error_code getVaPtr(uint64_t VA, uintptr_t &Res) const
uint32_t getSymbolFlags(DataRefImpl Symb) const override
ErrorOr< uint64_t > getSymbolAddress(DataRefImpl Symb) const override
std::error_code getName(StringRef &Result) const
uint64_t getSectionAddress(DataRefImpl Sec) const override
iterator_range< const coff_relocation * > getRelocations(const coff_section *Sec) const
std::error_code getSymbolName(StringRef &Result) const
void moveSymbolNext(DataRefImpl &Symb) const override
bool isFunctionDefinition() const
support::ulittle32_t NamePointerRVA
support::ulittle32_t ExportRVA
size_t size() const
size - Get the array size.
bool isRelocatableObject() const override
True if this is a relocatable object (.o/.obj).
unsigned getArch() const override
imported_symbol_iterator imported_symbol_end() const
unsigned getSectionID(SectionRef Sec) const
content_iterator< SectionRef > section_iterator
static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Size)
relocation_iterator section_rel_end(DataRefImpl Sec) const override
support::ulittle32_t Characteristics
bool isFileRecord() const
The instances of the Type class are immutable: once they are created, they are never changed...
uint16_t getMachine() const
std::error_code getDataDirectory(uint32_t index, const data_directory *&Res) const
const char * getBufferEnd() const
basic_symbol_iterator symbol_end_impl() const override
int32_t getSectionNumber() const
std::error_code getImportLookupTableRVA(uint32_t &Result) const
export_directory_iterator export_directory_end() const
base_reloc_iterator base_reloc_begin() const
support::ulittle32_t RelativeVirtualAddress
std::error_code getOrdinal(uint16_t &Result) const
std::error_code getPE32PlusHeader(const pe32plus_header *&Res) const
relocation_iterator section_rel_begin(DataRefImpl Sec) const override
support::ulittle16_t Type
support::ulittle32_t OrdinalTableRVA
COFFSymbolRef getCOFFSymbol(const DataRefImpl &Ref) const
section_iterator_range sections() const
export_directory_iterator export_directory_begin() const
static imported_symbol_iterator makeImportedSymbolIterator(const COFFObjectFile *Object, uintptr_t Ptr, int Index)
support::ulittle32_t SizeOfRawData
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
content_iterator< RelocationRef > relocation_iterator
uint64_t getRelocationType(DataRefImpl Rel) const override
StringRef getFileFormatName() const override
content_iterator< ImportDirectoryEntryRef > import_directory_iterator
support::ulittle32_t VirtualAddress
support::ulittle32_t SymbolTableIndex
std::error_code getSymbolSection(DataRefImpl Symb, section_iterator &Res) const override
size_t getBufferSize() const
friend class ImportDirectoryEntryRef
basic_symbol_iterator symbol_end() const
content_iterator< BasicSymbolRef > basic_symbol_iterator
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
import_directory_iterator import_directory_begin() const
support::ulittle32_t PointerToRawData
bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
friend class RelocationRef
bool isWeakExternal() const
uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override
static bool decodeBase64StringEntry(StringRef Str, uint32_t &Result)
imported_symbol_iterator imported_symbol_end() const
content_iterator< ExportDirectoryEntryRef > export_directory_iterator
bool isSectionData(DataRefImpl Sec) const override
detail::packed_endian_specific_integral< int16_t, little, unaligned > little16_t
const dos_header * getDOSHeader() const
basic_symbol_iterator symbol_begin_impl() const override
std::error_code getImportLookupEntry(const import_lookup_table_entry32 *&Result) const
A range adaptor for a pair of iterators.
section_iterator section_end() const override
delay_import_directory_iterator delay_import_directory_begin() const
support::ulittle32_t Size
uint8_t getNumberOfAuxSymbols() const
unsigned getSymbolSectionID(SymbolRef Sym) const
detail::packed_endian_specific_integral< uint16_t, little, unaligned > ulittle16_t
std::error_code getHintName(uint32_t Rva, uint16_t &Hint, StringRef &Name) const
This is a value type class that represents a single symbol in the list of symbols in the object file...
support::ulittle32_t Zeroes
const coff_relocation * getCOFFRelocation(const RelocationRef &Reloc) const
imported_symbol_iterator imported_symbol_begin() const
symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override
delay_import_directory_iterator delay_import_directory_end() const
support::ulittle32_t NumberOfNamePointers
std::error_code getPE32Header(const pe32_header *&Res) const
bool isSectionDefinition() const
iterator_range< imported_symbol_iterator > imported_symbols() const
bool isSectionText(DataRefImpl Sec) const override
bool operator==(const DelayImportDirectoryEntryRef &Other) const
std::error_code getImportTableEntry(const import_directory_table_entry *&Result) const
uintptr_t getSymbolTable() const
const coff_symbol_generic * getGeneric() const
std::error_code getDllName(StringRef &Result) const
bool operator==(const BaseRelocRef &Other) const
void getRelocationTypeName(DataRefImpl Rel, SmallVectorImpl< char > &Result) const override
uint64_t getSymbolValue(DataRefImpl Symb) const
detail::packed_endian_specific_integral< uint64_t, little, unaligned > ulittle64_t
content_iterator< DelayImportDirectoryEntryRef > delay_import_directory_iterator
support::ulittle32_t AddressTableEntries
static const char PEMagic[]
size_t getSymbolTableEntrySize() const
iterator_range< export_directory_iterator > export_directories() const
bool isSectionVirtual(DataRefImpl Sec) const override
static imported_symbol_iterator importedSymbolEnd(uint32_t RVA, const COFFObjectFile *Object)
bool operator==(const ImportedSymbolRef &Other) const
uint64_t getSectionSize(DataRefImpl Sec) const override
support::ulittle16_t NumberOfRelocations
uint32_t getNumberOfSymbols() const
uint8_t NumberOfAuxSymbols
bool isAnyUndefined() const
bool isSectionBSS(DataRefImpl Sec) const override
base_reloc_iterator base_reloc_end() const
detail::packed_endian_specific_integral< uint32_t, little, unaligned > ulittle32_t
std::error_code getSymbolName(StringRef &Result) const
std::error_code getOrdinalBase(uint32_t &Result) const
LLVM Value Representation.
support::ulittle32_t ExportAddressTableRVA
static std::error_code checkOffset(MemoryBufferRef M, uintptr_t Addr, const uint64_t Size)
StringRef - Represent a constant reference to a string, i.e.
std::error_code getType(uint8_t &Type) const
content_iterator< BaseRelocRef > base_reloc_iterator
uint32_t getPointerToSymbolTable() const
std::error_code getName(StringRef &Result) const
uint32_t getHintNameRVA() const
ArrayRef< uint8_t > getSymbolAuxData(COFFSymbolRef Symbol) const
std::error_code getSection(int32_t index, const coff_section *&Res) const
std::error_code getExportRVA(uint32_t &Result) const
This is a value type class that represents a single section in the list of sections in the object fil...
SymbolRef::Type getSymbolType(DataRefImpl Symb) const override
bool empty() const
empty - Check if the string is empty.
iterator_range< delay_import_directory_iterator > delay_import_directories() const
support::ulittle32_t Offset
DataRefImpl getRawDataRefImpl() const