Clean up some things in the WindowsResource changes.

[ruiu]

LGTM

llvm/include/llvm/Object/WindowsResource.h

 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648007(v=vs.85).aspx
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_INCLUDE_LLVM_OBJECT_RESFILE_H
 #define LLVM_INCLUDE_LLVM_OBJECT_RESFILE_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include <map>
 
 namespace llvm {
-
 namespace object {
 
 class WindowsResource;
 
 class ResourceEntryRef {
 public:
   Error moveNext(bool &End);
   bool checkTypeString() const { return IsStringType; }

llvm/lib/Object/WindowsResource.cpp

 //===-- WindowsResource.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the .res file class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/WindowsResource.h"
-#include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/MathExtras.h"
 #include <ctime>
 #include <queue>
 #include <sstream>
 #include <system_error>
 
 using namespace llvm;
+using namespace object;
 
 namespace llvm {
 namespace object {
 
 #define RETURN_IF_ERROR(X)                                                     \
   if (auto EC = X)                                                             \
     return EC;
 

 }
 
 WindowsResourceParser::TreeNode &
 WindowsResourceParser::TreeNode::addChild(ArrayRef<UTF16> NameRef,
                                           bool &IsNewString) {
   std::string NameString;
   ArrayRef<UTF16> CorrectedName;
   std::vector<UTF16> EndianCorrectedName;
-  if (llvm::sys::IsBigEndianHost) {
+  if (sys::IsBigEndianHost) {
     EndianCorrectedName.resize(NameRef.size() + 1);
     std::copy(NameRef.begin(), NameRef.end(), EndianCorrectedName.begin() + 1);
     EndianCorrectedName[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
     CorrectedName = makeArrayRef(EndianCorrectedName);
   } else
     CorrectedName = NameRef;
-  llvm::convertUTF16ToUTF8String(CorrectedName, NameString);
+  convertUTF16ToUTF8String(CorrectedName, NameString);
 
   auto Child = StringChildren.find(NameString);
   if (Child == StringChildren.end()) {
     auto NewChild = createStringNode();
     IsNewString = true;
     WindowsResourceParser::TreeNode &Node = *NewChild;
     StringChildren.emplace(NameString, std::move(NewChild));
     return Node;
void WindowsResourceParser::TreeNode::print(ScopedPrinter &Writer,
   }
 }
 
 // This function returns the size of the entire resource tree, including
 // directory tables, directory entries, and data entries.  It does not include
 // the directory strings or the relocations of the .rsrc section.
 uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
   uint32_t Size = (IDChildren.size() + StringChildren.size()) *
-                  sizeof(llvm::object::coff_resource_dir_entry);
+                  sizeof(coff_resource_dir_entry);
 
   // Reached a node pointing to a data entry.
   if (IsDataNode) {
-    Size += sizeof(llvm::object::coff_resource_data_entry);
+    Size += sizeof(coff_resource_data_entry);
     return Size;
   }
 
   // If the node does not point to data, it must have a directory table pointing
   // to other nodes.
-  Size += sizeof(llvm::object::coff_resource_dir_table);
+  Size += sizeof(coff_resource_dir_table);
 
   for (auto const &Child : StringChildren) {
     Size += Child.second->getTreeSize();
   }
   for (auto const &Child : IDChildren) {
     Size += Child.second->getTreeSize();
   }
   return Size;
private:
   uint32_t SectionTwoOffset;
   const ArrayRef<std::vector<UTF16>> StringTable;
   std::vector<uint32_t> StringTableOffsets;
   std::vector<uint32_t> DataOffsets;
   std::vector<uint32_t> RelocationAddresses;
 };
 
 WindowsResourceCOFFWriter::WindowsResourceCOFFWriter(
-    std::unique_ptr<MemoryBuffer> &OutputBuffer,
-    COFF::MachineTypes MachineType, const WindowsResourceParser &Parser,
-    Error &E)
+    std::unique_ptr<MemoryBuffer> &OutputBuffer, COFF::MachineTypes MachineType,
+    const WindowsResourceParser &Parser, Error &E)
     : OutputBuffer(OutputBuffer), MachineType(MachineType),
       Resources(Parser.getTree()), Data(Parser.getData()),
       StringTable(Parser.getStringTable()) {
   performFileLayout();
 
   OutputBuffer = std::move(MemoryBuffer::getNewMemBuffer(FileSize));
 }
 
 void WindowsResourceCOFFWriter::performFileLayout() {
   // Add size of COFF header.
-  FileSize = llvm::COFF::Header16Size;
+  FileSize = COFF::Header16Size;
 
   // one .rsrc section header for directory tree, another for resource data.
-  FileSize += 2 * llvm::COFF::SectionSize;
+  FileSize += 2 * COFF::SectionSize;
 
   performSectionOneLayout();
   performSectionTwoLayout();
 
   // We have reached the address of the symbol table.
   SymbolTableOffset = FileSize;
 
-  FileSize += llvm::COFF::Symbol16Size;     // size of the @feat.00 symbol.
-  FileSize += 4 * llvm::COFF::Symbol16Size; // symbol + aux for each section.
-  FileSize += Data.size() * llvm::COFF::Symbol16Size; // 1 symbol per resource.
+  FileSize += COFF::Symbol16Size;     // size of the @feat.00 symbol.
+  FileSize += 4 * COFF::Symbol16Size; // symbol + aux for each section.
+  FileSize += Data.size() * COFF::Symbol16Size; // 1 symbol per resource.
   FileSize += 4; // four null bytes for the string table.
 }
 
 void WindowsResourceCOFFWriter::performSectionOneLayout() {
   SectionOneOffset = FileSize;
 
   SectionOneSize = Resources.getTreeSize();
   uint32_t CurrentStringOffset = SectionOneSize;
   uint32_t TotalStringTableSize = 0;
   for (auto const &String : StringTable) {
     StringTableOffsets.push_back(CurrentStringOffset);
     uint32_t StringSize = String.size() * sizeof(UTF16) + sizeof(uint16_t);
     CurrentStringOffset += StringSize;
     TotalStringTableSize += StringSize;
   }
   SectionOneSize += alignTo(TotalStringTableSize, sizeof(uint32_t));
 
   // account for the relocations of section one.
   SectionOneRelocations = FileSize + SectionOneSize;
   FileSize += SectionOneSize;
-  FileSize += Data.size() *
-              llvm::COFF::RelocationSize; // one relocation for each resource.
+  FileSize +=
+      Data.size() * COFF::RelocationSize; // one relocation for each resource.
   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
 }
 
 void WindowsResourceCOFFWriter::performSectionTwoLayout() {
   // add size of .rsrc$2 section, which contains all resource data on 8-byte
   // alignment.
   SectionTwoOffset = FileSize;
   SectionTwoSize = 0;
   for (auto const &Entry : Data) {
     DataOffsets.push_back(SectionTwoSize);
-    SectionTwoSize += llvm::alignTo(Entry.size(), sizeof(uint64_t));
+    SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
   }
   FileSize += SectionTwoSize;
   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
 }
 
 static std::time_t getTime() {
   std::time_t Now = time(nullptr);
   if (Now < 0 || !isUInt<32>(Now))
Error WindowsResourceCOFFWriter::write() {
   writeSymbolTable();
   writeStringTable();
 
   return Error::success();
 }
 
 void WindowsResourceCOFFWriter::writeCOFFHeader() {
   // Write the COFF header.
-  auto *Header =
-      reinterpret_cast<llvm::object::coff_file_header *>(BufferStart);
+  auto *Header = reinterpret_cast<coff_file_header *>(BufferStart);
   switch (MachineType) {
   case COFF::IMAGE_FILE_MACHINE_ARMNT:
-    Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT;
+    Header->Machine = COFF::IMAGE_FILE_MACHINE_ARMNT;
     break;
   case COFF::IMAGE_FILE_MACHINE_AMD64:
-    Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
+    Header->Machine = COFF::IMAGE_FILE_MACHINE_AMD64;
     break;
   case COFF::IMAGE_FILE_MACHINE_I386:
-    Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_I386;
+    Header->Machine = COFF::IMAGE_FILE_MACHINE_I386;
     break;
   default:
-    Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+    Header->Machine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
   }
   Header->NumberOfSections = 2;
   Header->TimeDateStamp = getTime();
   Header->PointerToSymbolTable = SymbolTableOffset;
   // One symbol for every resource plus 2 for each section and @feat.00
   Header->NumberOfSymbols = Data.size() + 5;
   Header->SizeOfOptionalHeader = 0;
-  Header->Characteristics = llvm::COFF::IMAGE_FILE_32BIT_MACHINE;
+  Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
 }
 
 void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
   // Write the first section header.
-  CurrentOffset += sizeof(llvm::object::coff_file_header);
-  auto *SectionOneHeader = reinterpret_cast<llvm::object::coff_section *>(
-      BufferStart + CurrentOffset);
-  strncpy(SectionOneHeader->Name, ".rsrc$01", (size_t)llvm::COFF::NameSize);
+  CurrentOffset += sizeof(coff_file_header);
+  auto *SectionOneHeader =
+      reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
+  strncpy(SectionOneHeader->Name, ".rsrc$01", (size_t)COFF::NameSize);
   SectionOneHeader->VirtualSize = 0;
   SectionOneHeader->VirtualAddress = 0;
   SectionOneHeader->SizeOfRawData = SectionOneSize;
   SectionOneHeader->PointerToRawData = SectionOneOffset;
   SectionOneHeader->PointerToRelocations = SectionOneRelocations;
   SectionOneHeader->PointerToLinenumbers = 0;
   SectionOneHeader->NumberOfRelocations = Data.size();
   SectionOneHeader->NumberOfLinenumbers = 0;
-  SectionOneHeader->Characteristics = llvm::COFF::IMAGE_SCN_ALIGN_1BYTES;
-  SectionOneHeader->Characteristics +=
-      llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
-  SectionOneHeader->Characteristics +=
-      llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
-  SectionOneHeader->Characteristics += llvm::COFF::IMAGE_SCN_MEM_READ;
+  SectionOneHeader->Characteristics = COFF::IMAGE_SCN_ALIGN_1BYTES;
+  SectionOneHeader->Characteristics += COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
+  SectionOneHeader->Characteristics += COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
+  SectionOneHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
 }
 
 void WindowsResourceCOFFWriter::writeSecondSectionHeader() {
   // Write the second section header.
-  CurrentOffset += sizeof(llvm::object::coff_section);
-  auto *SectionTwoHeader = reinterpret_cast<llvm::object::coff_section *>(
-      BufferStart + CurrentOffset);
-  strncpy(SectionTwoHeader->Name, ".rsrc$02", (size_t)llvm::COFF::NameSize);
+  CurrentOffset += sizeof(coff_section);
+  auto *SectionTwoHeader =
+      reinterpret_cast<coff_section *>(BufferStart + CurrentOffset);
+  strncpy(SectionTwoHeader->Name, ".rsrc$02", (size_t)COFF::NameSize);
   SectionTwoHeader->VirtualSize = 0;
   SectionTwoHeader->VirtualAddress = 0;
   SectionTwoHeader->SizeOfRawData = SectionTwoSize;
   SectionTwoHeader->PointerToRawData = SectionTwoOffset;
   SectionTwoHeader->PointerToRelocations = 0;
   SectionTwoHeader->PointerToLinenumbers = 0;
   SectionTwoHeader->NumberOfRelocations = 0;
   SectionTwoHeader->NumberOfLinenumbers = 0;
-  SectionTwoHeader->Characteristics =
-      llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
-  SectionTwoHeader->Characteristics += llvm::COFF::IMAGE_SCN_MEM_READ;
+  SectionTwoHeader->Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
+  SectionTwoHeader->Characteristics += COFF::IMAGE_SCN_MEM_READ;
 }
 
 void WindowsResourceCOFFWriter::writeFirstSection() {
   // Write section one.
-  CurrentOffset += sizeof(llvm::object::coff_section);
+  CurrentOffset += sizeof(coff_section);
 
   writeDirectoryTree();
   writeDirectoryStringTable();
   writeFirstSectionRelocations();
 
   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
 }
 
 void WindowsResourceCOFFWriter::writeSecondSection() {
   // Now write the .rsrc$02 section.
   for (auto const &RawDataEntry : Data) {
     std::copy(RawDataEntry.begin(), RawDataEntry.end(),
               BufferStart + CurrentOffset);
     CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
   }
 
   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
 }
 
 void WindowsResourceCOFFWriter::writeSymbolTable() {
   // Now write the symbol table.
   // First, the feat symbol.
-  auto *Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
-                                                                 CurrentOffset);
-  strncpy(Symbol->Name.ShortName, "@feat.00", (size_t)llvm::COFF::NameSize);
+  auto *Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+  strncpy(Symbol->Name.ShortName, "@feat.00", (size_t)COFF::NameSize);
   Symbol->Value = 0x11;
   Symbol->SectionNumber = 0xffff;
-  Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
-  Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
   Symbol->NumberOfAuxSymbols = 0;
-  CurrentOffset += sizeof(llvm::object::coff_symbol16);
+  CurrentOffset += sizeof(coff_symbol16);
 
   // Now write the .rsrc1 symbol + aux.
-  Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
-                                                           CurrentOffset);
-  strncpy(Symbol->Name.ShortName, ".rsrc$01", (size_t)llvm::COFF::NameSize);
+  Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+  strncpy(Symbol->Name.ShortName, ".rsrc$01", (size_t)COFF::NameSize);
   Symbol->Value = 0;
   Symbol->SectionNumber = 1;
-  Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
-  Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
   Symbol->NumberOfAuxSymbols = 1;
-  CurrentOffset += sizeof(llvm::object::coff_symbol16);
-  auto *Aux = reinterpret_cast<llvm::object::coff_aux_section_definition *>(
-      BufferStart + CurrentOffset);
+  CurrentOffset += sizeof(coff_symbol16);
+  auto *Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
+                                                              CurrentOffset);
   Aux->Length = SectionOneSize;
   Aux->NumberOfRelocations = Data.size();
   Aux->NumberOfLinenumbers = 0;
   Aux->CheckSum = 0;
   Aux->NumberLowPart = 0;
   Aux->Selection = 0;
-  CurrentOffset += sizeof(llvm::object::coff_aux_section_definition);
+  CurrentOffset += sizeof(coff_aux_section_definition);
 
   // Now write the .rsrc2 symbol + aux.
-  Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
-                                                           CurrentOffset);
-  strncpy(Symbol->Name.ShortName, ".rsrc$02", (size_t)llvm::COFF::NameSize);
+  Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+  strncpy(Symbol->Name.ShortName, ".rsrc$02", (size_t)COFF::NameSize);
   Symbol->Value = 0;
   Symbol->SectionNumber = 2;
-  Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
-  Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+  Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+  Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
   Symbol->NumberOfAuxSymbols = 1;
-  CurrentOffset += sizeof(llvm::object::coff_symbol16);
-  Aux = reinterpret_cast<llvm::object::coff_aux_section_definition *>(
-      BufferStart + CurrentOffset);
+  CurrentOffset += sizeof(coff_symbol16);
+  Aux = reinterpret_cast<coff_aux_section_definition *>(BufferStart +
+                                                        CurrentOffset);
   Aux->Length = SectionTwoSize;
   Aux->NumberOfRelocations = 0;
   Aux->NumberOfLinenumbers = 0;
   Aux->CheckSum = 0;
   Aux->NumberLowPart = 0;
   Aux->Selection = 0;
-  CurrentOffset += sizeof(llvm::object::coff_aux_section_definition);
+  CurrentOffset += sizeof(coff_aux_section_definition);
 
   // Now write a symbol for each relocation.
   for (unsigned i = 0; i < Data.size(); i++) {
     char RelocationName[9];
     sprintf(RelocationName, "$R%06X", DataOffsets[i]);
-    Symbol = reinterpret_cast<llvm::object::coff_symbol16 *>(BufferStart +
-                                                             CurrentOffset);
-    strncpy(Symbol->Name.ShortName, RelocationName,
-            (size_t)llvm::COFF::NameSize);
+    Symbol = reinterpret_cast<coff_symbol16 *>(BufferStart + CurrentOffset);
+    strncpy(Symbol->Name.ShortName, RelocationName, (size_t)COFF::NameSize);
     Symbol->Value = DataOffsets[i];
     Symbol->SectionNumber = 1;
-    Symbol->Type = llvm::COFF::IMAGE_SYM_DTYPE_NULL;
-    Symbol->StorageClass = llvm::COFF::IMAGE_SYM_CLASS_STATIC;
+    Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
+    Symbol->StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
     Symbol->NumberOfAuxSymbols = 0;
-    CurrentOffset += sizeof(llvm::object::coff_symbol16);
+    CurrentOffset += sizeof(coff_symbol16);
   }
 }
 
 void WindowsResourceCOFFWriter::writeStringTable() {
   // Just 4 null bytes for the string table.
   auto COFFStringTable = reinterpret_cast<void *>(BufferStart + CurrentOffset);
   memset(COFFStringTable, 0, 4);
 }
 
 void WindowsResourceCOFFWriter::writeDirectoryTree() {
   // Traverse parsed resource tree breadth-first and write the corresponding
   // COFF objects.
   std::queue<const WindowsResourceParser::TreeNode *> Queue;
   Queue.push(&Resources);
-  uint32_t NextLevelOffset = sizeof(llvm::object::coff_resource_dir_table) +
-                             (Resources.getStringChildren().size() +
+  uint32_t NextLevelOffset =
+      sizeof(coff_resource_dir_table) + (Resources.getStringChildren().size() +
                                          Resources.getIDChildren().size()) *
-                                 sizeof(llvm::object::coff_resource_dir_entry);
+                                            sizeof(coff_resource_dir_entry);
   std::vector<const WindowsResourceParser::TreeNode *> DataEntriesTreeOrder;
   uint32_t CurrentRelativeOffset = 0;
 
   while (!Queue.empty()) {
     auto CurrentNode = Queue.front();
     Queue.pop();
-    auto *Table = reinterpret_cast<llvm::object::coff_resource_dir_table *>(
-        BufferStart + CurrentOffset);
+    auto *Table = reinterpret_cast<coff_resource_dir_table *>(BufferStart +
+                                                              CurrentOffset);
     Table->Characteristics = CurrentNode->getCharacteristics();
     Table->TimeDateStamp = 0;
     Table->MajorVersion = CurrentNode->getMajorVersion();
     Table->MinorVersion = CurrentNode->getMinorVersion();
     auto &IDChildren = CurrentNode->getIDChildren();
     auto &StringChildren = CurrentNode->getStringChildren();
     Table->NumberOfNameEntries = StringChildren.size();
     Table->NumberOfIDEntries = IDChildren.size();
-    CurrentOffset += sizeof(llvm::object::coff_resource_dir_table);
-    CurrentRelativeOffset += sizeof(llvm::object::coff_resource_dir_table);
+    CurrentOffset += sizeof(coff_resource_dir_table);
+    CurrentRelativeOffset += sizeof(coff_resource_dir_table);
 
     // Write the directory entries immediately following each directory table.
     for (auto const &Child : StringChildren) {
-      auto *Entry = reinterpret_cast<llvm::object::coff_resource_dir_entry *>(
-          BufferStart + CurrentOffset);
+      auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
+                                                                CurrentOffset);
       Entry->Identifier.NameOffset =
           StringTableOffsets[Child.second->getStringIndex()];
       if (Child.second->checkIsDataNode()) {
         Entry->Offset.DataEntryOffset = NextLevelOffset;
-        NextLevelOffset += sizeof(llvm::object::coff_resource_data_entry);
+        NextLevelOffset += sizeof(coff_resource_data_entry);
         DataEntriesTreeOrder.push_back(Child.second.get());
       } else {
         Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
-        NextLevelOffset += sizeof(llvm::object::coff_resource_dir_table) +
+        NextLevelOffset += sizeof(coff_resource_dir_table) +
                            (Child.second->getStringChildren().size() +
                             Child.second->getIDChildren().size()) *
-                               sizeof(llvm::object::coff_resource_dir_entry);
+                               sizeof(coff_resource_dir_entry);
         Queue.push(Child.second.get());
       }
-      CurrentOffset += sizeof(llvm::object::coff_resource_dir_entry);
-      CurrentRelativeOffset += sizeof(llvm::object::coff_resource_dir_entry);
+      CurrentOffset += sizeof(coff_resource_dir_entry);
+      CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
     }
     for (auto const &Child : IDChildren) {
-      auto *Entry = reinterpret_cast<llvm::object::coff_resource_dir_entry *>(
-          BufferStart + CurrentOffset);
+      auto *Entry = reinterpret_cast<coff_resource_dir_entry *>(BufferStart +
+                                                                CurrentOffset);
       Entry->Identifier.ID = Child.first;
       if (Child.second->checkIsDataNode()) {
         Entry->Offset.DataEntryOffset = NextLevelOffset;
-        NextLevelOffset += sizeof(llvm::object::coff_resource_data_entry);
+        NextLevelOffset += sizeof(coff_resource_data_entry);
         DataEntriesTreeOrder.push_back(Child.second.get());
       } else {
         Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
-        NextLevelOffset += sizeof(llvm::object::coff_resource_dir_table) +
+        NextLevelOffset += sizeof(coff_resource_dir_table) +
                            (Child.second->getStringChildren().size() +
                             Child.second->getIDChildren().size()) *
-                               sizeof(llvm::object::coff_resource_dir_entry);
+                               sizeof(coff_resource_dir_entry);
         Queue.push(Child.second.get());
       }
-      CurrentOffset += sizeof(llvm::object::coff_resource_dir_entry);
-      CurrentRelativeOffset += sizeof(llvm::object::coff_resource_dir_entry);
+      CurrentOffset += sizeof(coff_resource_dir_entry);
+      CurrentRelativeOffset += sizeof(coff_resource_dir_entry);
     }
   }
 
   RelocationAddresses.resize(Data.size());
   // Now write all the resource data entries.
   for (auto DataNodes : DataEntriesTreeOrder) {
-    auto *Entry = reinterpret_cast<llvm::object::coff_resource_data_entry *>(
-        BufferStart + CurrentOffset);
+    auto *Entry = reinterpret_cast<coff_resource_data_entry *>(BufferStart +
+                                                               CurrentOffset);
     RelocationAddresses[DataNodes->getDataIndex()] = CurrentRelativeOffset;
     Entry->DataRVA = 0; // Set to zero because it is a relocation.
     Entry->DataSize = Data[DataNodes->getDataIndex()].size();
     Entry->Codepage = 0;
     Entry->Reserved = 0;
-    CurrentOffset += sizeof(llvm::object::coff_resource_data_entry);
-    CurrentRelativeOffset += sizeof(llvm::object::coff_resource_data_entry);
+    CurrentOffset += sizeof(coff_resource_data_entry);
+    CurrentRelativeOffset += sizeof(coff_resource_data_entry);
   }
 }
 
 void WindowsResourceCOFFWriter::writeDirectoryStringTable() {
   // Now write the directory string table for .rsrc$01
   uint32_t TotalStringTableSize = 0;
   for (auto &String : StringTable) {
     uint16_t Length = String.size();

 
 void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
 
   // Now write the relocations for .rsrc$01
   // Five symbols already in table before we start, @feat.00 and 2 for each
   // .rsrc section.
   uint32_t NextSymbolIndex = 5;
   for (unsigned i = 0; i < Data.size(); i++) {
-    auto *Reloc = reinterpret_cast<llvm::object::coff_relocation *>(
-        BufferStart + CurrentOffset);
+    auto *Reloc =
+        reinterpret_cast<coff_relocation *>(BufferStart + CurrentOffset);
     Reloc->VirtualAddress = RelocationAddresses[i];
     Reloc->SymbolTableIndex = NextSymbolIndex++;
     switch (MachineType) {
     case COFF::IMAGE_FILE_MACHINE_ARMNT:
-      Reloc->Type = llvm::COFF::IMAGE_REL_ARM_ADDR32NB;
+      Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
       break;
     case COFF::IMAGE_FILE_MACHINE_AMD64:
-      Reloc->Type = llvm::COFF::IMAGE_REL_AMD64_ADDR32NB;
+      Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
       break;
     case COFF::IMAGE_FILE_MACHINE_I386:
-      Reloc->Type = llvm::COFF::IMAGE_REL_I386_DIR32NB;
+      Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
       break;
     default:
       Reloc->Type = 0;
     }
-    CurrentOffset += sizeof(llvm::object::coff_relocation);
+    CurrentOffset += sizeof(coff_relocation);
   }
 }
 
 Error writeWindowsResourceCOFF(std::unique_ptr<MemoryBuffer> &OutputBuffer,
                                COFF::MachineTypes MachineType,
                                const WindowsResourceParser &Parser) {
   Error E = Error::success();
   WindowsResourceCOFFWriter Writer(OutputBuffer, MachineType, Parser, E);
   if (E)
     return E;
   return Writer.write();
 }
 
 } // namespace object
 } // namespace llvm

llvm/tools/llvm-cvtres/llvm-cvtres.h

-//===- llvm-cvtres.h ------------------------------------------ *- C++ --*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_LLVMCVTRES_LLVMCVTRES_H
-#define LLVM_TOOLS_LLVMCVTRES_LLVMCVTRES_H
-
-#include <system_error>
-
-void error(std::error_code EC);
-
-#endif

llvm/tools/llvm-cvtres/llvm-cvtres.cpp

 //===- llvm-cvtres.cpp - Serialize .res files into .obj ---------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Serialize .res files into .obj files.  This is intended to be a
 // platform-independent port of Microsoft's cvtres.exe.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm-cvtres.h"
-
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/BinaryStreamError.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include <system_error>
+
 using namespace llvm;
 using namespace object;
 
 namespace {
 
 enum ID {
   OPT_INVALID = 0, // This is not an option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
if (InputFiles.size() == 0) {
     reportError("No input file specified.\n");
   }
 
   SmallString<128> OutputFile;
 
   if (InputArgs.hasArg(OPT_OUT)) {
     OutputFile = InputArgs.getLastArgValue(OPT_OUT);
   } else {
-    OutputFile = llvm::sys::path::filename(StringRef(InputFiles[0]));
-    llvm::sys::path::replace_extension(OutputFile, ".obj");
+    OutputFile = sys::path::filename(StringRef(InputFiles[0]));
+    sys::path::replace_extension(OutputFile, ".obj");
   }
 
   if (Verbose) {
     outs() << "Machine: ";
     switch (MachineType) {
     case COFF::IMAGE_FILE_MACHINE_ARMNT:
       outs() << "ARM\n";
       break;
     case COFF::IMAGE_FILE_MACHINE_I386:
       outs() << "X86\n";
       break;
     default:
       outs() << "X64\n";
     }
   }
 
   WindowsResourceParser Parser;
 
   for (const auto &File : InputFiles) {
-    Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
-        object::createBinary(File);
+    Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File);
     if (!BinaryOrErr)
       reportError(File, errorToErrorCode(BinaryOrErr.takeError()));
 
     Binary &Binary = *BinaryOrErr.get().getBinary();
 
     WindowsResource *RF = dyn_cast<WindowsResource>(&Binary);
     if (!RF)
       reportError(File + ": unrecognized file format.\n");
if (Verbose) {
       outs() << "Number of resources: " << EntryNumber << "\n";
     }
 
     error(Parser.parse(RF));
   }
 
   if (Verbose) {
     Parser.printTree(outs());
-    Parser.printTree(errs());
   }
 
   std::unique_ptr<MemoryBuffer> OutputBuffer;
   error(llvm::object::writeWindowsResourceCOFF(OutputBuffer, MachineType,
                                                Parser));
   auto FileOrErr =
       FileOutputBuffer::create(OutputFile, OutputBuffer->getBufferSize());
   if (!FileOrErr)
     reportError(OutputFile, FileOrErr.getError());
   std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
   std::copy(OutputBuffer->getBufferStart(), OutputBuffer->getBufferEnd(),
             FileBuffer->getBufferStart());
   ;
   error(FileBuffer->commit());
 
   if (Verbose) {
-    Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
-        object::createBinary(OutputFile);
+    Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(OutputFile);
     if (!BinaryOrErr)
       reportError(OutputFile, errorToErrorCode(BinaryOrErr.takeError()));
     Binary &Binary = *BinaryOrErr.get().getBinary();
     ScopedPrinter W(errs());
     W.printBinaryBlock("Output File Raw Data", Binary.getData());
   }
 
   return 0;
 }