WindowsResource.cpp revision 344779 
1//===-- WindowsResource.cpp -------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the .res file class.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Object/WindowsResource.h"
15#include "llvm/Object/COFF.h"
16#include "llvm/Support/FileOutputBuffer.h"
17#include "llvm/Support/FormatVariadic.h"
18#include "llvm/Support/MathExtras.h"
19#include <ctime>
20#include <queue>
21#include <system_error>
22
23using namespace llvm;
24using namespace object;
25
26namespace llvm {
27namespace object {
28
29#define RETURN_IF_ERROR(X)                                                     \
30  if (auto EC = X)                                                             \
31    return EC;
32
33const 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.
37const uint32_t SECTION_ALIGNMENT = sizeof(uint64_t);
38
39uint32_t WindowsResourceParser::TreeNode::StringCount = 0;
40uint32_t WindowsResourceParser::TreeNode::DataCount = 0;
41
42WindowsResource::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
49Expected<std::unique_ptr<WindowsResource>>
50WindowsResource::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
59Expected<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
66ResourceEntryRef::ResourceEntryRef(BinaryStreamRef Ref,
67                                   const WindowsResource *Owner)
68    : Reader(Ref) {}
69
70Expected<ResourceEntryRef>
71ResourceEntryRef::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
78Error 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
89static 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
106Error 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
129WindowsResourceParser::WindowsResourceParser() : Root(false) {}
130
131Error WindowsResourceParser::parse(WindowsResource *WR) {
132  auto EntryOrErr = WR->getHeadEntry();
133  if (!EntryOrErr) {
134    auto E = EntryOrErr.takeError();
135    if (E.isA<EmptyResError>()) {
136      // Check if the .res file contains no entries.  In this case we don't have
137      // to throw an error but can rather just return without parsing anything.
138      // This applies for files which have a valid PE header magic and the
139      // mandatory empty null resource entry.  Files which do not fit this
140      // criteria would have already been filtered out by
141      // WindowsResource::createWindowsResource().
142      consumeError(std::move(E));
143      return Error::success();
144    }
145    return E;
146  }
147
148  ResourceEntryRef Entry = EntryOrErr.get();
149  bool End = false;
150  while (!End) {
151    Data.push_back(Entry.getData());
152
153    bool IsNewTypeString = false;
154    bool IsNewNameString = false;
155
156    Root.addEntry(Entry, IsNewTypeString, IsNewNameString);
157
158    if (IsNewTypeString)
159      StringTable.push_back(Entry.getTypeString());
160
161    if (IsNewNameString)
162      StringTable.push_back(Entry.getNameString());
163
164    RETURN_IF_ERROR(Entry.moveNext(End));
165  }
166
167  return Error::success();
168}
169
170void WindowsResourceParser::printTree(raw_ostream &OS) const {
171  ScopedPrinter Writer(OS);
172  Root.print(Writer, "Resource Tree");
173}
174
175void WindowsResourceParser::TreeNode::addEntry(const ResourceEntryRef &Entry,
176                                               bool &IsNewTypeString,
177                                               bool &IsNewNameString) {
178  TreeNode &TypeNode = addTypeNode(Entry, IsNewTypeString);
179  TreeNode &NameNode = TypeNode.addNameNode(Entry, IsNewNameString);
180  NameNode.addLanguageNode(Entry);
181}
182
183WindowsResourceParser::TreeNode::TreeNode(bool IsStringNode) {
184  if (IsStringNode)
185    StringIndex = StringCount++;
186}
187
188WindowsResourceParser::TreeNode::TreeNode(uint16_t MajorVersion,
189                                          uint16_t MinorVersion,
190                                          uint32_t Characteristics)
191    : IsDataNode(true), MajorVersion(MajorVersion), MinorVersion(MinorVersion),
192      Characteristics(Characteristics) {
193    DataIndex = DataCount++;
194}
195
196std::unique_ptr<WindowsResourceParser::TreeNode>
197WindowsResourceParser::TreeNode::createStringNode() {
198  return std::unique_ptr<TreeNode>(new TreeNode(true));
199}
200
201std::unique_ptr<WindowsResourceParser::TreeNode>
202WindowsResourceParser::TreeNode::createIDNode() {
203  return std::unique_ptr<TreeNode>(new TreeNode(false));
204}
205
206std::unique_ptr<WindowsResourceParser::TreeNode>
207WindowsResourceParser::TreeNode::createDataNode(uint16_t MajorVersion,
208                                                uint16_t MinorVersion,
209                                                uint32_t Characteristics) {
210  return std::unique_ptr<TreeNode>(
211      new TreeNode(MajorVersion, MinorVersion, Characteristics));
212}
213
214WindowsResourceParser::TreeNode &
215WindowsResourceParser::TreeNode::addTypeNode(const ResourceEntryRef &Entry,
216                                             bool &IsNewTypeString) {
217  if (Entry.checkTypeString())
218    return addChild(Entry.getTypeString(), IsNewTypeString);
219  else
220    return addChild(Entry.getTypeID());
221}
222
223WindowsResourceParser::TreeNode &
224WindowsResourceParser::TreeNode::addNameNode(const ResourceEntryRef &Entry,
225                                             bool &IsNewNameString) {
226  if (Entry.checkNameString())
227    return addChild(Entry.getNameString(), IsNewNameString);
228  else
229    return addChild(Entry.getNameID());
230}
231
232WindowsResourceParser::TreeNode &
233WindowsResourceParser::TreeNode::addLanguageNode(
234    const ResourceEntryRef &Entry) {
235  return addChild(Entry.getLanguage(), true, Entry.getMajorVersion(),
236                  Entry.getMinorVersion(), Entry.getCharacteristics());
237}
238
239WindowsResourceParser::TreeNode &WindowsResourceParser::TreeNode::addChild(
240    uint32_t ID, bool IsDataNode, uint16_t MajorVersion, uint16_t MinorVersion,
241    uint32_t Characteristics) {
242  auto Child = IDChildren.find(ID);
243  if (Child == IDChildren.end()) {
244    auto NewChild =
245        IsDataNode ? createDataNode(MajorVersion, MinorVersion, Characteristics)
246                   : createIDNode();
247    WindowsResourceParser::TreeNode &Node = *NewChild;
248    IDChildren.emplace(ID, std::move(NewChild));
249    return Node;
250  } else
251    return *(Child->second);
252}
253
254WindowsResourceParser::TreeNode &
255WindowsResourceParser::TreeNode::addChild(ArrayRef<UTF16> NameRef,
256                                          bool &IsNewString) {
257  std::string NameString;
258  ArrayRef<UTF16> CorrectedName;
259  std::vector<UTF16> EndianCorrectedName;
260  if (sys::IsBigEndianHost) {
261    EndianCorrectedName.resize(NameRef.size() + 1);
262    llvm::copy(NameRef, EndianCorrectedName.begin() + 1);
263    EndianCorrectedName[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
264    CorrectedName = makeArrayRef(EndianCorrectedName);
265  } else
266    CorrectedName = NameRef;
267  convertUTF16ToUTF8String(CorrectedName, NameString);
268
269  auto Child = StringChildren.find(NameString);
270  if (Child == StringChildren.end()) {
271    auto NewChild = createStringNode();
272    IsNewString = true;
273    WindowsResourceParser::TreeNode &Node = *NewChild;
274    StringChildren.emplace(NameString, std::move(NewChild));
275    return Node;
276  } else
277    return *(Child->second);
278}
279
280void WindowsResourceParser::TreeNode::print(ScopedPrinter &Writer,
281                                            StringRef Name) const {
282  ListScope NodeScope(Writer, Name);
283  for (auto const &Child : StringChildren) {
284    Child.second->print(Writer, Child.first);
285  }
286  for (auto const &Child : IDChildren) {
287    Child.second->print(Writer, to_string(Child.first));
288  }
289}
290
291// This function returns the size of the entire resource tree, including
292// directory tables, directory entries, and data entries.  It does not include
293// the directory strings or the relocations of the .rsrc section.
294uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
295  uint32_t Size = (IDChildren.size() + StringChildren.size()) *
296                  sizeof(coff_resource_dir_entry);
297
298  // Reached a node pointing to a data entry.
299  if (IsDataNode) {
300    Size += sizeof(coff_resource_data_entry);
301    return Size;
302  }
303
304  // If the node does not point to data, it must have a directory table pointing
305  // to other nodes.
306  Size += sizeof(coff_resource_dir_table);
307
308  for (auto const &Child : StringChildren) {
309    Size += Child.second->getTreeSize();
310  }
311  for (auto const &Child : IDChildren) {
312    Size += Child.second->getTreeSize();
313  }
314  return Size;
315}
316
317class WindowsResourceCOFFWriter {
318public:
319  WindowsResourceCOFFWriter(COFF::MachineTypes MachineType,
320                            const WindowsResourceParser &Parser, Error &E);
321  std::unique_ptr<MemoryBuffer> write();
322
323private:
324  void performFileLayout();
325  void performSectionOneLayout();
326  void performSectionTwoLayout();
327  void writeCOFFHeader();
328  void writeFirstSectionHeader();
329  void writeSecondSectionHeader();
330  void writeFirstSection();
331  void writeSecondSection();
332  void writeSymbolTable();
333  void writeStringTable();
334  void writeDirectoryTree();
335  void writeDirectoryStringTable();
336  void writeFirstSectionRelocations();
337  std::unique_ptr<WritableMemoryBuffer> OutputBuffer;
338  char *BufferStart;
339  uint64_t CurrentOffset = 0;
340  COFF::MachineTypes MachineType;
341  const WindowsResourceParser::TreeNode &Resources;
342  const ArrayRef<std::vector<uint8_t>> Data;
343  uint64_t FileSize;
344  uint32_t SymbolTableOffset;
345  uint32_t SectionOneSize;
346  uint32_t SectionOneOffset;
347  uint32_t SectionOneRelocations;
348  uint32_t SectionTwoSize;
349  uint32_t SectionTwoOffset;
350  const ArrayRef<std::vector<UTF16>> StringTable;
351  std::vector<uint32_t> StringTableOffsets;
352  std::vector<uint32_t> DataOffsets;
353  std::vector<uint32_t> RelocationAddresses;
354};
355
356WindowsResourceCOFFWriter::WindowsResourceCOFFWriter(
357    COFF::MachineTypes MachineType, const WindowsResourceParser &Parser,
358    Error &E)
359    : MachineType(MachineType), Resources(Parser.getTree()),
360      Data(Parser.getData()), StringTable(Parser.getStringTable()) {
361  performFileLayout();
362
363  OutputBuffer = WritableMemoryBuffer::getNewMemBuffer(FileSize);
364}
365
366void WindowsResourceCOFFWriter::performFileLayout() {
367  // Add size of COFF header.
368  FileSize = COFF::Header16Size;
369
370  // one .rsrc section header for directory tree, another for resource data.
371  FileSize += 2 * COFF::SectionSize;
372
373  performSectionOneLayout();
374  performSectionTwoLayout();
375
376  // We have reached the address of the symbol table.
377  SymbolTableOffset = FileSize;
378
379  FileSize += COFF::Symbol16Size;     // size of the @feat.00 symbol.
380  FileSize += 4 * COFF::Symbol16Size; // symbol + aux for each section.
381  FileSize += Data.size() * COFF::Symbol16Size; // 1 symbol per resource.
382  FileSize += 4; // four null bytes for the string table.
383}
384
385void WindowsResourceCOFFWriter::performSectionOneLayout() {
386  SectionOneOffset = FileSize;
387
388  SectionOneSize = Resources.getTreeSize();
389  uint32_t CurrentStringOffset = SectionOneSize;
390  uint32_t TotalStringTableSize = 0;
391  for (auto const &String : StringTable) {
392    StringTableOffsets.push_back(CurrentStringOffset);
393    uint32_t StringSize = String.size() * sizeof(UTF16) + sizeof(uint16_t);
394    CurrentStringOffset += StringSize;
395    TotalStringTableSize += StringSize;
396  }
397  SectionOneSize += alignTo(TotalStringTableSize, sizeof(uint32_t));
398
399  // account for the relocations of section one.
400  SectionOneRelocations = FileSize + SectionOneSize;
401  FileSize += SectionOneSize;
402  FileSize +=
403      Data.size() * COFF::RelocationSize; // one relocation for each resource.
404  FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
405}
406
407void WindowsResourceCOFFWriter::performSectionTwoLayout() {
408  // add size of .rsrc$2 section, which contains all resource data on 8-byte
409  // alignment.
410  SectionTwoOffset = FileSize;
411  SectionTwoSize = 0;
412  for (auto const &Entry : Data) {
413    DataOffsets.push_back(SectionTwoSize);
414    SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
415  }
416  FileSize += SectionTwoSize;
417  FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
418}
419
420static std::time_t getTime() {
421  std::time_t Now = time(nullptr);
422  if (Now < 0 || !isUInt<32>(Now))
423    return UINT32_MAX;
424  return Now;
425}
426
427std::unique_ptr<MemoryBuffer> WindowsResourceCOFFWriter::write() {
428  BufferStart = OutputBuffer->getBufferStart();
429
430  writeCOFFHeader();
431  writeFirstSectionHeader();
432  writeSecondSectionHeader();
433  writeFirstSection();
434  writeSecondSection();
435  writeSymbolTable();
436  writeStringTable();
437
438  return std::move(OutputBuffer);
439}
440
441void WindowsResourceCOFFWriter::writeCOFFHeader() {
442  // Write the COFF header.
443  auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
444  Header->Machine = MachineType;
445  Header->NumberOfSections = 2;
446  Header->TimeDateStamp = getTime();
447  Header->PointerToSymbolTable = SymbolTableOffset;
448  // One symbol for every resource plus 2 for each section and @feat.00
449  Header->NumberOfSymbols = Data.size() + 5;
450  Header->SizeOfOptionalHeader = 0;
451  Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
452}
453
454void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
455  // Write the first section header.
456  CurrentOffset += sizeof(coff_file_header);
457  auto *SectionOneHeader =
458      reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
459  strncpy(SectionOneHeader->Name, ".rsrc$01", (size_t)COFF::NameSize);
460  SectionOneHeader->VirtualSize = 0;
461  SectionOneHeader->VirtualAddress = 0;
462  SectionOneHeader->SizeOfRawData = SectionOneSize;
463  SectionOneHeader->PointerToRawData = SectionOneOffset;
464  SectionOneHeader->PointerToRelocations = SectionOneRelocations;
465  SectionOneHeader->PointerToLinenumbers = 0;
466  SectionOneHeader->NumberOfRelocations = Data.size();
467  SectionOneHeader->NumberOfLinenumbers = 0;
468  SectionOneHeader->Characteristics += COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
469  SectionOneHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
470}
471
472void WindowsResourceCOFFWriter::writeSecondSectionHeader() {
473  // Write the second section header.
474  CurrentOffset += sizeof(coff_section);
475  auto *SectionTwoHeader =
476      reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
477  strncpy(SectionTwoHeader->Name, ".rsrc$02", (size_t)COFF::NameSize);
478  SectionTwoHeader->VirtualSize = 0;
479  SectionTwoHeader->VirtualAddress = 0;
480  SectionTwoHeader->SizeOfRawData = SectionTwoSize;
481  SectionTwoHeader->PointerToRawData = SectionTwoOffset;
482  SectionTwoHeader->PointerToRelocations = 0;
483  SectionTwoHeader->PointerToLinenumbers = 0;
484  SectionTwoHeader->NumberOfRelocations = 0;
485  SectionTwoHeader->NumberOfLinenumbers = 0;
486  SectionTwoHeader->Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
487  SectionTwoHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
488}
489
490void WindowsResourceCOFFWriter::writeFirstSection() {
491  // Write section one.
492  CurrentOffset += sizeof(coff_section);
493
494  writeDirectoryTree();
495  writeDirectoryStringTable();
496  writeFirstSectionRelocations();
497
498  CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
499}
500
501void WindowsResourceCOFFWriter::writeSecondSection() {
502  // Now write the .rsrc$02 section.
503  for (auto const &RawDataEntry : Data) {
504    llvm::copy(RawDataEntry, BufferStart + CurrentOffset);
505    CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
506  }
507
508  CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
509}
510
511void WindowsResourceCOFFWriter::writeSymbolTable() {
512  // Now write the symbol table.
513  // First, the feat symbol.
514  auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
515  strncpy(Symbol->Name.ShortName, "@feat.00", (size_t)COFF::NameSize);
516  Symbol->Value = 0x11;
517  Symbol->SectionNumber = 0xffff;
518  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
519  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
520  Symbol->NumberOfAuxSymbols = 0;
521  CurrentOffset += sizeof(coff_symbol16);
522
523  // Now write the .rsrc1 symbol + aux.
524  Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
525  strncpy(Symbol->Name.ShortName, ".rsrc$01", (size_t)COFF::NameSize);
526  Symbol->Value = 0;
527  Symbol->SectionNumber = 1;
528  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
529  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
530  Symbol->NumberOfAuxSymbols = 1;
531  CurrentOffset += sizeof(coff_symbol16);
532  auto *Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
533                                                              CurrentOffset);
534  Aux->Length = SectionOneSize;
535  Aux->NumberOfRelocations = Data.size();
536  Aux->NumberOfLinenumbers = 0;
537  Aux->CheckSum = 0;
538  Aux->NumberLowPart = 0;
539  Aux->Selection = 0;
540  CurrentOffset += sizeof(coff_aux_section_definition);
541
542  // Now write the .rsrc2 symbol + aux.
543  Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
544  strncpy(Symbol->Name.ShortName, ".rsrc$02", (size_t)COFF::NameSize);
545  Symbol->Value = 0;
546  Symbol->SectionNumber = 2;
547  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
548  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
549  Symbol->NumberOfAuxSymbols = 1;
550  CurrentOffset += sizeof(coff_symbol16);
551  Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
552                                                        CurrentOffset);
553  Aux->Length = SectionTwoSize;
554  Aux->NumberOfRelocations = 0;
555  Aux->NumberOfLinenumbers = 0;
556  Aux->CheckSum = 0;
557  Aux->NumberLowPart = 0;
558  Aux->Selection = 0;
559  CurrentOffset += sizeof(coff_aux_section_definition);
560
561  // Now write a symbol for each relocation.
562  for (unsigned i = 0; i < Data.size(); i++) {
563    auto RelocationName = formatv("$R{0:X-6}", i & 0xffffff).sstr<COFF::NameSize>();
564    Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
565    memcpy(Symbol->Name.ShortName, RelocationName.data(), (size_t) COFF::NameSize);
566    Symbol->Value = DataOffsets[i];
567    Symbol->SectionNumber = 2;
568    Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
569    Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
570    Symbol->NumberOfAuxSymbols = 0;
571    CurrentOffset += sizeof(coff_symbol16);
572  }
573}
574
575void WindowsResourceCOFFWriter::writeStringTable() {
576  // Just 4 null bytes for the string table.
577  auto COFFStringTable = reinterpret_cast<void *>(BufferStart + CurrentOffset);
578  memset(COFFStringTable, 0, 4);
579}
580
581void WindowsResourceCOFFWriter::writeDirectoryTree() {
582  // Traverse parsed resource tree breadth-first and write the corresponding
583  // COFF objects.
584  std::queue<const WindowsResourceParser::TreeNode *> Queue;
585  Queue.push(&Resources);
586  uint32_t NextLevelOffset =
587      sizeof(coff_resource_dir_table) + (Resources.getStringChildren().size() +
588                                         Resources.getIDChildren().size()) *
589                                            sizeof(coff_resource_dir_entry);
590  std::vector<const WindowsResourceParser::TreeNode *> DataEntriesTreeOrder;
591  uint32_t CurrentRelativeOffset = 0;
592
593  while (!Queue.empty()) {
594    auto CurrentNode = Queue.front();
595    Queue.pop();
596    auto *Table = reinterpret_cast<coff_resource_dir_table *>(BufferStart +
597                                                              CurrentOffset);
598    Table->Characteristics = CurrentNode->getCharacteristics();
599    Table->TimeDateStamp = 0;
600    Table->MajorVersion = CurrentNode->getMajorVersion();
601    Table->MinorVersion = CurrentNode->getMinorVersion();
602    auto &IDChildren = CurrentNode->getIDChildren();
603    auto &StringChildren = CurrentNode->getStringChildren();
604    Table->NumberOfNameEntries = StringChildren.size();
605    Table->NumberOfIDEntries = IDChildren.size();
606    CurrentOffset += sizeof(coff_resource_dir_table);
607    CurrentRelativeOffset += sizeof(coff_resource_dir_table);
608
609    // Write the directory entries immediately following each directory table.
610    for (auto const &Child : StringChildren) {
611      auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
612                                                                CurrentOffset);
613      Entry->Identifier.setNameOffset(
614          StringTableOffsets[Child.second->getStringIndex()]);
615      if (Child.second->checkIsDataNode()) {
616        Entry->Offset.DataEntryOffset = NextLevelOffset;
617        NextLevelOffset += sizeof(coff_resource_data_entry);
618        DataEntriesTreeOrder.push_back(Child.second.get());
619      } else {
620        Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
621        NextLevelOffset += sizeof(coff_resource_dir_table) +
622                           (Child.second->getStringChildren().size() +
623                            Child.second->getIDChildren().size()) *
624                               sizeof(coff_resource_dir_entry);
625        Queue.push(Child.second.get());
626      }
627      CurrentOffset += sizeof(coff_resource_dir_entry);
628      CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
629    }
630    for (auto const &Child : IDChildren) {
631      auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
632                                                                CurrentOffset);
633      Entry->Identifier.ID = Child.first;
634      if (Child.second->checkIsDataNode()) {
635        Entry->Offset.DataEntryOffset = NextLevelOffset;
636        NextLevelOffset += sizeof(coff_resource_data_entry);
637        DataEntriesTreeOrder.push_back(Child.second.get());
638      } else {
639        Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
640        NextLevelOffset += sizeof(coff_resource_dir_table) +
641                           (Child.second->getStringChildren().size() +
642                            Child.second->getIDChildren().size()) *
643                               sizeof(coff_resource_dir_entry);
644        Queue.push(Child.second.get());
645      }
646      CurrentOffset += sizeof(coff_resource_dir_entry);
647      CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
648    }
649  }
650
651  RelocationAddresses.resize(Data.size());
652  // Now write all the resource data entries.
653  for (auto DataNodes : DataEntriesTreeOrder) {
654    auto *Entry = reinterpret_cast<coff_resource_data_entry *>(BufferStart +
655                                                               CurrentOffset);
656    RelocationAddresses[DataNodes->getDataIndex()] = CurrentRelativeOffset;
657    Entry->DataRVA = 0; // Set to zero because it is a relocation.
658    Entry->DataSize = Data[DataNodes->getDataIndex()].size();
659    Entry->Codepage = 0;
660    Entry->Reserved = 0;
661    CurrentOffset += sizeof(coff_resource_data_entry);
662    CurrentRelativeOffset += sizeof(coff_resource_data_entry);
663  }
664}
665
666void WindowsResourceCOFFWriter::writeDirectoryStringTable() {
667  // Now write the directory string table for .rsrc$01
668  uint32_t TotalStringTableSize = 0;
669  for (auto &String : StringTable) {
670    uint16_t Length = String.size();
671    support::endian::write16le(BufferStart + CurrentOffset, Length);
672    CurrentOffset += sizeof(uint16_t);
673    auto *Start = reinterpret_cast<UTF16 *>(BufferStart + CurrentOffset);
674    llvm::copy(String, Start);
675    CurrentOffset += Length * sizeof(UTF16);
676    TotalStringTableSize += Length * sizeof(UTF16) + sizeof(uint16_t);
677  }
678  CurrentOffset +=
679      alignTo(TotalStringTableSize, sizeof(uint32_t)) - TotalStringTableSize;
680}
681
682void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
683
684  // Now write the relocations for .rsrc$01
685  // Five symbols already in table before we start, @feat.00 and 2 for each
686  // .rsrc section.
687  uint32_t NextSymbolIndex = 5;
688  for (unsigned i = 0; i < Data.size(); i++) {
689    auto *Reloc =
690        reinterpret_cast<coff_relocation *>(BufferStart + CurrentOffset);
691    Reloc->VirtualAddress = RelocationAddresses[i];
692    Reloc->SymbolTableIndex = NextSymbolIndex++;
693    switch (MachineType) {
694    case COFF::IMAGE_FILE_MACHINE_ARMNT:
695      Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
696      break;
697    case COFF::IMAGE_FILE_MACHINE_AMD64:
698      Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
699      break;
700    case COFF::IMAGE_FILE_MACHINE_I386:
701      Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
702      break;
703    case COFF::IMAGE_FILE_MACHINE_ARM64:
704      Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
705      break;
706    default:
707      llvm_unreachable("unknown machine type");
708    }
709    CurrentOffset += sizeof(coff_relocation);
710  }
711}
712
713Expected<std::unique_ptr<MemoryBuffer>>
714writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
715                         const WindowsResourceParser &Parser) {
716  Error E = Error::success();
717  WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
718  if (E)
719    return std::move(E);
720  return Writer.write();
721}
722
723} // namespace object
724} // namespace llvm
725