WindowsResource.cpp revision 327952 
198944Sobrien//===-- WindowsResource.cpp -------------------------------------*- C++ -*-===//
298944Sobrien//
398944Sobrien//                     The LLVM Compiler Infrastructure
498944Sobrien//
598944Sobrien// This file is distributed under the University of Illinois Open Source
698944Sobrien// License. See LICENSE.TXT for details.
798944Sobrien//
898944Sobrien//===----------------------------------------------------------------------===//
998944Sobrien//
1098944Sobrien// This file implements the .res file class.
1198944Sobrien//
1298944Sobrien//===----------------------------------------------------------------------===//
1398944Sobrien
1498944Sobrien#include "llvm/Object/WindowsResource.h"
1598944Sobrien#include "llvm/Object/COFF.h"
1698944Sobrien#include "llvm/Support/FileOutputBuffer.h"
1798944Sobrien#include "llvm/Support/FormatVariadic.h"
1898944Sobrien#include "llvm/Support/MathExtras.h"
1998944Sobrien#include <ctime>
2098944Sobrien#include <queue>
2198944Sobrien#include <system_error>
22130803Smarcel
23130803Smarcelusing namespace llvm;
2498944Sobrienusing namespace object;
2598944Sobrien
2698944Sobriennamespace llvm {
2798944Sobriennamespace object {
2898944Sobrien
2998944Sobrien#define RETURN_IF_ERROR(X)                                                     \
3098944Sobrien  if (auto EC = X)                                                             \
3198944Sobrien    return EC;
3298944Sobrien
3398944Sobrienconst uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
3498944Sobrien
3598944Sobrien// COFF files seem to be inconsistent with alignment between sections, just use
3698944Sobrien// 8-byte because it makes everyone happy.
3798944Sobrienconst uint32_t SECTION_ALIGNMENT = sizeof(uint64_t);
3898944Sobrien
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    std::copy(NameRef.begin(), NameRef.end(), 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<MemoryBuffer> 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 = MemoryBuffer::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 = const_cast<char *>(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    std::copy(RawDataEntry.begin(), RawDataEntry.end(),
505              BufferStart + CurrentOffset);
506    CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
507  }
508
509  CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
510}
511
512void WindowsResourceCOFFWriter::writeSymbolTable() {
513  // Now write the symbol table.
514  // First, the feat symbol.
515  auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
516  strncpy(Symbol->Name.ShortName, "@feat.00", (size_t)COFF::NameSize);
517  Symbol->Value = 0x11;
518  Symbol->SectionNumber = 0xffff;
519  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
520  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
521  Symbol->NumberOfAuxSymbols = 0;
522  CurrentOffset += sizeof(coff_symbol16);
523
524  // Now write the .rsrc1 symbol + aux.
525  Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
526  strncpy(Symbol->Name.ShortName, ".rsrc$01", (size_t)COFF::NameSize);
527  Symbol->Value = 0;
528  Symbol->SectionNumber = 1;
529  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
530  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
531  Symbol->NumberOfAuxSymbols = 1;
532  CurrentOffset += sizeof(coff_symbol16);
533  auto *Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
534                                                              CurrentOffset);
535  Aux->Length = SectionOneSize;
536  Aux->NumberOfRelocations = Data.size();
537  Aux->NumberOfLinenumbers = 0;
538  Aux->CheckSum = 0;
539  Aux->NumberLowPart = 0;
540  Aux->Selection = 0;
541  CurrentOffset += sizeof(coff_aux_section_definition);
542
543  // Now write the .rsrc2 symbol + aux.
544  Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
545  strncpy(Symbol->Name.ShortName, ".rsrc$02", (size_t)COFF::NameSize);
546  Symbol->Value = 0;
547  Symbol->SectionNumber = 2;
548  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
549  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
550  Symbol->NumberOfAuxSymbols = 1;
551  CurrentOffset += sizeof(coff_symbol16);
552  Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
553                                                        CurrentOffset);
554  Aux->Length = SectionTwoSize;
555  Aux->NumberOfRelocations = 0;
556  Aux->NumberOfLinenumbers = 0;
557  Aux->CheckSum = 0;
558  Aux->NumberLowPart = 0;
559  Aux->Selection = 0;
560  CurrentOffset += sizeof(coff_aux_section_definition);
561
562  // Now write a symbol for each relocation.
563  for (unsigned i = 0; i < Data.size(); i++) {
564    auto RelocationName = formatv("$R{0:X-6}", i & 0xffffff).sstr<COFF::NameSize>();
565    Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
566    memcpy(Symbol->Name.ShortName, RelocationName.data(), (size_t) COFF::NameSize);
567    Symbol->Value = DataOffsets[i];
568    Symbol->SectionNumber = 2;
569    Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
570    Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
571    Symbol->NumberOfAuxSymbols = 0;
572    CurrentOffset += sizeof(coff_symbol16);
573  }
574}
575
576void WindowsResourceCOFFWriter::writeStringTable() {
577  // Just 4 null bytes for the string table.
578  auto COFFStringTable = reinterpret_cast<void *>(BufferStart + CurrentOffset);
579  memset(COFFStringTable, 0, 4);
580}
581
582void WindowsResourceCOFFWriter::writeDirectoryTree() {
583  // Traverse parsed resource tree breadth-first and write the corresponding
584  // COFF objects.
585  std::queue<const WindowsResourceParser::TreeNode *> Queue;
586  Queue.push(&Resources);
587  uint32_t NextLevelOffset =
588      sizeof(coff_resource_dir_table) + (Resources.getStringChildren().size() +
589                                         Resources.getIDChildren().size()) *
590                                            sizeof(coff_resource_dir_entry);
591  std::vector<const WindowsResourceParser::TreeNode *> DataEntriesTreeOrder;
592  uint32_t CurrentRelativeOffset = 0;
593
594  while (!Queue.empty()) {
595    auto CurrentNode = Queue.front();
596    Queue.pop();
597    auto *Table = reinterpret_cast<coff_resource_dir_table *>(BufferStart +
598                                                              CurrentOffset);
599    Table->Characteristics = CurrentNode->getCharacteristics();
600    Table->TimeDateStamp = 0;
601    Table->MajorVersion = CurrentNode->getMajorVersion();
602    Table->MinorVersion = CurrentNode->getMinorVersion();
603    auto &IDChildren = CurrentNode->getIDChildren();
604    auto &StringChildren = CurrentNode->getStringChildren();
605    Table->NumberOfNameEntries = StringChildren.size();
606    Table->NumberOfIDEntries = IDChildren.size();
607    CurrentOffset += sizeof(coff_resource_dir_table);
608    CurrentRelativeOffset += sizeof(coff_resource_dir_table);
609
610    // Write the directory entries immediately following each directory table.
611    for (auto const &Child : StringChildren) {
612      auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
613                                                                CurrentOffset);
614      Entry->Identifier.setNameOffset(
615          StringTableOffsets[Child.second->getStringIndex()]);
616      if (Child.second->checkIsDataNode()) {
617        Entry->Offset.DataEntryOffset = NextLevelOffset;
618        NextLevelOffset += sizeof(coff_resource_data_entry);
619        DataEntriesTreeOrder.push_back(Child.second.get());
620      } else {
621        Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
622        NextLevelOffset += sizeof(coff_resource_dir_table) +
623                           (Child.second->getStringChildren().size() +
624                            Child.second->getIDChildren().size()) *
625                               sizeof(coff_resource_dir_entry);
626        Queue.push(Child.second.get());
627      }
628      CurrentOffset += sizeof(coff_resource_dir_entry);
629      CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
630    }
631    for (auto const &Child : IDChildren) {
632      auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
633                                                                CurrentOffset);
634      Entry->Identifier.ID = Child.first;
635      if (Child.second->checkIsDataNode()) {
636        Entry->Offset.DataEntryOffset = NextLevelOffset;
637        NextLevelOffset += sizeof(coff_resource_data_entry);
638        DataEntriesTreeOrder.push_back(Child.second.get());
639      } else {
640        Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
641        NextLevelOffset += sizeof(coff_resource_dir_table) +
642                           (Child.second->getStringChildren().size() +
643                            Child.second->getIDChildren().size()) *
644                               sizeof(coff_resource_dir_entry);
645        Queue.push(Child.second.get());
646      }
647      CurrentOffset += sizeof(coff_resource_dir_entry);
648      CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
649    }
650  }
651
652  RelocationAddresses.resize(Data.size());
653  // Now write all the resource data entries.
654  for (auto DataNodes : DataEntriesTreeOrder) {
655    auto *Entry = reinterpret_cast<coff_resource_data_entry *>(BufferStart +
656                                                               CurrentOffset);
657    RelocationAddresses[DataNodes->getDataIndex()] = CurrentRelativeOffset;
658    Entry->DataRVA = 0; // Set to zero because it is a relocation.
659    Entry->DataSize = Data[DataNodes->getDataIndex()].size();
660    Entry->Codepage = 0;
661    Entry->Reserved = 0;
662    CurrentOffset += sizeof(coff_resource_data_entry);
663    CurrentRelativeOffset += sizeof(coff_resource_data_entry);
664  }
665}
666
667void WindowsResourceCOFFWriter::writeDirectoryStringTable() {
668  // Now write the directory string table for .rsrc$01
669  uint32_t TotalStringTableSize = 0;
670  for (auto &String : StringTable) {
671    uint16_t Length = String.size();
672    support::endian::write16le(BufferStart + CurrentOffset, Length);
673    CurrentOffset += sizeof(uint16_t);
674    auto *Start = reinterpret_cast<UTF16 *>(BufferStart + CurrentOffset);
675    std::copy(String.begin(), String.end(), Start);
676    CurrentOffset += Length * sizeof(UTF16);
677    TotalStringTableSize += Length * sizeof(UTF16) + sizeof(uint16_t);
678  }
679  CurrentOffset +=
680      alignTo(TotalStringTableSize, sizeof(uint32_t)) - TotalStringTableSize;
681}
682
683void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
684
685  // Now write the relocations for .rsrc$01
686  // Five symbols already in table before we start, @feat.00 and 2 for each
687  // .rsrc section.
688  uint32_t NextSymbolIndex = 5;
689  for (unsigned i = 0; i < Data.size(); i++) {
690    auto *Reloc =
691        reinterpret_cast<coff_relocation *>(BufferStart + CurrentOffset);
692    Reloc->VirtualAddress = RelocationAddresses[i];
693    Reloc->SymbolTableIndex = NextSymbolIndex++;
694    switch (MachineType) {
695    case COFF::IMAGE_FILE_MACHINE_ARMNT:
696      Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
697      break;
698    case COFF::IMAGE_FILE_MACHINE_AMD64:
699      Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
700      break;
701    case COFF::IMAGE_FILE_MACHINE_I386:
702      Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
703      break;
704    case COFF::IMAGE_FILE_MACHINE_ARM64:
705      Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
706      break;
707    default:
708      llvm_unreachable("unknown machine type");
709    }
710    CurrentOffset += sizeof(coff_relocation);
711  }
712}
713
714Expected<std::unique_ptr<MemoryBuffer>>
715writeWindowsResourceCOFF(COFF::MachineTypes MachineType,
716                         const WindowsResourceParser &Parser) {
717  Error E = Error::success();
718  WindowsResourceCOFFWriter Writer(MachineType, Parser, E);
719  if (E)
720    return std::move(E);
721  return Writer.write();
722}
723
724} // namespace object
725} // namespace llvm
726