summaryrefslogtreecommitdiff
path: root/lib/Object/WindowsResource.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Object/WindowsResource.cpp')
-rw-r--r--lib/Object/WindowsResource.cpp270
1 files changed, 123 insertions, 147 deletions
diff --git a/lib/Object/WindowsResource.cpp b/lib/Object/WindowsResource.cpp
index 3f6080d48f9d..ff9b9ca35eb5 100644
--- a/lib/Object/WindowsResource.cpp
+++ b/lib/Object/WindowsResource.cpp
@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "llvm/Object/WindowsResource.h"
-#include "llvm/BinaryFormat/COFF.h"
#include "llvm/Object/COFF.h"
#include "llvm/Support/FileOutputBuffer.h"
#include "llvm/Support/MathExtras.h"
@@ -21,6 +20,9 @@
#include <sstream>
#include <system_error>
+using namespace llvm;
+using namespace object;
+
namespace llvm {
namespace object {
@@ -34,23 +36,19 @@ const uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
// 8-byte because it makes everyone happy.
const uint32_t SECTION_ALIGNMENT = sizeof(uint64_t);
-static const size_t ResourceMagicSize = 16;
-
-static const size_t NullEntrySize = 16;
-
uint32_t WindowsResourceParser::TreeNode::StringCount = 0;
uint32_t WindowsResourceParser::TreeNode::DataCount = 0;
WindowsResource::WindowsResource(MemoryBufferRef Source)
: Binary(Binary::ID_WinRes, Source) {
- size_t LeadingSize = ResourceMagicSize + NullEntrySize;
+ size_t LeadingSize = WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE;
BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize),
support::little);
}
Expected<std::unique_ptr<WindowsResource>>
WindowsResource::createWindowsResource(MemoryBufferRef Source) {
- if (Source.getBufferSize() < ResourceMagicSize + NullEntrySize)
+ if (Source.getBufferSize() < WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE)
return make_error<GenericBinaryError>(
"File too small to be a resource file",
object_error::invalid_file_type);
@@ -103,12 +101,10 @@ static Error readStringOrId(BinaryStreamReader &Reader, uint16_t &ID,
}
Error ResourceEntryRef::loadNext() {
- uint32_t DataSize;
- RETURN_IF_ERROR(Reader.readInteger(DataSize));
- uint32_t HeaderSize;
- RETURN_IF_ERROR(Reader.readInteger(HeaderSize));
+ const WinResHeaderPrefix *Prefix;
+ RETURN_IF_ERROR(Reader.readObject(Prefix));
- if (HeaderSize < MIN_HEADER_SIZE)
+ if (Prefix->HeaderSize < MIN_HEADER_SIZE)
return make_error<GenericBinaryError>("Header size is too small.",
object_error::parse_failed);
@@ -116,13 +112,13 @@ Error ResourceEntryRef::loadNext() {
RETURN_IF_ERROR(readStringOrId(Reader, NameID, Name, IsStringName));
- RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t)));
+ RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_HEADER_ALIGNMENT));
RETURN_IF_ERROR(Reader.readObject(Suffix));
- RETURN_IF_ERROR(Reader.readArray(Data, DataSize));
+ RETURN_IF_ERROR(Reader.readArray(Data, Prefix->DataSize));
- RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t)));
+ RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_DATA_ALIGNMENT));
return Error::success();
}
@@ -246,14 +242,14 @@ WindowsResourceParser::TreeNode::addChild(ArrayRef<UTF16> NameRef,
std::string NameString;
ArrayRef<UTF16> CorrectedName;
std::vector<UTF16> EndianCorrectedName;
- if (llvm::sys::IsBigEndianHost) {
+ if (sys::IsBigEndianHost) {
EndianCorrectedName.resize(NameRef.size() + 1);
std::copy(NameRef.begin(), NameRef.end(), EndianCorrectedName.begin() + 1);
EndianCorrectedName[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
CorrectedName = makeArrayRef(EndianCorrectedName);
} else
CorrectedName = NameRef;
- llvm::convertUTF16ToUTF8String(CorrectedName, NameString);
+ convertUTF16ToUTF8String(CorrectedName, NameString);
auto Child = StringChildren.find(NameString);
if (Child == StringChildren.end()) {
@@ -282,17 +278,17 @@ void WindowsResourceParser::TreeNode::print(ScopedPrinter &Writer,
// the directory strings or the relocations of the .rsrc section.
uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
uint32_t Size = (IDChildren.size() + StringChildren.size()) *
- sizeof(llvm::object::coff_resource_dir_entry);
+ sizeof(coff_resource_dir_entry);
// Reached a node pointing to a data entry.
if (IsDataNode) {
- Size += sizeof(llvm::object::coff_resource_data_entry);
+ 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(llvm::object::coff_resource_dir_table);
+ Size += sizeof(coff_resource_dir_table);
for (auto const &Child : StringChildren) {
Size += Child.second->getTreeSize();
@@ -305,9 +301,9 @@ uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
class WindowsResourceCOFFWriter {
public:
- WindowsResourceCOFFWriter(StringRef OutputFile, Machine MachineType,
+ WindowsResourceCOFFWriter(COFF::MachineTypes MachineType,
const WindowsResourceParser &Parser, Error &E);
- Error write();
+ std::unique_ptr<MemoryBuffer> write();
private:
void performFileLayout();
@@ -323,10 +319,10 @@ private:
void writeDirectoryTree();
void writeDirectoryStringTable();
void writeFirstSectionRelocations();
- std::unique_ptr<FileOutputBuffer> Buffer;
- uint8_t *BufferStart;
+ std::unique_ptr<MemoryBuffer> OutputBuffer;
+ char *BufferStart;
uint64_t CurrentOffset = 0;
- Machine MachineType;
+ COFF::MachineTypes MachineType;
const WindowsResourceParser::TreeNode &Resources;
const ArrayRef<std::vector<uint8_t>> Data;
uint64_t FileSize;
@@ -343,28 +339,21 @@ private:
};
WindowsResourceCOFFWriter::WindowsResourceCOFFWriter(
- StringRef OutputFile, Machine MachineType,
- const WindowsResourceParser &Parser, Error &E)
+ COFF::MachineTypes MachineType, const WindowsResourceParser &Parser,
+ Error &E)
: MachineType(MachineType), Resources(Parser.getTree()),
Data(Parser.getData()), StringTable(Parser.getStringTable()) {
performFileLayout();
- ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
- FileOutputBuffer::create(OutputFile, FileSize);
- if (!BufferOrErr) {
- E = errorCodeToError(BufferOrErr.getError());
- return;
- }
-
- Buffer = std::move(*BufferOrErr);
+ OutputBuffer = MemoryBuffer::getNewMemBuffer(FileSize);
}
void WindowsResourceCOFFWriter::performFileLayout() {
// Add size of COFF header.
- FileSize = llvm::COFF::Header16Size;
+ FileSize = COFF::Header16Size;
// one .rsrc section header for directory tree, another for resource data.
- FileSize += 2 * llvm::COFF::SectionSize;
+ FileSize += 2 * COFF::SectionSize;
performSectionOneLayout();
performSectionTwoLayout();
@@ -372,9 +361,9 @@ void WindowsResourceCOFFWriter::performFileLayout() {
// We have reached the address of the symbol table.
SymbolTableOffset = FileSize;
- FileSize += llvm::COFF::Symbol16Size; // size of the @feat.00 symbol.
- FileSize += 4 * llvm::COFF::Symbol16Size; // symbol + aux for each section.
- FileSize += Data.size() * llvm::COFF::Symbol16Size; // 1 symbol per resource.
+ 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.
}
@@ -395,8 +384,8 @@ void WindowsResourceCOFFWriter::performSectionOneLayout() {
// account for the relocations of section one.
SectionOneRelocations = FileSize + SectionOneSize;
FileSize += SectionOneSize;
- FileSize += Data.size() *
- llvm::COFF::RelocationSize; // one relocation for each resource.
+ FileSize +=
+ Data.size() * COFF::RelocationSize; // one relocation for each resource.
FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
}
@@ -407,7 +396,7 @@ void WindowsResourceCOFFWriter::performSectionTwoLayout() {
SectionTwoSize = 0;
for (auto const &Entry : Data) {
DataOffsets.push_back(SectionTwoSize);
- SectionTwoSize += llvm::alignTo(Entry.size(), sizeof(uint64_t));
+ SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
}
FileSize += SectionTwoSize;
FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
@@ -420,8 +409,8 @@ static std::time_t getTime() {
return Now;
}
-Error WindowsResourceCOFFWriter::write() {
- BufferStart = Buffer->getBufferStart();
+std::unique_ptr<MemoryBuffer> WindowsResourceCOFFWriter::write() {
+ BufferStart = const_cast<char *>(OutputBuffer->getBufferStart());
writeCOFFHeader();
writeFirstSectionHeader();
@@ -431,29 +420,24 @@ Error WindowsResourceCOFFWriter::write() {
writeSymbolTable();
writeStringTable();
- if (auto EC = Buffer->commit()) {
- return errorCodeToError(EC);
- }
-
- return Error::success();
+ return std::move(OutputBuffer);
}
void WindowsResourceCOFFWriter::writeCOFFHeader() {
// Write the COFF header.
- auto *Header =
- reinterpret_cast<llvm::object::coff_file_header *>(BufferStart);
+ auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
switch (MachineType) {
- case Machine::ARM:
- Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT;
+ case COFF::IMAGE_FILE_MACHINE_ARMNT:
+ Header->Machine = COFF::IMAGE_FILE_MACHINE_ARMNT;
break;
- case Machine::X64:
- Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
+ case COFF::IMAGE_FILE_MACHINE_AMD64:
+ Header->Machine = COFF::IMAGE_FILE_MACHINE_AMD64;
break;
- case Machine::X86:
- Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_I386;
+ case COFF::IMAGE_FILE_MACHINE_I386:
+ Header->Machine = COFF::IMAGE_FILE_MACHINE_I386;
break;
default:
- Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+ Header->Machine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
}
Header->NumberOfSections = 2;
Header->TimeDateStamp = getTime();
@@ -461,15 +445,15 @@ void WindowsResourceCOFFWriter::writeCOFFHeader() {
// One symbol for every resource plus 2 for each section and @feat.00
Header->NumberOfSymbols = Data.size() + 5;
Header->SizeOfOptionalHeader = 0;
- Header->Characteristics = llvm::COFF::IMAGE_FILE_32BIT_MACHINE;
+ Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
}
void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
// Write the first section header.
- CurrentOffset += sizeof(llvm::object::coff_file_header);
- auto *SectionOneHeader = reinterpret_cast<llvm::object::coff_section *>(
- BufferStart + CurrentOffset);
- strncpy(SectionOneHeader->Name, ".rsrc$01", (size_t)llvm::COFF::NameSize);
+ CurrentOffset += sizeof(coff_file_header);
+ auto *SectionOneHeader =
+ reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
+ strncpy(SectionOneHeader->Name, ".rsrc$01", (size_t)COFF::NameSize);
SectionOneHeader->VirtualSize = 0;
SectionOneHeader->VirtualAddress = 0;
SectionOneHeader->SizeOfRawData = SectionOneSize;
@@ -478,19 +462,16 @@ void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
SectionOneHeader->PointerToLinenumbers = 0;
SectionOneHeader->NumberOfRelocations = Data.size();
SectionOneHeader->NumberOfLinenumbers = 0;
- SectionOneHeader->Characteristics = llvm::COFF::IMAGE_SCN_ALIGN_1BYTES;
- SectionOneHeader->Characteristics +=
- llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
- SectionOneHeader->Characteristics += llvm::COFF::IMAGE_SCN_MEM_DISCARDABLE;
- SectionOneHeader->Characteristics += llvm::COFF::IMAGE_SCN_MEM_READ;
+ 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(llvm::object::coff_section);
- auto *SectionTwoHeader = reinterpret_cast<llvm::object::coff_section *>(
- BufferStart + CurrentOffset);
- strncpy(SectionTwoHeader->Name, ".rsrc$02", (size_t)llvm::COFF::NameSize);
+ CurrentOffset += sizeof(coff_section);
+ auto *SectionTwoHeader =
+ reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
+ strncpy(SectionTwoHeader->Name, ".rsrc$02", (size_t)COFF::NameSize);
SectionTwoHeader->VirtualSize = 0;
SectionTwoHeader->VirtualAddress = 0;
SectionTwoHeader->SizeOfRawData = SectionTwoSize;
@@ -499,14 +480,13 @@ void WindowsResourceCOFFWriter::writeSecondSectionHeader() {
SectionTwoHeader->PointerToLinenumbers = 0;
SectionTwoHeader->NumberOfRelocations = 0;
SectionTwoHeader->NumberOfLinenumbers = 0;
- SectionTwoHeader->Characteristics =
- llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
- SectionTwoHeader->Characteristics += llvm::COFF::IMAGE_SCN_MEM_READ;
+ SectionTwoHeader->Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
+ SectionTwoHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
}
void WindowsResourceCOFFWriter::writeFirstSection() {
// Write section one.
- CurrentOffset += sizeof(llvm::object::coff_section);
+ CurrentOffset += sizeof(coff_section);
writeDirectoryTree();
writeDirectoryStringTable();
@@ -529,70 +509,65 @@ void WindowsResourceCOFFWriter::writeSecondSection() {
void WindowsResourceCOFFWriter::writeSymbolTable() {
// Now write the symbol table.
// First, the feat symbol.
- auto *Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
- CurrentOffset);
- strncpy(Symbol->Name.ShortName, "@feat.00", (size_t)llvm::COFF::NameSize);
+ auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+ strncpy(Symbol->Name.ShortName, "@feat.00", (size_t)COFF::NameSize);
Symbol->Value = 0x11;
Symbol->SectionNumber = 0xffff;
- Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
- Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+ Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+ Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 0;
- CurrentOffset += sizeof(llvm::object::coff_symbol16);
+ CurrentOffset += sizeof(coff_symbol16);
// Now write the .rsrc1 symbol + aux.
- Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
- CurrentOffset);
- strncpy(Symbol->Name.ShortName, ".rsrc$01", (size_t)llvm::COFF::NameSize);
+ Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+ strncpy(Symbol->Name.ShortName, ".rsrc$01", (size_t)COFF::NameSize);
Symbol->Value = 0;
Symbol->SectionNumber = 1;
- Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
- Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+ Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+ Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 1;
- CurrentOffset += sizeof(llvm::object::coff_symbol16);
- auto *Aux = reinterpret_cast<llvm::object::coff_aux_section_definition *>(
- BufferStart + CurrentOffset);
+ 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(llvm::object::coff_aux_section_definition);
+ CurrentOffset += sizeof(coff_aux_section_definition);
// Now write the .rsrc2 symbol + aux.
- Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
- CurrentOffset);
- strncpy(Symbol->Name.ShortName, ".rsrc$02", (size_t)llvm::COFF::NameSize);
+ Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+ strncpy(Symbol->Name.ShortName, ".rsrc$02", (size_t)COFF::NameSize);
Symbol->Value = 0;
Symbol->SectionNumber = 2;
- Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
- Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+ Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+ Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 1;
- CurrentOffset += sizeof(llvm::object::coff_symbol16);
- Aux = reinterpret_cast<llvm::object::coff_aux_section_definition *>(
- BufferStart + CurrentOffset);
+ 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(llvm::object::coff_aux_section_definition);
+ CurrentOffset += sizeof(coff_aux_section_definition);
// Now write a symbol for each relocation.
for (unsigned i = 0; i < Data.size(); i++) {
char RelocationName[9];
sprintf(RelocationName, "$R%06X", DataOffsets[i]);
- Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
- CurrentOffset);
- strncpy(Symbol->Name.ShortName, RelocationName,
- (size_t)llvm::COFF::NameSize);
+ Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+ strncpy(Symbol->Name.ShortName, RelocationName, (size_t)COFF::NameSize);
Symbol->Value = DataOffsets[i];
Symbol->SectionNumber = 1;
- Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
- Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+ Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+ Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
Symbol->NumberOfAuxSymbols = 0;
- CurrentOffset += sizeof(llvm::object::coff_symbol16);
+ CurrentOffset += sizeof(coff_symbol16);
}
}
@@ -607,18 +582,18 @@ void WindowsResourceCOFFWriter::writeDirectoryTree() {
// COFF objects.
std::queue<const WindowsResourceParser::TreeNode *> Queue;
Queue.push(&Resources);
- uint32_t NextLevelOffset = sizeof(llvm::object::coff_resource_dir_table) +
- (Resources.getStringChildren().size() +
- Resources.getIDChildren().size()) *
- sizeof(llvm::object::coff_resource_dir_entry);
+ 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<llvm::object::coff_resource_dir_table *>(
- BufferStart + CurrentOffset);
+ auto *Table = reinterpret_cast<coff_resource_dir_table *>(BufferStart +
+ CurrentOffset);
Table->Characteristics = CurrentNode->getCharacteristics();
Table->TimeDateStamp = 0;
Table->MajorVersion = CurrentNode->getMajorVersion();
@@ -627,63 +602,63 @@ void WindowsResourceCOFFWriter::writeDirectoryTree() {
auto &StringChildren = CurrentNode->getStringChildren();
Table->NumberOfNameEntries = StringChildren.size();
Table->NumberOfIDEntries = IDChildren.size();
- CurrentOffset += sizeof(llvm::object::coff_resource_dir_table);
- CurrentRelativeOffset += sizeof(llvm::object::coff_resource_dir_table);
+ 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<llvm::object::coff_resource_dir_entry *>(
- BufferStart + CurrentOffset);
+ auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
+ CurrentOffset);
Entry->Identifier.NameOffset =
StringTableOffsets[Child.second->getStringIndex()];
if (Child.second->checkIsDataNode()) {
Entry->Offset.DataEntryOffset = NextLevelOffset;
- NextLevelOffset += sizeof(llvm::object::coff_resource_data_entry);
+ NextLevelOffset += sizeof(coff_resource_data_entry);
DataEntriesTreeOrder.push_back(Child.second.get());
} else {
Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
- NextLevelOffset += sizeof(llvm::object::coff_resource_dir_table) +
+ NextLevelOffset += sizeof(coff_resource_dir_table) +
(Child.second->getStringChildren().size() +
Child.second->getIDChildren().size()) *
- sizeof(llvm::object::coff_resource_dir_entry);
+ sizeof(coff_resource_dir_entry);
Queue.push(Child.second.get());
}
- CurrentOffset += sizeof(llvm::object::coff_resource_dir_entry);
- CurrentRelativeOffset += sizeof(llvm::object::coff_resource_dir_entry);
+ CurrentOffset += sizeof(coff_resource_dir_entry);
+ CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
}
for (auto const &Child : IDChildren) {
- auto *Entry = reinterpret_cast<llvm::object::coff_resource_dir_entry *>(
- BufferStart + CurrentOffset);
+ 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(llvm::object::coff_resource_data_entry);
+ NextLevelOffset += sizeof(coff_resource_data_entry);
DataEntriesTreeOrder.push_back(Child.second.get());
} else {
Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
- NextLevelOffset += sizeof(llvm::object::coff_resource_dir_table) +
+ NextLevelOffset += sizeof(coff_resource_dir_table) +
(Child.second->getStringChildren().size() +
Child.second->getIDChildren().size()) *
- sizeof(llvm::object::coff_resource_dir_entry);
+ sizeof(coff_resource_dir_entry);
Queue.push(Child.second.get());
}
- CurrentOffset += sizeof(llvm::object::coff_resource_dir_entry);
- CurrentRelativeOffset += sizeof(llvm::object::coff_resource_dir_entry);
+ 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<llvm::object::coff_resource_data_entry *>(
- BufferStart + CurrentOffset);
+ 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(llvm::object::coff_resource_data_entry);
- CurrentRelativeOffset += sizeof(llvm::object::coff_resource_data_entry);
+ CurrentOffset += sizeof(coff_resource_data_entry);
+ CurrentRelativeOffset += sizeof(coff_resource_data_entry);
}
}
@@ -710,33 +685,34 @@ void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
// .rsrc section.
uint32_t NextSymbolIndex = 5;
for (unsigned i = 0; i < Data.size(); i++) {
- auto *Reloc = reinterpret_cast<llvm::object::coff_relocation *>(
- BufferStart + CurrentOffset);
+ auto *Reloc =
+ reinterpret_cast<coff_relocation *>(BufferStart + CurrentOffset);
Reloc->VirtualAddress = RelocationAddresses[i];
Reloc->SymbolTableIndex = NextSymbolIndex++;
switch (MachineType) {
- case Machine::ARM:
- Reloc->Type = llvm::COFF::IMAGE_REL_ARM_ADDR32NB;
+ case COFF::IMAGE_FILE_MACHINE_ARMNT:
+ Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
break;
- case Machine::X64:
- Reloc->Type = llvm::COFF::IMAGE_REL_AMD64_ADDR32NB;
+ case COFF::IMAGE_FILE_MACHINE_AMD64:
+ Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
break;
- case Machine::X86:
- Reloc->Type = llvm::COFF::IMAGE_REL_I386_DIR32NB;
+ case COFF::IMAGE_FILE_MACHINE_I386:
+ Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
break;
default:
Reloc->Type = 0;
}
- CurrentOffset += sizeof(llvm::object::coff_relocation);
+ CurrentOffset += sizeof(coff_relocation);
}
}
-Error writeWindowsResourceCOFF(StringRef OutputFile, Machine MachineType,
- const WindowsResourceParser &Parser) {
+Expected<std::unique_ptr<MemoryBuffer>>
+writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
+ const WindowsResourceParser &Parser) {
Error E = Error::success();
- WindowsResourceCOFFWriter Writer(OutputFile, MachineType, Parser, E);
+ WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
if (E)
- return E;
+ return std::move(E);
return Writer.write();
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 14:07:01 +0000