Add functionality to cvtres to parse all entries in res file.

[ecbeckmann]

Use binary stream.

[ecbeckmann]

Made it look nicer.

[ruiu]

I'd recommend renaming ResFile WindowsRes or WindowsResource everywhere, as I don't think Res or ResFile sound very familiar even for those who have an experience of Windows development, and for those who don't know about it, Res has no evidence about what that is.

llvm/include/llvm/Object/Binary.h

60 ↗

(On Diff #98960)

You want to add comment that this is Windows Resource, just like above enums.

Maybe ID_WINDOWS_RESOURCE is better? ID_RES seems too short.

llvm/include/llvm/Object/ResFile.h

10 ↗

(On Diff #98960)

the Windows .res, as Unix developers usually don't know what .res is.

25 ↗

(On Diff #98960)

nit: remove

28–30 ↗

(On Diff #98960)

You are using this macro only three times in this file, so it is better not to use it. In general you want to avoid using C macros, particularly in header files as it could conflict with .cpp files using the same identifier (unless you #undef the macro at end of the header.)

51 ↗

(On Diff #98960)

remove

[ruiu]

llvm/include/llvm/Object/ResFile.h

45 ↗

(On Diff #98960)

I believe we should use llvm::Error instead of std::error_code for new code.

56 ↗

(On Diff #98960)

Looks like you want to allow users instantiate this class only with createResFile(). If so, it's better to make the constructor private.

59 ↗

(On Diff #98960)

Functions should start with a verb. Maybe getHeadEntry?

61 ↗

(On Diff #98960)

v -> V

83–84 ↗

(On Diff #98960)

We have alignTo function to do this.

87 ↗

(On Diff #98960)

Please fix format.

llvm/lib/Object/ResFile.cpp

38 ↗

(On Diff #98960)

Format.

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

79–81 ↗

(On Diff #98960)

It's more natural to do if (EC) reportError(...).

[zturner]

llvm/include/llvm/Object/Binary.h

60 ↗

(On Diff #98960)

Maybe ID_WinRes, // Windows resource data

llvm/include/llvm/Object/ResFile.h

10 ↗

(On Diff #98960)

Also maybe a brief sentence about what a .res file is.

28–30 ↗

(On Diff #98960)

Alternatively, move the macro to a cpp file (see below for related comment), or move the macro to the same place where errorToErrorCode is defined, so other people can make use of it and we don't have to copy the code around anymore.

32–34 ↗

(On Diff #98960)

This can probably go to the cpp file if you de-inline the functions below.

36 ↗

(On Diff #98960)

Same.

68 ↗

(On Diff #98960)

I think you should store the BinaryByteStream here in this class, not in the Ref class. This makes a lot of things much easier. See below for an example.

75 ↗

(On Diff #98960)

None of these seem like good candidates for inline functions. As an aside, if we did want to inline them, the best thing to do is declare them in the body of the class, not after you have finished definiing the class. In any case, can you move these to a cpp file?

82–87 ↗

(On Diff #98960)

Ideally we'd like to get rid of as much math as possible. BinaryStreamWriter has a function called padToAlign that does exactly this. Perhaps you could add alignTo(unsigned N) to `BinaryStreamReader which simply skips the appropriate number of bytes.

llvm/lib/Object/ResFile.cpp

29–32 ↗

(On Diff #98960)

Since this code is already part of the ResFile class, I don't know if passing the Error as an output parameter is necessary. Just move the constructor logic to this function, and make the constructor (declared private), take final values that require no processing.

37–38 ↗

(On Diff #98960)

If the BBS is in the ResFile instead of the ResFileRef, and the ResFileRef instead stores a BinaryStreamRef, you can just write:

return ResEntryRef(BBS.slice(LeadingSize, BBS.size()-LeadingSize));

[zturner]

llvm/lib/Object/ResFile.cpp

37–38 ↗

(On Diff #98960)

Alternatively, return ResEntryRef(BBS.drop_front(LeadingSize).drop_back(LeadingSize));

[zturner]

llvm/include/llvm/Object/ResFile.h

68 ↗

(On Diff #98960)

I made some improvements to the BinaryStreamClass recently, it should simplify some of this.

82–87 ↗

(On Diff #98960)

BinaryStreamReader now has a method called padToAlignment. The entire rest of this function can just be replaced with:

RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t));
End = (Reader.bytesRemaining() == 0);

llvm/lib/Object/ResFile.cpp

37–38 ↗

(On Diff #98960)

My bad, I misunderstood this code the first time. It's just return ResEntryRef(BBS.drop_front(LeadingSize));

[ecbeckmann]

Updated error output to be more informative, also made more clear naming scheme, removed inlines, and made use of helper functions.

[majnemer]

llvm/lib/Support/BinaryStreamReader.cpp

14 ↗

(On Diff #99379)

Why is this needed?

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

125–132 ↗

(On Diff #99379)

StringSwitch

[ecbeckmann]

llvm/include/llvm/Object/ResFile.h

28–30 ↗

(On Diff #98960)

Moved to the cpp file. I'm not sure if we want to put into Error.h because there are some variations in the codebase between returning errors and error codes.

llvm/lib/Object/ResFile.cpp

37–38 ↗

(On Diff #98960)

I opted to just have ResourceEntryRef take a BinaryStreamRef instead of an ArrayRef.

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

79–81 ↗

(On Diff #98960)

true....but llvm style guide prefers early return

[ecbeckmann]

Removed unnecessary includes, added StringSwitch.

llvm/lib/Support/BinaryStreamReader.cpp

14 ↗

(On Diff #99379)

woops! Forgot to remove that.

[ecbeckmann]

Fixed some things my clang-format changed.

[ecbeckmann]

Reverted some things my clang-format touched for some reason.

[zturner]

llvm/include/llvm/Object/WindowsResource.h

1–2 ↗

(On Diff #99383)

Can you fix this so that it's exactly 80 characters so it doesn't wrap?

llvm/lib/Object/WindowsResource.cpp

33–36 ↗

(On Diff #99383)

BBS = BinaryByteStream(Data.getBuffer(), support::little).drop_front(LeadingSize);

47 ↗

(On Diff #99383)

return llvm::make_unique<WindowsResource>(Source);

64–71 ↗

(On Diff #99383)

Maybe I'm missing something, but I don't think any of these lines are needed? You're computing Offset here by adding together the sizes of the two fields you just wrote. Then subtracting the size of the two fields you just wrote, at which point Offset is going to be 0. So you're skipping zero bytes, then padding to 4 byte alignment, but since you just read 2 uint32s, it should already be 4 byte aligned.

I think you can just delete all of this?

llvm/tools/llvm-cvtres/ResCOFFWriter.h

1–18 ↗

(On Diff #99383)

Do we need a header file just for this? Maybe just put it in llvm-cvtres.h?

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

15 ↗

(On Diff #99383)

Remove this include. In the future though, stadard includes go after llvm includes.

121 ↗

(On Diff #99383)

Remove

122–126 ↗

(On Diff #99383)

std::string MachineString = InputArgs.getLastArgValue(OPT_MACHINE).upper();

153 ↗

(On Diff #99383)

const auto &File

174–183 ↗

(On Diff #99383)

outs() << StringSwitch<machine>(Machine).(machine::ARM, "ARM")...

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

15 ↗

(On Diff #99383)

Can you put this in the same file as the other enum? That said, it looks like maybe it is only used from 1 file? In that case make it static inline in the file where you need it.

[ruiu]

llvm/include/llvm/Object/Binary.h

137 ↗

(On Diff #99603)

isWinRes

llvm/include/llvm/Object/WindowsResource.h

1–2 ↗

(On Diff #99603)

Format.

58 ↗

(On Diff #99603)

Format?

59 ↗

(On Diff #99603)

Do you need this?

llvm/lib/Object/WindowsResource.cpp

47–48 ↗

(On Diff #99603)

return make_unique<WindowsResource>(Source)?

llvm/test/tools/llvm-cvtres/resource.test

5–6 ↗

(On Diff #99603)

Since you have only one test, you can omit -check-prefix, and s/TEST_RES/CHECK/. ("CHECK" is the default name.)

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

162 ↗

(On Diff #99603)

You defined cvtres_error just for this line? If so, it seems too much to me. You could just do reportError("Unsupported machine architecture").

184 ↗

(On Diff #99603)

If you add \n at end of all the above strings, you can remove this line. This is shorter and probably better

if (Machine == machine::ARM)
  outs() << "ARM\n";
else if (Machine == machine::X86")
  outs() << "X86\n";
else
 outs() << "X64"\n";

[zturner]

llvm/lib/Object/WindowsResource.cpp

64–71 ↗

(On Diff #99383)

Ahh I think I follow now. But why are you just reading the data and header size, but not the *actual* data or headers?

[ecbeckmann]

some minor fixes

[ecbeckmann]

llvm/lib/Object/WindowsResource.cpp

64–71 ↗

(On Diff #99383)

This patch was just to add functionality for iterating through the entries without reading them just yet. It will be easy in future patches to add functions to ResourceEntryRef to return specific fields from each entry.

47–48 ↗

(On Diff #99603)

Unfortunately, since we made the constructor private it cannot be accessed by make_unique

llvm/tools/llvm-cvtres/ResCOFFWriter.h

1–18 ↗

(On Diff #99383)

When I eventually get to generating the COFF output file, that code will live in this file. This module is what needs to know what machine type it is generating for, so I thought I should place the enum here. But for now, I guess we can remove this file.

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

174–183 ↗

(On Diff #99383)

Unfortunately StringSwitch only goes from StringRef -> value, not the other way around. There's no constructor that takes a value parameter.

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

15 ↗

(On Diff #99383)

In future patches this function will surely be used in multiple files.

[zturner]

llvm/lib/Object/WindowsResource.cpp

33–36 ↗

(On Diff #99621)

My motivation for suggesting the change was ultimately to kill the reinterpret_cast which we should avoid wherever possible. Can we try this?

BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize), support::little);

[ruiu]

llvm/include/llvm/Object/WindowsResource.h

61 ↗

(On Diff #99621)

Remove inline as it is redundant. When you write a function definition inside class declaration, it is inline by default.

llvm/test/tools/llvm-cvtres/resource.test

5–6 ↗

(On Diff #99621)

Now you can write this in a single line.

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

72 ↗

(On Diff #99621)

I think err is unbuffered, so you don't need flush().

81 ↗

(On Diff #99621)

Can you run clang-format-diff? There are many formatting errors (in terms of the LLVM coding style) in this file.

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

15 ↗

(On Diff #99383)

Add this header in the future patch which needs this header. Adding a stub is usually fine, but this file seems too stub-y.

[ecbeckmann]

Cleaned up some more.

[ecbeckmann]

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

15 ↗

(On Diff #99383)

The header file itself is has already been commited into LLVM...are you saying we should not put the declarations here yet?

[zturner]

llvm/lib/Object/WindowsResource.cpp

64–71 ↗

(On Diff #99383)

I see. Can you then change to this?

BinaryStreamRef HeaderBytes;
BinaryStreamRef DataBytes;
RETURN_IF_ERROR(Reader.readStreamRef(HeaderBytes, HeaderSize));
RETURN_IF_ERROR(Reader.readStreamRef(DataBytes, DataSize));
RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t));

BTW, it seems strange to me that data size comes first and header size comes second. Are you sure the first two reads aren't reversed?

At least this way the logic is more clear and there's no math or manual jumping around which makes it hard to follow.

[ecbeckmann]

Load header and data sections into stream readers.

[ecbeckmann]

llvm/lib/Object/WindowsResource.cpp

64–71 ↗

(On Diff #99383)

Ah I see. In this case HeaderBytes and DataBytes should be made class variables as well.

I agree that it is a strange convention, and indeed the actual Microsoft documentation says that the order is Header Size followed by Data Size. However, this documentation is incorrect, and I've verified that the order is in fact Data Size > Header Size by examining several .res files in the hexcode editor.

[zturner]

lgtm after reflowing the comment.

llvm/lib/Object/WindowsResource.cpp

83–88 ↗

(On Diff #99655)

Can you move this comment up a line? It looks pretty bad like this.

[ecbeckmann]

Fixed formatting problems

llvm/include/llvm/Object/WindowsResource.h

59 ↗

(On Diff #99603)

Yes because the destructor is declared virtual in the base class.

[ecbeckmann]

One more formatting issue

llvm/trunk/include/llvm/Object/Binary.h

enum {
     ID_ELF64L, // ELF 64-bit, little endian
     ID_ELF64B, // ELF 64-bit, big endian
 
     ID_MachO32L, // MachO 32-bit, little endian
     ID_MachO32B, // MachO 32-bit, big endian
     ID_MachO64L, // MachO 64-bit, little endian
     ID_MachO64B, // MachO 64-bit, big endian
 
+    ID_WinRes, // Windows resource (.res) file.
+
     ID_Wasm,
 
     ID_EndObjects
   };
 
   static inline unsigned int getELFType(bool isLE, bool is64Bits) {
     if (isLE)
       return is64Bits ? ID_ELF64L : ID_ELF32L;
bool isIR() const {
     return TypeID == ID_IR;
   }
 
   bool isLittleEndian() const {
     return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B ||
              TypeID == ID_MachO32B || TypeID == ID_MachO64B);
   }
 
+  bool isWinRes() const { return TypeID == ID_WinRes; }
+
   Triple::ObjectFormatType getTripleObjectFormat() const {
     if (isCOFF())
       return Triple::COFF;
     if (isMachO())
       return Triple::MachO;
     if (isELF())
       return Triple::ELF;
     return Triple::UnknownObjectFormat;

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

+//===-- WindowsResource.h ---------------------------------------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===---------------------------------------------------------------------===//
+//
+// This file declares the .res file class.  .res files are intermediate
+// products of the typical resource-compilation process on Windows.  This
+// process is as follows:
+//
+// .rc file(s) ---(rc.exe)---> .res file(s) ---(cvtres.exe)---> COFF file
+//
+// .rc files are human-readable scripts that list all resources a program uses.
+//
+// They are compiled into .res files, which are a list of the resources in
+// binary form.
+//
+// Finally the data stored in the .res is compiled into a COFF file, where it
+// is organized in a directory tree structure for optimized access by the
+// program during runtime.
+//
+// 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/Object/Binary.h"
+#include "llvm/Support/BinaryByteStream.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+namespace object {
+
+class WindowsResource;
+
+class ResourceEntryRef {
+public:
+  Error moveNext(bool &End);
+
+private:
+  friend class WindowsResource;
+
+  ResourceEntryRef(BinaryStreamRef Ref, const WindowsResource *Owner,
+                   Error &Err);
+  Error loadNext();
+
+  BinaryStreamReader Reader;
+  BinaryStreamRef HeaderBytes;
+  BinaryStreamRef DataBytes;
+  const WindowsResource *OwningRes = nullptr;
+};
+
+class WindowsResource : public Binary {
+public:
+  ~WindowsResource() override;
+  Expected<ResourceEntryRef> getHeadEntry();
+
+  static bool classof(const Binary *V) { return V->isWinRes(); }
+
+  static Expected<std::unique_ptr<WindowsResource>>
+  createWindowsResource(MemoryBufferRef Source);
+
+private:
+  friend class ResourceEntryRef;
+
+  WindowsResource(MemoryBufferRef Source);
+
+  BinaryByteStream BBS;
+};
+
+} // namespace object
+} // namespace llvm
+
+#endif

llvm/trunk/include/llvm/Support/BinaryStreamReader.h

 #define LLVM_SUPPORT_BINARYSTREAMREADER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/type_traits.h"
 
 #include <string>
 #include <type_traits>
 
 namespace llvm {
 
 /// \brief Provides read only access to a subclass of `BinaryStream`.  Provides

llvm/trunk/include/llvm/Support/FileSystem.h

enum Impl {
     macho_dynamically_linked_shared_lib_stub, ///< Mach-O Shared lib stub
     macho_dsym_companion,     ///< Mach-O dSYM companion file
     macho_kext_bundle,        ///< Mach-O kext bundle file
     macho_universal_binary,   ///< Mach-O universal binary
     coff_cl_gl_object,        ///< Microsoft cl.exe's intermediate code file
     coff_object,              ///< COFF object file
     coff_import_library,      ///< COFF import library
     pecoff_executable,        ///< PECOFF executable file
-    windows_resource,         ///< Windows compiled resource file (.rc)
+    windows_resource,         ///< Windows compiled resource file (.res)
     wasm_object               ///< WebAssembly Object file
   };
 
   bool is_object() const {
     return V != unknown;
   }
 
   file_magic() = default;

llvm/trunk/lib/Object/Binary.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/WindowsResource.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <algorithm>
 #include <memory>
 #include <system_error>
switch (Type) {
     case sys::fs::file_magic::coff_object:
     case sys::fs::file_magic::coff_import_library:
     case sys::fs::file_magic::pecoff_executable:
     case sys::fs::file_magic::bitcode:
     case sys::fs::file_magic::wasm_object:
       return ObjectFile::createSymbolicFile(Buffer, Type, Context);
     case sys::fs::file_magic::macho_universal_binary:
       return MachOUniversalBinary::create(Buffer);
+    case sys::fs::file_magic::windows_resource:
+      return WindowsResource::createWindowsResource(Buffer);
     case sys::fs::file_magic::unknown:
     case sys::fs::file_magic::coff_cl_gl_object:
-    case sys::fs::file_magic::windows_resource:
       // Unrecognized object file format.
       return errorCodeToError(object_error::invalid_file_type);
   }
   llvm_unreachable("Unexpected Binary File Type");
 }
 
 Expected<OwningBinary<Binary>> object::createBinary(StringRef Path) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =

llvm/trunk/lib/Object/CMakeLists.txt

add_llvm_library(LLVMObject
   MachOUniversal.cpp
   ModuleSymbolTable.cpp
   Object.cpp
   ObjectFile.cpp
   RecordStreamer.cpp
   SymbolicFile.cpp
   SymbolSize.cpp
   WasmObjectFile.cpp
+  WindowsResource.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Object
 
   DEPENDS
   intrinsics_gen
   )

llvm/trunk/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/Object/Error.h"
+#include <system_error>
+
+namespace llvm {
+namespace object {
+
+static const char ResourceMagic[] = {
+    '\0',   '\0',   '\0', '\0', '\x20', '\0',   '\0', '\0',
+    '\xff', '\xff', '\0', '\0', '\xff', '\xff', '\0', '\0'};
+
+static const char NullEntry[16] = {'\0'};
+
+#define RETURN_IF_ERROR(X)                                                     \
+  if (auto EC = X)                                                             \
+    return EC;
+
+WindowsResource::WindowsResource(MemoryBufferRef Source)
+    : Binary(Binary::ID_WinRes, Source) {
+  size_t LeadingSize = sizeof(ResourceMagic) + sizeof(NullEntry);
+  BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize),
+                         support::little);
+}
+
+WindowsResource::~WindowsResource() = default;
+
+Expected<std::unique_ptr<WindowsResource>>
+WindowsResource::createWindowsResource(MemoryBufferRef Source) {
+  if (Source.getBufferSize() < sizeof(ResourceMagic) + sizeof(NullEntry))
+    return make_error<GenericBinaryError>(
+        "File too small to be a resource file",
+        object_error::invalid_file_type);
+  std::unique_ptr<WindowsResource> Ret(new WindowsResource(Source));
+  return std::move(Ret);
+}
+
+Expected<ResourceEntryRef> WindowsResource::getHeadEntry() {
+  Error Err = Error::success();
+  auto Ref = ResourceEntryRef(BinaryStreamRef(BBS), this, Err);
+  if (Err)
+    return std::move(Err);
+  return Ref;
+}
+
+ResourceEntryRef::ResourceEntryRef(BinaryStreamRef Ref,
+                                   const WindowsResource *Owner, Error &Err)
+    : Reader(Ref), OwningRes(Owner) {
+  if (loadNext())
+    Err = make_error<GenericBinaryError>("Could not read first entry.",
+                                         object_error::unexpected_eof);
+}
+
+Error ResourceEntryRef::moveNext(bool &End) {
+  // Reached end of all the entries.
+  if (Reader.bytesRemaining() == 0) {
+    End = true;
+    return Error::success();
+  }
+  RETURN_IF_ERROR(loadNext());
+
+  return Error::success();
+}
+
+Error ResourceEntryRef::loadNext() {
+  uint32_t DataSize;
+  RETURN_IF_ERROR(Reader.readInteger(DataSize));
+  uint32_t HeaderSize;
+  RETURN_IF_ERROR(Reader.readInteger(HeaderSize));
+  // The data and header size ints are themselves part of the header, so we must
+  // subtract them from the size.
+  RETURN_IF_ERROR(
+      Reader.readStreamRef(HeaderBytes, HeaderSize - 2 * sizeof(uint32_t)));
+  RETURN_IF_ERROR(Reader.readStreamRef(DataBytes, DataSize));
+  RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t)));
+  return Error::success();
+}
+
+} // namespace object
+} // namespace llvm

llvm/trunk/test/tools/llvm-cvtres/Inputs/test_resource.rc

+#include "windows.h"
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+myaccelerators ACCELERATORS
+{
+  "^C", 999, VIRTKEY, ALT
+  "D", 1100, VIRTKEY, CONTROL, SHIFT
+  "^R", 444, ASCII, NOINVERT
+}
+
+cursor BITMAP "cursor_small.bmp"
+okay BITMAP "okay_small.bmp"
+
+14432 MENU
+LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED
+{
+  MENUITEM "yu", 100
+  MENUITEM "shala", 101
+  MENUITEM "kaoya", 102
+}
+
+testdialog DIALOG 10, 10, 200, 300
+STYLE WS_POPUP | WS_BORDER
+CAPTION "Test"
+{
+  CTEXT "Continue:", 1, 10, 10, 230, 14
+  PUSHBUTTON "&OK", 2, 66, 134, 161, 13
+}
+
+12 ACCELERATORS
+{
+  "X", 164, VIRTKEY, ALT
+  "H", 5678, VIRTKEY, CONTROL, SHIFT
+  "^R", 444, ASCII, NOINVERT
+}
+
+"eat" MENU
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_AUS
+{
+  MENUITEM "fish", 100
+  MENUITEM "salad", 101
+  MENUITEM "duck", 102
+}

llvm/trunk/test/tools/llvm-cvtres/resource.test

+// The input was generated with the following command, using the original Windows
+// rc.exe:
+// > rc /fo test_resource.res /nologo test_resource.rc
+
+RUN: llvm-cvtres %p/Inputs/test_resource.res | FileCheck %s
+
+CHECK: Number of resources: 7

llvm/trunk/tools/llvm-cvtres/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  Object
   Option
   Support
   )
 
 set(LLVM_TARGET_DEFINITIONS Opts.td)
 
 tablegen(LLVM Opts.inc -gen-opt-parser-defs)
 add_public_tablegen_target(CvtResTableGen)
 
 add_llvm_tool(llvm-cvtres
   llvm-cvtres.cpp
   )

llvm/trunk/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);
+
+enum class machine { UNKNOWN = 0, ARM, X64, X86 };
+
 #endif

llvm/trunk/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"
 
 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,  \
                HELPTEXT, METAVAR)                                              \
   OPT_##ID,

 class CvtResOptTable : public opt::OptTable {
 public:
   CvtResOptTable() : OptTable(InfoTable, true) {}
 };
 
 static ExitOnError ExitOnErr;
 }
 
+LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
+  errs() << Msg;
+  exit(1);
+}
+
+static void reportError(StringRef Input, std::error_code EC) {
+  reportError(Twine(Input) + ": " + EC.message() + ".\n");
+}
+
+void error(std::error_code EC) {
+  if (!EC)
+    return;
+  reportError(EC.message() + ".\n");
+}
+
+void error(Error EC) {
+  if (!EC)
+    return;
+  handleAllErrors(std::move(EC),
+                  [&](const ErrorInfoBase &EI) { reportError(EI.message()); });
+}
+
 int main(int argc_, const char *argv_[]) {
   sys::PrintStackTraceOnErrorSignal(argv_[0]);
   PrettyStackTraceProgram X(argc_, argv_);
 
   ExitOnErr.setBanner("llvm-cvtres: ");
 
   SmallVector<const char *, 256> argv;
   SpecificBumpPtrAllocator<char> ArgAllocator;
   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
       argv, makeArrayRef(argv_, argc_), ArgAllocator)));
 
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   CvtResOptTable T;
   unsigned MAI, MAC;
-  ArrayRef<const char *> ArgsArr = makeArrayRef(argv_, argc_);
+  ArrayRef<const char *> ArgsArr = makeArrayRef(argv_ + 1, argc_);
   opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
 
-  if (InputArgs.hasArg(OPT_HELP))
+  if (InputArgs.hasArg(OPT_HELP)) {
     T.PrintHelp(outs(), "cvtres", "Resource Converter", false);
+    return 0;
+  }
+
+  machine Machine;
 
+  if (InputArgs.hasArg(OPT_MACHINE)) {
+    std::string MachineString = InputArgs.getLastArgValue(OPT_MACHINE).upper();
+    Machine = StringSwitch<machine>(MachineString)
+                  .Case("ARM", machine::ARM)
+                  .Case("X64", machine::X64)
+                  .Case("X86", machine::X86)
+                  .Default(machine::UNKNOWN);
+    if (Machine == machine::UNKNOWN)
+      reportError("Unsupported machine architecture");
+  } else {
+    outs() << "Machine architecture not specified; assumed X64.\n";
+    Machine = machine::X64;
+  }
+
+  std::vector<std::string> InputFiles = InputArgs.getAllArgValues(OPT_INPUT);
+
+  if (InputFiles.size() == 0) {
+    reportError("No input file specified");
+  }
+
+  SmallString<128> OutputFile;
+
+  if (InputArgs.hasArg(OPT_OUT)) {
+    OutputFile = InputArgs.getLastArgValue(OPT_OUT);
+  } else {
+    OutputFile = StringRef(InputFiles[0]);
+    llvm::sys::path::replace_extension(OutputFile, ".obj");
+  }
+
+  for (const auto &File : InputFiles) {
+    Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
+        object::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");
+
+    int EntryNumber = 0;
+    Expected<ResourceEntryRef> EntryOrErr = RF->getHeadEntry();
+    if (!EntryOrErr)
+      error(EntryOrErr.takeError());
+    ResourceEntryRef Entry = EntryOrErr.get();
+    bool End = false;
+    while (!End) {
+      error(Entry.moveNext(End));
+      EntryNumber++;
+    }
+    outs() << "Number of resources: " << EntryNumber << "\n";
+  }
+  outs() << "Machine: ";
+  switch (Machine) {
+  case machine::ARM:
+    outs() << "ARM\n";
+    break;
+  case machine::X86:
+    outs() << "X86\n";
+    break;
+  default:
+    outs() << "X64\n";
+  }
   return 0;
 }