llvm-project
1990 строк · 70.1 Кб
1//===- COFFObjectFile.cpp - COFF object file implementation ---------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9// This file declares the COFFObjectFile class.10//11//===----------------------------------------------------------------------===//12// Returns false if size is greater than the buffer size. And sets ec.46static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Size) {47if (M.getBufferSize() < Size) {48EC = object_error::unexpected_eof;49return false;50}51return true;52}53// Sets Obj unless any bytes in [addr, addr + size) fall outsize of m.55// Returns unexpected_eof if error.56template <typename T>57static Error getObject(const T *&Obj, MemoryBufferRef M, const void *Ptr,58const uint64_t Size = sizeof(T)) {59uintptr_t Addr = reinterpret_cast<uintptr_t>(Ptr);60if (Error E = Binary::checkOffset(M, Addr, Size))61return E;62Obj = reinterpret_cast<const T *>(Addr);63return Error::success();64}65// Decode a string table entry in base 64 (//AAAAAA). Expects \arg Str without67// prefixed slashes.68static bool decodeBase64StringEntry(StringRef Str, uint32_t &Result) {69assert(Str.size() <= 6 && "String too long, possible overflow.");70if (Str.size() > 6)71return true;72}99}117}134}149}153}157}164}185}208}239}244}257}262}268}273}283}287}291}300}305}309}314}319}327// The .debug sections are the only debug sections for COFF329// (\see MCObjectFileInfo.cpp).330bool COFFObjectFile::isDebugSection(DataRefImpl Ref) const {331Expected<StringRef> SectionNameOrErr = getSectionName(Ref);332if (!SectionNameOrErr) {333// TODO: Report the error message properly.334consumeError(SectionNameOrErr.takeError());335return false;336}337StringRef SectionName = SectionNameOrErr.get();338return SectionName.starts_with(".debug");339}340}347}354}374}394}404}414// Initialize the pointer to the symbol table.416Error COFFObjectFile::initSymbolTablePtr() {417if (COFFHeader)418if (Error E = getObject(419SymbolTable16, Data, base() + getPointerToSymbolTable(),420(uint64_t)getNumberOfSymbols() * getSymbolTableEntrySize()))421return E;422}453}462// Returns the file offset for the given VA.464Error COFFObjectFile::getVaPtr(uint64_t Addr, uintptr_t &Res) const {465uint64_t ImageBase = getImageBase();466uint64_t Rva = Addr - ImageBase;467assert(Rva <= UINT32_MAX);468return getRvaPtr((uint32_t)Rva, Res);469}470// Returns the file offset for the given RVA.472Error COFFObjectFile::getRvaPtr(uint32_t Addr, uintptr_t &Res,473const char *ErrorContext) const {474for (const SectionRef &S : sections()) {475const coff_section *Section = getCOFFSection(S);476uint32_t SectionStart = Section->VirtualAddress;477uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize;478if (SectionStart <= Addr && Addr < SectionEnd) {479// A table/directory entry can be pointing to somewhere in a stripped480// section, in an object that went through `objcopy --only-keep-debug`.481// In this case we don't want to cause the parsing of the object file to482// fail, otherwise it will be impossible to use this object as debug info483// in LLDB. Return SectionStrippedError here so that484// COFFObjectFile::initialize can ignore the error.485// Somewhat common binaries may have RVAs pointing outside of the486// provided raw data. Instead of rejecting the binaries, just487// treat the section as stripped for these purposes.488if (Section->SizeOfRawData < Section->VirtualSize &&489Addr >= SectionStart + Section->SizeOfRawData) {490return make_error<SectionStrippedError>();491}492uint32_t Offset = Addr - SectionStart;493Res = reinterpret_cast<uintptr_t>(base()) + Section->PointerToRawData +494Offset;495return Error::success();496}497}498if (ErrorContext)499return createStringError(object_error::parse_failed,500"RVA 0x%" PRIx32 " for %s not found", Addr,501ErrorContext);502return createStringError(object_error::parse_failed,503"RVA 0x%" PRIx32 " not found", Addr);504}505}531// Returns hint and name fields, assuming \p Rva is pointing to a Hint/Name533// table entry.534Error COFFObjectFile::getHintName(uint32_t Rva, uint16_t &Hint,535StringRef &Name) const {536uintptr_t IntPtr = 0;537if (Error E = getRvaPtr(Rva, IntPtr))538return E;539const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr);540Hint = *reinterpret_cast<const ulittle16_t *>(Ptr);541Name = StringRef(reinterpret_cast<const char *>(Ptr + 2));542return Error::success();543}544}563}574// Find the import table.576Error COFFObjectFile::initImportTablePtr() {577// First, we get the RVA of the import table. If the file lacks a pointer to578// the import table, do nothing.579const data_directory *DataEntry = getDataDirectory(COFF::IMPORT_TABLE);580if (!DataEntry)581return Error::success();582}600// Initializes DelayImportDirectory and NumberOfDelayImportDirectory.602Error COFFObjectFile::initDelayImportTablePtr() {603const data_directory *DataEntry =604getDataDirectory(COFF::DELAY_IMPORT_DESCRIPTOR);605if (!DataEntry)606return Error::success();607if (DataEntry->RelativeVirtualAddress == 0)608return Error::success();609}624// Find the export table.626Error COFFObjectFile::initExportTablePtr() {627// First, we get the RVA of the export table. If the file lacks a pointer to628// the export table, do nothing.629const data_directory *DataEntry = getDataDirectory(COFF::EXPORT_TABLE);630if (!DataEntry)631return Error::success();632}648}672}702}737}805}813}832}974}980}987}996}1001delay_import_directory_iterator1003COFFObjectFile::delay_import_directory_begin() const {1004return delay_import_directory_iterator(1005DelayImportDirectoryEntryRef(DelayImportDirectory, 0, this));1006}1007delay_import_directory_iterator1009COFFObjectFile::delay_import_directory_end() const {1010return delay_import_directory_iterator(1011DelayImportDirectoryEntryRef(1012DelayImportDirectory, NumberOfDelayImportDirectory, this));1013}1014}1019}1027}1033}1041}1045}1049}1053}1072}1076}1082}1087}1093}1098}1102}1113}1126}1135}1139}1153}1176}1186}1208}1224}1242}1246}1251}1256}1270}1275}1280}1288}1292}1297}1303}1401}1410}1414}1420}1425}1433}1438}1449}1457}1476imported_symbol_iterator1478ImportDirectoryEntryRef::imported_symbol_begin() const {1479return importedSymbolBegin(ImportTable[Index].ImportAddressTableRVA,1480OwningObject);1481}1482imported_symbol_iterator1484ImportDirectoryEntryRef::imported_symbol_end() const {1485return importedSymbolEnd(ImportTable[Index].ImportAddressTableRVA,1486OwningObject);1487}1488}1493}1498}1503}1508}1517Error1519ImportDirectoryEntryRef::getImportLookupTableRVA(uint32_t &Result) const {1520Result = ImportTable[Index].ImportLookupTableRVA;1521return Error::success();1522}1523}1529}1534}1538imported_symbol_iterator1540DelayImportDirectoryEntryRef::imported_symbol_begin() const {1541return importedSymbolBegin(Table[Index].DelayImportNameTable,1542OwningObject);1543}1544imported_symbol_iterator1546DelayImportDirectoryEntryRef::imported_symbol_end() const {1547return importedSymbolEnd(Table[Index].DelayImportNameTable,1548OwningObject);1549}1550}1555}1564}1570}1584}1589}1593// Returns the name of the current export symbol. If the symbol is exported only1595// by ordinal, the empty string is set as a result.1596Error ExportDirectoryEntryRef::getDllName(StringRef &Result) const {1597uintptr_t IntPtr = 0;1598if (Error E =1599OwningObject->getRvaPtr(ExportTable->NameRVA, IntPtr, "dll name"))1600return E;1601Result = StringRef(reinterpret_cast<const char *>(IntPtr));1602return Error::success();1603}1604// Returns the starting ordinal number.1606Error ExportDirectoryEntryRef::getOrdinalBase(uint32_t &Result) const {1607Result = ExportTable->OrdinalBase;1608return Error::success();1609}1610// Returns the export ordinal of the current export symbol.1612Error ExportDirectoryEntryRef::getOrdinal(uint32_t &Result) const {1613Result = ExportTable->OrdinalBase + Index;1614return Error::success();1615}1616// Returns the address of the current export symbol.1618Error ExportDirectoryEntryRef::getExportRVA(uint32_t &Result) const {1619uintptr_t IntPtr = 0;1620if (Error EC = OwningObject->getRvaPtr(ExportTable->ExportAddressTableRVA,1621IntPtr, "export address"))1622return EC;1623const export_address_table_entry *entry =1624reinterpret_cast<const export_address_table_entry *>(IntPtr);1625Result = entry[Index].ExportRVA;1626return Error::success();1627}1628// Returns the name of the current export symbol. If the symbol is exported only1630// by ordinal, the empty string is set as a result.1631Error1632ExportDirectoryEntryRef::getSymbolName(StringRef &Result) const {1633uintptr_t IntPtr = 0;1634if (Error EC = OwningObject->getRvaPtr(ExportTable->OrdinalTableRVA, IntPtr,1635"export ordinal table"))1636return EC;1637const ulittle16_t *Start = reinterpret_cast<const ulittle16_t *>(IntPtr);1638}1658}1673}1684}1690}1694}1714}1722}1730}1752}1757}1761}1779}1785}1791}1809}1814}1825}1836}1847}1853}1859}1863}1874}1887}1905}1991