X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FObject%2FCOFFObjectFile.cpp;h=4c38b8fd2b066248258e72f96370ef37fb21bdf1;hb=fd491461fc4bf24de4b29d5fba6f2c09c5d2311f;hp=a1fc51ad4ca5784af337f11ed00ded5a9b5b2a32;hpb=237544b16d9d99496395f2250547e4eda1d43c95;p=oota-llvm.git diff --git a/lib/Object/COFFObjectFile.cpp b/lib/Object/COFFObjectFile.cpp index a1fc51ad4ca..4c38b8fd2b0 100644 --- a/lib/Object/COFFObjectFile.cpp +++ b/lib/Object/COFFObjectFile.cpp @@ -54,7 +54,7 @@ static std::error_code checkOffset(MemoryBufferRef M, uintptr_t Addr, template static std::error_code getObject(const T *&Obj, MemoryBufferRef M, const void *Ptr, - const size_t Size = sizeof(T)) { + const uint64_t Size = sizeof(T)) { uintptr_t Addr = uintptr_t(Ptr); if (std::error_code EC = checkOffset(M, Addr, Size)) return EC; @@ -101,13 +101,10 @@ const coff_symbol_type *COFFObjectFile::toSymb(DataRefImpl Ref) const { const coff_symbol_type *Addr = reinterpret_cast(Ref.p); + assert(!checkOffset(Data, uintptr_t(Addr), sizeof(*Addr))); #ifndef NDEBUG // Verify that the symbol points to a valid entry in the symbol table. uintptr_t Offset = uintptr_t(Addr) - uintptr_t(base()); - if (Offset < getPointerToSymbolTable() || - Offset >= getPointerToSymbolTable() + - (getNumberOfSymbols() * sizeof(coff_symbol_type))) - report_fatal_error("Symbol was outside of symbol table."); assert((Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type) == 0 && "Symbol did not point to the beginning of a symbol"); @@ -133,14 +130,15 @@ const coff_section *COFFObjectFile::toSec(DataRefImpl Ref) const { } void COFFObjectFile::moveSymbolNext(DataRefImpl &Ref) const { + auto End = reinterpret_cast(StringTable); if (SymbolTable16) { const coff_symbol16 *Symb = toSymb(Ref); Symb += 1 + Symb->NumberOfAuxSymbols; - Ref.p = reinterpret_cast(Symb); + Ref.p = std::min(reinterpret_cast(Symb), End); } else if (SymbolTable32) { const coff_symbol32 *Symb = toSymb(Ref); Symb += 1 + Symb->NumberOfAuxSymbols; - Ref.p = reinterpret_cast(Symb); + Ref.p = std::min(reinterpret_cast(Symb), End); } else { llvm_unreachable("no symbol table pointer!"); } @@ -192,7 +190,9 @@ std::error_code COFFObjectFile::getSymbolType(DataRefImpl Ref, Result = SymbolRef::ST_Data; } else if (Symb.isFileRecord()) { Result = SymbolRef::ST_File; - } else if (SectionNumber == COFF::IMAGE_SYM_DEBUG) { + } else if (SectionNumber == COFF::IMAGE_SYM_DEBUG || + Symb.isSectionDefinition()) { + // TODO: perhaps we need a new symbol type ST_Section. Result = SymbolRef::ST_Debug; } else if (!COFF::isReservedSectionNumber(SectionNumber)) { const coff_section *Section = nullptr; @@ -262,7 +262,7 @@ std::error_code COFFObjectFile::getSymbolSize(DataRefImpl Ref, } const section_iterator SecEnd = section_end(); uint64_t AfterAddr = UnknownAddressOrSize; - for (const symbol_iterator &SymbI : symbols()) { + for (const symbol_iterator SymbI : symbols()) { section_iterator SecI = SecEnd; if (std::error_code EC = SymbI->getSection(SecI)) return EC; @@ -361,27 +361,17 @@ bool COFFObjectFile::isSectionData(DataRefImpl Ref) const { bool COFFObjectFile::isSectionBSS(DataRefImpl Ref) const { const coff_section *Sec = toSec(Ref); - return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; -} - -bool COFFObjectFile::isSectionRequiredForExecution(DataRefImpl Ref) const { - // FIXME: Unimplemented - return true; + 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; } bool COFFObjectFile::isSectionVirtual(DataRefImpl Ref) const { const coff_section *Sec = toSec(Ref); - return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; -} - -bool COFFObjectFile::isSectionZeroInit(DataRefImpl Ref) const { - // FIXME: Unimplemented. - return false; -} - -bool COFFObjectFile::isSectionReadOnlyData(DataRefImpl Ref) const { - // FIXME: Unimplemented. - return false; + // 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, @@ -403,7 +393,8 @@ static uint32_t getNumberOfRelocations(const coff_section *Sec, if (getObject(FirstReloc, M, reinterpret_cast( base + Sec->PointerToRelocations))) return 0; - return FirstReloc->VirtualAddress; + // -1 to exclude this first relocation entry. + return FirstReloc->VirtualAddress - 1; } return Sec->NumberOfRelocations; } @@ -446,15 +437,15 @@ relocation_iterator COFFObjectFile::section_rel_end(DataRefImpl Ref) const { // Initialize the pointer to the symbol table. std::error_code COFFObjectFile::initSymbolTablePtr() { if (COFFHeader) - if (std::error_code EC = - getObject(SymbolTable16, Data, base() + getPointerToSymbolTable(), - getNumberOfSymbols() * getSymbolTableEntrySize())) + if (std::error_code EC = getObject( + SymbolTable16, Data, base() + getPointerToSymbolTable(), + (uint64_t)getNumberOfSymbols() * getSymbolTableEntrySize())) return EC; if (COFFBigObjHeader) - if (std::error_code EC = - getObject(SymbolTable32, Data, base() + getPointerToSymbolTable(), - getNumberOfSymbols() * getSymbolTableEntrySize())) + if (std::error_code EC = getObject( + SymbolTable32, Data, base() + getPointerToSymbolTable(), + (uint64_t)getNumberOfSymbols() * getSymbolTableEntrySize())) return EC; // Find string table. The first four byte of the string table contains the @@ -587,6 +578,23 @@ std::error_code COFFObjectFile::initExportTablePtr() { return object_error::success; } +std::error_code COFFObjectFile::initBaseRelocPtr() { + const data_directory *DataEntry; + if (getDataDirectory(COFF::BASE_RELOCATION_TABLE, DataEntry)) + return object_error::success; + if (DataEntry->RelativeVirtualAddress == 0) + return object_error::success; + + uintptr_t IntPtr = 0; + if (std::error_code EC = getRvaPtr(DataEntry->RelativeVirtualAddress, IntPtr)) + return EC; + BaseRelocHeader = reinterpret_cast( + IntPtr); + BaseRelocEnd = reinterpret_cast( + IntPtr + DataEntry->Size); + return object_error::success; +} + COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC) : ObjectFile(Binary::ID_COFF, Object), COFFHeader(nullptr), COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr), @@ -594,7 +602,8 @@ COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC) SymbolTable32(nullptr), StringTable(nullptr), StringTableSize(0), ImportDirectory(nullptr), NumberOfImportDirectory(0), DelayImportDirectory(nullptr), NumberOfDelayImportDirectory(0), - ExportDirectory(nullptr) { + ExportDirectory(nullptr), BaseRelocHeader(nullptr), + BaseRelocEnd(nullptr) { // Check that we at least have enough room for a header. if (!checkSize(Data, EC, sizeof(coff_file_header))) return; @@ -681,13 +690,20 @@ COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC) } if ((EC = getObject(SectionTable, Data, base() + CurPtr, - getNumberOfSections() * sizeof(coff_section)))) + (uint64_t)getNumberOfSections() * sizeof(coff_section)))) return; // Initialize the pointer to the symbol table. - if (getPointerToSymbolTable() != 0) + if (getPointerToSymbolTable() != 0) { if ((EC = initSymbolTablePtr())) return; + } else { + // We had better not have any symbols if we don't have a symbol table. + if (getNumberOfSymbols() != 0) { + EC = object_error::parse_failed; + return; + } + } // Initialize the pointer to the beginning of the import table. if ((EC = initImportTablePtr())) @@ -699,6 +715,10 @@ COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC) if ((EC = initExportTablePtr())) return; + // Initialize the pointer to the base relocation table. + if ((EC = initBaseRelocPtr())) + return; + EC = object_error::success; } @@ -765,6 +785,14 @@ section_iterator COFFObjectFile::section_end() const { return section_iterator(SectionRef(Ret, this)); } +base_reloc_iterator COFFObjectFile::base_reloc_begin() const { + return base_reloc_iterator(BaseRelocRef(BaseRelocHeader, this)); +} + +base_reloc_iterator COFFObjectFile::base_reloc_end() const { + return base_reloc_iterator(BaseRelocRef(BaseRelocEnd, this)); +} + uint8_t COFFObjectFile::getBytesInAddress() const { return getArch() == Triple::x86_64 ? 8 : 4; } @@ -811,6 +839,10 @@ COFFObjectFile::export_directories() const { return make_range(export_directory_begin(), export_directory_end()); } +iterator_range COFFObjectFile::base_relocs() const { + 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; @@ -843,15 +875,15 @@ COFFObjectFile::getDataDirectory(uint32_t Index, std::error_code COFFObjectFile::getSection(int32_t Index, const coff_section *&Result) const { - // Check for special index values. + Result = nullptr; if (COFF::isReservedSectionNumber(Index)) - Result = nullptr; - else if (Index > 0 && static_cast(Index) <= getNumberOfSections()) + return object_error::success; + if (static_cast(Index) <= getNumberOfSections()) { // We already verified the section table data, so no need to check again. Result = SectionTable + (Index - 1); - else - return object_error::parse_failed; - return object_error::success; + return object_error::success; + } + return object_error::parse_failed; } std::error_code COFFObjectFile::getString(uint32_t Offset, @@ -1001,12 +1033,14 @@ std::error_code COFFObjectFile::getRelocationOffset(DataRefImpl Rel, symbol_iterator COFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const { const coff_relocation *R = toRel(Rel); DataRefImpl Ref; + if (R->SymbolTableIndex >= getNumberOfSymbols()) + return symbol_end(); if (SymbolTable16) Ref.p = reinterpret_cast(SymbolTable16 + R->SymbolTableIndex); else if (SymbolTable32) Ref.p = reinterpret_cast(SymbolTable32 + R->SymbolTableIndex); else - return symbol_end(); + llvm_unreachable("no symbol table pointer!"); return symbol_iterator(SymbolRef(Ref, this)); } @@ -1428,3 +1462,37 @@ ObjectFile::createCOFFObjectFile(MemoryBufferRef Object) { return EC; return std::move(Ret); } + +bool BaseRelocRef::operator==(const BaseRelocRef &Other) const { + return Header == Other.Header && Index == Other.Index; +} + +void BaseRelocRef::moveNext() { + // Header->BlockSize is the size of the current block, including the + // size of the header itself. + uint32_t Size = sizeof(*Header) + + sizeof(coff_base_reloc_block_entry) * (Index + 1); + if (Size == Header->BlockSize) { + // .reloc contains a list of base relocation blocks. Each block + // consists of the header followed by entries. The header contains + // how many entories will follow. When we reach the end of the + // current block, proceed to the next block. + Header = reinterpret_cast( + reinterpret_cast(Header) + Size); + Index = 0; + } else { + ++Index; + } +} + +std::error_code BaseRelocRef::getType(uint8_t &Type) const { + auto *Entry = reinterpret_cast(Header + 1); + Type = Entry[Index].getType(); + return object_error::success; +} + +std::error_code BaseRelocRef::getRVA(uint32_t &Result) const { + auto *Entry = reinterpret_cast(Header + 1); + Result = Header->PageRVA + Entry[Index].getOffset(); + return object_error::success; +}