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 #define UNWRAP_REF_OR_RETURN(Name, Expr)                                       \
34   auto Name##OrErr = Expr;                                                     \
35   if (!Name##OrErr)                                                            \
36     return Name##OrErr.takeError();                                            \
37   const auto &Name = *Name##OrErr;
38 
39 #define UNWRAP_OR_RETURN(Name, Expr)                                           \
40   auto Name##OrErr = Expr;                                                     \
41   if (!Name##OrErr)                                                            \
42     return Name##OrErr.takeError();                                            \
43   auto Name = *Name##OrErr;
44 
45 const uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
46 
47 // COFF files seem to be inconsistent with alignment between sections, just use
48 // 8-byte because it makes everyone happy.
49 const uint32_t SECTION_ALIGNMENT = sizeof(uint64_t);
50 
51 WindowsResource::WindowsResource(MemoryBufferRef Source)
52     : Binary(Binary::ID_WinRes, Source) {
53   size_t LeadingSize = WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE;
54   BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize),
55                          support::little);
56 }
57 
58 // static
59 Expected<std::unique_ptr<WindowsResource>>
60 WindowsResource::createWindowsResource(MemoryBufferRef Source) {
61   if (Source.getBufferSize() < WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE)
62     return make_error<GenericBinaryError>(
63         Source.getBufferIdentifier() + ": too small to be a resource file",
64         object_error::invalid_file_type);
65   std::unique_ptr<WindowsResource> Ret(new WindowsResource(Source));
66   return std::move(Ret);
67 }
68 
69 Expected<ResourceEntryRef> WindowsResource::getHeadEntry() {
70   if (BBS.getLength() < sizeof(WinResHeaderPrefix) + sizeof(WinResHeaderSuffix))
71     return make_error<EmptyResError>(getFileName() + " contains no entries",
72                                      object_error::unexpected_eof);
73   return ResourceEntryRef::create(BinaryStreamRef(BBS), this);
74 }
75 
76 ResourceEntryRef::ResourceEntryRef(BinaryStreamRef Ref,
77                                    const WindowsResource *Owner)
78     : Reader(Ref), Owner(Owner) {}
79 
80 Expected<ResourceEntryRef>
81 ResourceEntryRef::create(BinaryStreamRef BSR, const WindowsResource *Owner) {
82   auto Ref = ResourceEntryRef(BSR, Owner);
83   if (auto E = Ref.loadNext())
84     return std::move(E);
85   return Ref;
86 }
87 
88 Error ResourceEntryRef::moveNext(bool &End) {
89   // Reached end of all the entries.
90   if (Reader.bytesRemaining() == 0) {
91     End = true;
92     return Error::success();
93   }
94   RETURN_IF_ERROR(loadNext());
95 
96   return Error::success();
97 }
98 
99 static Error readStringOrId(BinaryStreamReader &Reader, uint16_t &ID,
100                             ArrayRef<UTF16> &Str, bool &IsString) {
101   uint16_t IDFlag;
102   RETURN_IF_ERROR(Reader.readInteger(IDFlag));
103   IsString = IDFlag != 0xffff;
104 
105   if (IsString) {
106     Reader.setOffset(
107         Reader.getOffset() -
108         sizeof(uint16_t)); // Re-read the bytes which we used to check the flag.
109     RETURN_IF_ERROR(Reader.readWideString(Str));
110   } else
111     RETURN_IF_ERROR(Reader.readInteger(ID));
112 
113   return Error::success();
114 }
115 
116 Error ResourceEntryRef::loadNext() {
117   const WinResHeaderPrefix *Prefix;
118   RETURN_IF_ERROR(Reader.readObject(Prefix));
119 
120   if (Prefix->HeaderSize < MIN_HEADER_SIZE)
121     return make_error<GenericBinaryError>(Owner->getFileName() +
122                                               ": header size too small",
123                                           object_error::parse_failed);
124 
125   RETURN_IF_ERROR(readStringOrId(Reader, TypeID, Type, IsStringType));
126 
127   RETURN_IF_ERROR(readStringOrId(Reader, NameID, Name, IsStringName));
128 
129   RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_HEADER_ALIGNMENT));
130 
131   RETURN_IF_ERROR(Reader.readObject(Suffix));
132 
133   RETURN_IF_ERROR(Reader.readArray(Data, Prefix->DataSize));
134 
135   RETURN_IF_ERROR(Reader.padToAlignment(WIN_RES_DATA_ALIGNMENT));
136 
137   return Error::success();
138 }
139 
140 WindowsResourceParser::WindowsResourceParser(bool MinGW)
141     : Root(false), MinGW(MinGW) {}
142 
143 void printResourceTypeName(uint16_t TypeID, raw_ostream &OS) {
144   switch (TypeID) {
145   case  1: OS << "CURSOR (ID 1)"; break;
146   case  2: OS << "BITMAP (ID 2)"; break;
147   case  3: OS << "ICON (ID 3)"; break;
148   case  4: OS << "MENU (ID 4)"; break;
149   case  5: OS << "DIALOG (ID 5)"; break;
150   case  6: OS << "STRINGTABLE (ID 6)"; break;
151   case  7: OS << "FONTDIR (ID 7)"; break;
152   case  8: OS << "FONT (ID 8)"; break;
153   case  9: OS << "ACCELERATOR (ID 9)"; break;
154   case 10: OS << "RCDATA (ID 10)"; break;
155   case 11: OS << "MESSAGETABLE (ID 11)"; break;
156   case 12: OS << "GROUP_CURSOR (ID 12)"; break;
157   case 14: OS << "GROUP_ICON (ID 14)"; break;
158   case 16: OS << "VERSIONINFO (ID 16)"; break;
159   case 17: OS << "DLGINCLUDE (ID 17)"; break;
160   case 19: OS << "PLUGPLAY (ID 19)"; break;
161   case 20: OS << "VXD (ID 20)"; break;
162   case 21: OS << "ANICURSOR (ID 21)"; break;
163   case 22: OS << "ANIICON (ID 22)"; break;
164   case 23: OS << "HTML (ID 23)"; break;
165   case 24: OS << "MANIFEST (ID 24)"; break;
166   default: OS << "ID " << TypeID; break;
167   }
168 }
169 
170 static bool convertUTF16LEToUTF8String(ArrayRef<UTF16> Src, std::string &Out) {
171   if (!sys::IsBigEndianHost)
172     return convertUTF16ToUTF8String(Src, Out);
173 
174   std::vector<UTF16> EndianCorrectedSrc;
175   EndianCorrectedSrc.resize(Src.size() + 1);
176   llvm::copy(Src, EndianCorrectedSrc.begin() + 1);
177   EndianCorrectedSrc[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
178   return convertUTF16ToUTF8String(makeArrayRef(EndianCorrectedSrc), Out);
179 }
180 
181 static std::string makeDuplicateResourceError(
182     const ResourceEntryRef &Entry, StringRef File1, StringRef File2) {
183   std::string Ret;
184   raw_string_ostream OS(Ret);
185 
186   OS << "duplicate resource:";
187 
188   OS << " type ";
189   if (Entry.checkTypeString()) {
190     std::string UTF8;
191     if (!convertUTF16LEToUTF8String(Entry.getTypeString(), UTF8))
192       UTF8 = "(failed conversion from UTF16)";
193     OS << '\"' << UTF8 << '\"';
194   } else
195     printResourceTypeName(Entry.getTypeID(), OS);
196 
197   OS << "/name ";
198   if (Entry.checkNameString()) {
199     std::string UTF8;
200     if (!convertUTF16LEToUTF8String(Entry.getNameString(), UTF8))
201       UTF8 = "(failed conversion from UTF16)";
202     OS << '\"' << UTF8 << '\"';
203   } else {
204     OS << "ID " << Entry.getNameID();
205   }
206 
207   OS << "/language " << Entry.getLanguage() << ", in " << File1 << " and in "
208      << File2;
209 
210   return OS.str();
211 }
212 
213 static void printStringOrID(const WindowsResourceParser::StringOrID &S,
214                             raw_string_ostream &OS, bool IsType, bool IsID) {
215   if (S.IsString) {
216     std::string UTF8;
217     if (!convertUTF16LEToUTF8String(S.String, UTF8))
218       UTF8 = "(failed conversion from UTF16)";
219     OS << '\"' << UTF8 << '\"';
220   } else if (IsType)
221     printResourceTypeName(S.ID, OS);
222   else if (IsID)
223     OS << "ID " << S.ID;
224   else
225     OS << S.ID;
226 }
227 
228 static std::string makeDuplicateResourceError(
229     const std::vector<WindowsResourceParser::StringOrID> &Context,
230     StringRef File1, StringRef File2) {
231   std::string Ret;
232   raw_string_ostream OS(Ret);
233 
234   OS << "duplicate resource:";
235 
236   if (Context.size() >= 1) {
237     OS << " type ";
238     printStringOrID(Context[0], OS, /* IsType */ true, /* IsID */ true);
239   }
240 
241   if (Context.size() >= 2) {
242     OS << "/name ";
243     printStringOrID(Context[1], OS, /* IsType */ false, /* IsID */ true);
244   }
245 
246   if (Context.size() >= 3) {
247     OS << "/language ";
248     printStringOrID(Context[2], OS, /* IsType */ false, /* IsID */ false);
249   }
250   OS << ", in " << File1 << " and in " << File2;
251 
252   return OS.str();
253 }
254 
255 // MinGW specific. Remove default manifests (with language zero) if there are
256 // other manifests present, and report an error if there are more than one
257 // manifest with a non-zero language code.
258 // GCC has the concept of a default manifest resource object, which gets
259 // linked in implicitly if present. This default manifest has got language
260 // id zero, and should be dropped silently if there's another manifest present.
261 // If the user resources surprisignly had a manifest with language id zero,
262 // we should also ignore the duplicate default manifest.
263 void WindowsResourceParser::cleanUpManifests(
264     std::vector<std::string> &Duplicates) {
265   auto TypeIt = Root.IDChildren.find(/* RT_MANIFEST */ 24);
266   if (TypeIt == Root.IDChildren.end())
267     return;
268 
269   TreeNode *TypeNode = TypeIt->second.get();
270   auto NameIt =
271       TypeNode->IDChildren.find(/* CREATEPROCESS_MANIFEST_RESOURCE_ID */ 1);
272   if (NameIt == TypeNode->IDChildren.end())
273     return;
274 
275   TreeNode *NameNode = NameIt->second.get();
276   if (NameNode->IDChildren.size() <= 1)
277     return; // None or one manifest present, all good.
278 
279   // If we have more than one manifest, drop the language zero one if present,
280   // and check again.
281   auto LangZeroIt = NameNode->IDChildren.find(0);
282   if (LangZeroIt != NameNode->IDChildren.end() &&
283       LangZeroIt->second->IsDataNode) {
284     uint32_t RemovedIndex = LangZeroIt->second->DataIndex;
285     NameNode->IDChildren.erase(LangZeroIt);
286     Data.erase(Data.begin() + RemovedIndex);
287     Root.shiftDataIndexDown(RemovedIndex);
288 
289     // If we're now down to one manifest, all is good.
290     if (NameNode->IDChildren.size() <= 1)
291       return;
292   }
293 
294   // More than one non-language-zero manifest
295   auto FirstIt = NameNode->IDChildren.begin();
296   uint32_t FirstLang = FirstIt->first;
297   TreeNode *FirstNode = FirstIt->second.get();
298   auto LastIt = NameNode->IDChildren.rbegin();
299   uint32_t LastLang = LastIt->first;
300   TreeNode *LastNode = LastIt->second.get();
301   Duplicates.push_back(
302       ("duplicate non-default manifests with languages " + Twine(FirstLang) +
303        " in " + InputFilenames[FirstNode->Origin] + " and " + Twine(LastLang) +
304        " in " + InputFilenames[LastNode->Origin])
305           .str());
306 }
307 
308 // Ignore duplicates of manifests with language zero (the default manifest),
309 // in case the user has provided a manifest with that language id. See
310 // the function comment above for context. Only returns true if MinGW is set
311 // to true.
312 bool WindowsResourceParser::shouldIgnoreDuplicate(
313     const ResourceEntryRef &Entry) const {
314   return MinGW && !Entry.checkTypeString() &&
315          Entry.getTypeID() == /* RT_MANIFEST */ 24 &&
316          !Entry.checkNameString() &&
317          Entry.getNameID() == /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ 1 &&
318          Entry.getLanguage() == 0;
319 }
320 
321 bool WindowsResourceParser::shouldIgnoreDuplicate(
322     const std::vector<StringOrID> &Context) const {
323   return MinGW && Context.size() == 3 && !Context[0].IsString &&
324          Context[0].ID == /* RT_MANIFEST */ 24 && !Context[1].IsString &&
325          Context[1].ID == /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ 1 &&
326          !Context[2].IsString && Context[2].ID == 0;
327 }
328 
329 Error WindowsResourceParser::parse(WindowsResource *WR,
330                                    std::vector<std::string> &Duplicates) {
331   auto EntryOrErr = WR->getHeadEntry();
332   if (!EntryOrErr) {
333     auto E = EntryOrErr.takeError();
334     if (E.isA<EmptyResError>()) {
335       // Check if the .res file contains no entries.  In this case we don't have
336       // to throw an error but can rather just return without parsing anything.
337       // This applies for files which have a valid PE header magic and the
338       // mandatory empty null resource entry.  Files which do not fit this
339       // criteria would have already been filtered out by
340       // WindowsResource::createWindowsResource().
341       consumeError(std::move(E));
342       return Error::success();
343     }
344     return E;
345   }
346 
347   ResourceEntryRef Entry = EntryOrErr.get();
348   uint32_t Origin = InputFilenames.size();
349   InputFilenames.push_back(std::string(WR->getFileName()));
350   bool End = false;
351   while (!End) {
352 
353     TreeNode *Node;
354     bool IsNewNode = Root.addEntry(Entry, Origin, Data, StringTable, Node);
355     if (!IsNewNode) {
356       if (!shouldIgnoreDuplicate(Entry))
357         Duplicates.push_back(makeDuplicateResourceError(
358             Entry, InputFilenames[Node->Origin], WR->getFileName()));
359     }
360 
361     RETURN_IF_ERROR(Entry.moveNext(End));
362   }
363 
364   return Error::success();
365 }
366 
367 Error WindowsResourceParser::parse(ResourceSectionRef &RSR, StringRef Filename,
368                                    std::vector<std::string> &Duplicates) {
369   UNWRAP_REF_OR_RETURN(BaseTable, RSR.getBaseTable());
370   uint32_t Origin = InputFilenames.size();
371   InputFilenames.push_back(std::string(Filename));
372   std::vector<StringOrID> Context;
373   return addChildren(Root, RSR, BaseTable, Origin, Context, Duplicates);
374 }
375 
376 void WindowsResourceParser::printTree(raw_ostream &OS) const {
377   ScopedPrinter Writer(OS);
378   Root.print(Writer, "Resource Tree");
379 }
380 
381 bool WindowsResourceParser::TreeNode::addEntry(
382     const ResourceEntryRef &Entry, uint32_t Origin,
383     std::vector<std::vector<uint8_t>> &Data,
384     std::vector<std::vector<UTF16>> &StringTable, TreeNode *&Result) {
385   TreeNode &TypeNode = addTypeNode(Entry, StringTable);
386   TreeNode &NameNode = TypeNode.addNameNode(Entry, StringTable);
387   return NameNode.addLanguageNode(Entry, Origin, Data, Result);
388 }
389 
390 Error WindowsResourceParser::addChildren(TreeNode &Node,
391                                          ResourceSectionRef &RSR,
392                                          const coff_resource_dir_table &Table,
393                                          uint32_t Origin,
394                                          std::vector<StringOrID> &Context,
395                                          std::vector<std::string> &Duplicates) {
396 
397   for (int i = 0; i < Table.NumberOfNameEntries + Table.NumberOfIDEntries;
398        i++) {
399     UNWRAP_REF_OR_RETURN(Entry, RSR.getTableEntry(Table, i));
400     TreeNode *Child;
401 
402     if (Entry.Offset.isSubDir()) {
403 
404       // Create a new subdirectory and recurse
405       if (i < Table.NumberOfNameEntries) {
406         UNWRAP_OR_RETURN(NameString, RSR.getEntryNameString(Entry));
407         Child = &Node.addNameChild(NameString, StringTable);
408         Context.push_back(StringOrID(NameString));
409       } else {
410         Child = &Node.addIDChild(Entry.Identifier.ID);
411         Context.push_back(StringOrID(Entry.Identifier.ID));
412       }
413 
414       UNWRAP_REF_OR_RETURN(NextTable, RSR.getEntrySubDir(Entry));
415       Error E =
416           addChildren(*Child, RSR, NextTable, Origin, Context, Duplicates);
417       if (E)
418         return E;
419       Context.pop_back();
420 
421     } else {
422 
423       // Data leaves are supposed to have a numeric ID as identifier (language).
424       if (Table.NumberOfNameEntries > 0)
425         return createStringError(object_error::parse_failed,
426                                  "unexpected string key for data object");
427 
428       // Try adding a data leaf
429       UNWRAP_REF_OR_RETURN(DataEntry, RSR.getEntryData(Entry));
430       TreeNode *Child;
431       Context.push_back(StringOrID(Entry.Identifier.ID));
432       bool Added = Node.addDataChild(Entry.Identifier.ID, Table.MajorVersion,
433                                      Table.MinorVersion, Table.Characteristics,
434                                      Origin, Data.size(), Child);
435       if (Added) {
436         UNWRAP_OR_RETURN(Contents, RSR.getContents(DataEntry));
437         Data.push_back(ArrayRef<uint8_t>(
438             reinterpret_cast<const uint8_t *>(Contents.data()),
439             Contents.size()));
440       } else {
441         if (!shouldIgnoreDuplicate(Context))
442           Duplicates.push_back(makeDuplicateResourceError(
443               Context, InputFilenames[Child->Origin], InputFilenames.back()));
444       }
445       Context.pop_back();
446 
447     }
448   }
449   return Error::success();
450 }
451 
452 WindowsResourceParser::TreeNode::TreeNode(uint32_t StringIndex)
453     : StringIndex(StringIndex) {}
454 
455 WindowsResourceParser::TreeNode::TreeNode(uint16_t MajorVersion,
456                                           uint16_t MinorVersion,
457                                           uint32_t Characteristics,
458                                           uint32_t Origin, uint32_t DataIndex)
459     : IsDataNode(true), DataIndex(DataIndex), MajorVersion(MajorVersion),
460       MinorVersion(MinorVersion), Characteristics(Characteristics),
461       Origin(Origin) {}
462 
463 std::unique_ptr<WindowsResourceParser::TreeNode>
464 WindowsResourceParser::TreeNode::createStringNode(uint32_t Index) {
465   return std::unique_ptr<TreeNode>(new TreeNode(Index));
466 }
467 
468 std::unique_ptr<WindowsResourceParser::TreeNode>
469 WindowsResourceParser::TreeNode::createIDNode() {
470   return std::unique_ptr<TreeNode>(new TreeNode(0));
471 }
472 
473 std::unique_ptr<WindowsResourceParser::TreeNode>
474 WindowsResourceParser::TreeNode::createDataNode(uint16_t MajorVersion,
475                                                 uint16_t MinorVersion,
476                                                 uint32_t Characteristics,
477                                                 uint32_t Origin,
478                                                 uint32_t DataIndex) {
479   return std::unique_ptr<TreeNode>(new TreeNode(
480       MajorVersion, MinorVersion, Characteristics, Origin, DataIndex));
481 }
482 
483 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addTypeNode(
484     const ResourceEntryRef &Entry,
485     std::vector<std::vector<UTF16>> &StringTable) {
486   if (Entry.checkTypeString())
487     return addNameChild(Entry.getTypeString(), StringTable);
488   else
489     return addIDChild(Entry.getTypeID());
490 }
491 
492 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addNameNode(
493     const ResourceEntryRef &Entry,
494     std::vector<std::vector<UTF16>> &StringTable) {
495   if (Entry.checkNameString())
496     return addNameChild(Entry.getNameString(), StringTable);
497   else
498     return addIDChild(Entry.getNameID());
499 }
500 
501 bool WindowsResourceParser::TreeNode::addLanguageNode(
502     const ResourceEntryRef &Entry, uint32_t Origin,
503     std::vector<std::vector<uint8_t>> &Data, TreeNode *&Result) {
504   bool Added = addDataChild(Entry.getLanguage(), Entry.getMajorVersion(),
505                             Entry.getMinorVersion(), Entry.getCharacteristics(),
506                             Origin, Data.size(), Result);
507   if (Added)
508     Data.push_back(Entry.getData());
509   return Added;
510 }
511 
512 bool WindowsResourceParser::TreeNode::addDataChild(
513     uint32_t ID, uint16_t MajorVersion, uint16_t MinorVersion,
514     uint32_t Characteristics, uint32_t Origin, uint32_t DataIndex,
515     TreeNode *&Result) {
516   auto NewChild = createDataNode(MajorVersion, MinorVersion, Characteristics,
517                                  Origin, DataIndex);
518   auto ElementInserted = IDChildren.emplace(ID, std::move(NewChild));
519   Result = ElementInserted.first->second.get();
520   return ElementInserted.second;
521 }
522 
523 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addIDChild(
524     uint32_t ID) {
525   auto Child = IDChildren.find(ID);
526   if (Child == IDChildren.end()) {
527     auto NewChild = createIDNode();
528     WindowsResourceParser::TreeNode &Node = *NewChild;
529     IDChildren.emplace(ID, std::move(NewChild));
530     return Node;
531   } else
532     return *(Child->second);
533 }
534 
535 WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addNameChild(
536     ArrayRef<UTF16> NameRef, std::vector<std::vector<UTF16>> &StringTable) {
537   std::string NameString;
538   convertUTF16LEToUTF8String(NameRef, NameString);
539 
540   auto Child = StringChildren.find(NameString);
541   if (Child == StringChildren.end()) {
542     auto NewChild = createStringNode(StringTable.size());
543     StringTable.push_back(NameRef);
544     WindowsResourceParser::TreeNode &Node = *NewChild;
545     StringChildren.emplace(NameString, std::move(NewChild));
546     return Node;
547   } else
548     return *(Child->second);
549 }
550 
551 void WindowsResourceParser::TreeNode::print(ScopedPrinter &Writer,
552                                             StringRef Name) const {
553   ListScope NodeScope(Writer, Name);
554   for (auto const &Child : StringChildren) {
555     Child.second->print(Writer, Child.first);
556   }
557   for (auto const &Child : IDChildren) {
558     Child.second->print(Writer, to_string(Child.first));
559   }
560 }
561 
562 // This function returns the size of the entire resource tree, including
563 // directory tables, directory entries, and data entries.  It does not include
564 // the directory strings or the relocations of the .rsrc section.
565 uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
566   uint32_t Size = (IDChildren.size() + StringChildren.size()) *
567                   sizeof(coff_resource_dir_entry);
568 
569   // Reached a node pointing to a data entry.
570   if (IsDataNode) {
571     Size += sizeof(coff_resource_data_entry);
572     return Size;
573   }
574 
575   // If the node does not point to data, it must have a directory table pointing
576   // to other nodes.
577   Size += sizeof(coff_resource_dir_table);
578 
579   for (auto const &Child : StringChildren) {
580     Size += Child.second->getTreeSize();
581   }
582   for (auto const &Child : IDChildren) {
583     Size += Child.second->getTreeSize();
584   }
585   return Size;
586 }
587 
588 // Shift DataIndex of all data children with an Index greater or equal to the
589 // given one, to fill a gap from removing an entry from the Data vector.
590 void WindowsResourceParser::TreeNode::shiftDataIndexDown(uint32_t Index) {
591   if (IsDataNode && DataIndex >= Index) {
592     DataIndex--;
593   } else {
594     for (auto &Child : IDChildren)
595       Child.second->shiftDataIndexDown(Index);
596     for (auto &Child : StringChildren)
597       Child.second->shiftDataIndexDown(Index);
598   }
599 }
600 
601 class WindowsResourceCOFFWriter {
602 public:
603   WindowsResourceCOFFWriter(COFF::MachineTypes MachineType,
604                             const WindowsResourceParser &Parser, Error &E);
605   std::unique_ptr<MemoryBuffer> write(uint32_t TimeDateStamp);
606 
607 private:
608   void performFileLayout();
609   void performSectionOneLayout();
610   void performSectionTwoLayout();
611   void writeCOFFHeader(uint32_t TimeDateStamp);
612   void writeFirstSectionHeader();
613   void writeSecondSectionHeader();
614   void writeFirstSection();
615   void writeSecondSection();
616   void writeSymbolTable();
617   void writeStringTable();
618   void writeDirectoryTree();
619   void writeDirectoryStringTable();
620   void writeFirstSectionRelocations();
621   std::unique_ptr<WritableMemoryBuffer> OutputBuffer;
622   char *BufferStart;
623   uint64_t CurrentOffset = 0;
624   COFF::MachineTypes MachineType;
625   const WindowsResourceParser::TreeNode &Resources;
626   const ArrayRef<std::vector<uint8_t>> Data;
627   uint64_t FileSize;
628   uint32_t SymbolTableOffset;
629   uint32_t SectionOneSize;
630   uint32_t SectionOneOffset;
631   uint32_t SectionOneRelocations;
632   uint32_t SectionTwoSize;
633   uint32_t SectionTwoOffset;
634   const ArrayRef<std::vector<UTF16>> StringTable;
635   std::vector<uint32_t> StringTableOffsets;
636   std::vector<uint32_t> DataOffsets;
637   std::vector<uint32_t> RelocationAddresses;
638 };
639 
640 WindowsResourceCOFFWriter::WindowsResourceCOFFWriter(
641     COFF::MachineTypes MachineType, const WindowsResourceParser &Parser,
642     Error &E)
643     : MachineType(MachineType), Resources(Parser.getTree()),
644       Data(Parser.getData()), StringTable(Parser.getStringTable()) {
645   performFileLayout();
646 
647   OutputBuffer = WritableMemoryBuffer::getNewMemBuffer(
648       FileSize, "internal .obj file created from .res files");
649 }
650 
651 void WindowsResourceCOFFWriter::performFileLayout() {
652   // Add size of COFF header.
653   FileSize = COFF::Header16Size;
654 
655   // one .rsrc section header for directory tree, another for resource data.
656   FileSize += 2 * COFF::SectionSize;
657 
658   performSectionOneLayout();
659   performSectionTwoLayout();
660 
661   // We have reached the address of the symbol table.
662   SymbolTableOffset = FileSize;
663 
664   FileSize += COFF::Symbol16Size;     // size of the @feat.00 symbol.
665   FileSize += 4 * COFF::Symbol16Size; // symbol + aux for each section.
666   FileSize += Data.size() * COFF::Symbol16Size; // 1 symbol per resource.
667   FileSize += 4; // four null bytes for the string table.
668 }
669 
670 void WindowsResourceCOFFWriter::performSectionOneLayout() {
671   SectionOneOffset = FileSize;
672 
673   SectionOneSize = Resources.getTreeSize();
674   uint32_t CurrentStringOffset = SectionOneSize;
675   uint32_t TotalStringTableSize = 0;
676   for (auto const &String : StringTable) {
677     StringTableOffsets.push_back(CurrentStringOffset);
678     uint32_t StringSize = String.size() * sizeof(UTF16) + sizeof(uint16_t);
679     CurrentStringOffset += StringSize;
680     TotalStringTableSize += StringSize;
681   }
682   SectionOneSize += alignTo(TotalStringTableSize, sizeof(uint32_t));
683 
684   // account for the relocations of section one.
685   SectionOneRelocations = FileSize + SectionOneSize;
686   FileSize += SectionOneSize;
687   FileSize +=
688       Data.size() * COFF::RelocationSize; // one relocation for each resource.
689   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
690 }
691 
692 void WindowsResourceCOFFWriter::performSectionTwoLayout() {
693   // add size of .rsrc$2 section, which contains all resource data on 8-byte
694   // alignment.
695   SectionTwoOffset = FileSize;
696   SectionTwoSize = 0;
697   for (auto const &Entry : Data) {
698     DataOffsets.push_back(SectionTwoSize);
699     SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
700   }
701   FileSize += SectionTwoSize;
702   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
703 }
704 
705 std::unique_ptr<MemoryBuffer>
706 WindowsResourceCOFFWriter::write(uint32_t TimeDateStamp) {
707   BufferStart = OutputBuffer->getBufferStart();
708 
709   writeCOFFHeader(TimeDateStamp);
710   writeFirstSectionHeader();
711   writeSecondSectionHeader();
712   writeFirstSection();
713   writeSecondSection();
714   writeSymbolTable();
715   writeStringTable();
716 
717   return std::move(OutputBuffer);
718 }
719 
720 // According to COFF specification, if the Src has a size equal to Dest,
721 // it's okay to *not* copy the trailing zero.
722 static void coffnamecpy(char (&Dest)[COFF::NameSize], StringRef Src) {
723   assert(Src.size() <= COFF::NameSize &&
724          "Src is larger than COFF::NameSize");
725   assert((Src.size() == COFF::NameSize || Dest[Src.size()] == '\0') &&
726          "Dest not zeroed upon initialization");
727   memcpy(Dest, Src.data(), Src.size());
728 }
729 
730 void WindowsResourceCOFFWriter::writeCOFFHeader(uint32_t TimeDateStamp) {
731   // Write the COFF header.
732   auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
733   Header->Machine = MachineType;
734   Header->NumberOfSections = 2;
735   Header->TimeDateStamp = TimeDateStamp;
736   Header->PointerToSymbolTable = SymbolTableOffset;
737   // One symbol for every resource plus 2 for each section and 1 for @feat.00
738   Header->NumberOfSymbols = Data.size() + 5;
739   Header->SizeOfOptionalHeader = 0;
740   // cvtres.exe sets 32BIT_MACHINE even for 64-bit machine types. Match it.
741   Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
742 }
743 
744 void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
745   // Write the first section header.
746   CurrentOffset += sizeof(coff_file_header);
747   auto *SectionOneHeader =
748       reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
749   coffnamecpy(SectionOneHeader->Name, ".rsrc$01");
750   SectionOneHeader->VirtualSize = 0;
751   SectionOneHeader->VirtualAddress = 0;
752   SectionOneHeader->SizeOfRawData = SectionOneSize;
753   SectionOneHeader->PointerToRawData = SectionOneOffset;
754   SectionOneHeader->PointerToRelocations = SectionOneRelocations;
755   SectionOneHeader->PointerToLinenumbers = 0;
756   SectionOneHeader->NumberOfRelocations = Data.size();
757   SectionOneHeader->NumberOfLinenumbers = 0;
758   SectionOneHeader->Characteristics += COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
759   SectionOneHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
760 }
761 
762 void WindowsResourceCOFFWriter::writeSecondSectionHeader() {
763   // Write the second section header.
764   CurrentOffset += sizeof(coff_section);
765   auto *SectionTwoHeader =
766       reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
767   coffnamecpy(SectionTwoHeader->Name, ".rsrc$02");
768   SectionTwoHeader->VirtualSize = 0;
769   SectionTwoHeader->VirtualAddress = 0;
770   SectionTwoHeader->SizeOfRawData = SectionTwoSize;
771   SectionTwoHeader->PointerToRawData = SectionTwoOffset;
772   SectionTwoHeader->PointerToRelocations = 0;
773   SectionTwoHeader->PointerToLinenumbers = 0;
774   SectionTwoHeader->NumberOfRelocations = 0;
775   SectionTwoHeader->NumberOfLinenumbers = 0;
776   SectionTwoHeader->Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
777   SectionTwoHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
778 }
779 
780 void WindowsResourceCOFFWriter::writeFirstSection() {
781   // Write section one.
782   CurrentOffset += sizeof(coff_section);
783 
784   writeDirectoryTree();
785   writeDirectoryStringTable();
786   writeFirstSectionRelocations();
787 
788   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
789 }
790 
791 void WindowsResourceCOFFWriter::writeSecondSection() {
792   // Now write the .rsrc$02 section.
793   for (auto const &RawDataEntry : Data) {
794     llvm::copy(RawDataEntry, BufferStart + CurrentOffset);
795     CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
796   }
797 
798   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
799 }
800 
801 void WindowsResourceCOFFWriter::writeSymbolTable() {
802   // Now write the symbol table.
803   // First, the feat symbol.
804   auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
805   coffnamecpy(Symbol->Name.ShortName, "@feat.00");
806   Symbol->Value = 0x11;
807   Symbol->SectionNumber = 0xffff;
808   Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
809   Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
810   Symbol->NumberOfAuxSymbols = 0;
811   CurrentOffset += sizeof(coff_symbol16);
812 
813   // Now write the .rsrc1 symbol + aux.
814   Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
815   coffnamecpy(Symbol->Name.ShortName, ".rsrc$01");
816   Symbol->Value = 0;
817   Symbol->SectionNumber = 1;
818   Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
819   Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
820   Symbol->NumberOfAuxSymbols = 1;
821   CurrentOffset += sizeof(coff_symbol16);
822   auto *Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
823                                                               CurrentOffset);
824   Aux->Length = SectionOneSize;
825   Aux->NumberOfRelocations = Data.size();
826   Aux->NumberOfLinenumbers = 0;
827   Aux->CheckSum = 0;
828   Aux->NumberLowPart = 0;
829   Aux->Selection = 0;
830   CurrentOffset += sizeof(coff_aux_section_definition);
831 
832   // Now write the .rsrc2 symbol + aux.
833   Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
834   coffnamecpy(Symbol->Name.ShortName, ".rsrc$02");
835   Symbol->Value = 0;
836   Symbol->SectionNumber = 2;
837   Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
838   Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
839   Symbol->NumberOfAuxSymbols = 1;
840   CurrentOffset += sizeof(coff_symbol16);
841   Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
842                                                         CurrentOffset);
843   Aux->Length = SectionTwoSize;
844   Aux->NumberOfRelocations = 0;
845   Aux->NumberOfLinenumbers = 0;
846   Aux->CheckSum = 0;
847   Aux->NumberLowPart = 0;
848   Aux->Selection = 0;
849   CurrentOffset += sizeof(coff_aux_section_definition);
850 
851   // Now write a symbol for each relocation.
852   for (unsigned i = 0; i < Data.size(); i++) {
853     auto RelocationName = formatv("$R{0:X-6}", i & 0xffffff).sstr<COFF::NameSize>();
854     Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
855     coffnamecpy(Symbol->Name.ShortName, RelocationName);
856     Symbol->Value = DataOffsets[i];
857     Symbol->SectionNumber = 2;
858     Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
859     Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
860     Symbol->NumberOfAuxSymbols = 0;
861     CurrentOffset += sizeof(coff_symbol16);
862   }
863 }
864 
865 void WindowsResourceCOFFWriter::writeStringTable() {
866   // Just 4 null bytes for the string table.
867   auto COFFStringTable = reinterpret_cast<void *>(BufferStart + CurrentOffset);
868   memset(COFFStringTable, 0, 4);
869 }
870 
871 void WindowsResourceCOFFWriter::writeDirectoryTree() {
872   // Traverse parsed resource tree breadth-first and write the corresponding
873   // COFF objects.
874   std::queue<const WindowsResourceParser::TreeNode *> Queue;
875   Queue.push(&Resources);
876   uint32_t NextLevelOffset =
877       sizeof(coff_resource_dir_table) + (Resources.getStringChildren().size() +
878                                          Resources.getIDChildren().size()) *
879                                             sizeof(coff_resource_dir_entry);
880   std::vector<const WindowsResourceParser::TreeNode *> DataEntriesTreeOrder;
881   uint32_t CurrentRelativeOffset = 0;
882 
883   while (!Queue.empty()) {
884     auto CurrentNode = Queue.front();
885     Queue.pop();
886     auto *Table = reinterpret_cast<coff_resource_dir_table *>(BufferStart +
887                                                               CurrentOffset);
888     Table->Characteristics = CurrentNode->getCharacteristics();
889     Table->TimeDateStamp = 0;
890     Table->MajorVersion = CurrentNode->getMajorVersion();
891     Table->MinorVersion = CurrentNode->getMinorVersion();
892     auto &IDChildren = CurrentNode->getIDChildren();
893     auto &StringChildren = CurrentNode->getStringChildren();
894     Table->NumberOfNameEntries = StringChildren.size();
895     Table->NumberOfIDEntries = IDChildren.size();
896     CurrentOffset += sizeof(coff_resource_dir_table);
897     CurrentRelativeOffset += sizeof(coff_resource_dir_table);
898 
899     // Write the directory entries immediately following each directory table.
900     for (auto const &Child : StringChildren) {
901       auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
902                                                                 CurrentOffset);
903       Entry->Identifier.setNameOffset(
904           StringTableOffsets[Child.second->getStringIndex()]);
905       if (Child.second->checkIsDataNode()) {
906         Entry->Offset.DataEntryOffset = NextLevelOffset;
907         NextLevelOffset += sizeof(coff_resource_data_entry);
908         DataEntriesTreeOrder.push_back(Child.second.get());
909       } else {
910         Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
911         NextLevelOffset += sizeof(coff_resource_dir_table) +
912                            (Child.second->getStringChildren().size() +
913                             Child.second->getIDChildren().size()) *
914                                sizeof(coff_resource_dir_entry);
915         Queue.push(Child.second.get());
916       }
917       CurrentOffset += sizeof(coff_resource_dir_entry);
918       CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
919     }
920     for (auto const &Child : IDChildren) {
921       auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
922                                                                 CurrentOffset);
923       Entry->Identifier.ID = Child.first;
924       if (Child.second->checkIsDataNode()) {
925         Entry->Offset.DataEntryOffset = NextLevelOffset;
926         NextLevelOffset += sizeof(coff_resource_data_entry);
927         DataEntriesTreeOrder.push_back(Child.second.get());
928       } else {
929         Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
930         NextLevelOffset += sizeof(coff_resource_dir_table) +
931                            (Child.second->getStringChildren().size() +
932                             Child.second->getIDChildren().size()) *
933                                sizeof(coff_resource_dir_entry);
934         Queue.push(Child.second.get());
935       }
936       CurrentOffset += sizeof(coff_resource_dir_entry);
937       CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
938     }
939   }
940 
941   RelocationAddresses.resize(Data.size());
942   // Now write all the resource data entries.
943   for (auto DataNodes : DataEntriesTreeOrder) {
944     auto *Entry = reinterpret_cast<coff_resource_data_entry *>(BufferStart +
945                                                                CurrentOffset);
946     RelocationAddresses[DataNodes->getDataIndex()] = CurrentRelativeOffset;
947     Entry->DataRVA = 0; // Set to zero because it is a relocation.
948     Entry->DataSize = Data[DataNodes->getDataIndex()].size();
949     Entry->Codepage = 0;
950     Entry->Reserved = 0;
951     CurrentOffset += sizeof(coff_resource_data_entry);
952     CurrentRelativeOffset += sizeof(coff_resource_data_entry);
953   }
954 }
955 
956 void WindowsResourceCOFFWriter::writeDirectoryStringTable() {
957   // Now write the directory string table for .rsrc$01
958   uint32_t TotalStringTableSize = 0;
959   for (auto &String : StringTable) {
960     uint16_t Length = String.size();
961     support::endian::write16le(BufferStart + CurrentOffset, Length);
962     CurrentOffset += sizeof(uint16_t);
963     auto *Start = reinterpret_cast<UTF16 *>(BufferStart + CurrentOffset);
964     llvm::copy(String, Start);
965     CurrentOffset += Length * sizeof(UTF16);
966     TotalStringTableSize += Length * sizeof(UTF16) + sizeof(uint16_t);
967   }
968   CurrentOffset +=
969       alignTo(TotalStringTableSize, sizeof(uint32_t)) - TotalStringTableSize;
970 }
971 
972 void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
973 
974   // Now write the relocations for .rsrc$01
975   // Five symbols already in table before we start, @feat.00 and 2 for each
976   // .rsrc section.
977   uint32_t NextSymbolIndex = 5;
978   for (unsigned i = 0; i < Data.size(); i++) {
979     auto *Reloc =
980         reinterpret_cast<coff_relocation *>(BufferStart + CurrentOffset);
981     Reloc->VirtualAddress = RelocationAddresses[i];
982     Reloc->SymbolTableIndex = NextSymbolIndex++;
983     switch (MachineType) {
984     case COFF::IMAGE_FILE_MACHINE_ARMNT:
985       Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
986       break;
987     case COFF::IMAGE_FILE_MACHINE_AMD64:
988       Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
989       break;
990     case COFF::IMAGE_FILE_MACHINE_I386:
991       Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
992       break;
993     case COFF::IMAGE_FILE_MACHINE_ARM64:
994       Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
995       break;
996     default:
997       llvm_unreachable("unknown machine type");
998     }
999     CurrentOffset += sizeof(coff_relocation);
1000   }
1001 }
1002 
1003 Expected<std::unique_ptr<MemoryBuffer>>
1004 writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
1005                          const WindowsResourceParser &Parser,
1006                          uint32_t TimeDateStamp) {
1007   Error E = Error::success();
1008   WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
1009   if (E)
1010     return std::move(E);
1011   return Writer.write(TimeDateStamp);
1012 }
1013 
1014 } // namespace object
1015 } // namespace llvm
1016