450 lines
16 KiB
C++
450 lines
16 KiB
C++
//===- Writer.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 "Writer.h"
|
|
#include "Object.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 COFFWriter::finalizeRelocTargets() {
|
|
for (Section &Sec : Obj.getMutableSections()) {
|
|
for (Relocation &R : Sec.Relocs) {
|
|
const Symbol *Sym = Obj.findSymbol(R.Target);
|
|
if (Sym == nullptr)
|
|
return createStringError(object_error::invalid_symbol_index,
|
|
"relocation target '%s' (%zu) not found",
|
|
R.TargetName.str().c_str(), R.Target);
|
|
R.Reloc.SymbolTableIndex = Sym->RawIndex;
|
|
}
|
|
}
|
|
return Error::success();
|
|
}
|
|
|
|
Error COFFWriter::finalizeSymbolContents() {
|
|
for (Symbol &Sym : Obj.getMutableSymbols()) {
|
|
if (Sym.TargetSectionId <= 0) {
|
|
// Undefined, or a special kind of symbol. These negative values
|
|
// are stored in the SectionNumber field which is unsigned.
|
|
Sym.Sym.SectionNumber = static_cast<uint32_t>(Sym.TargetSectionId);
|
|
} else {
|
|
const Section *Sec = Obj.findSection(Sym.TargetSectionId);
|
|
if (Sec == nullptr)
|
|
return createStringError(object_error::invalid_symbol_index,
|
|
"symbol '%s' points to a removed section",
|
|
Sym.Name.str().c_str());
|
|
Sym.Sym.SectionNumber = Sec->Index;
|
|
|
|
if (Sym.Sym.NumberOfAuxSymbols == 1 &&
|
|
Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC) {
|
|
coff_aux_section_definition *SD =
|
|
reinterpret_cast<coff_aux_section_definition *>(
|
|
Sym.AuxData[0].Opaque);
|
|
uint32_t SDSectionNumber;
|
|
if (Sym.AssociativeComdatTargetSectionId == 0) {
|
|
// Not a comdat associative section; just set the Number field to
|
|
// the number of the section itself.
|
|
SDSectionNumber = Sec->Index;
|
|
} else {
|
|
Sec = Obj.findSection(Sym.AssociativeComdatTargetSectionId);
|
|
if (Sec == nullptr)
|
|
return createStringError(
|
|
object_error::invalid_symbol_index,
|
|
"symbol '%s' is associative to a removed section",
|
|
Sym.Name.str().c_str());
|
|
SDSectionNumber = Sec->Index;
|
|
}
|
|
// Update the section definition with the new section number.
|
|
SD->NumberLowPart = static_cast<uint16_t>(SDSectionNumber);
|
|
SD->NumberHighPart = static_cast<uint16_t>(SDSectionNumber >> 16);
|
|
}
|
|
}
|
|
// Check that we actually have got AuxData to match the weak symbol target
|
|
// we want to set. Only >= 1 would be required, but only == 1 makes sense.
|
|
if (Sym.WeakTargetSymbolId && Sym.Sym.NumberOfAuxSymbols == 1) {
|
|
coff_aux_weak_external *WE =
|
|
reinterpret_cast<coff_aux_weak_external *>(Sym.AuxData[0].Opaque);
|
|
const Symbol *Target = Obj.findSymbol(*Sym.WeakTargetSymbolId);
|
|
if (Target == nullptr)
|
|
return createStringError(object_error::invalid_symbol_index,
|
|
"symbol '%s' is missing its weak target",
|
|
Sym.Name.str().c_str());
|
|
WE->TagIndex = Target->RawIndex;
|
|
}
|
|
}
|
|
return Error::success();
|
|
}
|
|
|
|
void COFFWriter::layoutSections() {
|
|
for (auto &S : Obj.getMutableSections()) {
|
|
if (S.Header.SizeOfRawData > 0)
|
|
S.Header.PointerToRawData = FileSize;
|
|
FileSize += S.Header.SizeOfRawData; // For executables, this is already
|
|
// aligned to FileAlignment.
|
|
if (S.Relocs.size() >= 0xffff) {
|
|
S.Header.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
|
|
S.Header.NumberOfRelocations = 0xffff;
|
|
S.Header.PointerToRelocations = FileSize;
|
|
FileSize += sizeof(coff_relocation);
|
|
} else {
|
|
S.Header.NumberOfRelocations = S.Relocs.size();
|
|
S.Header.PointerToRelocations = S.Relocs.size() ? FileSize : 0;
|
|
}
|
|
|
|
FileSize += S.Relocs.size() * sizeof(coff_relocation);
|
|
FileSize = alignTo(FileSize, FileAlignment);
|
|
|
|
if (S.Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
|
|
SizeOfInitializedData += S.Header.SizeOfRawData;
|
|
}
|
|
}
|
|
|
|
size_t COFFWriter::finalizeStringTable() {
|
|
for (const auto &S : Obj.getSections())
|
|
if (S.Name.size() > COFF::NameSize)
|
|
StrTabBuilder.add(S.Name);
|
|
|
|
for (const auto &S : Obj.getSymbols())
|
|
if (S.Name.size() > COFF::NameSize)
|
|
StrTabBuilder.add(S.Name);
|
|
|
|
StrTabBuilder.finalize();
|
|
|
|
for (auto &S : Obj.getMutableSections()) {
|
|
memset(S.Header.Name, 0, sizeof(S.Header.Name));
|
|
if (S.Name.size() > COFF::NameSize) {
|
|
snprintf(S.Header.Name, sizeof(S.Header.Name), "/%d",
|
|
(int)StrTabBuilder.getOffset(S.Name));
|
|
} else {
|
|
memcpy(S.Header.Name, S.Name.data(), S.Name.size());
|
|
}
|
|
}
|
|
for (auto &S : Obj.getMutableSymbols()) {
|
|
if (S.Name.size() > COFF::NameSize) {
|
|
S.Sym.Name.Offset.Zeroes = 0;
|
|
S.Sym.Name.Offset.Offset = StrTabBuilder.getOffset(S.Name);
|
|
} else {
|
|
strncpy(S.Sym.Name.ShortName, S.Name.data(), COFF::NameSize);
|
|
}
|
|
}
|
|
return StrTabBuilder.getSize();
|
|
}
|
|
|
|
template <class SymbolTy>
|
|
std::pair<size_t, size_t> COFFWriter::finalizeSymbolTable() {
|
|
size_t RawSymIndex = 0;
|
|
for (auto &S : Obj.getMutableSymbols()) {
|
|
// Symbols normally have NumberOfAuxSymbols set correctly all the time.
|
|
// For file symbols, we need to know the output file's symbol size to be
|
|
// able to calculate the number of slots it occupies.
|
|
if (!S.AuxFile.empty())
|
|
S.Sym.NumberOfAuxSymbols =
|
|
alignTo(S.AuxFile.size(), sizeof(SymbolTy)) / sizeof(SymbolTy);
|
|
S.RawIndex = RawSymIndex;
|
|
RawSymIndex += 1 + S.Sym.NumberOfAuxSymbols;
|
|
}
|
|
return std::make_pair(RawSymIndex * sizeof(SymbolTy), sizeof(SymbolTy));
|
|
}
|
|
|
|
Error COFFWriter::finalize(bool IsBigObj) {
|
|
size_t SymTabSize, SymbolSize;
|
|
std::tie(SymTabSize, SymbolSize) = IsBigObj
|
|
? finalizeSymbolTable<coff_symbol32>()
|
|
: finalizeSymbolTable<coff_symbol16>();
|
|
|
|
if (Error E = finalizeRelocTargets())
|
|
return E;
|
|
if (Error E = finalizeSymbolContents())
|
|
return E;
|
|
|
|
size_t SizeOfHeaders = 0;
|
|
FileAlignment = 1;
|
|
size_t PeHeaderSize = 0;
|
|
if (Obj.IsPE) {
|
|
Obj.DosHeader.AddressOfNewExeHeader =
|
|
sizeof(Obj.DosHeader) + Obj.DosStub.size();
|
|
SizeOfHeaders += Obj.DosHeader.AddressOfNewExeHeader + sizeof(PEMagic);
|
|
|
|
FileAlignment = Obj.PeHeader.FileAlignment;
|
|
Obj.PeHeader.NumberOfRvaAndSize = Obj.DataDirectories.size();
|
|
|
|
PeHeaderSize = Obj.Is64 ? sizeof(pe32plus_header) : sizeof(pe32_header);
|
|
SizeOfHeaders +=
|
|
PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
|
|
}
|
|
Obj.CoffFileHeader.NumberOfSections = Obj.getSections().size();
|
|
SizeOfHeaders +=
|
|
IsBigObj ? sizeof(coff_bigobj_file_header) : sizeof(coff_file_header);
|
|
SizeOfHeaders += sizeof(coff_section) * Obj.getSections().size();
|
|
SizeOfHeaders = alignTo(SizeOfHeaders, FileAlignment);
|
|
|
|
Obj.CoffFileHeader.SizeOfOptionalHeader =
|
|
PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
|
|
|
|
FileSize = SizeOfHeaders;
|
|
SizeOfInitializedData = 0;
|
|
|
|
layoutSections();
|
|
|
|
if (Obj.IsPE) {
|
|
Obj.PeHeader.SizeOfHeaders = SizeOfHeaders;
|
|
Obj.PeHeader.SizeOfInitializedData = SizeOfInitializedData;
|
|
|
|
if (!Obj.getSections().empty()) {
|
|
const Section &S = Obj.getSections().back();
|
|
Obj.PeHeader.SizeOfImage =
|
|
alignTo(S.Header.VirtualAddress + S.Header.VirtualSize,
|
|
Obj.PeHeader.SectionAlignment);
|
|
}
|
|
|
|
// If the PE header had a checksum, clear it, since it isn't valid
|
|
// any longer. (We don't calculate a new one.)
|
|
Obj.PeHeader.CheckSum = 0;
|
|
}
|
|
|
|
size_t StrTabSize = finalizeStringTable();
|
|
|
|
size_t PointerToSymbolTable = FileSize;
|
|
// StrTabSize <= 4 is the size of an empty string table, only consisting
|
|
// of the length field.
|
|
if (SymTabSize == 0 && StrTabSize <= 4 && Obj.IsPE) {
|
|
// For executables, don't point to the symbol table and skip writing
|
|
// the length field, if both the symbol and string tables are empty.
|
|
PointerToSymbolTable = 0;
|
|
StrTabSize = 0;
|
|
}
|
|
|
|
size_t NumRawSymbols = SymTabSize / SymbolSize;
|
|
Obj.CoffFileHeader.PointerToSymbolTable = PointerToSymbolTable;
|
|
Obj.CoffFileHeader.NumberOfSymbols = NumRawSymbols;
|
|
FileSize += SymTabSize + StrTabSize;
|
|
FileSize = alignTo(FileSize, FileAlignment);
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
void COFFWriter::writeHeaders(bool IsBigObj) {
|
|
uint8_t *Ptr = Buf.getBufferStart();
|
|
if (Obj.IsPE) {
|
|
memcpy(Ptr, &Obj.DosHeader, sizeof(Obj.DosHeader));
|
|
Ptr += sizeof(Obj.DosHeader);
|
|
memcpy(Ptr, Obj.DosStub.data(), Obj.DosStub.size());
|
|
Ptr += Obj.DosStub.size();
|
|
memcpy(Ptr, PEMagic, sizeof(PEMagic));
|
|
Ptr += sizeof(PEMagic);
|
|
}
|
|
if (!IsBigObj) {
|
|
memcpy(Ptr, &Obj.CoffFileHeader, sizeof(Obj.CoffFileHeader));
|
|
Ptr += sizeof(Obj.CoffFileHeader);
|
|
} else {
|
|
// Generate a coff_bigobj_file_header, filling it in with the values
|
|
// from Obj.CoffFileHeader. All extra fields that don't exist in
|
|
// coff_file_header can be set to hardcoded values.
|
|
coff_bigobj_file_header BigObjHeader;
|
|
BigObjHeader.Sig1 = IMAGE_FILE_MACHINE_UNKNOWN;
|
|
BigObjHeader.Sig2 = 0xffff;
|
|
BigObjHeader.Version = BigObjHeader::MinBigObjectVersion;
|
|
BigObjHeader.Machine = Obj.CoffFileHeader.Machine;
|
|
BigObjHeader.TimeDateStamp = Obj.CoffFileHeader.TimeDateStamp;
|
|
memcpy(BigObjHeader.UUID, BigObjMagic, sizeof(BigObjMagic));
|
|
BigObjHeader.unused1 = 0;
|
|
BigObjHeader.unused2 = 0;
|
|
BigObjHeader.unused3 = 0;
|
|
BigObjHeader.unused4 = 0;
|
|
// The value in Obj.CoffFileHeader.NumberOfSections is truncated, thus
|
|
// get the original one instead.
|
|
BigObjHeader.NumberOfSections = Obj.getSections().size();
|
|
BigObjHeader.PointerToSymbolTable = Obj.CoffFileHeader.PointerToSymbolTable;
|
|
BigObjHeader.NumberOfSymbols = Obj.CoffFileHeader.NumberOfSymbols;
|
|
|
|
memcpy(Ptr, &BigObjHeader, sizeof(BigObjHeader));
|
|
Ptr += sizeof(BigObjHeader);
|
|
}
|
|
if (Obj.IsPE) {
|
|
if (Obj.Is64) {
|
|
memcpy(Ptr, &Obj.PeHeader, sizeof(Obj.PeHeader));
|
|
Ptr += sizeof(Obj.PeHeader);
|
|
} else {
|
|
pe32_header PeHeader;
|
|
copyPeHeader(PeHeader, Obj.PeHeader);
|
|
// The pe32plus_header (stored in Object) lacks the BaseOfData field.
|
|
PeHeader.BaseOfData = Obj.BaseOfData;
|
|
|
|
memcpy(Ptr, &PeHeader, sizeof(PeHeader));
|
|
Ptr += sizeof(PeHeader);
|
|
}
|
|
for (const auto &DD : Obj.DataDirectories) {
|
|
memcpy(Ptr, &DD, sizeof(DD));
|
|
Ptr += sizeof(DD);
|
|
}
|
|
}
|
|
for (const auto &S : Obj.getSections()) {
|
|
memcpy(Ptr, &S.Header, sizeof(S.Header));
|
|
Ptr += sizeof(S.Header);
|
|
}
|
|
}
|
|
|
|
void COFFWriter::writeSections() {
|
|
for (const auto &S : Obj.getSections()) {
|
|
uint8_t *Ptr = Buf.getBufferStart() + S.Header.PointerToRawData;
|
|
ArrayRef<uint8_t> Contents = S.getContents();
|
|
std::copy(Contents.begin(), Contents.end(), Ptr);
|
|
|
|
// For executable sections, pad the remainder of the raw data size with
|
|
// 0xcc, which is int3 on x86.
|
|
if ((S.Header.Characteristics & IMAGE_SCN_CNT_CODE) &&
|
|
S.Header.SizeOfRawData > Contents.size())
|
|
memset(Ptr + Contents.size(), 0xcc,
|
|
S.Header.SizeOfRawData - Contents.size());
|
|
|
|
Ptr += S.Header.SizeOfRawData;
|
|
|
|
if (S.Relocs.size() >= 0xffff) {
|
|
object::coff_relocation R;
|
|
R.VirtualAddress = S.Relocs.size() + 1;
|
|
R.SymbolTableIndex = 0;
|
|
R.Type = 0;
|
|
memcpy(Ptr, &R, sizeof(R));
|
|
Ptr += sizeof(R);
|
|
}
|
|
for (const auto &R : S.Relocs) {
|
|
memcpy(Ptr, &R.Reloc, sizeof(R.Reloc));
|
|
Ptr += sizeof(R.Reloc);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <class SymbolTy> void COFFWriter::writeSymbolStringTables() {
|
|
uint8_t *Ptr = Buf.getBufferStart() + Obj.CoffFileHeader.PointerToSymbolTable;
|
|
for (const auto &S : Obj.getSymbols()) {
|
|
// Convert symbols back to the right size, from coff_symbol32.
|
|
copySymbol<SymbolTy, coff_symbol32>(*reinterpret_cast<SymbolTy *>(Ptr),
|
|
S.Sym);
|
|
Ptr += sizeof(SymbolTy);
|
|
if (!S.AuxFile.empty()) {
|
|
// For file symbols, just write the string into the aux symbol slots,
|
|
// assuming that the unwritten parts are initialized to zero in the memory
|
|
// mapped file.
|
|
std::copy(S.AuxFile.begin(), S.AuxFile.end(), Ptr);
|
|
Ptr += S.Sym.NumberOfAuxSymbols * sizeof(SymbolTy);
|
|
} else {
|
|
// For other auxillary symbols, write their opaque payload into one symbol
|
|
// table slot each. For big object files, the symbols are larger than the
|
|
// opaque auxillary symbol struct and we leave padding at the end of each
|
|
// entry.
|
|
for (const AuxSymbol &AuxSym : S.AuxData) {
|
|
ArrayRef<uint8_t> Ref = AuxSym.getRef();
|
|
std::copy(Ref.begin(), Ref.end(), Ptr);
|
|
Ptr += sizeof(SymbolTy);
|
|
}
|
|
}
|
|
}
|
|
if (StrTabBuilder.getSize() > 4 || !Obj.IsPE) {
|
|
// Always write a string table in object files, even an empty one.
|
|
StrTabBuilder.write(Ptr);
|
|
Ptr += StrTabBuilder.getSize();
|
|
}
|
|
}
|
|
|
|
Error COFFWriter::write(bool IsBigObj) {
|
|
if (Error E = finalize(IsBigObj))
|
|
return E;
|
|
|
|
if (Error E = Buf.allocate(FileSize))
|
|
return E;
|
|
|
|
writeHeaders(IsBigObj);
|
|
writeSections();
|
|
if (IsBigObj)
|
|
writeSymbolStringTables<coff_symbol32>();
|
|
else
|
|
writeSymbolStringTables<coff_symbol16>();
|
|
|
|
if (Obj.IsPE)
|
|
if (Error E = patchDebugDirectory())
|
|
return E;
|
|
|
|
return Buf.commit();
|
|
}
|
|
|
|
Expected<uint32_t> COFFWriter::virtualAddressToFileAddress(uint32_t RVA) {
|
|
for (const auto &S : Obj.getSections()) {
|
|
if (RVA >= S.Header.VirtualAddress &&
|
|
RVA < S.Header.VirtualAddress + S.Header.SizeOfRawData)
|
|
return S.Header.PointerToRawData + RVA - S.Header.VirtualAddress;
|
|
}
|
|
return createStringError(object_error::parse_failed,
|
|
"debug directory payload not found");
|
|
}
|
|
|
|
// Locate which sections contain the debug directories, iterate over all
|
|
// the debug_directory structs in there, and set the PointerToRawData field
|
|
// in all of them, according to their new physical location in the file.
|
|
Error COFFWriter::patchDebugDirectory() {
|
|
if (Obj.DataDirectories.size() < DEBUG_DIRECTORY)
|
|
return Error::success();
|
|
const data_directory *Dir = &Obj.DataDirectories[DEBUG_DIRECTORY];
|
|
if (Dir->Size <= 0)
|
|
return Error::success();
|
|
for (const auto &S : Obj.getSections()) {
|
|
if (Dir->RelativeVirtualAddress >= S.Header.VirtualAddress &&
|
|
Dir->RelativeVirtualAddress <
|
|
S.Header.VirtualAddress + S.Header.SizeOfRawData) {
|
|
if (Dir->RelativeVirtualAddress + Dir->Size >
|
|
S.Header.VirtualAddress + S.Header.SizeOfRawData)
|
|
return createStringError(object_error::parse_failed,
|
|
"debug directory extends past end of section");
|
|
|
|
size_t Offset = Dir->RelativeVirtualAddress - S.Header.VirtualAddress;
|
|
uint8_t *Ptr = Buf.getBufferStart() + S.Header.PointerToRawData + Offset;
|
|
uint8_t *End = Ptr + Dir->Size;
|
|
while (Ptr < End) {
|
|
debug_directory *Debug = reinterpret_cast<debug_directory *>(Ptr);
|
|
if (!Debug->AddressOfRawData)
|
|
return createStringError(object_error::parse_failed,
|
|
"debug directory payload outside of "
|
|
"mapped sections not supported");
|
|
if (Expected<uint32_t> FilePosOrErr =
|
|
virtualAddressToFileAddress(Debug->AddressOfRawData))
|
|
Debug->PointerToRawData = *FilePosOrErr;
|
|
else
|
|
return FilePosOrErr.takeError();
|
|
Ptr += sizeof(debug_directory);
|
|
Offset += sizeof(debug_directory);
|
|
}
|
|
// Debug directory found and patched, all done.
|
|
return Error::success();
|
|
}
|
|
}
|
|
return createStringError(object_error::parse_failed,
|
|
"debug directory not found");
|
|
}
|
|
|
|
Error COFFWriter::write() {
|
|
bool IsBigObj = Obj.getSections().size() > MaxNumberOfSections16;
|
|
if (IsBigObj && Obj.IsPE)
|
|
return createStringError(object_error::parse_failed,
|
|
"too many sections for executable");
|
|
return write(IsBigObj);
|
|
}
|
|
|
|
} // end namespace coff
|
|
} // end namespace objcopy
|
|
} // end namespace llvm
|