mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-05-02 10:56:07 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/llvm/lib/ObjCopy/COFF/COFFWriter.cpp
Martin Storsjö 30d5b755ea [llvm-objcopy] [COFF] Always set PointerToRawData when writing a COFF file 
If we don't want to set PointerToRawData, for an empty section,
we do must set it to zero explicitly. Some object file generators
do set it to zero for empty sections, while others set a nonzero
value pointing at the end of the previous section.

If the value was nonzero on input, we need to update it - either
setting it to zero, or to a valid offset in the output file (not
out of bounds)

This fixes https://github.com/mstorsjo/llvm-mingw/issues/313.

Testing this is tricky, because we can't use yaml2obj, since that
doesn't produce object files with nonzero PointerToRawData for
empty sections. We can use llvm-mc to assemble a small file
(assuming that LLVM's MC layer keeps this behaviour), or bundle
a small binary object file. I opted for using llvm-mc for now here
(with a test that it actually does keep this property), but I don't
mind changing it to a canned object file to make the test less brittle.

Differential Revision: https://reviews.llvm.org/D138783
2022-11-28 22:40:00 +02:00

469 lines
17 KiB
C++
Raw Blame History

//===- COFFWriter.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 "COFFWriter.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/Errc.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;
else
S.Header.PointerToRawData = 0;
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;
}
}
Expected<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) {
// Short names can go in the field directly.
memcpy(S.Header.Name, S.Name.data(), S.Name.size());
} else {
// Offset of the section name in the string table.
size_t Offset = StrTabBuilder.getOffset(S.Name);
if (!COFF::encodeSectionName(S.Header.Name, Offset))
return createStringError(object_error::invalid_section_index,
"COFF string table is greater than 64GB, "
"unable to encode section name offset");
}
}
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;
}
Expected<size_t> StrTabSizeOrErr = finalizeStringTable();
if (!StrTabSizeOrErr)
return StrTabSizeOrErr.takeError();
size_t StrTabSize = *StrTabSizeOrErr;
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 = reinterpret_cast<uint8_t *>(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 = reinterpret_cast<uint8_t *>(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 = reinterpret_cast<uint8_t *>(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;
Buf = WritableMemoryBuffer::getNewMemBuffer(FileSize);
if (!Buf)
return createStringError(llvm::errc::not_enough_memory,
"failed to allocate memory buffer of " +
Twine::utohexstr(FileSize) + " bytes.");
writeHeaders(IsBigObj);
writeSections();
if (IsBigObj)
writeSymbolStringTables<coff_symbol32>();
else
writeSymbolStringTables<coff_symbol16>();
if (Obj.IsPE)
if (Error E = patchDebugDirectory())
return E;
// TODO: Implement direct writing to the output stream (without intermediate
// memory buffer Buf).
Out.write(Buf->getBufferStart(), Buf->getBufferSize());
return Error::success();
}
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 = reinterpret_cast<uint8_t *>(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->PointerToRawData) {
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
Reference in New Issue View Git Blame Copy Permalink