| //===- COFFReader.cpp -----------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "COFFReader.h" |
| #include "COFFObject.h" |
| #include "llvm/ADT/ArrayRef.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/BinaryFormat/COFF.h" |
| #include "llvm/Object/COFF.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include <cstddef> |
| #include <cstdint> |
| |
| namespace llvm { |
| namespace objcopy { |
| namespace coff { |
| |
| using namespace object; |
| using namespace COFF; |
| |
| Error COFFReader::readExecutableHeaders(Object &Obj) const { |
| const dos_header *DH = COFFObj.getDOSHeader(); |
| Obj.Is64 = COFFObj.is64(); |
| if (!DH) |
| return Error::success(); |
| |
| Obj.IsPE = true; |
| Obj.DosHeader = *DH; |
| if (DH->AddressOfNewExeHeader > sizeof(*DH)) |
| Obj.DosStub = ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&DH[1]), |
| DH->AddressOfNewExeHeader - sizeof(*DH)); |
| |
| if (COFFObj.is64()) { |
| Obj.PeHeader = *COFFObj.getPE32PlusHeader(); |
| } else { |
| const pe32_header *PE32 = COFFObj.getPE32Header(); |
| copyPeHeader(Obj.PeHeader, *PE32); |
| // The pe32plus_header (stored in Object) lacks the BaseOfData field. |
| Obj.BaseOfData = PE32->BaseOfData; |
| } |
| |
| for (size_t I = 0; I < Obj.PeHeader.NumberOfRvaAndSize; I++) { |
| const data_directory *Dir = COFFObj.getDataDirectory(I); |
| if (!Dir) |
| return errorCodeToError(object_error::parse_failed); |
| Obj.DataDirectories.emplace_back(*Dir); |
| } |
| return Error::success(); |
| } |
| |
| Error COFFReader::readSections(Object &Obj) const { |
| std::vector<Section> Sections; |
| // Section indexing starts from 1. |
| for (size_t I = 1, E = COFFObj.getNumberOfSections(); I <= E; I++) { |
| Expected<const coff_section *> SecOrErr = COFFObj.getSection(I); |
| if (!SecOrErr) |
| return SecOrErr.takeError(); |
| const coff_section *Sec = *SecOrErr; |
| Sections.push_back(Section()); |
| Section &S = Sections.back(); |
| S.Header = *Sec; |
| S.Header.Characteristics &= ~COFF::IMAGE_SCN_LNK_NRELOC_OVFL; |
| ArrayRef<uint8_t> Contents; |
| if (Error E = COFFObj.getSectionContents(Sec, Contents)) |
| return E; |
| S.setContentsRef(Contents); |
| ArrayRef<coff_relocation> Relocs = COFFObj.getRelocations(Sec); |
| for (const coff_relocation &R : Relocs) |
| S.Relocs.push_back(R); |
| if (Expected<StringRef> NameOrErr = COFFObj.getSectionName(Sec)) |
| S.Name = *NameOrErr; |
| else |
| return NameOrErr.takeError(); |
| } |
| Obj.addSections(Sections); |
| return Error::success(); |
| } |
| |
| Error COFFReader::readSymbols(Object &Obj, bool IsBigObj) const { |
| std::vector<Symbol> Symbols; |
| Symbols.reserve(COFFObj.getNumberOfSymbols()); |
| ArrayRef<Section> Sections = Obj.getSections(); |
| for (uint32_t I = 0, E = COFFObj.getNumberOfSymbols(); I < E;) { |
| Expected<COFFSymbolRef> SymOrErr = COFFObj.getSymbol(I); |
| if (!SymOrErr) |
| return SymOrErr.takeError(); |
| COFFSymbolRef SymRef = *SymOrErr; |
| |
| Symbols.push_back(Symbol()); |
| Symbol &Sym = Symbols.back(); |
| // Copy symbols from the original form into an intermediate coff_symbol32. |
| if (IsBigObj) |
| copySymbol(Sym.Sym, |
| *reinterpret_cast<const coff_symbol32 *>(SymRef.getRawPtr())); |
| else |
| copySymbol(Sym.Sym, |
| *reinterpret_cast<const coff_symbol16 *>(SymRef.getRawPtr())); |
| auto NameOrErr = COFFObj.getSymbolName(SymRef); |
| if (!NameOrErr) |
| return NameOrErr.takeError(); |
| Sym.Name = *NameOrErr; |
| |
| ArrayRef<uint8_t> AuxData = COFFObj.getSymbolAuxData(SymRef); |
| size_t SymSize = IsBigObj ? sizeof(coff_symbol32) : sizeof(coff_symbol16); |
| assert(AuxData.size() == SymSize * SymRef.getNumberOfAuxSymbols()); |
| // The auxillary symbols are structs of sizeof(coff_symbol16) each. |
| // In the big object format (where symbols are coff_symbol32), each |
| // auxillary symbol is padded with 2 bytes at the end. Copy each |
| // auxillary symbol to the Sym.AuxData vector. For file symbols, |
| // the whole range of aux symbols are interpreted as one null padded |
| // string instead. |
| if (SymRef.isFileRecord()) |
| Sym.AuxFile = StringRef(reinterpret_cast<const char *>(AuxData.data()), |
| AuxData.size()) |
| .rtrim('\0'); |
| else |
| for (size_t I = 0; I < SymRef.getNumberOfAuxSymbols(); I++) |
| Sym.AuxData.push_back(AuxData.slice(I * SymSize, sizeof(AuxSymbol))); |
| |
| // Find the unique id of the section |
| if (SymRef.getSectionNumber() <= |
| 0) // Special symbol (undefined/absolute/debug) |
| Sym.TargetSectionId = SymRef.getSectionNumber(); |
| else if (static_cast<uint32_t>(SymRef.getSectionNumber() - 1) < |
| Sections.size()) |
| Sym.TargetSectionId = Sections[SymRef.getSectionNumber() - 1].UniqueId; |
| else |
| return createStringError(object_error::parse_failed, |
| "section number out of range"); |
| // For section definitions, check if it is comdat associative, and if |
| // it is, find the target section unique id. |
| const coff_aux_section_definition *SD = SymRef.getSectionDefinition(); |
| const coff_aux_weak_external *WE = SymRef.getWeakExternal(); |
| if (SD && SD->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE) { |
| int32_t Index = SD->getNumber(IsBigObj); |
| if (Index <= 0 || static_cast<uint32_t>(Index - 1) >= Sections.size()) |
| return createStringError(object_error::parse_failed, |
| "unexpected associative section index"); |
| Sym.AssociativeComdatTargetSectionId = Sections[Index - 1].UniqueId; |
| } else if (WE) { |
| // This is a raw symbol index for now, but store it in the Symbol |
| // until we've added them to the Object, which assigns the final |
| // unique ids. |
| Sym.WeakTargetSymbolId = WE->TagIndex; |
| } |
| I += 1 + SymRef.getNumberOfAuxSymbols(); |
| } |
| Obj.addSymbols(Symbols); |
| return Error::success(); |
| } |
| |
| Error COFFReader::setSymbolTargets(Object &Obj) const { |
| std::vector<const Symbol *> RawSymbolTable; |
| for (const Symbol &Sym : Obj.getSymbols()) { |
| RawSymbolTable.push_back(&Sym); |
| for (size_t I = 0; I < Sym.Sym.NumberOfAuxSymbols; I++) |
| RawSymbolTable.push_back(nullptr); |
| } |
| for (Symbol &Sym : Obj.getMutableSymbols()) { |
| // Convert WeakTargetSymbolId from the original raw symbol index to |
| // a proper unique id. |
| if (Sym.WeakTargetSymbolId) { |
| if (*Sym.WeakTargetSymbolId >= RawSymbolTable.size()) |
| return createStringError(object_error::parse_failed, |
| "weak external reference out of range"); |
| const Symbol *Target = RawSymbolTable[*Sym.WeakTargetSymbolId]; |
| if (Target == nullptr) |
| return createStringError(object_error::parse_failed, |
| "invalid SymbolTableIndex"); |
| Sym.WeakTargetSymbolId = Target->UniqueId; |
| } |
| } |
| for (Section &Sec : Obj.getMutableSections()) { |
| for (Relocation &R : Sec.Relocs) { |
| if (R.Reloc.SymbolTableIndex >= RawSymbolTable.size()) |
| return createStringError(object_error::parse_failed, |
| "SymbolTableIndex out of range"); |
| const Symbol *Sym = RawSymbolTable[R.Reloc.SymbolTableIndex]; |
| if (Sym == nullptr) |
| return createStringError(object_error::parse_failed, |
| "invalid SymbolTableIndex"); |
| R.Target = Sym->UniqueId; |
| R.TargetName = Sym->Name; |
| } |
| } |
| return Error::success(); |
| } |
| |
| Expected<std::unique_ptr<Object>> COFFReader::create() const { |
| auto Obj = std::make_unique<Object>(); |
| |
| bool IsBigObj = false; |
| if (const coff_file_header *CFH = COFFObj.getCOFFHeader()) { |
| Obj->CoffFileHeader = *CFH; |
| } else { |
| const coff_bigobj_file_header *CBFH = COFFObj.getCOFFBigObjHeader(); |
| if (!CBFH) |
| return createStringError(object_error::parse_failed, |
| "no COFF file header returned"); |
| // Only copying the few fields from the bigobj header that we need |
| // and won't recreate in the end. |
| Obj->CoffFileHeader.Machine = CBFH->Machine; |
| Obj->CoffFileHeader.TimeDateStamp = CBFH->TimeDateStamp; |
| IsBigObj = true; |
| } |
| |
| if (Error E = readExecutableHeaders(*Obj)) |
| return std::move(E); |
| if (Error E = readSections(*Obj)) |
| return std::move(E); |
| if (Error E = readSymbols(*Obj, IsBigObj)) |
| return std::move(E); |
| if (Error E = setSymbolTargets(*Obj)) |
| return std::move(E); |
| |
| return std::move(Obj); |
| } |
| |
| } // end namespace coff |
| } // end namespace objcopy |
| } // end namespace llvm |
