27 #define RETURN_IF_ERROR(X) \
31 #define UNWRAP_REF_OR_RETURN(Name, Expr) \
32 auto Name##OrErr = Expr; \
34 return Name##OrErr.takeError(); \
35 const auto &Name = *Name##OrErr;
37 #define UNWRAP_OR_RETURN(Name, Expr) \
38 auto Name##OrErr = Expr; \
40 return Name##OrErr.takeError(); \
41 auto Name = *Name##OrErr;
60 return make_error<GenericBinaryError>(
61 Source.getBufferIdentifier() +
": too small to be a resource file",
62 object_error::invalid_file_type);
69 return make_error<EmptyResError>(
getFileName() +
" contains no entries",
70 object_error::unexpected_eof);
76 : Reader(
Ref), Owner(Owner) {}
80 auto Ref = ResourceEntryRef(
BSR, Owner);
81 if (
auto E =
Ref.loadNext())
101 IsString = IDFlag != 0xffff;
114 Error ResourceEntryRef::loadNext() {
115 const WinResHeaderPrefix *
Prefix;
119 return make_error<GenericBinaryError>(Owner->getFileName() +
120 ": header size too small",
139 : Root(
false), MinGW(MinGW) {}
143 case 1: OS <<
"CURSOR (ID 1)";
break;
144 case 2: OS <<
"BITMAP (ID 2)";
break;
145 case 3: OS <<
"ICON (ID 3)";
break;
146 case 4: OS <<
"MENU (ID 4)";
break;
147 case 5: OS <<
"DIALOG (ID 5)";
break;
148 case 6: OS <<
"STRINGTABLE (ID 6)";
break;
149 case 7: OS <<
"FONTDIR (ID 7)";
break;
150 case 8: OS <<
"FONT (ID 8)";
break;
151 case 9: OS <<
"ACCELERATOR (ID 9)";
break;
152 case 10: OS <<
"RCDATA (ID 10)";
break;
153 case 11: OS <<
"MESSAGETABLE (ID 11)";
break;
154 case 12: OS <<
"GROUP_CURSOR (ID 12)";
break;
155 case 14: OS <<
"GROUP_ICON (ID 14)";
break;
156 case 16: OS <<
"VERSIONINFO (ID 16)";
break;
157 case 17: OS <<
"DLGINCLUDE (ID 17)";
break;
158 case 19: OS <<
"PLUGPLAY (ID 19)";
break;
159 case 20: OS <<
"VXD (ID 20)";
break;
160 case 21: OS <<
"ANICURSOR (ID 21)";
break;
161 case 22: OS <<
"ANIICON (ID 22)";
break;
162 case 23: OS <<
"HTML (ID 23)";
break;
163 case 24: OS <<
"MANIFEST (ID 24)";
break;
164 default: OS <<
"ID " <<
TypeID;
break;
172 std::vector<UTF16> EndianCorrectedSrc;
173 EndianCorrectedSrc.resize(Src.size() + 1);
174 llvm::copy(Src, EndianCorrectedSrc.begin() + 1);
184 OS <<
"duplicate resource:";
187 if (Entry.checkTypeString()) {
190 UTF8 =
"(failed conversion from UTF16)";
191 OS <<
'\"' <<
UTF8 <<
'\"';
196 if (Entry.checkNameString()) {
199 UTF8 =
"(failed conversion from UTF16)";
200 OS <<
'\"' <<
UTF8 <<
'\"';
202 OS <<
"ID " << Entry.getNameID();
205 OS <<
"/language " << Entry.getLanguage() <<
", in " << File1 <<
" and in "
216 UTF8 =
"(failed conversion from UTF16)";
217 OS <<
'\"' <<
UTF8 <<
'\"';
227 const std::vector<WindowsResourceParser::StringOrID> &
Context,
232 OS <<
"duplicate resource:";
248 OS <<
", in " << File1 <<
" and in " << File2;
262 std::vector<std::string> &Duplicates) {
263 auto TypeIt = Root.IDChildren.find( 24);
264 if (TypeIt == Root.IDChildren.end())
267 TreeNode *TypeNode = TypeIt->second.get();
269 TypeNode->IDChildren.find( 1);
270 if (NameIt == TypeNode->IDChildren.end())
273 TreeNode *NameNode = NameIt->second.get();
274 if (NameNode->IDChildren.size() <= 1)
279 auto LangZeroIt = NameNode->IDChildren.find(0);
280 if (LangZeroIt != NameNode->IDChildren.end() &&
281 LangZeroIt->second->IsDataNode) {
282 uint32_t RemovedIndex = LangZeroIt->second->DataIndex;
283 NameNode->IDChildren.erase(LangZeroIt);
284 Data.erase(Data.begin() + RemovedIndex);
285 Root.shiftDataIndexDown(RemovedIndex);
288 if (NameNode->IDChildren.size() <= 1)
293 auto FirstIt = NameNode->IDChildren.begin();
294 uint32_t FirstLang = FirstIt->first;
295 TreeNode *FirstNode = FirstIt->second.get();
296 auto LastIt = NameNode->IDChildren.rbegin();
298 TreeNode *LastNode = LastIt->second.get();
299 Duplicates.push_back(
300 (
"duplicate non-default manifests with languages " +
Twine(FirstLang) +
301 " in " + InputFilenames[FirstNode->Origin] +
" and " +
Twine(LastLang) +
302 " in " + InputFilenames[LastNode->Origin])
310 bool WindowsResourceParser::shouldIgnoreDuplicate(
312 return MinGW && !Entry.checkTypeString() &&
313 Entry.getTypeID() == 24 &&
314 !Entry.checkNameString() &&
315 Entry.getNameID() == 1 &&
316 Entry.getLanguage() == 0;
319 bool WindowsResourceParser::shouldIgnoreDuplicate(
320 const std::vector<StringOrID> &
Context)
const {
328 std::vector<std::string> &Duplicates) {
331 auto E = EntryOrErr.takeError();
346 uint32_t Origin = InputFilenames.size();
347 InputFilenames.push_back(std::string(WR->
getFileName()));
352 bool IsNewNode = Root.addEntry(Entry, Origin, Data, StringTable, Node);
354 if (!shouldIgnoreDuplicate(Entry))
356 Entry, InputFilenames[Node->Origin], WR->
getFileName()));
366 std::vector<std::string> &Duplicates) {
368 uint32_t Origin = InputFilenames.size();
369 InputFilenames.push_back(std::string(Filename));
370 std::vector<StringOrID>
Context;
371 return addChildren(Root, RSR, BaseTable, Origin,
Context, Duplicates);
376 Root.
print(Writer,
"Resource Tree");
379 bool WindowsResourceParser::TreeNode::addEntry(
381 std::vector<std::vector<uint8_t>> &Data,
382 std::vector<std::vector<UTF16>> &StringTable, TreeNode *&Result) {
383 TreeNode &TypeNode = addTypeNode(Entry, StringTable);
384 TreeNode &NameNode = TypeNode.addNameNode(Entry, StringTable);
385 return NameNode.addLanguageNode(Entry, Origin, Data, Result);
388 Error WindowsResourceParser::addChildren(TreeNode &Node,
389 ResourceSectionRef &RSR,
390 const coff_resource_dir_table &Table,
392 std::vector<StringOrID> &
Context,
393 std::vector<std::string> &Duplicates) {
395 for (
int i = 0;
i < Table.NumberOfNameEntries + Table.NumberOfIDEntries;
400 if (Entry.Offset.isSubDir()) {
403 if (
i < Table.NumberOfNameEntries) {
405 Child = &Node.addNameChild(NameString, StringTable);
406 Context.push_back(StringOrID(NameString));
408 Child = &Node.addIDChild(Entry.Identifier.ID);
409 Context.push_back(StringOrID(Entry.Identifier.ID));
414 addChildren(*Child, RSR, NextTable, Origin,
Context, Duplicates);
422 if (Table.NumberOfNameEntries > 0)
424 "unexpected string key for data object");
429 Context.push_back(StringOrID(Entry.Identifier.ID));
430 bool Added = Node.addDataChild(Entry.Identifier.ID, Table.MajorVersion,
431 Table.MinorVersion, Table.Characteristics,
432 Origin, Data.size(), Child);
436 reinterpret_cast<const uint8_t *
>(Contents.data()),
439 if (!shouldIgnoreDuplicate(
Context))
441 Context, InputFilenames[Child->Origin], InputFilenames.back()));
450 WindowsResourceParser::TreeNode::TreeNode(
uint32_t StringIndex)
451 : StringIndex(StringIndex) {}
453 WindowsResourceParser::TreeNode::TreeNode(
uint16_t MajorVersion,
457 : IsDataNode(
true), DataIndex(DataIndex), MajorVersion(MajorVersion),
461 std::unique_ptr<WindowsResourceParser::TreeNode>
462 WindowsResourceParser::TreeNode::createStringNode(
uint32_t Index) {
463 return std::unique_ptr<TreeNode>(
new TreeNode(
Index));
466 std::unique_ptr<WindowsResourceParser::TreeNode>
467 WindowsResourceParser::TreeNode::createIDNode() {
468 return std::unique_ptr<TreeNode>(
new TreeNode(0));
471 std::unique_ptr<WindowsResourceParser::TreeNode>
472 WindowsResourceParser::TreeNode::createDataNode(
uint16_t MajorVersion,
477 return std::unique_ptr<TreeNode>(
new TreeNode(
481 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addTypeNode(
482 const ResourceEntryRef &Entry,
483 std::vector<std::vector<UTF16>> &StringTable) {
484 if (Entry.checkTypeString())
485 return addNameChild(Entry.getTypeString(), StringTable);
487 return addIDChild(Entry.getTypeID());
490 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addNameNode(
491 const ResourceEntryRef &Entry,
492 std::vector<std::vector<UTF16>> &StringTable) {
493 if (Entry.checkNameString())
494 return addNameChild(Entry.getNameString(), StringTable);
496 return addIDChild(Entry.getNameID());
499 bool WindowsResourceParser::TreeNode::addLanguageNode(
500 const ResourceEntryRef &Entry,
uint32_t Origin,
501 std::vector<std::vector<uint8_t>> &Data, TreeNode *&Result) {
502 bool Added = addDataChild(Entry.getLanguage(), Entry.getMajorVersion(),
503 Entry.getMinorVersion(), Entry.getCharacteristics(),
504 Origin, Data.size(), Result);
506 Data.push_back(Entry.getData());
510 bool WindowsResourceParser::TreeNode::addDataChild(
514 auto NewChild = createDataNode(MajorVersion, MinorVersion,
Characteristics,
516 auto ElementInserted = IDChildren.emplace(
ID,
std::move(NewChild));
517 Result = ElementInserted.first->second.get();
518 return ElementInserted.second;
521 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addIDChild(
523 auto Child = IDChildren.find(
ID);
524 if (Child == IDChildren.end()) {
525 auto NewChild = createIDNode();
526 WindowsResourceParser::TreeNode &Node = *NewChild;
530 return *(Child->second);
533 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addNameChild(
534 ArrayRef<UTF16> NameRef, std::vector<std::vector<UTF16>> &StringTable) {
535 std::string NameString;
538 auto Child = StringChildren.find(NameString);
539 if (Child == StringChildren.end()) {
540 auto NewChild = createStringNode(StringTable.size());
541 StringTable.push_back(NameRef);
542 WindowsResourceParser::TreeNode &Node = *NewChild;
543 StringChildren.emplace(NameString,
std::move(NewChild));
546 return *(Child->second);
552 for (
auto const &Child : StringChildren) {
553 Child.second->print(Writer, Child.first);
555 for (
auto const &Child : IDChildren) {
556 Child.second->print(Writer,
to_string(Child.first));
564 uint32_t Size = (IDChildren.size() + StringChildren.size()) *
577 for (
auto const &Child : StringChildren) {
578 Size += Child.second->getTreeSize();
580 for (
auto const &Child : IDChildren) {
581 Size += Child.second->getTreeSize();
588 void WindowsResourceParser::TreeNode::shiftDataIndexDown(
uint32_t Index) {
589 if (IsDataNode && DataIndex >=
Index) {
592 for (
auto &Child : IDChildren)
593 Child.second->shiftDataIndexDown(
Index);
594 for (
auto &Child : StringChildren)
595 Child.second->shiftDataIndexDown(
Index);
606 void performFileLayout();
607 void performSectionOneLayout();
608 void performSectionTwoLayout();
609 void writeCOFFHeader(
uint32_t TimeDateStamp);
610 void writeFirstSectionHeader();
611 void writeSecondSectionHeader();
612 void writeFirstSection();
613 void writeSecondSection();
616 void writeDirectoryTree();
617 void writeDirectoryStringTable();
618 void writeFirstSectionRelocations();
619 std::unique_ptr<WritableMemoryBuffer> OutputBuffer;
633 std::vector<uint32_t> StringTableOffsets;
634 std::vector<uint32_t> DataOffsets;
635 std::vector<uint32_t> RelocationAddresses;
646 FileSize,
"internal .obj file created from .res files");
649 void WindowsResourceCOFFWriter::performFileLayout() {
656 performSectionOneLayout();
657 performSectionTwoLayout();
660 SymbolTableOffset = FileSize;
668 void WindowsResourceCOFFWriter::performSectionOneLayout() {
669 SectionOneOffset = FileSize;
672 uint32_t CurrentStringOffset = SectionOneSize;
674 for (
auto const &String : StringTable) {
675 StringTableOffsets.push_back(CurrentStringOffset);
677 CurrentStringOffset += StringSize;
678 TotalStringTableSize += StringSize;
683 SectionOneRelocations = FileSize + SectionOneSize;
684 FileSize += SectionOneSize;
690 void WindowsResourceCOFFWriter::performSectionTwoLayout() {
693 SectionTwoOffset = FileSize;
695 for (
auto const &Entry : Data) {
696 DataOffsets.push_back(SectionTwoSize);
699 FileSize += SectionTwoSize;
703 std::unique_ptr<MemoryBuffer>
705 BufferStart = OutputBuffer->getBufferStart();
707 writeCOFFHeader(TimeDateStamp);
708 writeFirstSectionHeader();
709 writeSecondSectionHeader();
711 writeSecondSection();
722 "Src is larger than COFF::NameSize");
724 "Dest not zeroed upon initialization");
725 memcpy(Dest, Src.data(), Src.size());
728 void WindowsResourceCOFFWriter::writeCOFFHeader(
uint32_t TimeDateStamp) {
730 auto *Header =
reinterpret_cast<coff_file_header *
>(BufferStart);
731 Header->Machine = MachineType;
732 Header->NumberOfSections = 2;
733 Header->TimeDateStamp = TimeDateStamp;
734 Header->PointerToSymbolTable = SymbolTableOffset;
736 Header->NumberOfSymbols =
Data.size() + 5;
737 Header->SizeOfOptionalHeader = 0;
742 void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
744 CurrentOffset +=
sizeof(coff_file_header);
745 auto *SectionOneHeader =
746 reinterpret_cast<coff_section *
>(BufferStart + CurrentOffset);
748 SectionOneHeader->VirtualSize = 0;
749 SectionOneHeader->VirtualAddress = 0;
750 SectionOneHeader->SizeOfRawData = SectionOneSize;
751 SectionOneHeader->PointerToRawData = SectionOneOffset;
752 SectionOneHeader->PointerToRelocations = SectionOneRelocations;
753 SectionOneHeader->PointerToLinenumbers = 0;
754 SectionOneHeader->NumberOfRelocations =
Data.size();
755 SectionOneHeader->NumberOfLinenumbers = 0;
760 void WindowsResourceCOFFWriter::writeSecondSectionHeader() {
762 CurrentOffset +=
sizeof(coff_section);
763 auto *SectionTwoHeader =
764 reinterpret_cast<coff_section *
>(BufferStart + CurrentOffset);
766 SectionTwoHeader->VirtualSize = 0;
767 SectionTwoHeader->VirtualAddress = 0;
768 SectionTwoHeader->SizeOfRawData = SectionTwoSize;
769 SectionTwoHeader->PointerToRawData = SectionTwoOffset;
770 SectionTwoHeader->PointerToRelocations = 0;
771 SectionTwoHeader->PointerToLinenumbers = 0;
772 SectionTwoHeader->NumberOfRelocations = 0;
773 SectionTwoHeader->NumberOfLinenumbers = 0;
778 void WindowsResourceCOFFWriter::writeFirstSection() {
780 CurrentOffset +=
sizeof(coff_section);
782 writeDirectoryTree();
783 writeDirectoryStringTable();
784 writeFirstSectionRelocations();
789 void WindowsResourceCOFFWriter::writeSecondSection() {
791 for (
auto const &RawDataEntry : Data) {
792 llvm::copy(RawDataEntry, BufferStart + CurrentOffset);
799 void WindowsResourceCOFFWriter::writeSymbolTable() {
805 Symbol->SectionNumber = 0xffff;
808 Symbol->NumberOfAuxSymbols = 0;
815 Symbol->SectionNumber = 1;
818 Symbol->NumberOfAuxSymbols = 1;
820 auto *Aux =
reinterpret_cast<coff_aux_section_definition *
>(BufferStart +
822 Aux->Length = SectionOneSize;
823 Aux->NumberOfRelocations =
Data.size();
824 Aux->NumberOfLinenumbers = 0;
826 Aux->NumberLowPart = 0;
828 CurrentOffset +=
sizeof(coff_aux_section_definition);
834 Symbol->SectionNumber = 2;
837 Symbol->NumberOfAuxSymbols = 1;
839 Aux =
reinterpret_cast<coff_aux_section_definition *
>(BufferStart +
841 Aux->Length = SectionTwoSize;
842 Aux->NumberOfRelocations = 0;
843 Aux->NumberOfLinenumbers = 0;
845 Aux->NumberLowPart = 0;
847 CurrentOffset +=
sizeof(coff_aux_section_definition);
850 for (
unsigned i = 0;
i <
Data.size();
i++) {
854 Symbol->Value = DataOffsets[
i];
855 Symbol->SectionNumber = 2;
858 Symbol->NumberOfAuxSymbols = 0;
863 void WindowsResourceCOFFWriter::writeStringTable() {
865 auto COFFStringTable =
reinterpret_cast<void *
>(BufferStart + CurrentOffset);
866 memset(COFFStringTable, 0, 4);
869 void WindowsResourceCOFFWriter::writeDirectoryTree() {
872 std::queue<const WindowsResourceParser::TreeNode *>
Queue;
873 Queue.push(&Resources);
877 sizeof(coff_resource_dir_entry);
878 std::vector<const WindowsResourceParser::TreeNode *> DataEntriesTreeOrder;
881 while (!
Queue.empty()) {
882 auto CurrentNode =
Queue.front();
884 auto *Table =
reinterpret_cast<coff_resource_dir_table *
>(BufferStart +
886 Table->Characteristics = CurrentNode->getCharacteristics();
887 Table->TimeDateStamp = 0;
888 Table->MajorVersion = CurrentNode->getMajorVersion();
889 Table->MinorVersion = CurrentNode->getMinorVersion();
890 auto &IDChildren = CurrentNode->getIDChildren();
891 auto &StringChildren = CurrentNode->getStringChildren();
892 Table->NumberOfNameEntries = StringChildren.size();
893 Table->NumberOfIDEntries = IDChildren.size();
894 CurrentOffset +=
sizeof(coff_resource_dir_table);
895 CurrentRelativeOffset +=
sizeof(coff_resource_dir_table);
898 for (
auto const &Child : StringChildren) {
899 auto *Entry =
reinterpret_cast<coff_resource_dir_entry *
>(BufferStart +
901 Entry->Identifier.setNameOffset(
902 StringTableOffsets[Child.second->getStringIndex()]);
903 if (Child.second->checkIsDataNode()) {
904 Entry->Offset.DataEntryOffset = NextLevelOffset;
905 NextLevelOffset +=
sizeof(coff_resource_data_entry);
906 DataEntriesTreeOrder.push_back(Child.second.get());
908 Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
909 NextLevelOffset +=
sizeof(coff_resource_dir_table) +
910 (Child.second->getStringChildren().size() +
911 Child.second->getIDChildren().size()) *
912 sizeof(coff_resource_dir_entry);
913 Queue.push(Child.second.get());
915 CurrentOffset +=
sizeof(coff_resource_dir_entry);
916 CurrentRelativeOffset +=
sizeof(coff_resource_dir_entry);
918 for (
auto const &Child : IDChildren) {
919 auto *Entry =
reinterpret_cast<coff_resource_dir_entry *
>(BufferStart +
921 Entry->Identifier.ID = Child.first;
922 if (Child.second->checkIsDataNode()) {
923 Entry->Offset.DataEntryOffset = NextLevelOffset;
924 NextLevelOffset +=
sizeof(coff_resource_data_entry);
925 DataEntriesTreeOrder.push_back(Child.second.get());
927 Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
928 NextLevelOffset +=
sizeof(coff_resource_dir_table) +
929 (Child.second->getStringChildren().size() +
930 Child.second->getIDChildren().size()) *
931 sizeof(coff_resource_dir_entry);
932 Queue.push(Child.second.get());
934 CurrentOffset +=
sizeof(coff_resource_dir_entry);
935 CurrentRelativeOffset +=
sizeof(coff_resource_dir_entry);
939 RelocationAddresses.resize(
Data.size());
941 for (
auto DataNodes : DataEntriesTreeOrder) {
942 auto *Entry =
reinterpret_cast<coff_resource_data_entry *
>(BufferStart +
944 RelocationAddresses[DataNodes->getDataIndex()] = CurrentRelativeOffset;
946 Entry->DataSize =
Data[DataNodes->getDataIndex()].size();
949 CurrentOffset +=
sizeof(coff_resource_data_entry);
950 CurrentRelativeOffset +=
sizeof(coff_resource_data_entry);
954 void WindowsResourceCOFFWriter::writeDirectoryStringTable() {
957 for (
auto &String : StringTable) {
961 auto *Start =
reinterpret_cast<UTF16 *
>(BufferStart + CurrentOffset);
963 CurrentOffset += Length *
sizeof(
UTF16);
964 TotalStringTableSize += Length *
sizeof(
UTF16) +
sizeof(
uint16_t);
967 alignTo(TotalStringTableSize,
sizeof(
uint32_t)) - TotalStringTableSize;
970 void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
976 for (
unsigned i = 0;
i <
Data.size();
i++) {
978 reinterpret_cast<coff_relocation *
>(BufferStart + CurrentOffset);
979 Reloc->VirtualAddress = RelocationAddresses[
i];
980 Reloc->SymbolTableIndex = NextSymbolIndex++;
981 switch (MachineType) {
997 CurrentOffset +=
sizeof(coff_relocation);
1009 return Writer.
write(TimeDateStamp);