RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity
5b24282a50
llvm-mirror/lib/Object/WindowsResource.cpp
serge-sans-paille c586828d3f Prevent gcc from issuing a warning upon coffnamecpy 
This is a follow up to d1262a6e9, more explicit to cope with GCC smartness.

Differential Revision: https://reviews.llvm.org/D74666
2020-02-18 16:13:59 +01:00

1016 lines
38 KiB
C++
Raw Blame History

//===-- WindowsResource.cpp -------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file implements the .res file class.
//
//===----------------------------------------------------------------------===//
#include "llvm/Object/WindowsResource.h"
#include "llvm/Object/COFF.h"
#include "llvm/Support/FileOutputBuffer.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/ScopedPrinter.h"
#include <ctime>
#include <queue>
#include <system_error>
using namespace llvm;
using namespace object;
namespace llvm {
namespace object {
#define RETURN_IF_ERROR(X) \
if (auto EC = X) \
return EC;
#define UNWRAP_REF_OR_RETURN(Name, Expr) \
auto Name##OrErr = Expr; \
if (!Name##OrErr) \
return Name##OrErr.takeError(); \
const auto &Name = *Name##OrErr;
#define UNWRAP_OR_RETURN(Name, Expr) \
auto Name##OrErr = Expr; \
if (!Name##OrErr) \
return Name##OrErr.takeError(); \
auto Name = *Name##OrErr;
const uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
// COFF files seem to be inconsistent with alignment between sections, just use
// 8-byte because it makes everyone happy.
const uint32_t SECTION_ALIGNMENT = sizeof(uint64_t);
WindowsResource::WindowsResource(MemoryBufferRef Source)
: Binary(Binary::ID_WinRes, Source) {
size_t LeadingSize = WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE;
BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize),
support::little);
}
// static
Expected<std::unique_ptr<WindowsResource>>
WindowsResource::createWindowsResource(MemoryBufferRef Source) {
if (Source.getBufferSize() < WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE)
return make_error<GenericBinaryError>(
Source.getBufferIdentifier() + ": too small to be a resource file",
object_error::invalid_file_type);
std::unique_ptr<WindowsResource> Ret(new WindowsResource(Source));
return std::move(Ret);
}
Expected<ResourceEntryRef> WindowsResource::getHeadEntry() {
if (BBS.getLength() < sizeof(WinResHeaderPrefix) + sizeof(WinResHeaderSuffix))
return make_error<EmptyResError>(getFileName() + " contains no entries",
object_error::unexpected_eof);
return ResourceEntryRef::create(BinaryStreamRef(BBS), this);
}
ResourceEntryRef::ResourceEntryRef(BinaryStreamRef Ref,
const WindowsResource *Owner)
: Reader(Ref), Owner(Owner) {}
Expected<ResourceEntryRef>
ResourceEntryRef::create(BinaryStreamRef BSR, const WindowsResource *Owner) {
auto Ref = ResourceEntryRef(BSR, Owner);
if (auto E = Ref.loadNext())
return std::move(E);
return Ref;
}
Error ResourceEntryRef::moveNext(bool &End) {
// Reached end of all the entries.
if (Reader.bytesRemaining() == 0) {
End = true;
return Error::success();
}
RETURN_IF_ERROR(loadNext());
return Error::success();
}
static Error readStringOrId(BinaryStreamReader &Reader, uint16_t &ID,
ArrayRef<UTF16> &Str, bool &IsString) {
uint16_t IDFlag;
RETURN_IF_ERROR(Reader.readInteger(IDFlag));
IsString = IDFlag != 0xffff;
if (IsString) {
Reader.setOffset(
Reader.getOffset() -
sizeof(uint16_t)); // Re-read the bytes which we used to check the flag.
RETURN_IF_ERROR(Reader.readWideString(Str));
} else
RETURN_IF_ERROR(Reader.readInteger(ID));
return Error::success();
}
Error ResourceEntryRef::loadNext() {
const WinResHeaderPrefix *Prefix;
RETURN_IF_ERROR(Reader.readObject(Prefix));
if (Prefix->HeaderSize < MIN_HEADER_SIZE)
return make_error<GenericBinaryError>(Owner->getFileName() +
": header size too small",
object_error::parse_failed);
RETURN_IF_ERROR(readStringOrId(Reader, TypeID, Type, IsStringType));
RETURN_IF_ERROR(readStringOrId(Reader, NameID, Name, IsStringName));
RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_HEADER_ALIGNMENT));
RETURN_IF_ERROR(Reader.readObject(Suffix));
RETURN_IF_ERROR(Reader.readArray(Data, Prefix->DataSize));
RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_DATA_ALIGNMENT));
return Error::success();
}
WindowsResourceParser::WindowsResourceParser(bool MinGW)
: Root(false), MinGW(MinGW) {}
void printResourceTypeName(uint16_t TypeID, raw_ostream &OS) {
switch (TypeID) {
case 1: OS << "CURSOR (ID 1)"; break;
case 2: OS << "BITMAP (ID 2)"; break;
case 3: OS << "ICON (ID 3)"; break;
case 4: OS << "MENU (ID 4)"; break;
case 5: OS << "DIALOG (ID 5)"; break;
case 6: OS << "STRINGTABLE (ID 6)"; break;
case 7: OS << "FONTDIR (ID 7)"; break;
case 8: OS << "FONT (ID 8)"; break;
case 9: OS << "ACCELERATOR (ID 9)"; break;
case 10: OS << "RCDATA (ID 10)"; break;
case 11: OS << "MESSAGETABLE (ID 11)"; break;
case 12: OS << "GROUP_CURSOR (ID 12)"; break;
case 14: OS << "GROUP_ICON (ID 14)"; break;
case 16: OS << "VERSIONINFO (ID 16)"; break;
case 17: OS << "DLGINCLUDE (ID 17)"; break;
case 19: OS << "PLUGPLAY (ID 19)"; break;
case 20: OS << "VXD (ID 20)"; break;
case 21: OS << "ANICURSOR (ID 21)"; break;
case 22: OS << "ANIICON (ID 22)"; break;
case 23: OS << "HTML (ID 23)"; break;
case 24: OS << "MANIFEST (ID 24)"; break;
default: OS << "ID " << TypeID; break;
}
}
static bool convertUTF16LEToUTF8String(ArrayRef<UTF16> Src, std::string &Out) {
if (!sys::IsBigEndianHost)
return convertUTF16ToUTF8String(Src, Out);
std::vector<UTF16> EndianCorrectedSrc;
EndianCorrectedSrc.resize(Src.size() + 1);
llvm::copy(Src, EndianCorrectedSrc.begin() + 1);
EndianCorrectedSrc[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
return convertUTF16ToUTF8String(makeArrayRef(EndianCorrectedSrc), Out);
}
static std::string makeDuplicateResourceError(
const ResourceEntryRef &Entry, StringRef File1, StringRef File2) {
std::string Ret;
raw_string_ostream OS(Ret);
OS << "duplicate resource:";
OS << " type ";
if (Entry.checkTypeString()) {
std::string UTF8;
if (!convertUTF16LEToUTF8String(Entry.getTypeString(), UTF8))
UTF8 = "(failed conversion from UTF16)";
OS << '\"' << UTF8 << '\"';
} else
printResourceTypeName(Entry.getTypeID(), OS);
OS << "/name ";
if (Entry.checkNameString()) {
std::string UTF8;
if (!convertUTF16LEToUTF8String(Entry.getNameString(), UTF8))
UTF8 = "(failed conversion from UTF16)";
OS << '\"' << UTF8 << '\"';
} else {
OS << "ID " << Entry.getNameID();
}
OS << "/language " << Entry.getLanguage() << ", in " << File1 << " and in "
<< File2;
return OS.str();
}
static void printStringOrID(const WindowsResourceParser::StringOrID &S,
raw_string_ostream &OS, bool IsType, bool IsID) {
if (S.IsString) {
std::string UTF8;
if (!convertUTF16LEToUTF8String(S.String, UTF8))
UTF8 = "(failed conversion from UTF16)";
OS << '\"' << UTF8 << '\"';
} else if (IsType)
printResourceTypeName(S.ID, OS);
else if (IsID)
OS << "ID " << S.ID;
else
OS << S.ID;
}
static std::string makeDuplicateResourceError(
const std::vector<WindowsResourceParser::StringOrID> &Context,
StringRef File1, StringRef File2) {
std::string Ret;
raw_string_ostream OS(Ret);
OS << "duplicate resource:";
if (Context.size() >= 1) {
OS << " type ";
printStringOrID(Context[0], OS, /* IsType */ true, /* IsID */ true);
}
if (Context.size() >= 2) {
OS << "/name ";
printStringOrID(Context[1], OS, /* IsType */ false, /* IsID */ true);
}
if (Context.size() >= 3) {
OS << "/language ";
printStringOrID(Context[2], OS, /* IsType */ false, /* IsID */ false);
}
OS << ", in " << File1 << " and in " << File2;
return OS.str();
}
// MinGW specific. Remove default manifests (with language zero) if there are
// other manifests present, and report an error if there are more than one
// manifest with a non-zero language code.
// GCC has the concept of a default manifest resource object, which gets
// linked in implicitly if present. This default manifest has got language
// id zero, and should be dropped silently if there's another manifest present.
// If the user resources surprisignly had a manifest with language id zero,
// we should also ignore the duplicate default manifest.
void WindowsResourceParser::cleanUpManifests(
std::vector<std::string> &Duplicates) {
auto TypeIt = Root.IDChildren.find(/* RT_MANIFEST */ 24);
if (TypeIt == Root.IDChildren.end())
return;
TreeNode *TypeNode = TypeIt->second.get();
auto NameIt =
TypeNode->IDChildren.find(/* CREATEPROCESS_MANIFEST_RESOURCE_ID */ 1);
if (NameIt == TypeNode->IDChildren.end())
return;
TreeNode *NameNode = NameIt->second.get();
if (NameNode->IDChildren.size() <= 1)
return; // None or one manifest present, all good.
// If we have more than one manifest, drop the language zero one if present,
// and check again.
auto LangZeroIt = NameNode->IDChildren.find(0);
if (LangZeroIt != NameNode->IDChildren.end() &&
LangZeroIt->second->IsDataNode) {
uint32_t RemovedIndex = LangZeroIt->second->DataIndex;
NameNode->IDChildren.erase(LangZeroIt);
Data.erase(Data.begin() + RemovedIndex);
Root.shiftDataIndexDown(RemovedIndex);
// If we're now down to one manifest, all is good.
if (NameNode->IDChildren.size() <= 1)
return;
}
// More than one non-language-zero manifest
auto FirstIt = NameNode->IDChildren.begin();
uint32_t FirstLang = FirstIt->first;
TreeNode *FirstNode = FirstIt->second.get();
auto LastIt = NameNode->IDChildren.rbegin();
uint32_t LastLang = LastIt->first;
TreeNode *LastNode = LastIt->second.get();
Duplicates.push_back(
("duplicate non-default manifests with languages " + Twine(FirstLang) +
" in " + InputFilenames[FirstNode->Origin] + " and " + Twine(LastLang) +
" in " + InputFilenames[LastNode->Origin])
.str());
}
// Ignore duplicates of manifests with language zero (the default manifest),
// in case the user has provided a manifest with that language id. See
// the function comment above for context. Only returns true if MinGW is set
// to true.
bool WindowsResourceParser::shouldIgnoreDuplicate(
const ResourceEntryRef &Entry) const {
return MinGW && !Entry.checkTypeString() &&
Entry.getTypeID() == /* RT_MANIFEST */ 24 &&
!Entry.checkNameString() &&
Entry.getNameID() == /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ 1 &&
Entry.getLanguage() == 0;
}
bool WindowsResourceParser::shouldIgnoreDuplicate(
const std::vector<StringOrID> &Context) const {
return MinGW && Context.size() == 3 && !Context[0].IsString &&
Context[0].ID == /* RT_MANIFEST */ 24 && !Context[1].IsString &&
Context[1].ID == /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ 1 &&
!Context[2].IsString && Context[2].ID == 0;
}
Error WindowsResourceParser::parse(WindowsResource *WR,
std::vector<std::string> &Duplicates) {
auto EntryOrErr = WR->getHeadEntry();
if (!EntryOrErr) {
auto E = EntryOrErr.takeError();
if (E.isA<EmptyResError>()) {
// Check if the .res file contains no entries. In this case we don't have
// to throw an error but can rather just return without parsing anything.
// This applies for files which have a valid PE header magic and the
// mandatory empty null resource entry. Files which do not fit this
// criteria would have already been filtered out by
// WindowsResource::createWindowsResource().
consumeError(std::move(E));
return Error::success();
}
return E;
}
ResourceEntryRef Entry = EntryOrErr.get();
uint32_t Origin = InputFilenames.size();
InputFilenames.push_back(std::string(WR->getFileName()));
bool End = false;
while (!End) {
TreeNode *Node;
bool IsNewNode = Root.addEntry(Entry, Origin, Data, StringTable, Node);
if (!IsNewNode) {
if (!shouldIgnoreDuplicate(Entry))
Duplicates.push_back(makeDuplicateResourceError(
Entry, InputFilenames[Node->Origin], WR->getFileName()));
}
RETURN_IF_ERROR(Entry.moveNext(End));
}
return Error::success();
}
Error WindowsResourceParser::parse(ResourceSectionRef &RSR, StringRef Filename,
std::vector<std::string> &Duplicates) {
UNWRAP_REF_OR_RETURN(BaseTable, RSR.getBaseTable());
uint32_t Origin = InputFilenames.size();
InputFilenames.push_back(std::string(Filename));
std::vector<StringOrID> Context;
return addChildren(Root, RSR, BaseTable, Origin, Context, Duplicates);
}
void WindowsResourceParser::printTree(raw_ostream &OS) const {
ScopedPrinter Writer(OS);
Root.print(Writer, "Resource Tree");
}
bool WindowsResourceParser::TreeNode::addEntry(
const ResourceEntryRef &Entry, uint32_t Origin,
std::vector<std::vector<uint8_t>> &Data,
std::vector<std::vector<UTF16>> &StringTable, TreeNode *&Result) {
TreeNode &TypeNode = addTypeNode(Entry, StringTable);
TreeNode &NameNode = TypeNode.addNameNode(Entry, StringTable);
return NameNode.addLanguageNode(Entry, Origin, Data, Result);
}
Error WindowsResourceParser::addChildren(TreeNode &Node,
ResourceSectionRef &RSR,
const coff_resource_dir_table &Table,
uint32_t Origin,
std::vector<StringOrID> &Context,
std::vector<std::string> &Duplicates) {
for (int i = 0; i < Table.NumberOfNameEntries + Table.NumberOfIDEntries;
i++) {
UNWRAP_REF_OR_RETURN(Entry, RSR.getTableEntry(Table, i));
TreeNode *Child;
if (Entry.Offset.isSubDir()) {
// Create a new subdirectory and recurse
if (i < Table.NumberOfNameEntries) {
UNWRAP_OR_RETURN(NameString, RSR.getEntryNameString(Entry));
Child = &Node.addNameChild(NameString, StringTable);
Context.push_back(StringOrID(NameString));
} else {
Child = &Node.addIDChild(Entry.Identifier.ID);
Context.push_back(StringOrID(Entry.Identifier.ID));
}
UNWRAP_REF_OR_RETURN(NextTable, RSR.getEntrySubDir(Entry));
Error E =
addChildren(*Child, RSR, NextTable, Origin, Context, Duplicates);
if (E)
return E;
Context.pop_back();
} else {
// Data leaves are supposed to have a numeric ID as identifier (language).
if (Table.NumberOfNameEntries > 0)
return createStringError(object_error::parse_failed,
"unexpected string key for data object");
// Try adding a data leaf
UNWRAP_REF_OR_RETURN(DataEntry, RSR.getEntryData(Entry));
TreeNode *Child;
Context.push_back(StringOrID(Entry.Identifier.ID));
bool Added = Node.addDataChild(Entry.Identifier.ID, Table.MajorVersion,
Table.MinorVersion, Table.Characteristics,
Origin, Data.size(), Child);
if (Added) {
UNWRAP_OR_RETURN(Contents, RSR.getContents(DataEntry));
Data.push_back(ArrayRef<uint8_t>(
reinterpret_cast<const uint8_t *>(Contents.data()),
Contents.size()));
} else {
if (!shouldIgnoreDuplicate(Context))
Duplicates.push_back(makeDuplicateResourceError(
Context, InputFilenames[Child->Origin], InputFilenames.back()));
}
Context.pop_back();
}
}
return Error::success();
}
WindowsResourceParser::TreeNode::TreeNode(uint32_t StringIndex)
: StringIndex(StringIndex) {}
WindowsResourceParser::TreeNode::TreeNode(uint16_t MajorVersion,
uint16_t MinorVersion,
uint32_t Characteristics,
uint32_t Origin, uint32_t DataIndex)
: IsDataNode(true), DataIndex(DataIndex), MajorVersion(MajorVersion),
MinorVersion(MinorVersion), Characteristics(Characteristics),
Origin(Origin) {}
std::unique_ptr<WindowsResourceParser::TreeNode>
WindowsResourceParser::TreeNode::createStringNode(uint32_t Index) {
return std::unique_ptr<TreeNode>(new TreeNode(Index));
}
std::unique_ptr<WindowsResourceParser::TreeNode>
WindowsResourceParser::TreeNode::createIDNode() {
return std::unique_ptr<TreeNode>(new TreeNode(0));
}
std::unique_ptr<WindowsResourceParser::TreeNode>
WindowsResourceParser::TreeNode::createDataNode(uint16_t MajorVersion,
uint16_t MinorVersion,
uint32_t Characteristics,
uint32_t Origin,
uint32_t DataIndex) {
return std::unique_ptr<TreeNode>(new TreeNode(
MajorVersion, MinorVersion, Characteristics, Origin, DataIndex));
}
WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addTypeNode(
const ResourceEntryRef &Entry,
std::vector<std::vector<UTF16>> &StringTable) {
if (Entry.checkTypeString())
return addNameChild(Entry.getTypeString(), StringTable);
else
return addIDChild(Entry.getTypeID());
}
WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addNameNode(
const ResourceEntryRef &Entry,
std::vector<std::vector<UTF16>> &StringTable) {
if (Entry.checkNameString())
return addNameChild(Entry.getNameString(), StringTable);
else
return addIDChild(Entry.getNameID());
}
bool WindowsResourceParser::TreeNode::addLanguageNode(
const ResourceEntryRef &Entry, uint32_t Origin,
std::vector<std::vector<uint8_t>> &Data, TreeNode *&Result) {
bool Added = addDataChild(Entry.getLanguage(), Entry.getMajorVersion(),
Entry.getMinorVersion(), Entry.getCharacteristics(),
Origin, Data.size(), Result);
if (Added)
Data.push_back(Entry.getData());
return Added;
}
bool WindowsResourceParser::TreeNode::addDataChild(
uint32_t ID, uint16_t MajorVersion, uint16_t MinorVersion,
uint32_t Characteristics, uint32_t Origin, uint32_t DataIndex,
TreeNode *&Result) {
auto NewChild = createDataNode(MajorVersion, MinorVersion, Characteristics,
Origin, DataIndex);
auto ElementInserted = IDChildren.emplace(ID, std::move(NewChild));
Result = ElementInserted.first->second.get();
return ElementInserted.second;
}
WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addIDChild(
uint32_t ID) {
auto Child = IDChildren.find(ID);
if (Child == IDChildren.end()) {
auto NewChild = createIDNode();
WindowsResourceParser::TreeNode &Node = *NewChild;
IDChildren.emplace(ID, std::move(NewChild));
return Node;
} else
return *(Child->second);
}
WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addNameChild(
ArrayRef<UTF16> NameRef, std::vector<std::vector<UTF16>> &StringTable) {
std::string NameString;
convertUTF16LEToUTF8String(NameRef, NameString);
auto Child = StringChildren.find(NameString);
if (Child == StringChildren.end()) {
auto NewChild = createStringNode(StringTable.size());
StringTable.push_back(NameRef);
WindowsResourceParser::TreeNode &Node = *NewChild;
StringChildren.emplace(NameString, std::move(NewChild));
return Node;
} else
return *(Child->second);
}
void WindowsResourceParser::TreeNode::print(ScopedPrinter &Writer,
StringRef Name) const {
ListScope NodeScope(Writer, Name);
for (auto const &Child : StringChildren) {
Child.second->print(Writer, Child.first);
}
for (auto const &Child : IDChildren) {
Child.second->print(Writer, to_string(Child.first));
}
}
// This function returns the size of the entire resource tree, including
// directory tables, directory entries, and data entries. It does not include
// the directory strings or the relocations of the .rsrc section.
uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
uint32_t Size = (IDChildren.size() + StringChildren.size()) *
sizeof(coff_resource_dir_entry);
// Reached a node pointing to a data entry.
if (IsDataNode) {
Size += sizeof(coff_resource_data_entry);
return Size;
}
// If the node does not point to data, it must have a directory table pointing
// to other nodes.
Size += sizeof(coff_resource_dir_table);
for (auto const &Child : StringChildren) {
Size += Child.second->getTreeSize();
}
for (auto const &Child : IDChildren) {
Size += Child.second->getTreeSize();
}
return Size;
}
// Shift DataIndex of all data children with an Index greater or equal to the
// given one, to fill a gap from removing an entry from the Data vector.
void WindowsResourceParser::TreeNode::shiftDataIndexDown(uint32_t Index) {
if (IsDataNode && DataIndex >= Index) {
DataIndex--;
} else {
for (auto &Child : IDChildren)
Child.second->shiftDataIndexDown(Index);
for (auto &Child : StringChildren)
Child.second->shiftDataIndexDown(Index);
}
}
class WindowsResourceCOFFWriter {
public:
WindowsResourceCOFFWriter(COFF::MachineTypes MachineType,
const WindowsResourceParser &Parser, Error &E);
std::unique_ptr<MemoryBuffer> write(uint32_t TimeDateStamp);
private:
void performFileLayout();
void performSectionOneLayout();
void performSectionTwoLayout();
void writeCOFFHeader(uint32_t TimeDateStamp);
void writeFirstSectionHeader();
void writeSecondSectionHeader();
void writeFirstSection();
void writeSecondSection();
void writeSymbolTable();
void writeStringTable();
void writeDirectoryTree();
void writeDirectoryStringTable();
void writeFirstSectionRelocations();
std::unique_ptr<WritableMemoryBuffer> OutputBuffer;
char *BufferStart;
uint64_t CurrentOffset = 0;
COFF::MachineTypes MachineType;
const WindowsResourceParser::TreeNode &Resources;
const ArrayRef<std::vector<uint8_t>> Data;
uint64_t FileSize;
uint32_t SymbolTableOffset;
uint32_t SectionOneSize;
uint32_t SectionOneOffset;
uint32_t SectionOneRelocations;
uint32_t SectionTwoSize;
uint32_t SectionTwoOffset;
const ArrayRef<std::vector<UTF16>> StringTable;
std::vector<uint32_t> StringTableOffsets;
std::vector<uint32_t> DataOffsets;
std::vector<uint32_t> RelocationAddresses;
};
WindowsResourceCOFFWriter::WindowsResourceCOFFWriter(
COFF::MachineTypes MachineType, const WindowsResourceParser &Parser,
Error &E)
: MachineType(MachineType), Resources(Parser.getTree()),
Data(Parser.getData()), StringTable(Parser.getStringTable()) {
performFileLayout();
OutputBuffer = WritableMemoryBuffer::getNewMemBuffer(
FileSize, "internal .obj file created from .res files");
}
void WindowsResourceCOFFWriter::performFileLayout() {
// Add size of COFF header.
FileSize = COFF::Header16Size;
// one .rsrc section header for directory tree, another for resource data.
FileSize += 2 * COFF::SectionSize;
performSectionOneLayout();
performSectionTwoLayout();
// We have reached the address of the symbol table.
SymbolTableOffset = FileSize;
FileSize += COFF::Symbol16Size; // size of the @feat.00 symbol.
FileSize += 4 * COFF::Symbol16Size; // symbol + aux for each section.
FileSize += Data.size() * COFF::Symbol16Size; // 1 symbol per resource.
FileSize += 4; // four null bytes for the string table.
}
void WindowsResourceCOFFWriter::performSectionOneLayout() {
SectionOneOffset = FileSize;
SectionOneSize = Resources.getTreeSize();
uint32_t CurrentStringOffset = SectionOneSize;
uint32_t TotalStringTableSize = 0;
for (auto const &String : StringTable) {
StringTableOffsets.push_back(CurrentStringOffset);
uint32_t StringSize = String.size() * sizeof(UTF16) + sizeof(uint16_t);
CurrentStringOffset += StringSize;
TotalStringTableSize += StringSize;
}
SectionOneSize += alignTo(TotalStringTableSize, sizeof(uint32_t));
// account for the relocations of section one.
SectionOneRelocations = FileSize + SectionOneSize;
FileSize += SectionOneSize;
FileSize +=
Data.size() * COFF::RelocationSize; // one relocation for each resource.
FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
}
void WindowsResourceCOFFWriter::performSectionTwoLayout() {
// add size of .rsrc$2 section, which contains all resource data on 8-byte
// alignment.
SectionTwoOffset = FileSize;
SectionTwoSize = 0;
for (auto const &Entry : Data) {
DataOffsets.push_back(SectionTwoSize);
SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
}
FileSize += SectionTwoSize;
FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
}
std::unique_ptr<MemoryBuffer>
WindowsResourceCOFFWriter::write(uint32_t TimeDateStamp) {
BufferStart = OutputBuffer->getBufferStart();
writeCOFFHeader(TimeDateStamp);
writeFirstSectionHeader();
writeSecondSectionHeader();
writeFirstSection();
writeSecondSection();
writeSymbolTable();
writeStringTable();
return std::move(OutputBuffer);
}
// According to COFF specification, if the Src has a size equal to Dest,
// it's okay to *not* copy the trailing zero.
static void coffnamecpy(char (&Dest)[COFF::NameSize], StringRef Src) {
assert(Src.size() <= COFF::NameSize &&
"Src is larger than COFF::NameSize");
assert((Src.size() == COFF::NameSize || Dest[Src.size()] == '\0') &&
"Dest not zeroed upon initialization");
memcpy(Dest, Src.data(), Src.size());
}
void WindowsResourceCOFFWriter::writeCOFFHeader(uint32_t TimeDateStamp) {
// Write the COFF header.
auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
Header->Machine = MachineType;
Header->NumberOfSections = 2;
Header->TimeDateStamp = TimeDateStamp;
Header->PointerToSymbolTable = SymbolTableOffset;
// One symbol for every resource plus 2 for each section and 1 for @feat.00
Header->NumberOfSymbols = Data.size() + 5;
Header->SizeOfOptionalHeader = 0;
// cvtres.exe sets 32BIT_MACHINE even for 64-bit machine types. Match it.
Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
}
void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
// Write the first section header.
CurrentOffset += sizeof(coff_file_header);
auto *SectionOneHeader =
reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
coffnamecpy(SectionOneHeader->Name, ".rsrc$01");
SectionOneHeader->VirtualSize = 0;
SectionOneHeader->VirtualAddress = 0;
SectionOneHeader->SizeOfRawData = SectionOneSize;
SectionOneHeader->PointerToRawData = SectionOneOffset;
SectionOneHeader->PointerToRelocations = SectionOneRelocations;
SectionOneHeader->PointerToLinenumbers = 0;
SectionOneHeader->NumberOfRelocations = Data.size();
SectionOneHeader->NumberOfLinenumbers = 0;
SectionOneHeader->Characteristics += COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
SectionOneHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
}
void WindowsResourceCOFFWriter::writeSecondSectionHeader() {
// Write the second section header.
CurrentOffset += sizeof(coff_section);
auto *SectionTwoHeader =
reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
coffnamecpy(SectionTwoHeader->Name, ".rsrc$02");
SectionTwoHeader->VirtualSize = 0;
SectionTwoHeader->VirtualAddress = 0;
SectionTwoHeader->SizeOfRawData = SectionTwoSize;
SectionTwoHeader->PointerToRawData = SectionTwoOffset;
SectionTwoHeader->PointerToRelocations = 0;
SectionTwoHeader->PointerToLinenumbers = 0;
SectionTwoHeader->NumberOfRelocations = 0;
SectionTwoHeader->NumberOfLinenumbers = 0;
SectionTwoHeader->Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
SectionTwoHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
}
void WindowsResourceCOFFWriter::writeFirstSection() {
// Write section one.
CurrentOffset += sizeof(coff_section);
writeDirectoryTree();
writeDirectoryStringTable();
writeFirstSectionRelocations();
CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
}
void WindowsResourceCOFFWriter::writeSecondSection() {
// Now write the .rsrc$02 section.
for (auto const &RawDataEntry : Data) {
llvm::copy(RawDataEntry, BufferStart + CurrentOffset);
CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
}
CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
}
void WindowsResourceCOFFWriter::writeSymbolTable() {
// Now write the symbol table.
// First, the feat symbol.
auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
coffnamecpy(Symbol->Name.ShortName, "@feat.00");
Symbol->Value = 0x11;
Symbol->SectionNumber = 0xffff;
Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 0;
CurrentOffset += sizeof(coff_symbol16);
// Now write the .rsrc1 symbol + aux.
Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
coffnamecpy(Symbol->Name.ShortName, ".rsrc$01");
Symbol->Value = 0;
Symbol->SectionNumber = 1;
Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 1;
CurrentOffset += sizeof(coff_symbol16);
auto *Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
CurrentOffset);
Aux->Length = SectionOneSize;
Aux->NumberOfRelocations = Data.size();
Aux->NumberOfLinenumbers = 0;
Aux->CheckSum = 0;
Aux->NumberLowPart = 0;
Aux->Selection = 0;
CurrentOffset += sizeof(coff_aux_section_definition);
// Now write the .rsrc2 symbol + aux.
Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
coffnamecpy(Symbol->Name.ShortName, ".rsrc$02");
Symbol->Value = 0;
Symbol->SectionNumber = 2;
Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 1;
CurrentOffset += sizeof(coff_symbol16);
Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
CurrentOffset);
Aux->Length = SectionTwoSize;
Aux->NumberOfRelocations = 0;
Aux->NumberOfLinenumbers = 0;
Aux->CheckSum = 0;
Aux->NumberLowPart = 0;
Aux->Selection = 0;
CurrentOffset += sizeof(coff_aux_section_definition);
// Now write a symbol for each relocation.
for (unsigned i = 0; i < Data.size(); i++) {
auto RelocationName = formatv("$R{0:X-6}", i & 0xffffff).sstr<COFF::NameSize>();
Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
coffnamecpy(Symbol->Name.ShortName, RelocationName);
Symbol->Value = DataOffsets[i];
Symbol->SectionNumber = 2;
Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 0;
CurrentOffset += sizeof(coff_symbol16);
}
}
void WindowsResourceCOFFWriter::writeStringTable() {
// Just 4 null bytes for the string table.
auto COFFStringTable = reinterpret_cast<void *>(BufferStart + CurrentOffset);
memset(COFFStringTable, 0, 4);
}
void WindowsResourceCOFFWriter::writeDirectoryTree() {
// Traverse parsed resource tree breadth-first and write the corresponding
// COFF objects.
std::queue<const WindowsResourceParser::TreeNode *> Queue;
Queue.push(&Resources);
uint32_t NextLevelOffset =
sizeof(coff_resource_dir_table) + (Resources.getStringChildren().size() +
Resources.getIDChildren().size()) *
sizeof(coff_resource_dir_entry);
std::vector<const WindowsResourceParser::TreeNode *> DataEntriesTreeOrder;
uint32_t CurrentRelativeOffset = 0;
while (!Queue.empty()) {
auto CurrentNode = Queue.front();
Queue.pop();
auto *Table = reinterpret_cast<coff_resource_dir_table *>(BufferStart +
CurrentOffset);
Table->Characteristics = CurrentNode->getCharacteristics();
Table->TimeDateStamp = 0;
Table->MajorVersion = CurrentNode->getMajorVersion();
Table->MinorVersion = CurrentNode->getMinorVersion();
auto &IDChildren = CurrentNode->getIDChildren();
auto &StringChildren = CurrentNode->getStringChildren();
Table->NumberOfNameEntries = StringChildren.size();
Table->NumberOfIDEntries = IDChildren.size();
CurrentOffset += sizeof(coff_resource_dir_table);
CurrentRelativeOffset += sizeof(coff_resource_dir_table);
// Write the directory entries immediately following each directory table.
for (auto const &Child : StringChildren) {
auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
CurrentOffset);
Entry->Identifier.setNameOffset(
StringTableOffsets[Child.second->getStringIndex()]);
if (Child.second->checkIsDataNode()) {
Entry->Offset.DataEntryOffset = NextLevelOffset;
NextLevelOffset += sizeof(coff_resource_data_entry);
DataEntriesTreeOrder.push_back(Child.second.get());
} else {
Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
NextLevelOffset += sizeof(coff_resource_dir_table) +
(Child.second->getStringChildren().size() +
Child.second->getIDChildren().size()) *
sizeof(coff_resource_dir_entry);
Queue.push(Child.second.get());
}
CurrentOffset += sizeof(coff_resource_dir_entry);
CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
}
for (auto const &Child : IDChildren) {
auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
CurrentOffset);
Entry->Identifier.ID = Child.first;
if (Child.second->checkIsDataNode()) {
Entry->Offset.DataEntryOffset = NextLevelOffset;
NextLevelOffset += sizeof(coff_resource_data_entry);
DataEntriesTreeOrder.push_back(Child.second.get());
} else {
Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
NextLevelOffset += sizeof(coff_resource_dir_table) +
(Child.second->getStringChildren().size() +
Child.second->getIDChildren().size()) *
sizeof(coff_resource_dir_entry);
Queue.push(Child.second.get());
}
CurrentOffset += sizeof(coff_resource_dir_entry);
CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
}
}
RelocationAddresses.resize(Data.size());
// Now write all the resource data entries.
for (auto DataNodes : DataEntriesTreeOrder) {
auto *Entry = reinterpret_cast<coff_resource_data_entry *>(BufferStart +
CurrentOffset);
RelocationAddresses[DataNodes->getDataIndex()] = CurrentRelativeOffset;
Entry->DataRVA = 0; // Set to zero because it is a relocation.
Entry->DataSize = Data[DataNodes->getDataIndex()].size();
Entry->Codepage = 0;
Entry->Reserved = 0;
CurrentOffset += sizeof(coff_resource_data_entry);
CurrentRelativeOffset += sizeof(coff_resource_data_entry);
}
}
void WindowsResourceCOFFWriter::writeDirectoryStringTable() {
// Now write the directory string table for .rsrc$01
uint32_t TotalStringTableSize = 0;
for (auto &String : StringTable) {
uint16_t Length = String.size();
support::endian::write16le(BufferStart + CurrentOffset, Length);
CurrentOffset += sizeof(uint16_t);
auto *Start = reinterpret_cast<UTF16 *>(BufferStart + CurrentOffset);
llvm::copy(String, Start);
CurrentOffset += Length * sizeof(UTF16);
TotalStringTableSize += Length * sizeof(UTF16) + sizeof(uint16_t);
}
CurrentOffset +=
alignTo(TotalStringTableSize, sizeof(uint32_t)) - TotalStringTableSize;
}
void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
// Now write the relocations for .rsrc$01
// Five symbols already in table before we start, @feat.00 and 2 for each
// .rsrc section.
uint32_t NextSymbolIndex = 5;
for (unsigned i = 0; i < Data.size(); i++) {
auto *Reloc =
reinterpret_cast<coff_relocation *>(BufferStart + CurrentOffset);
Reloc->VirtualAddress = RelocationAddresses[i];
Reloc->SymbolTableIndex = NextSymbolIndex++;
switch (MachineType) {
case COFF::IMAGE_FILE_MACHINE_ARMNT:
Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
break;
case COFF::IMAGE_FILE_MACHINE_AMD64:
Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
break;
case COFF::IMAGE_FILE_MACHINE_I386:
Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
break;
case COFF::IMAGE_FILE_MACHINE_ARM64:
Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
break;
default:
llvm_unreachable("unknown machine type");
}
CurrentOffset += sizeof(coff_relocation);
}
}
Expected<std::unique_ptr<MemoryBuffer>>
writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
const WindowsResourceParser &Parser,
uint32_t TimeDateStamp) {
Error E = Error::success();
WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
if (E)
return std::move(E);
return Writer.write(TimeDateStamp);
}
} // namespace object
} // namespace llvm
Reference in New Issue View Git Blame Copy Permalink