LLVM  7.0.0svn
WindowsResource.cpp
Go to the documentation of this file.
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 
15 #include "llvm/Object/COFF.h"
19 #include <ctime>
20 #include <queue>
21 #include <system_error>
22 
23 using namespace llvm;
24 using namespace object;
25 
26 namespace llvm {
27 namespace object {
28 
29 #define RETURN_IF_ERROR(X) \
30  if (auto EC = X) \
31  return EC;
32 
33 const uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
34 
35 // COFF files seem to be inconsistent with alignment between sections, just use
36 // 8-byte because it makes everyone happy.
37 const uint32_t SECTION_ALIGNMENT = sizeof(uint64_t);
38 
39 uint32_t WindowsResourceParser::TreeNode::StringCount = 0;
40 uint32_t WindowsResourceParser::TreeNode::DataCount = 0;
41 
42 WindowsResource::WindowsResource(MemoryBufferRef Source)
43  : Binary(Binary::ID_WinRes, Source) {
44  size_t LeadingSize = WIN_RES_MAGIC_SIZE + WIN_RES_NULL_ENTRY_SIZE;
45  BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize),
47 }
48 
52  return make_error<GenericBinaryError>(
53  "File too small to be a resource file",
55  std::unique_ptr<WindowsResource> Ret(new WindowsResource(Source));
56  return std::move(Ret);
57 }
58 
60  if (BBS.getLength() < sizeof(WinResHeaderPrefix) + sizeof(WinResHeaderSuffix))
61  return make_error<EmptyResError>(".res contains no entries",
63  return ResourceEntryRef::create(BinaryStreamRef(BBS), this);
64 }
65 
66 ResourceEntryRef::ResourceEntryRef(BinaryStreamRef Ref,
67  const WindowsResource *Owner)
68  : Reader(Ref) {}
69 
71 ResourceEntryRef::create(BinaryStreamRef BSR, const WindowsResource *Owner) {
72  auto Ref = ResourceEntryRef(BSR, Owner);
73  if (auto E = Ref.loadNext())
74  return std::move(E);
75  return Ref;
76 }
77 
79  // Reached end of all the entries.
80  if (Reader.bytesRemaining() == 0) {
81  End = true;
82  return Error::success();
83  }
84  RETURN_IF_ERROR(loadNext());
85 
86  return Error::success();
87 }
88 
89 static Error readStringOrId(BinaryStreamReader &Reader, uint16_t &ID,
90  ArrayRef<UTF16> &Str, bool &IsString) {
91  uint16_t IDFlag;
92  RETURN_IF_ERROR(Reader.readInteger(IDFlag));
93  IsString = IDFlag != 0xffff;
94 
95  if (IsString) {
96  Reader.setOffset(
97  Reader.getOffset() -
98  sizeof(uint16_t)); // Re-read the bytes which we used to check the flag.
99  RETURN_IF_ERROR(Reader.readWideString(Str));
100  } else
101  RETURN_IF_ERROR(Reader.readInteger(ID));
102 
103  return Error::success();
104 }
105 
106 Error ResourceEntryRef::loadNext() {
107  const WinResHeaderPrefix *Prefix;
108  RETURN_IF_ERROR(Reader.readObject(Prefix));
109 
110  if (Prefix->HeaderSize < MIN_HEADER_SIZE)
111  return make_error<GenericBinaryError>("Header size is too small.",
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 
130 
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 
171  ScopedPrinter Writer(OS);
172  Root.print(Writer, "Resource Tree");
173 }
174 
175 void 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 
183 WindowsResourceParser::TreeNode::TreeNode(bool IsStringNode) {
184  if (IsStringNode)
185  StringIndex = StringCount++;
186 }
187 
188 WindowsResourceParser::TreeNode::TreeNode(uint16_t MajorVersion,
189  uint16_t MinorVersion,
191  : IsDataNode(true), MajorVersion(MajorVersion), MinorVersion(MinorVersion),
192  Characteristics(Characteristics) {
193  DataIndex = DataCount++;
194 }
195 
196 std::unique_ptr<WindowsResourceParser::TreeNode>
197 WindowsResourceParser::TreeNode::createStringNode() {
198  return std::unique_ptr<TreeNode>(new TreeNode(true));
199 }
200 
201 std::unique_ptr<WindowsResourceParser::TreeNode>
202 WindowsResourceParser::TreeNode::createIDNode() {
203  return std::unique_ptr<TreeNode>(new TreeNode(false));
204 }
205 
206 std::unique_ptr<WindowsResourceParser::TreeNode>
207 WindowsResourceParser::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 
215 WindowsResourceParser::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 
224 WindowsResourceParser::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 
233 WindowsResourceParser::TreeNode::addLanguageNode(
234  const ResourceEntryRef &Entry) {
235  return addChild(Entry.getLanguage(), true, Entry.getMajorVersion(),
236  Entry.getMinorVersion(), Entry.getCharacteristics());
237 }
238 
239 WindowsResourceParser::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 
255 WindowsResourceParser::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 
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.
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 
318 public:
321  std::unique_ptr<MemoryBuffer> write();
322 
323 private:
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;
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 
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 
366 void 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 
385 void 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 
407 void 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 
420 static 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 
427 std::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 
441 void 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 
454 void 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 
472 void 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 
490 void 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 
501 void 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 
512 void 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;
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;
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;
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 
576 void 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 
582 void 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 
667 void 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 
683 void 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) {
696  Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
697  break;
699  Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
700  break;
702  Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
703  break;
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 
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
coff_symbol< support::ulittle16_t > coff_symbol16
Definition: COFF.h:266
constexpr bool isUInt< 32 >(uint64_t x)
Definition: MathExtras.h:347
const size_t WIN_RES_NULL_ENTRY_SIZE
support::ulittle16_t Machine
Definition: COFF.h:77
An implementation of BinaryStream which holds its entire data set in a single contiguous buffer...
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Error readInteger(T &Dest)
Read an integer of the specified endianness into Dest and update the stream&#39;s offset.
iterator begin() const
Definition: ArrayRef.h:137
Error parse(WindowsResource *WR)
Error readWideString(ArrayRef< UTF16 > &Dest)
Similar to readCString, however read a null-terminated UTF16 string instead.
support::ulittle32_t HeaderSize
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:683
unsigned short UTF16
Definition: ConvertUTF.h:111
No complex type; simple scalar variable.
Definition: COFF.h:260
constexpr bool IsBigEndianHost
Definition: Host.h:47
MachineTypes
Definition: COFF.h:94
Machine is based on a 32bit word architecture.
Definition: COFF.h:146
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
const uint32_t SECTION_ALIGNMENT
void write16le(void *P, uint16_t V)
Definition: Endian.h:403
const Children< uint32_t > & getIDChildren() const
The access may reference the value stored in memory.
TypeID
Definitions of all of the base types for the Type system.
Definition: Type.h:55
#define UNI_UTF16_BYTE_ORDER_MARK_SWAPPED
Definition: ConvertUTF.h:125
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
static std::unique_ptr< WritableMemoryBuffer > getNewMemBuffer(size_t Size, const Twine &BufferName="")
Allocate a new zero-initialized MemoryBuffer of the specified size.
static Expected< std::unique_ptr< WindowsResource > > createWindowsResource(MemoryBufferRef Source)
Expected< ResourceEntryRef > getHeadEntry()
const uint32_t MIN_HEADER_SIZE
size_t getBufferSize() const
Definition: MemoryBuffer.h:283
WindowsResourceCOFFWriter(COFF::MachineTypes MachineType, const WindowsResourceParser &Parser, Error &E)
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Definition: COFF.h:731
ArrayRef< uint8_t > getData() const
static const unsigned End
ArrayRef< UTF16 > getTypeString() const
static Error readStringOrId(BinaryStreamReader &Reader, uint16_t &ID, ArrayRef< UTF16 > &Str, bool &IsString)
static std::time_t getTime()
static void write(bool isBE, void *P, T V)
void printTree(raw_ostream &OS) const
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:962
support::ulittle32_t VirtualAddress
Definition: COFF.h:465
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void setOffset(uint32_t Off)
const ArrayRef< std::vector< UTF16 > > getStringTable() const
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
const uint32_t WIN_RES_HEADER_ALIGNMENT
const ArrayRef< std::vector< uint8_t > > getData() const
BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.
iterator end() const
Definition: ArrayRef.h:138
std::unique_ptr< MemoryBuffer > write()
Bit scan reverse.
MemoryBufferRef Data
Definition: Binary.h:37
bool convertUTF16ToUTF8String(ArrayRef< char > SrcBytes, std::string &Out)
Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
const size_t WIN_RES_MAGIC_SIZE
Definition: COFF.h:708
Expected< std::unique_ptr< MemoryBuffer > > writeWindowsResourceCOFF(llvm::COFF::MachineTypes MachineType, const WindowsResourceParser &Parser)
static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind, bool Deterministic, ArrayRef< MemberData > Members, StringRef StringTable)
COFFYAML::WeakExternalCharacteristics Characteristics
Definition: COFFYAML.cpp:323
static void writeStringTable(std::vector< uint8_t > &B, ArrayRef< const std::string > Strings)
uint32_t getLength() override
Return the number of bytes of data in this stream.
ArrayRef< UTF16 > getNameString() const
const std::string to_string(const T &Value)
Definition: ScopedPrinter.h:62
const uint32_t WIN_RES_DATA_ALIGNMENT
#define RETURN_IF_ERROR(X)
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
void print(ScopedPrinter &Writer, StringRef Name) const
Provides read only access to a subclass of BinaryStream.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
support::ulittle32_t Characteristics
Definition: COFF.h:739
const TreeNode & getTree() const
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:960
const Children< std::string > & getStringChildren() const