1 //===-- WindowsResource.cpp -------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the .res file class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/Object/WindowsResource.h"
14 #include "llvm/Object/COFF.h"
15 #include "llvm/Support/FileOutputBuffer.h"
16 #include "llvm/Support/FormatVariadic.h"
17 #include "llvm/Support/MathExtras.h"
18 #include "llvm/Support/ScopedPrinter.h"
19 #include <ctime>
20 #include <queue>
21 #include <system_error>
22 
23 using namespace llvm;
24 using namespace object;
25 
26 namespace llvm {
27 namespace object {
28 
29 #define RETURN_IF_ERROR(X)                                                     \
30   if (auto EC = X)                                                             \
31     return EC;
32 
33 const uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
34 
35 // COFF files seem to be inconsistent with alignment between sections, just use
36 // 8-byte because it makes everyone happy.
37 const uint32_t SECTION_ALIGNMENT = sizeof(uint64_t);
38 
39 uint32_t WindowsResourceParser::TreeNode::StringCount = 0;
40 uint32_t WindowsResourceParser::TreeNode::DataCount = 0;
41 
42 WindowsResource::WindowsResource(MemoryBufferRef Source)
43     : Binary(Binary::ID_WinRes, Source) {
44   size_t LeadingSize = WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE;
45   BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize),
46                          support::little);
47 }
48 
49 Expected<std::unique_ptr<WindowsResource>>
50 WindowsResource::createWindowsResource(MemoryBufferRef Source) {
51   if (Source.getBufferSize() < WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE)
52     return make_error<GenericBinaryError>(
53         "File too small to be a resource file",
54         object_error::invalid_file_type);
55   std::unique_ptr<WindowsResource> Ret(new WindowsResource(Source));
56   return std::move(Ret);
57 }
58 
59 Expected<ResourceEntryRef> WindowsResource::getHeadEntry() {
60   if (BBS.getLength() < sizeof(WinResHeaderPrefix) + sizeof(WinResHeaderSuffix))
61     return make_error<EmptyResError>(".res contains no entries",
62                                      object_error::unexpected_eof);
63   return ResourceEntryRef::create(BinaryStreamRef(BBS), this);
64 }
65 
66 ResourceEntryRef::ResourceEntryRef(BinaryStreamRef Ref,
67                                    const WindowsResource *Owner)
68     : Reader(Ref) {}
69 
70 Expected<ResourceEntryRef>
71 ResourceEntryRef::create(BinaryStreamRef BSR, const WindowsResource *Owner) {
72   auto Ref = ResourceEntryRef(BSR, Owner);
73   if (auto E = Ref.loadNext())
74     return std::move(E);
75   return Ref;
76 }
77 
78 Error ResourceEntryRef::moveNext(bool &End) {
79   // Reached end of all the entries.
80   if (Reader.bytesRemaining() == 0) {
81     End = true;
82     return Error::success();
83   }
84   RETURN_IF_ERROR(loadNext());
85 
86   return Error::success();
87 }
88 
89 static Error readStringOrId(BinaryStreamReader &Reader, uint16_t &ID,
90                             ArrayRef<UTF16> &Str, bool &IsString) {
91   uint16_t IDFlag;
92   RETURN_IF_ERROR(Reader.readInteger(IDFlag));
93   IsString = IDFlag != 0xffff;
94 
95   if (IsString) {
96     Reader.setOffset(
97         Reader.getOffset() -
98         sizeof(uint16_t)); // Re-read the bytes which we used to check the flag.
99     RETURN_IF_ERROR(Reader.readWideString(Str));
100   } else
101     RETURN_IF_ERROR(Reader.readInteger(ID));
102 
103   return Error::success();
104 }
105 
106 Error ResourceEntryRef::loadNext() {
107   const WinResHeaderPrefix *Prefix;
108   RETURN_IF_ERROR(Reader.readObject(Prefix));
109 
110   if (Prefix->HeaderSize < MIN_HEADER_SIZE)
111     return make_error<GenericBinaryError>("Header size is too small.",
112                                           object_error::parse_failed);
113 
114   RETURN_IF_ERROR(readStringOrId(Reader, TypeID, Type, IsStringType));
115 
116   RETURN_IF_ERROR(readStringOrId(Reader, NameID, Name, IsStringName));
117 
118   RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_HEADER_ALIGNMENT));
119 
120   RETURN_IF_ERROR(Reader.readObject(Suffix));
121 
122   RETURN_IF_ERROR(Reader.readArray(Data, Prefix->DataSize));
123 
124   RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_DATA_ALIGNMENT));
125 
126   return Error::success();
127 }
128 
129 WindowsResourceParser::WindowsResourceParser() : Root(false) {}
130 
131 void printResourceTypeName(uint16_t TypeID, raw_ostream &OS) {
132   switch (TypeID) {
133   case  1: OS << "CURSOR (ID 1)"; break;
134   case  2: OS << "BITMAP (ID 2)"; break;
135   case  3: OS << "ICON (ID 3)"; break;
136   case  4: OS << "MENU (ID 4)"; break;
137   case  5: OS << "DIALOG (ID 5)"; break;
138   case  6: OS << "STRINGTABLE (ID 6)"; break;
139   case  7: OS << "FONTDIR (ID 7)"; break;
140   case  8: OS << "FONT (ID 8)"; break;
141   case  9: OS << "ACCELERATOR (ID 9)"; break;
142   case 10: OS << "RCDATA (ID 10)"; break;
143   case 11: OS << "MESSAGETABLE (ID 11)"; break;
144   case 12: OS << "GROUP_CURSOR (ID 12)"; break;
145   case 14: OS << "GROUP_ICON (ID 14)"; break;
146   case 16: OS << "VERSIONINFO (ID 16)"; break;
147   case 17: OS << "DLGINCLUDE (ID 17)"; break;
148   case 19: OS << "PLUGPLAY (ID 19)"; break;
149   case 20: OS << "VXD (ID 20)"; break;
150   case 21: OS << "ANICURSOR (ID 21)"; break;
151   case 22: OS << "ANIICON (ID 22)"; break;
152   case 23: OS << "HTML (ID 23)"; break;
153   case 24: OS << "MANIFEST (ID 24)"; break;
154   default: OS << "ID " << TypeID; break;
155   }
156 }
157 
158 static bool convertUTF16LEToUTF8String(ArrayRef<UTF16> Src, std::string &Out) {
159   if (!sys::IsBigEndianHost)
160     return convertUTF16ToUTF8String(Src, Out);
161 
162   std::vector<UTF16> EndianCorrectedSrc;
163   EndianCorrectedSrc.resize(Src.size() + 1);
164   llvm::copy(Src, EndianCorrectedSrc.begin() + 1);
165   EndianCorrectedSrc[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
166   return convertUTF16ToUTF8String(makeArrayRef(EndianCorrectedSrc), Out);
167 }
168 
169 static Error makeDuplicateResourceError(const ResourceEntryRef &Entry,
170                                         StringRef File1, StringRef File2) {
171   std::string Ret;
172   raw_string_ostream OS(Ret);
173 
174   OS << "duplicate resource:";
175 
176   OS << " type ";
177   if (Entry.checkTypeString()) {
178     std::string UTF8;
179     if (!convertUTF16LEToUTF8String(Entry.getTypeString(), UTF8))
180       UTF8 = "(failed conversion from UTF16)";
181     OS << '\"' << UTF8 << '\"';
182   } else
183     printResourceTypeName(Entry.getTypeID(), OS);
184 
185   OS << "/name ";
186   if (Entry.checkNameString()) {
187     std::string UTF8;
188     if (!convertUTF16LEToUTF8String(Entry.getNameString(), UTF8))
189       UTF8 = "(failed conversion from UTF16)";
190     OS << '\"' << UTF8 << '\"';
191   } else {
192     OS << "ID " << Entry.getNameID();
193   }
194 
195   OS << "/language " << Entry.getLanguage() << ", in " << File1 << " and in "
196      << File2;
197 
198   return make_error<GenericBinaryError>(OS.str(), object_error::parse_failed);
199 }
200 
201 Error WindowsResourceParser::parse(WindowsResource *WR) {
202   auto EntryOrErr = WR->getHeadEntry();
203   if (!EntryOrErr) {
204     auto E = EntryOrErr.takeError();
205     if (E.isA<EmptyResError>()) {
206       // Check if the .res file contains no entries.  In this case we don't have
207       // to throw an error but can rather just return without parsing anything.
208       // This applies for files which have a valid PE header magic and the
209       // mandatory empty null resource entry.  Files which do not fit this
210       // criteria would have already been filtered out by
211       // WindowsResource::createWindowsResource().
212       consumeError(std::move(E));
213       return Error::success();
214     }
215     return E;
216   }
217 
218   ResourceEntryRef Entry = EntryOrErr.get();
219   bool End = false;
220   while (!End) {
221     Data.push_back(Entry.getData());
222 
223     bool IsNewTypeString = false;
224     bool IsNewNameString = false;
225 
226     TreeNode* Node;
227     bool IsNewNode = Root.addEntry(Entry, InputFilenames.size(),
228                                    IsNewTypeString, IsNewNameString, Node);
229     InputFilenames.push_back(WR->getFileName());
230     if (!IsNewNode)
231       return makeDuplicateResourceError(Entry, InputFilenames[Node->Origin],
232                                         WR->getFileName());
233 
234     if (IsNewTypeString)
235       StringTable.push_back(Entry.getTypeString());
236 
237     if (IsNewNameString)
238       StringTable.push_back(Entry.getNameString());
239 
240     RETURN_IF_ERROR(Entry.moveNext(End));
241   }
242 
243   return Error::success();
244 }
245 
246 void WindowsResourceParser::printTree(raw_ostream &OS) const {
247   ScopedPrinter Writer(OS);
248   Root.print(Writer, "Resource Tree");
249 }
250 
251 bool WindowsResourceParser::TreeNode::addEntry(const ResourceEntryRef &Entry,
252                                                uint32_t Origin,
253                                                bool &IsNewTypeString,
254                                                bool &IsNewNameString,
255                                                TreeNode *&Result) {
256   TreeNode &TypeNode = addTypeNode(Entry, IsNewTypeString);
257   TreeNode &NameNode = TypeNode.addNameNode(Entry, IsNewNameString);
258   return NameNode.addLanguageNode(Entry, Origin, Result);
259 }
260 
261 WindowsResourceParser::TreeNode::TreeNode(bool IsStringNode) {
262   if (IsStringNode)
263     StringIndex = StringCount++;
264 }
265 
266 WindowsResourceParser::TreeNode::TreeNode(uint16_t MajorVersion,
267                                           uint16_t MinorVersion,
268                                           uint32_t Characteristics,
269                                           uint32_t Origin)
270     : IsDataNode(true), MajorVersion(MajorVersion), MinorVersion(MinorVersion),
271       Characteristics(Characteristics), Origin(Origin) {
272   DataIndex = DataCount++;
273 }
274 
275 std::unique_ptr<WindowsResourceParser::TreeNode>
276 WindowsResourceParser::TreeNode::createStringNode() {
277   return std::unique_ptr<TreeNode>(new TreeNode(true));
278 }
279 
280 std::unique_ptr<WindowsResourceParser::TreeNode>
281 WindowsResourceParser::TreeNode::createIDNode() {
282   return std::unique_ptr<TreeNode>(new TreeNode(false));
283 }
284 
285 std::unique_ptr<WindowsResourceParser::TreeNode>
286 WindowsResourceParser::TreeNode::createDataNode(uint16_t MajorVersion,
287                                                 uint16_t MinorVersion,
288                                                 uint32_t Characteristics,
289                                                 uint32_t Origin) {
290   return std::unique_ptr<TreeNode>(
291       new TreeNode(MajorVersion, MinorVersion, Characteristics, Origin));
292 }
293 
294 WindowsResourceParser::TreeNode &
295 WindowsResourceParser::TreeNode::addTypeNode(const ResourceEntryRef &Entry,
296                                              bool &IsNewTypeString) {
297   if (Entry.checkTypeString())
298     return addNameChild(Entry.getTypeString(), IsNewTypeString);
299   else
300     return addIDChild(Entry.getTypeID());
301 }
302 
303 WindowsResourceParser::TreeNode &
304 WindowsResourceParser::TreeNode::addNameNode(const ResourceEntryRef &Entry,
305                                              bool &IsNewNameString) {
306   if (Entry.checkNameString())
307     return addNameChild(Entry.getNameString(), IsNewNameString);
308   else
309     return addIDChild(Entry.getNameID());
310 }
311 
312 bool WindowsResourceParser::TreeNode::addLanguageNode(
313     const ResourceEntryRef &Entry, uint32_t Origin, TreeNode *&Result) {
314   return addDataChild(Entry.getLanguage(), Entry.getMajorVersion(),
315                       Entry.getMinorVersion(), Entry.getCharacteristics(),
316                       Origin, Result);
317 }
318 
319 bool WindowsResourceParser::TreeNode::addDataChild(
320     uint32_t ID, uint16_t MajorVersion, uint16_t MinorVersion,
321     uint32_t Characteristics, uint32_t Origin, TreeNode *&Result) {
322   auto NewChild =
323       createDataNode(MajorVersion, MinorVersion, Characteristics, Origin);
324   auto ElementInserted = IDChildren.emplace(ID, std::move(NewChild));
325   Result = ElementInserted.first->second.get();
326   return ElementInserted.second;
327 }
328 
329 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addIDChild(
330     uint32_t ID) {
331   auto Child = IDChildren.find(ID);
332   if (Child == IDChildren.end()) {
333     auto NewChild = createIDNode();
334     WindowsResourceParser::TreeNode &Node = *NewChild;
335     IDChildren.emplace(ID, std::move(NewChild));
336     return Node;
337   } else
338     return *(Child->second);
339 }
340 
341 WindowsResourceParser::TreeNode &
342 WindowsResourceParser::TreeNode::addNameChild(ArrayRef<UTF16> NameRef,
343                                               bool &IsNewString) {
344   std::string NameString;
345   convertUTF16LEToUTF8String(NameRef, NameString);
346 
347   auto Child = StringChildren.find(NameString);
348   if (Child == StringChildren.end()) {
349     auto NewChild = createStringNode();
350     IsNewString = true;
351     WindowsResourceParser::TreeNode &Node = *NewChild;
352     StringChildren.emplace(NameString, std::move(NewChild));
353     return Node;
354   } else
355     return *(Child->second);
356 }
357 
358 void WindowsResourceParser::TreeNode::print(ScopedPrinter &Writer,
359                                             StringRef Name) const {
360   ListScope NodeScope(Writer, Name);
361   for (auto const &Child : StringChildren) {
362     Child.second->print(Writer, Child.first);
363   }
364   for (auto const &Child : IDChildren) {
365     Child.second->print(Writer, to_string(Child.first));
366   }
367 }
368 
369 // This function returns the size of the entire resource tree, including
370 // directory tables, directory entries, and data entries.  It does not include
371 // the directory strings or the relocations of the .rsrc section.
372 uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
373   uint32_t Size = (IDChildren.size() + StringChildren.size()) *
374                   sizeof(coff_resource_dir_entry);
375 
376   // Reached a node pointing to a data entry.
377   if (IsDataNode) {
378     Size += sizeof(coff_resource_data_entry);
379     return Size;
380   }
381 
382   // If the node does not point to data, it must have a directory table pointing
383   // to other nodes.
384   Size += sizeof(coff_resource_dir_table);
385 
386   for (auto const &Child : StringChildren) {
387     Size += Child.second->getTreeSize();
388   }
389   for (auto const &Child : IDChildren) {
390     Size += Child.second->getTreeSize();
391   }
392   return Size;
393 }
394 
395 class WindowsResourceCOFFWriter {
396 public:
397   WindowsResourceCOFFWriter(COFF::MachineTypes MachineType,
398                             const WindowsResourceParser &Parser, Error &E);
399   std::unique_ptr<MemoryBuffer> write();
400 
401 private:
402   void performFileLayout();
403   void performSectionOneLayout();
404   void performSectionTwoLayout();
405   void writeCOFFHeader();
406   void writeFirstSectionHeader();
407   void writeSecondSectionHeader();
408   void writeFirstSection();
409   void writeSecondSection();
410   void writeSymbolTable();
411   void writeStringTable();
412   void writeDirectoryTree();
413   void writeDirectoryStringTable();
414   void writeFirstSectionRelocations();
415   std::unique_ptr<WritableMemoryBuffer> OutputBuffer;
416   char *BufferStart;
417   uint64_t CurrentOffset = 0;
418   COFF::MachineTypes MachineType;
419   const WindowsResourceParser::TreeNode &Resources;
420   const ArrayRef<std::vector<uint8_t>> Data;
421   uint64_t FileSize;
422   uint32_t SymbolTableOffset;
423   uint32_t SectionOneSize;
424   uint32_t SectionOneOffset;
425   uint32_t SectionOneRelocations;
426   uint32_t SectionTwoSize;
427   uint32_t SectionTwoOffset;
428   const ArrayRef<std::vector<UTF16>> StringTable;
429   std::vector<uint32_t> StringTableOffsets;
430   std::vector<uint32_t> DataOffsets;
431   std::vector<uint32_t> RelocationAddresses;
432 };
433 
434 WindowsResourceCOFFWriter::WindowsResourceCOFFWriter(
435     COFF::MachineTypes MachineType, const WindowsResourceParser &Parser,
436     Error &E)
437     : MachineType(MachineType), Resources(Parser.getTree()),
438       Data(Parser.getData()), StringTable(Parser.getStringTable()) {
439   performFileLayout();
440 
441   OutputBuffer = WritableMemoryBuffer::getNewMemBuffer(FileSize);
442 }
443 
444 void WindowsResourceCOFFWriter::performFileLayout() {
445   // Add size of COFF header.
446   FileSize = COFF::Header16Size;
447 
448   // one .rsrc section header for directory tree, another for resource data.
449   FileSize += 2 * COFF::SectionSize;
450 
451   performSectionOneLayout();
452   performSectionTwoLayout();
453 
454   // We have reached the address of the symbol table.
455   SymbolTableOffset = FileSize;
456 
457   FileSize += COFF::Symbol16Size;     // size of the @feat.00 symbol.
458   FileSize += 4 * COFF::Symbol16Size; // symbol + aux for each section.
459   FileSize += Data.size() * COFF::Symbol16Size; // 1 symbol per resource.
460   FileSize += 4; // four null bytes for the string table.
461 }
462 
463 void WindowsResourceCOFFWriter::performSectionOneLayout() {
464   SectionOneOffset = FileSize;
465 
466   SectionOneSize = Resources.getTreeSize();
467   uint32_t CurrentStringOffset = SectionOneSize;
468   uint32_t TotalStringTableSize = 0;
469   for (auto const &String : StringTable) {
470     StringTableOffsets.push_back(CurrentStringOffset);
471     uint32_t StringSize = String.size() * sizeof(UTF16) + sizeof(uint16_t);
472     CurrentStringOffset += StringSize;
473     TotalStringTableSize += StringSize;
474   }
475   SectionOneSize += alignTo(TotalStringTableSize, sizeof(uint32_t));
476 
477   // account for the relocations of section one.
478   SectionOneRelocations = FileSize + SectionOneSize;
479   FileSize += SectionOneSize;
480   FileSize +=
481       Data.size() * COFF::RelocationSize; // one relocation for each resource.
482   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
483 }
484 
485 void WindowsResourceCOFFWriter::performSectionTwoLayout() {
486   // add size of .rsrc$2 section, which contains all resource data on 8-byte
487   // alignment.
488   SectionTwoOffset = FileSize;
489   SectionTwoSize = 0;
490   for (auto const &Entry : Data) {
491     DataOffsets.push_back(SectionTwoSize);
492     SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
493   }
494   FileSize += SectionTwoSize;
495   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
496 }
497 
498 static std::time_t getTime() {
499   std::time_t Now = time(nullptr);
500   if (Now < 0 || !isUInt<32>(Now))
501     return UINT32_MAX;
502   return Now;
503 }
504 
505 std::unique_ptr<MemoryBuffer> WindowsResourceCOFFWriter::write() {
506   BufferStart = OutputBuffer->getBufferStart();
507 
508   writeCOFFHeader();
509   writeFirstSectionHeader();
510   writeSecondSectionHeader();
511   writeFirstSection();
512   writeSecondSection();
513   writeSymbolTable();
514   writeStringTable();
515 
516   return std::move(OutputBuffer);
517 }
518 
519 void WindowsResourceCOFFWriter::writeCOFFHeader() {
520   // Write the COFF header.
521   auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
522   Header->Machine = MachineType;
523   Header->NumberOfSections = 2;
524   Header->TimeDateStamp = getTime();
525   Header->PointerToSymbolTable = SymbolTableOffset;
526   // One symbol for every resource plus 2 for each section and @feat.00
527   Header->NumberOfSymbols = Data.size() + 5;
528   Header->SizeOfOptionalHeader = 0;
529   Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
530 }
531 
532 void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
533   // Write the first section header.
534   CurrentOffset += sizeof(coff_file_header);
535   auto *SectionOneHeader =
536       reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
537   strncpy(SectionOneHeader->Name, ".rsrc$01", (size_t)COFF::NameSize);
538   SectionOneHeader->VirtualSize = 0;
539   SectionOneHeader->VirtualAddress = 0;
540   SectionOneHeader->SizeOfRawData = SectionOneSize;
541   SectionOneHeader->PointerToRawData = SectionOneOffset;
542   SectionOneHeader->PointerToRelocations = SectionOneRelocations;
543   SectionOneHeader->PointerToLinenumbers = 0;
544   SectionOneHeader->NumberOfRelocations = Data.size();
545   SectionOneHeader->NumberOfLinenumbers = 0;
546   SectionOneHeader->Characteristics += COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
547   SectionOneHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
548 }
549 
550 void WindowsResourceCOFFWriter::writeSecondSectionHeader() {
551   // Write the second section header.
552   CurrentOffset += sizeof(coff_section);
553   auto *SectionTwoHeader =
554       reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
555   strncpy(SectionTwoHeader->Name, ".rsrc$02", (size_t)COFF::NameSize);
556   SectionTwoHeader->VirtualSize = 0;
557   SectionTwoHeader->VirtualAddress = 0;
558   SectionTwoHeader->SizeOfRawData = SectionTwoSize;
559   SectionTwoHeader->PointerToRawData = SectionTwoOffset;
560   SectionTwoHeader->PointerToRelocations = 0;
561   SectionTwoHeader->PointerToLinenumbers = 0;
562   SectionTwoHeader->NumberOfRelocations = 0;
563   SectionTwoHeader->NumberOfLinenumbers = 0;
564   SectionTwoHeader->Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
565   SectionTwoHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
566 }
567 
568 void WindowsResourceCOFFWriter::writeFirstSection() {
569   // Write section one.
570   CurrentOffset += sizeof(coff_section);
571 
572   writeDirectoryTree();
573   writeDirectoryStringTable();
574   writeFirstSectionRelocations();
575 
576   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
577 }
578 
579 void WindowsResourceCOFFWriter::writeSecondSection() {
580   // Now write the .rsrc$02 section.
581   for (auto const &RawDataEntry : Data) {
582     llvm::copy(RawDataEntry, BufferStart + CurrentOffset);
583     CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
584   }
585 
586   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
587 }
588 
589 void WindowsResourceCOFFWriter::writeSymbolTable() {
590   // Now write the symbol table.
591   // First, the feat symbol.
592   auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
593   strncpy(Symbol->Name.ShortName, "@feat.00", (size_t)COFF::NameSize);
594   Symbol->Value = 0x11;
595   Symbol->SectionNumber = 0xffff;
596   Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
597   Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
598   Symbol->NumberOfAuxSymbols = 0;
599   CurrentOffset += sizeof(coff_symbol16);
600 
601   // Now write the .rsrc1 symbol + aux.
602   Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
603   strncpy(Symbol->Name.ShortName, ".rsrc$01", (size_t)COFF::NameSize);
604   Symbol->Value = 0;
605   Symbol->SectionNumber = 1;
606   Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
607   Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
608   Symbol->NumberOfAuxSymbols = 1;
609   CurrentOffset += sizeof(coff_symbol16);
610   auto *Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
611                                                               CurrentOffset);
612   Aux->Length = SectionOneSize;
613   Aux->NumberOfRelocations = Data.size();
614   Aux->NumberOfLinenumbers = 0;
615   Aux->CheckSum = 0;
616   Aux->NumberLowPart = 0;
617   Aux->Selection = 0;
618   CurrentOffset += sizeof(coff_aux_section_definition);
619 
620   // Now write the .rsrc2 symbol + aux.
621   Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
622   strncpy(Symbol->Name.ShortName, ".rsrc$02", (size_t)COFF::NameSize);
623   Symbol->Value = 0;
624   Symbol->SectionNumber = 2;
625   Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
626   Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
627   Symbol->NumberOfAuxSymbols = 1;
628   CurrentOffset += sizeof(coff_symbol16);
629   Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
630                                                         CurrentOffset);
631   Aux->Length = SectionTwoSize;
632   Aux->NumberOfRelocations = 0;
633   Aux->NumberOfLinenumbers = 0;
634   Aux->CheckSum = 0;
635   Aux->NumberLowPart = 0;
636   Aux->Selection = 0;
637   CurrentOffset += sizeof(coff_aux_section_definition);
638 
639   // Now write a symbol for each relocation.
640   for (unsigned i = 0; i < Data.size(); i++) {
641     auto RelocationName = formatv("$R{0:X-6}", i & 0xffffff).sstr<COFF::NameSize>();
642     Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
643     memcpy(Symbol->Name.ShortName, RelocationName.data(), (size_t) COFF::NameSize);
644     Symbol->Value = DataOffsets[i];
645     Symbol->SectionNumber = 2;
646     Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
647     Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
648     Symbol->NumberOfAuxSymbols = 0;
649     CurrentOffset += sizeof(coff_symbol16);
650   }
651 }
652 
653 void WindowsResourceCOFFWriter::writeStringTable() {
654   // Just 4 null bytes for the string table.
655   auto COFFStringTable = reinterpret_cast<void *>(BufferStart + CurrentOffset);
656   memset(COFFStringTable, 0, 4);
657 }
658 
659 void WindowsResourceCOFFWriter::writeDirectoryTree() {
660   // Traverse parsed resource tree breadth-first and write the corresponding
661   // COFF objects.
662   std::queue<const WindowsResourceParser::TreeNode *> Queue;
663   Queue.push(&Resources);
664   uint32_t NextLevelOffset =
665       sizeof(coff_resource_dir_table) + (Resources.getStringChildren().size() +
666                                          Resources.getIDChildren().size()) *
667                                             sizeof(coff_resource_dir_entry);
668   std::vector<const WindowsResourceParser::TreeNode *> DataEntriesTreeOrder;
669   uint32_t CurrentRelativeOffset = 0;
670 
671   while (!Queue.empty()) {
672     auto CurrentNode = Queue.front();
673     Queue.pop();
674     auto *Table = reinterpret_cast<coff_resource_dir_table *>(BufferStart +
675                                                               CurrentOffset);
676     Table->Characteristics = CurrentNode->getCharacteristics();
677     Table->TimeDateStamp = 0;
678     Table->MajorVersion = CurrentNode->getMajorVersion();
679     Table->MinorVersion = CurrentNode->getMinorVersion();
680     auto &IDChildren = CurrentNode->getIDChildren();
681     auto &StringChildren = CurrentNode->getStringChildren();
682     Table->NumberOfNameEntries = StringChildren.size();
683     Table->NumberOfIDEntries = IDChildren.size();
684     CurrentOffset += sizeof(coff_resource_dir_table);
685     CurrentRelativeOffset += sizeof(coff_resource_dir_table);
686 
687     // Write the directory entries immediately following each directory table.
688     for (auto const &Child : StringChildren) {
689       auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
690                                                                 CurrentOffset);
691       Entry->Identifier.setNameOffset(
692           StringTableOffsets[Child.second->getStringIndex()]);
693       if (Child.second->checkIsDataNode()) {
694         Entry->Offset.DataEntryOffset = NextLevelOffset;
695         NextLevelOffset += sizeof(coff_resource_data_entry);
696         DataEntriesTreeOrder.push_back(Child.second.get());
697       } else {
698         Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
699         NextLevelOffset += sizeof(coff_resource_dir_table) +
700                            (Child.second->getStringChildren().size() +
701                             Child.second->getIDChildren().size()) *
702                                sizeof(coff_resource_dir_entry);
703         Queue.push(Child.second.get());
704       }
705       CurrentOffset += sizeof(coff_resource_dir_entry);
706       CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
707     }
708     for (auto const &Child : IDChildren) {
709       auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
710                                                                 CurrentOffset);
711       Entry->Identifier.ID = Child.first;
712       if (Child.second->checkIsDataNode()) {
713         Entry->Offset.DataEntryOffset = NextLevelOffset;
714         NextLevelOffset += sizeof(coff_resource_data_entry);
715         DataEntriesTreeOrder.push_back(Child.second.get());
716       } else {
717         Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
718         NextLevelOffset += sizeof(coff_resource_dir_table) +
719                            (Child.second->getStringChildren().size() +
720                             Child.second->getIDChildren().size()) *
721                                sizeof(coff_resource_dir_entry);
722         Queue.push(Child.second.get());
723       }
724       CurrentOffset += sizeof(coff_resource_dir_entry);
725       CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
726     }
727   }
728 
729   RelocationAddresses.resize(Data.size());
730   // Now write all the resource data entries.
731   for (auto DataNodes : DataEntriesTreeOrder) {
732     auto *Entry = reinterpret_cast<coff_resource_data_entry *>(BufferStart +
733                                                                CurrentOffset);
734     RelocationAddresses[DataNodes->getDataIndex()] = CurrentRelativeOffset;
735     Entry->DataRVA = 0; // Set to zero because it is a relocation.
736     Entry->DataSize = Data[DataNodes->getDataIndex()].size();
737     Entry->Codepage = 0;
738     Entry->Reserved = 0;
739     CurrentOffset += sizeof(coff_resource_data_entry);
740     CurrentRelativeOffset += sizeof(coff_resource_data_entry);
741   }
742 }
743 
744 void WindowsResourceCOFFWriter::writeDirectoryStringTable() {
745   // Now write the directory string table for .rsrc$01
746   uint32_t TotalStringTableSize = 0;
747   for (auto &String : StringTable) {
748     uint16_t Length = String.size();
749     support::endian::write16le(BufferStart + CurrentOffset, Length);
750     CurrentOffset += sizeof(uint16_t);
751     auto *Start = reinterpret_cast<UTF16 *>(BufferStart + CurrentOffset);
752     llvm::copy(String, Start);
753     CurrentOffset += Length * sizeof(UTF16);
754     TotalStringTableSize += Length * sizeof(UTF16) + sizeof(uint16_t);
755   }
756   CurrentOffset +=
757       alignTo(TotalStringTableSize, sizeof(uint32_t)) - TotalStringTableSize;
758 }
759 
760 void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
761 
762   // Now write the relocations for .rsrc$01
763   // Five symbols already in table before we start, @feat.00 and 2 for each
764   // .rsrc section.
765   uint32_t NextSymbolIndex = 5;
766   for (unsigned i = 0; i < Data.size(); i++) {
767     auto *Reloc =
768         reinterpret_cast<coff_relocation *>(BufferStart + CurrentOffset);
769     Reloc->VirtualAddress = RelocationAddresses[i];
770     Reloc->SymbolTableIndex = NextSymbolIndex++;
771     switch (MachineType) {
772     case COFF::IMAGE_FILE_MACHINE_ARMNT:
773       Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
774       break;
775     case COFF::IMAGE_FILE_MACHINE_AMD64:
776       Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
777       break;
778     case COFF::IMAGE_FILE_MACHINE_I386:
779       Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
780       break;
781     case COFF::IMAGE_FILE_MACHINE_ARM64:
782       Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
783       break;
784     default:
785       llvm_unreachable("unknown machine type");
786     }
787     CurrentOffset += sizeof(coff_relocation);
788   }
789 }
790 
791 Expected<std::unique_ptr<MemoryBuffer>>
792 writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
793                          const WindowsResourceParser &Parser) {
794   Error E = Error::success();
795   WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
796   if (E)
797     return std::move(E);
798   return Writer.write();
799 }
800 
801 } // namespace object
802 } // namespace llvm
803