Switch external cvtres.exe for llvm's own resource library

[ecbeckmann]

Summary

.In this patch, I flip the switch in DriverUtils from using the externalcvtres.exe tool to using the Windows Resource library in llvm.I also fixed a bug where .rsrc sections were marked as discardable
memory and therefore were placed in the wrong order in the final PE.

Furthermore, I modified WindowsResource to write the coff directly to a
memory buffer instead of to file, also had it use the machine types
already declared in COFF.h instead creating my own enum.

Changed WindowsResourceCOFFWriter to write to a memory buffer instead of file. Also got rid of my own Machine enum and use the one defined in COFF.h

[ruiu]

As a convention, please write a short summary (ideally less than 80 chars) on the first line of a commit message, so that they are not wrapped around
... like this.

lld/COFF/DriverUtils.cpp

599–604

In LLD we avoid auto unless a concrete type is obvious, so replace auto with a concrete type.

603

Error messages should start with a lowercase letter.

605

And shouldn't end with a full stop. By following that rule, you can concatenate multiple error messages like this.

error while reading file: failed to parse .res file: unexpected EOF

607–612

In LLD we usually use much shorter name. This would be just MB.

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

209

Stray ;.

[ecbeckmann]

In D34265#781998, @ruiu wrote:

As a convention, please write a short summary (ideally less than 80 chars) on the first line of a commit message, so that they are not wrapped around
... like this.

Yes sorry about this. In the commit message just the first sentence is the title and the rest is the summary below. I think arc diff put it all together though.

[ruiu]

The first line of a commit message should be shorter than that is now. If you look at other commits, you'll find that their first lines are usually less than 80 or 100 characters.

[ecbeckmann]

Cleaned up style-related errors. Also switched more tests to be cross-platform instead of windows only.

[ecbeckmann]

In D34265#782500, @ruiu wrote:

The first line of a commit message should be shorter than that is now. If you look at other commits, you'll find that their first lines are usually less than 80 or 100 characters.

I meant the title should be "Switch external cvtres.exe for llvm's own resource library" which is less than 80 characters.

[ruiu]

LGTM

[zturner]

llvm/trunk/include/llvm/Object/WindowsResource.h

184 ↗

(On Diff #102874)

Either make this a reference or a pointer, but not a reference to a unique_ptr. Probably a reference is fine since it doesn't make sense to write something without a valid output buffer.

llvm/trunk/lib/Object/WindowsResource.cpp

310–312 ↗

(On Diff #102874)

Same thing here.

356 ↗

(On Diff #102874)

This is a bit strange. First we initialize the member variable OutputBuffer with the constructor argument (in the initializer list), and then we overwrite.... one of the two items with a new memory buffer? I'm not sure which one takes precedence here, but I think it's probably the constructor arg which means you're treating the constructor arg as an in/out parameter, which is pretty non-standard.

In any case, can you re-think this logic to make it more sensible? Do you intend for this class to take ownership of the input parameter? if so, then pass the unique_ptr by value, not by reference. If not, then pass the MemoryBuffer by reference, and we don't need the unique_ptr at all.

421 ↗

(On Diff #102874)

The previous code didn't need a const_cast. Why does the new code?

[zturner]

Also, sorry for being slow on reviewing this, but feel free to make the suggestions in a follow up patch.

[ecbeckmann]

llvm/trunk/lib/Object/WindowsResource.cpp

356 ↗

(On Diff #102874)

The idea is that we get an uninitialized reference to a MemBuf from the user, and then initialize it with the final COFF. It must be uninitialized because in order to initialize a MemBuf you must know the size you have to allocate, and this should be calculated only within the WindowsResourceCOFFWriter class. For all intents and purposes this parameter is an output, and is not used as an input in any way.

Therefore passing by reference won't work because we are the ones to initialize the buffer, it can't be done outside. We also cannot pass unique_ptr by value because this parameter needs to be an output accessible to the user, we aren't using it as an input in any way.

Probably the best solution then is to take a MemoryBuffer pointer as input?

421 ↗

(On Diff #102874)

Because you can write to a FileOutputBuffer, however MemoryBuffer was implemented to be read-only for some reason. We must use the MemoryBuffer class because this is how Driver(Util) in LLD is currently implemented. There is precedent in other places of the codebase for using const_cast to write to MemoryBuffer, such as in NativeProcessNetBSD and ScratchBuffer.

[zturner]

llvm/trunk/lib/Object/WindowsResource.cpp

356 ↗

(On Diff #102874)

In that case instead of returning an Error, how about returning an Expected<unique_ptr<MemoryBuffer>> from writeWindowsCOFFResource?

[ecbeckmann]

llvm/trunk/lib/Object/WindowsResource.cpp

356 ↗

(On Diff #102874)

That seems like the best option

lld/COFF/DriverUtils.cpp

 #include "Config.h"
 #include "Driver.h"
 #include "Error.h"
 #include "Memory.h"
 #include "Symbols.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Object/COFF.h"
+#include "llvm/Object/WindowsResource.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
fatal("/failifmismatch: mismatch detected: " + Existing + " and " + V +
           " for key " + K);
   Config->MustMatch[K] = V;
 }
 
 // Convert Windows resource files (.res files) to a .obj file
 // using cvtres.exe.
 std::unique_ptr<MemoryBuffer>
 convertResToCOFF(const std::vector<MemoryBufferRef> &MBs) {
-  // Create an output file path.
-  TemporaryFile File("resource-file", "obj");
+  object::WindowsResourceParser Parser;
 
-  // Execute cvtres.exe.
-  Executor E("cvtres.exe");
-  E.add("/machine:" + machineToStr(Config->Machine));
-  E.add("/readonly");
-  E.add("/nologo");
-  E.add("/out:" + Twine(File.Path));
-
-  // We must create new files because the memory buffers we have may have no
-  // underlying file still existing on the disk.
-  // It happens if it was created from a TemporaryFile, which usually delete
-  // the file just after creating the MemoryBuffer.
-  std::vector<TemporaryFile> ResFiles;
-  ResFiles.reserve(MBs.size());
   for (MemoryBufferRef MB : MBs) {
-    // We store the temporary file in a vector to avoid deletion
-    // before running cvtres
-    ResFiles.emplace_back("resource-file", "res");
-    TemporaryFile& ResFile = ResFiles.back();
-    // Write the content of the resource in a temporary file
-    std::error_code EC;
-    raw_fd_ostream OS(ResFile.Path, EC, sys::fs::F_None);
-    if (EC)
-      fatal(EC, "failed to open " + ResFile.Path);
-    OS << MB.getBuffer();
-    OS.close();
-
-    E.add(ResFile.Path);
+    std::unique_ptr<object::Binary> Bin = check(object::createBinary(MB));
+    object::WindowsResource *RF = dyn_cast<object::WindowsResource>(Bin.get());
+    if (!RF)
+      fatal("cannot compile non-resource file as resource");
+    if (auto EC = Parser.parse(RF))
+      fatal(EC, "failed to parse .res file");
   }
 
-  E.run();
-  return File.getMemoryBuffer();
+  std::unique_ptr<MemoryBuffer> MB;
+  if (auto EC =
+          llvm::object::writeWindowsResourceCOFF(MB, Config->Machine, Parser))
+    fatal(EC, "failed to write resources to buffer");
+
+  return MB;
 }
 
 // Run MSVC link.exe for given in-memory object files.
 // Command line options are copied from those given to LLD.
 // This is for the /msvclto option.
 void runMSVCLinker(std::string Rsp, ArrayRef<StringRef> Objects) {
   // Write the in-memory object files to disk.
   std::vector<TemporaryFile> Temps;

lld/test/COFF/def-name.test

-# REQUIRES: winres
-
 # RUN: rm -rf %t
 # RUN: mkdir -p %t
 # RUN: cd %t
 # RUN: yaml2obj < %p/Inputs/ret42.yaml > in.obj
 
 # RUN: lld-link /entry:main in.obj
 # RUN: lld-link /entry:main /dll in.obj
 

lld/test/COFF/dll.test

-# REQUIRES: winres
-
 # RUN: yaml2obj < %p/Inputs/export.yaml > %t.obj
 # RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1 /export:exportfn2 \
 # RUN:   /export:mangled
 # RUN: llvm-objdump -p %t.dll | FileCheck -check-prefix=EXPORT %s
 
 EXPORT:      Export Table:
 EXPORT:      DLL name: dll.test.tmp.dll
 EXPORT:      Ordinal      RVA  Name

lld/test/COFF/dllimport-gc.test

-# REQUIRES: winres
-
 # RUN: yaml2obj < %p/Inputs/export.yaml > %t-lib.obj
 # RUN: lld-link /out:%t.dll /dll %t-lib.obj /implib:%t.lib /export:exportfn1
 
 # RUN: yaml2obj < %p/Inputs/oldname.yaml > %t-oldname.obj
 
 # RUN: yaml2obj < %s > %t.obj
 
 # RUN: lld-link /out:%t1.exe /entry:main %t.obj %t-oldname.obj %t.lib

lld/test/COFF/manifestinput.test

-# REQUIRES: winres
+# REQUIRES: win_mt
 
 # RUN: yaml2obj %p/Inputs/ret42.yaml > %t.obj
 # RUN: lld-link /out:%t.exe /entry:main \
 # RUN:   /manifestuac:"level='requireAdministrator'" \
 # RUN:   /manifestinput:%p/Inputs/manifestinput.test %t.obj
 # RUN: FileCheck %s < %t.exe.manifest
 
 CHECK: <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 CHECK: <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"><dependency><dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"></assemblyIdentity></dependentAssembly></dependency><trustInfo><security><requestedPrivileges><requestedExecutionLevel level="requireAdministrator" uiAccess="false"></requestedExecutionLevel></requestedPrivileges></security></trustInfo></assembly>

lld/test/COFF/noentry.test

-# REQUIRES: winres
-
 # RUN: yaml2obj < %p/Inputs/export.yaml > %t.obj
 # RUN: lld-link /out:%t.dll /dll %t.obj
 # RUN: llvm-readobj -file-headers %t.dll | FileCheck -check-prefix=ENTRY %s
 # RUN: lld-link /out:%t.dll /dll /noentry %t.obj
 # RUN: llvm-readobj -file-headers %t.dll | FileCheck -check-prefix=NOENTRY %s
 
 ENTRY:   AddressOfEntryPoint: 0x1000
 NOENTRY: AddressOfEntryPoint: 0x0

lld/test/COFF/out.test

-# REQUIRES: winres
 # RUN: yaml2obj < %p/Inputs/ret42.yaml > %t.obj
 
 # RUN: mkdir -p %T/out/tmp
 # RUN: cp %t.obj %T/out/out1.obj
 # RUN: cp %t.obj %T/out/tmp/out2
 # RUN: cp %t.obj %T/out/tmp/out3.xyz
 
 # RUN: rm -f out1.exe out2.exe out3.exe out3.dll

lld/test/COFF/resource.test

-# REQUIRES: winres
-
 # RUN: yaml2obj < %p/Inputs/ret42.yaml > %t.obj
 # RUN: lld-link /out:%t.exe /entry:main %t.obj %p/Inputs/resource.res
 
 # Check if the binary contains UTF-16LE string "Hello" copied from resource.res.
 # RUN: FileCheck --check-prefix=EXE %s < %t.exe
 
 EXE: {{H.e.l.l.o}}
 
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck  --check-prefix=HEADER %s
 
 HEADER: ResourceTableRVA: 0x1000
 HEADER: ResourceTableSize: 0x88

lld/test/lit.cfg

if re.search(r'PowerPC', archs):
     config.available_features.add('ppc')
 if re.search(r'AMDGPU', archs):
     config.available_features.add('amdgpu')
 llvm_config_cmd.wait()
 
 # Set a fake constant version so that we get consitent output.
 config.environment['LLD_VERSION'] = 'LLD 1.0'
 
-# Check if Windows resource file compiler exists.
-cvtres = lit.util.which('cvtres', config.environment['PATH'])
-rc = lit.util.which('rc', config.environment['PATH'])
-if cvtres and rc:
-    config.available_features.add('winres')
+# Check if the mt.exe Microsoft utility exists.
+if lit.util.which('mt.exe', config.environment['PATH']):
+    config.available_features.add('win_mt')

llvm/include/llvm/Object/WindowsResource.h

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include <map>
 
 namespace llvm {
 
-class FileOutputBuffer;
-
 namespace object {
 
 class WindowsResource;
 
-enum class Machine { UNKNOWN, ARM, X64, X86 };
-
 class ResourceEntryRef {
 public:
   Error moveNext(bool &End);
   bool checkTypeString() const { return IsStringType; }
   ArrayRef<UTF16> getTypeString() const { return Type; }
   uint16_t getTypeID() const { return TypeID; }
   bool checkNameString() const { return IsStringName; }
   ArrayRef<UTF16> getNameString() const { return Name; }
public:
   };
 
 private:
   TreeNode Root;
   std::vector<std::vector<uint8_t>> Data;
   std::vector<std::vector<UTF16>> StringTable;
 };
 
-Error writeWindowsResourceCOFF(StringRef OutputFile, Machine MachineType,
+Error writeWindowsResourceCOFF(std::unique_ptr<MemoryBuffer> &OutputBuffer,
+                               llvm::COFF::MachineTypes MachineType,
                                const WindowsResourceParser &Parser);
 
 } // namespace object
 } // namespace llvm
 
 #endif

llvm/lib/Object/WindowsResource.cpp

 #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;
+
 namespace llvm {
 namespace object {
 
 #define RETURN_IF_ERROR(X)                                                     \
   if (auto EC = X)                                                             \
     return EC;
 
 const uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
uint32_t WindowsResourceParser::TreeNode::getTreeSize() const {
   for (auto const &Child : IDChildren) {
     Size += Child.second->getTreeSize();
   }
   return Size;
 }
 
 class WindowsResourceCOFFWriter {
 public:
-  WindowsResourceCOFFWriter(StringRef OutputFile, Machine MachineType,
+  WindowsResourceCOFFWriter(std::unique_ptr<MemoryBuffer> &OutputBuffer,
+                            COFF::MachineTypes MachineType,
                             const WindowsResourceParser &Parser, Error &E);
   Error write();
 
 private:
   void performFileLayout();
   void performSectionOneLayout();
   void performSectionTwoLayout();
   void writeCOFFHeader();
   void writeFirstSectionHeader();
   void writeSecondSectionHeader();
   void writeFirstSection();
   void writeSecondSection();
   void writeSymbolTable();
   void writeStringTable();
   void writeDirectoryTree();
   void writeDirectoryStringTable();
   void writeFirstSectionRelocations();
-  std::unique_ptr<FileOutputBuffer> Buffer;
-  uint8_t *BufferStart;
+  std::unique_ptr<MemoryBuffer> &OutputBuffer;
+  char *BufferStart;
   uint64_t CurrentOffset = 0;
-  Machine MachineType;
+  COFF::MachineTypes MachineType;
   const WindowsResourceParser::TreeNode &Resources;
   const ArrayRef<std::vector<uint8_t>> Data;
   uint64_t FileSize;
   uint32_t SymbolTableOffset;
   uint32_t SectionOneSize;
   uint32_t SectionOneOffset;
   uint32_t SectionOneRelocations;
   uint32_t SectionTwoSize;
   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(
-    StringRef OutputFile, Machine MachineType,
+    std::unique_ptr<MemoryBuffer> &OutputBuffer, COFF::MachineTypes MachineType,
     const WindowsResourceParser &Parser, Error &E)
-    : MachineType(MachineType), Resources(Parser.getTree()),
-      Data(Parser.getData()), StringTable(Parser.getStringTable()) {
+    : OutputBuffer(OutputBuffer), MachineType(MachineType),
+      Resources(Parser.getTree()), Data(Parser.getData()),
+      StringTable(Parser.getStringTable()) {
   performFileLayout();
 
-  ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
-      FileOutputBuffer::create(OutputFile, FileSize);
-  if (!BufferOrErr) {
-    E = errorCodeToError(BufferOrErr.getError());
-    return;
-  }
-
-  Buffer = std::move(*BufferOrErr);
+  OutputBuffer = std::move(MemoryBuffer::getNewMemBuffer(FileSize));
 }
 
 void WindowsResourceCOFFWriter::performFileLayout() {
   // Add size of COFF header.
   FileSize = llvm::COFF::Header16Size;
 
   // one .rsrc section header for directory tree, another for resource data.
   FileSize += 2 * llvm::COFF::SectionSize;

 static std::time_t getTime() {
   std::time_t Now = time(nullptr);
   if (Now < 0 || !isUInt<32>(Now))
     return UINT32_MAX;
   return Now;
 }
 
 Error WindowsResourceCOFFWriter::write() {
-  BufferStart = Buffer->getBufferStart();
+  BufferStart = const_cast<char *>(OutputBuffer->getBufferStart());
 
   writeCOFFHeader();
   writeFirstSectionHeader();
   writeSecondSectionHeader();
   writeFirstSection();
   writeSecondSection();
   writeSymbolTable();
   writeStringTable();
 
-  if (auto EC = Buffer->commit()) {
-    return errorCodeToError(EC);
-  }
-
   return Error::success();
 }
 
 void WindowsResourceCOFFWriter::writeCOFFHeader() {
   // Write the COFF header.
   auto *Header =
       reinterpret_cast<llvm::object::coff_file_header *>(BufferStart);
   switch (MachineType) {
-  case Machine::ARM:
+  case COFF::IMAGE_FILE_MACHINE_ARMNT:
     Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT;
     break;
-  case Machine::X64:
+  case COFF::IMAGE_FILE_MACHINE_AMD64:
     Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
     break;
-  case Machine::X86:
+  case COFF::IMAGE_FILE_MACHINE_I386:
     Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_I386;
     break;
   default:
     Header->Machine = llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
   }
   Header->NumberOfSections = 2;
   Header->TimeDateStamp = getTime();
   Header->PointerToSymbolTable = SymbolTableOffset;
void WindowsResourceCOFFWriter::writeFirstSectionHeader() {
   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_MEM_DISCARDABLE;
+  SectionOneHeader->Characteristics +=
+      llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
   SectionOneHeader->Characteristics += llvm::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);
void WindowsResourceCOFFWriter::writeFirstSectionRelocations() {
   // .rsrc section.
   uint32_t NextSymbolIndex = 5;
   for (unsigned i = 0; i < Data.size(); i++) {
     auto *Reloc = reinterpret_cast<llvm::object::coff_relocation *>(
         BufferStart + CurrentOffset);
     Reloc->VirtualAddress = RelocationAddresses[i];
     Reloc->SymbolTableIndex = NextSymbolIndex++;
     switch (MachineType) {
-    case Machine::ARM:
+    case COFF::IMAGE_FILE_MACHINE_ARMNT:
       Reloc->Type = llvm::COFF::IMAGE_REL_ARM_ADDR32NB;
       break;
-    case Machine::X64:
+    case COFF::IMAGE_FILE_MACHINE_AMD64:
       Reloc->Type = llvm::COFF::IMAGE_REL_AMD64_ADDR32NB;
       break;
-    case Machine::X86:
+    case COFF::IMAGE_FILE_MACHINE_I386:
       Reloc->Type = llvm::COFF::IMAGE_REL_I386_DIR32NB;
       break;
     default:
       Reloc->Type = 0;
     }
     CurrentOffset += sizeof(llvm::object::coff_relocation);
   }
 }
 
-Error writeWindowsResourceCOFF(StringRef OutputFile, Machine MachineType,
+Error writeWindowsResourceCOFF(std::unique_ptr<MemoryBuffer> &OutputBuffer,
+                               COFF::MachineTypes MachineType,
                                const WindowsResourceParser &Parser) {
   Error E = Error::success();
-  WindowsResourceCOFFWriter Writer(OutputFile, MachineType, Parser, E);
+  WindowsResourceCOFFWriter Writer(OutputBuffer, MachineType, Parser, E);
   if (E)
     return E;
   return Writer.write();
 }
 
 } // namespace object
 } // namespace llvm

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

int main(int argc_, const char *argv_[]) {
 
   if (InputArgs.hasArg(OPT_HELP)) {
     T.PrintHelp(outs(), "cvtres", "Resource Converter", false);
     return 0;
   }
 
   bool Verbose = InputArgs.hasArg(OPT_VERBOSE);
 
-  Machine MachineType;
+  COFF::MachineTypes MachineType;
 
   if (InputArgs.hasArg(OPT_MACHINE)) {
     std::string MachineString = InputArgs.getLastArgValue(OPT_MACHINE).upper();
-    MachineType = StringSwitch<Machine>(MachineString)
-                      .Case("ARM", Machine::ARM)
-                      .Case("X64", Machine::X64)
-                      .Case("X86", Machine::X86)
-                      .Default(Machine::UNKNOWN);
-    if (MachineType == Machine::UNKNOWN)
+    MachineType = StringSwitch<COFF::MachineTypes>(MachineString)
+                      .Case("ARM", COFF::IMAGE_FILE_MACHINE_ARMNT)
+                      .Case("X64", COFF::IMAGE_FILE_MACHINE_AMD64)
+                      .Case("X86", COFF::IMAGE_FILE_MACHINE_I386)
+                      .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
+    if (MachineType == COFF::IMAGE_FILE_MACHINE_UNKNOWN)
       reportError("Unsupported machine architecture");
   } else {
     if (Verbose)
       outs() << "Machine architecture not specified; assumed X64.\n";
-    MachineType = Machine::X64;
+    MachineType = COFF::IMAGE_FILE_MACHINE_AMD64;
   }
 
   std::vector<std::string> InputFiles = InputArgs.getAllArgValues(OPT_INPUT);
 
   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");
   }
 
   if (Verbose) {
     outs() << "Machine: ";
     switch (MachineType) {
-    case Machine::ARM:
+    case COFF::IMAGE_FILE_MACHINE_ARMNT:
       outs() << "ARM\n";
       break;
-    case Machine::X86:
+    case COFF::IMAGE_FILE_MACHINE_I386:
       outs() << "X86\n";
       break;
     default:
       outs() << "X64\n";
     }
   }
 
   WindowsResourceParser Parser;
for (const auto &File : InputFiles) {
     error(Parser.parse(RF));
   }
 
   if (Verbose) {
     Parser.printTree(outs());
     Parser.printTree(errs());
   }
 
-  error(
-      llvm::object::writeWindowsResourceCOFF(OutputFile, MachineType, Parser));
+  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);
     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;
 }