[llvm-rc] [4/4] Add a GNU windres-like frontend to llvm-rc

[mstorsjo]

Summary

This primarily parses a different set of options and invokes the same
resource compiler as llvm-rc normally. Additionally, it can convert
directly to an object file (which is done with the separate cvtres tool,
or by the linker, in MSVC style setups).

(GNU windres also supports other conversions; from coff object file back
to .res, and from .res or object file back to .rc form; that's not yet
implemented.)

The other bigger complication lies in being able to imply or pass the
intended target triple, to let clang find the corresponding mingw sysroot
for finding include files, and for specifying the default output object
machine format.

It can be implied from the tool triple prefix, like
<triple>-[llvm-]windres, picked up from the windres option -F pe-x86-64
(where only BFD style format names are supported; as libbfd in binutils
doesn't support Windows on ARM, there's no such canonical name for the
ARM targets. Therefore, as an LLVM specific extension, this option is
extended to allow passing full triples.)

[mstorsjo]

Fixed the use of temp files so tests pass on windows, added missing dependencies for the new tool.

[mstorsjo]

CCing some more people involved with mingw tools, in case they have comments on some of the details here.

[mstorsjo]

Rebased on top of the updated preceding patch. Adjusted the logic for picking th
e default triple, to preserve the exact spelling of the default triple, if isWindowsGNUEnvironment() is true. Added a preprocessing test under clang.

[mstorsjo]

Rebased, updated with fixes making the full preprocessing test pass on windows, including fixes for the default arch when running on arches that aren't normally supported as windows targets.

[aganea]

llvm/tools/llvm-rc/llvm-rc.cpp

259–264

s/str/Str/

300

I would also need this function in D43002 (see unescapeSlashes), do you think we can move it to sys::path or any other "support" lib?

568

There was a latent issue here - unrelated to the moving of code around - I don't know if you want to fix it now or after? That is, s/16/0/.

[mstorsjo]

llvm/tools/llvm-rc/llvm-rc.cpp

259–264

Thanks, will fix.

300

This does things differently than your function - this converts \\\" into \" while your version leaves \\" if I read it correctly.

(I'm also considering a different, platform specific unescaping strategy - that'd be closer to how GNU windres behaves, but makes for a more inconsistent tool. Keeping the logic here makes it easier to tweak if needed.)

568

Hmm, as far as I can see, both rc.exe and GNU windres interpret values as hexadecimal - if I run e.g. rc.exe -l 40 test.rc, where 40 is ambiguous, I get language id 64.

[mstorsjo]

Updated the capitalization of one variable

[aganea]

llvm/tools/llvm-rc/llvm-rc.cpp

300

I think unescapeSlashes in D43002 was only a quick hack to allow copy-pasting a command-line file name from LIT outputs into the VS debugger options dialog. If the file name contains double quotes I would expect it to be converted as you do, but double quotes cannot happen in file names on Windows. In theory one could use the S_OBJNAME and LF_BUILDINFO records to repro a clang-cl build command on Linux, but that seems improbable? (since the feature is meant to be used on Windows)

568

Ok, we only have stuff like rc.exe /l 0x0409 in our build scripts, the 0x in front isn't consumed, I though it was mandatory.

[mstorsjo]

llvm/tools/llvm-rc/llvm-rc.cpp

300

Hmm, right. In any case - for that patch, I guess one would have to specify which unescaping one expects to do.

This one here is (currently) meant to be unix shell unescaping, but it could also be unix/windows shell unescaping based on what platform it runs on.

568

Ah, I see. I guess that's just good form to be explicit as user, as it indeed is quite ambiguous otherwise.

[mstorsjo]

Any further comments on this one, or is tolerable in this form? I'd prefer to not move the unescaping to shared code for now (as the exact definition of what it should do is a bit open).

[amccarth]

There's a lot going on here, but I don't see anything wrong. Thanks for the completeness of the tests and the comments, as that helps a lot in understanding what's going on here.

llvm/tools/llvm-rc/llvm-rc.cpp

295

".obj"?

[mstorsjo]

In D100756#2717331, @amccarth wrote:

There's a lot going on here, but I don't see anything wrong. Thanks for the completeness of the tests and the comments, as that helps a lot in understanding what's going on here.

Thanks!

With this in the tree, it'll be easier to reason about further requests to the preprocessing, when both use cases are available at once.

llvm/tools/llvm-rc/llvm-rc.cpp

295

Good point, I'll add that too.

[nickdesaulniers]

thanks for this patch @mstorsjo ! This is help AOSP LLVM move our windows builds of LLVM away from MinGW to LLVM!
https://android-review.googlesource.com/c/toolchain/llvm_android/+/1867380/

[mstorsjo]

In D100756#3088035, @nickdesaulniers wrote:

thanks for this patch @mstorsjo ! This is help AOSP LLVM move our windows builds of LLVM away from MinGW to LLVM!
https://android-review.googlesource.com/c/toolchain/llvm_android/+/1867380/

Thanks for letting me know - that’s nice to hear that it benefits you too!

Btw, a little nitpick about naming - MinGW is the SDK/environment that you’re still using, but you moved from GNU binutils windres to llvm windres - it’s just as little/much mingw as before. :P

clang/test/CMakeLists.txt

list(APPEND CLANG_TEST_DEPS
     llvm-objcopy
     llvm-objdump
     llvm-profdata
     llvm-rc
     llvm-readelf
     llvm-readobj
     llvm-strip
     llvm-symbolizer
+    llvm-windres
     opt
     split-file
     yaml2obj
     )
 
   if(TARGET llvm-lto)
     list(APPEND CLANG_TEST_DEPS llvm-lto)
   endif()

clang/test/Preprocessor/Inputs/llvm-windres.h

+#ifndef RC_INVOKED
+#error RC_INVOKED not defined
+#endif
+#ifndef _WIN32
+#error _WIN32 not defined
+#endif
+#ifndef __MINGW32__
+#error __MINGW32__ not defined
+#endif
+#define MY_ID 42

clang/test/Preprocessor/llvm-windres.rc

+// RUN: llvm-windres -I%p/Inputs %s %t.res
+// RUN: llvm-readobj %t.res | FileCheck %s
+// CHECK: Resource type (int): RCDATA (ID 10)
+// CHECK: Resource name (int): 42
+#include "llvm-windres.h"
+MY_ID RCDATA {
+  "a long string of data"
+}

llvm/test/CMakeLists.txt

set(LLVM_TEST_DEPENDS
           llvm-rtdyld
           llvm-size
           llvm-split
           llvm-strings
           llvm-strip
           llvm-symbolizer
           llvm-tblgen
           llvm-undname
+          llvm-windres
           llvm-xray
           not
           obj2yaml
           opt
           sancov
           sanstats
           split-file
           verify-uselistorder

llvm/test/lit.cfg.py

tools.extend([
     'llvm-cov', 'llvm-cxxdump', 'llvm-cvtres', 'llvm-diff', 'llvm-dis',
     'llvm-dwarfdump', 'llvm-dlltool', 'llvm-exegesis', 'llvm-extract',
     'llvm-isel-fuzzer', 'llvm-ifs',
     'llvm-install-name-tool', 'llvm-jitlink', 'llvm-opt-fuzzer', 'llvm-lib',
     'llvm-link', 'llvm-lto', 'llvm-lto2', 'llvm-mc', 'llvm-mca',
     'llvm-modextract', 'llvm-nm', 'llvm-objcopy', 'llvm-objdump', 'llvm-otool',
     'llvm-pdbutil', 'llvm-profdata', 'llvm-profgen', 'llvm-ranlib', 'llvm-rc', 'llvm-readelf',
     'llvm-readobj', 'llvm-rtdyld', 'llvm-size', 'llvm-split', 'llvm-strings',
-    'llvm-strip', 'llvm-tblgen', 'llvm-undname', 'llvm-c-test', 'llvm-cxxfilt',
+    'llvm-strip', 'llvm-tblgen', 'llvm-undname', 'llvm-windres',
+    'llvm-c-test', 'llvm-cxxfilt',
     'llvm-xray', 'yaml2obj', 'obj2yaml', 'yaml-bench', 'verify-uselistorder',
     'bugpoint', 'llc', 'llvm-symbolizer', 'opt', 'sancov', 'sanstats'])
 
 # The following tools are optional
 tools.extend([
     ToolSubst('llvm-go', unresolved='ignore'),
     ToolSubst('llvm-mt', unresolved='ignore'),
     ToolSubst('Kaleidoscope-Ch3', unresolved='ignore'),

llvm/test/tools/llvm-rc/codepage.test

 ; RUN: llvm-rc -no-preprocess /C 65001 /FO %t.utf8.res -- %p/Inputs/utf8.rc
 ; RUN: llvm-readobj %t.utf8.res | FileCheck %s --check-prefix=UTF8
+; RUN: llvm-windres --no-preprocess -c 65001 %p/Inputs/utf8.rc %t.utf8.res
+; RUN: llvm-readobj %t.utf8.res | FileCheck %s --check-prefix=UTF8
+; RUN: llvm-windres --no-preprocess --codepage 65001 %p/Inputs/utf8.rc %t.utf8.res
+; RUN: llvm-readobj %t.utf8.res | FileCheck %s --check-prefix=UTF8
 
 ; UTF8:      Resource type (int): STRINGTABLE (ID 6)
 ; UTF8-NEXT: Resource name (int): 1
 ; UTF8-NEXT: Data version: 0
 ; UTF8-NEXT: Memory flags: 0x1030
 ; UTF8-NEXT: Language ID: 1033
 ; UTF8-NEXT: Version (major): 0
 ; UTF8-NEXT: Version (minor): 0
 ; UTF8-NEXT: Characteristics: 0
 ; UTF8-NEXT: Data size: 68
 ; UTF8-NEXT: Data: (
 ; UTF8-NEXT:   0000: 00000700 E500E400 F6002000 A9002000  |.......... ... .|
 ; UTF8-NEXT:   0010: 61000B00 E500E400 F6002000 A9002000  |a......... ... .|
 ; UTF8-NEXT:   0020: E500E400 F6002000 A9000000 00000000  |...... .........|
 ; UTF8-NEXT:   0030: 00000000 00000000 00000000 00000000  |................|
 ; UTF8-NEXT:   0040: 00000000                             |....|
 ; UTF8-NEXT: )
 
 ; RUN: not llvm-rc -no-preprocess /C 65001 /FO %t.utf8-escape-narrow.res -- %p/Inputs/utf8-escape-narrow.rc 2>&1 | FileCheck %s --check-prefix UTF8_ESCAPE
 ; UTF8_ESCAPE: llvm-rc: Error in STRINGTABLE statement (ID 1):
 ; UTF8_ESCAPE-NEXT: Unable to interpret single byte (195) as UTF-8
 
 ; RUN: llvm-rc -no-preprocess /C 1252 /FO %t.cp1252.res -- %p/Inputs/cp1252.rc
 ; RUN: llvm-readobj %t.cp1252.res | FileCheck %s --check-prefix=CP1252
+; RUN: llvm-windres --no-preprocess -c 1252 %p/Inputs/cp1252.rc %t.cp1252.res
+; RUN: llvm-readobj %t.cp1252.res | FileCheck %s --check-prefix=CP1252
 
 ; CP1252:      Resource type (int): STRINGTABLE (ID 6)
 ; CP1252-NEXT: Resource name (int): 1
 ; CP1252-NEXT: Data version: 0
 ; CP1252-NEXT: Memory flags: 0x1030
 ; CP1252-NEXT: Language ID: 1033
 ; CP1252-NEXT: Version (major): 0
 ; CP1252-NEXT: Version (minor): 0

llvm/test/tools/llvm-rc/language.test

 ; RUN: llvm-rc -no-preprocess /l 40A /FO %t.res -- %p/Inputs/language.rc
 ; RUN: llvm-readobj %t.res | FileCheck %s
 ; RUN: llvm-rc -no-preprocess /l40A /FO %t.res -- %p/Inputs/language.rc
 ; RUN: llvm-readobj %t.res | FileCheck %s
+; RUN: llvm-windres --no-preprocess -l 40A %p/Inputs/language.rc %t.res
+; RUN: llvm-readobj %t.res | FileCheck %s
+; RUN: llvm-windres --no-preprocess --language 40A %p/Inputs/language.rc %t.res
+; RUN: llvm-readobj %t.res | FileCheck %s
 
 ; CHECK:      Resource name (int): 1
 ; CHECK-NEXT: Data version:
 ; CHECK-NEXT: Memory flags:
 ; CHECK-NEXT: Language ID: 2049
 
 ; CHECK:      Resource name (int): 2
 ; CHECK-NEXT: Data version:
 ; CHECK-NEXT: Memory flags:
 ; CHECK-NEXT: Language ID: 1034
 
 ; CHECK:      Resource name (int): 3
 ; CHECK-NEXT: Data version:
 ; CHECK-NEXT: Memory flags:
 ; CHECK-NEXT: Language ID: 4099

llvm/test/tools/llvm-rc/windres-format.test

+; Check that the various input/output formats (rc/res/coff) are implied
+; from file suffixes.
+
+; RUN: rm -f %t.res
+; RUN: llvm-windres --no-preprocess %p/Inputs/tag-stringtable-basic.rc %t.res
+; RUN: llvm-readobj %t.res | FileCheck %s --check-prefix=CHECK-RES
+
+; RUN: rm -f %t.o
+; RUN: llvm-windres --no-preprocess -F pe-x86-64 %p/Inputs/tag-stringtable-basic.rc %t.o
+; RUN: llvm-readobj --coff-resources %t.o | FileCheck %s --check-prefix=CHECK-OBJ
+
+; RUN: rm -f %t.obj
+; RUN: llvm-windres -F pe-x86-64 %t.res %t.obj
+; RUN: llvm-readobj --coff-resources %t.obj | FileCheck %s --check-prefix=CHECK-OBJ
+
+; Check that we can specify the input/output file types explicitly.
+; Also check options for specifying the input/output file names.
+
+; RUN: cat %p/Inputs/tag-stringtable-basic.rc > %t-anonymous
+; RUN: rm -f %t-anonymous2
+; RUN: llvm-windres --no-preprocess -O res -J rc -o %t-anonymous2 -i %t-anonymous
+; RUN: llvm-readobj %t-anonymous2 | FileCheck %s --check-prefix=CHECK-RES
+
+; RUN: rm -f %t-anonymous3
+; RUN: llvm-windres -F pe-x86-64 -J res -O coff -i%t-anonymous2 -o%t-anonymous3
+; RUN: llvm-readobj --coff-resources %t-anonymous3 | FileCheck %s --check-prefix=CHECK-OBJ
+
+; CHECK-RES: Resource type (int): STRINGTABLE
+
+; CHECK-OBJ: Format: COFF-x86-64
+; CHECK-OBJ: Resources [
+; CHECK-OBJ:   Total Number of Resources:
+
+; Check for format conversions that currently aren't supported.
+
+; RUN: not llvm-windres -F pe-x86-64 -J res -O rc -i%t-anonymous2 -o%t-anonymous 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR-OUTPUT
+; RUN: not llvm-windres -F pe-x86-64 -J coff -O res -i%t-anonymous3 -o%t-anonymous2 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR-INPUT
+
+; CHECK-ERROR-OUTPUT: Unsupported output format
+; CHECK-ERROR-INPUT: Unsupported input format

llvm/test/tools/llvm-rc/windres-prefix.test

+; REQUIRES: shell
+
+; RUN: rm -rf %t && mkdir %t
+
+; Check that a triple prefix on the executable gets picked up as target triple.
+
+; RUN: ln -fs $(which llvm-windres) %t/aarch64-w64-mingw32-windres
+; RUN: %t/aarch64-w64-mingw32-windres -### %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK-PREPROC
+; CHECK-PREPROC: "clang" "--driver-mode=gcc" "-target" "aarch64-w64-mingw32"
+
+; Check that the triple prefix also affects the output object file type.
+
+; RUN: %t/aarch64-w64-mingw32-windres --no-preprocess %p/Inputs/tag-stringtable-basic.rc %t.o
+; RUN: llvm-readobj --coff-resources %t.o | FileCheck %s --check-prefix=CHECK-OBJ
+
+; CHECK-OBJ: Format: COFF-ARM64
+; CHECK-OBJ: Resources [
+; CHECK-OBJ:   Total Number of Resources:

llvm/test/tools/llvm-rc/windres-preproc.test

+; RUN: llvm-windres -### --include-dir %p/incdir1 --include %p/incdir2 "-DFOO1=\\\"foo bar\\\"" -UFOO2 -D FOO3 --preprocessor-arg "-DFOO4=\\\"baz baz\\\"" %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK1
+; CHECK1: {{^}} "clang" "--driver-mode=gcc" "-target" "{{.*}}-w64-mingw32" "-E" "-xc" "-DRC_INVOKED" "{{.*}}empty.rc" "-o" "{{.*}}preproc-{{.*}}.rc" "-I" "{{.*}}incdir1" "-I" "{{.*}}incdir2" "-D" "FOO1=\"foo bar\"" "-U" "FOO2" "-D" "FOO3" "-DFOO4=\"baz baz\""{{$}}
+; RUN: llvm-windres -### --preprocessor "i686-w64-mingw32-gcc -E -DFOO=\\\"foo\\ bar\\\"" %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK2
+; CHECK2: {{^}} "i686-w64-mingw32-gcc" "-E" "-DFOO=\"foo bar\"" "{{.*}}empty.rc" "-o" "{{.*}}preproc-{{.*}}.rc"{{$}}

llvm/test/tools/llvm-rc/windres-target.test

+; Check handling of the -F/--target option for setting a specific BFD
+; target name.
+
+; RUN: llvm-windres -F pe-i386 -### %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK-I686
+; RUN: llvm-windres -Fpe-i386 -### %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK-I686
+; CHECK-I686: "clang" "--driver-mode=gcc" "-target" "i686-w64-mingw32"
+; RUN: llvm-windres --target pe-x86-64 -### %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK-X86-64
+; RUN: llvm-windres --target=pe-x86-64 -### %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK-X86-64
+; CHECK-X86-64: "clang" "--driver-mode=gcc" "-target" "x86_64-w64-mingw32"
+
+; LLVM windres specific: Check that we can pass a full triple via the
+; -F/--target option, if it doesn't match the BFD target names.
+
+; RUN: llvm-windres -F armv7-w64-mingw32 -### %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK-ARMV7
+; RUN: llvm-windres --target armv7-w64-mingw32 -### %p/Inputs/empty.rc %t.res | FileCheck %s --check-prefix=CHECK-ARMV7
+; CHECK-ARMV7: "clang" "--driver-mode=gcc" "-target" "armv7-w64-mingw32"
+
+; Check the actual written object types.
+
+; RUN: llvm-windres --no-preprocess -F i686-w64-mingw32 %p/Inputs/tag-stringtable-basic.rc %t.o
+; RUN: llvm-readobj --coff-resources %t.o | FileCheck %s --check-prefixes=CHECK-OBJ,CHECK-OBJ-I686
+; RUN: llvm-windres --no-preprocess -F x86_64-w64-mingw32 %p/Inputs/tag-stringtable-basic.rc %t.o
+; RUN: llvm-readobj --coff-resources %t.o | FileCheck %s --check-prefixes=CHECK-OBJ,CHECK-OBJ-X86-64
+; RUN: llvm-windres --no-preprocess -F armv7-w64-mingw32 %p/Inputs/tag-stringtable-basic.rc %t.o
+; RUN: llvm-readobj --coff-resources %t.o | FileCheck %s --check-prefixes=CHECK-OBJ,CHECK-OBJ-ARMV7
+; RUN: llvm-windres --no-preprocess -F aarch64-w64-mingw32 %p/Inputs/tag-stringtable-basic.rc %t.o
+; RUN: llvm-readobj --coff-resources %t.o | FileCheck %s --check-prefixes=CHECK-OBJ,CHECK-OBJ-AARCH64
+
+; CHECK-OBJ-I686: Format: COFF-i386
+; CHECK-OBJ-X86-64: Format: COFF-x86-64
+; CHECK-OBJ-ARMV7: Format: COFF-ARM{{$}}
+; CHECK-OBJ-AARCH64: Format: COFF-ARM64
+; CHECK-OBJ: Resources [
+; CHECK-OBJ:   Total Number of Resources:

llvm/test/tools/llvm-rc/windres-version.test

+; RUN: llvm-windres --version | FileCheck %s
+
+; Check that the printed version string contains the words "GNU windres",
+; which some build systems look for.
+
+; CHECK: GNU windres

llvm/tools/llvm-rc/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(RcTableGen)
+add_public_tablegen_target(RcOptsTableGen)
+
+set(LLVM_TARGET_DEFINITIONS WindresOpts.td)
+tablegen(LLVM WindresOpts.inc -gen-opt-parser-defs)
+add_public_tablegen_target(WindresOptsTableGen)
 
 add_llvm_tool(llvm-rc
   llvm-rc.cpp
   ResourceFileWriter.cpp
   ResourceScriptCppFilter.cpp
   ResourceScriptParser.cpp
   ResourceScriptStmt.cpp
   ResourceScriptToken.cpp
   )
+
+add_llvm_tool_symlink(llvm-windres llvm-rc)
+
+if(LLVM_INSTALL_BINUTILS_SYMLINKS)
+  add_llvm_tool_symlink(windres llvm-rc)
+endif()

llvm/tools/llvm-rc/WindresOpts.td

+include "llvm/Option/OptParser.td"
+
+multiclass Long<string name, string help> {
+  def NAME: Separate<["--"], name>;
+  def NAME # _eq: Joined<["--"], name # "=">, Alias<!cast<Separate>(NAME)>,
+    HelpText<help>;
+}
+
+multiclass LongAlias<string name, Option orig> {
+  def NAME: Separate<["--"], name>, Alias<orig>;
+  def NAME # _eq: Joined<["--"], name # "=">, Alias<orig>;
+}
+
+multiclass LongShort<string short, string long, string help> {
+  def NAME: Separate<["--"], long>;
+  def NAME # _eq: Joined<["--"], long # "=">, Alias<!cast<Separate>(NAME)>,
+    HelpText<help>;
+  def NAME # _short: JoinedOrSeparate<["-"], short>, Alias<!cast<Separate>(NAME)>;
+}
+
+multiclass F<string short, string long, string help> {
+  def NAME: Flag<["-"], short>;
+  def NAME # _long: Flag<["--"], long>, Alias<!cast<Flag>(NAME)>,
+    HelpText<help>;
+}
+
+defm input : LongShort<"i", "input", "Input file">;
+
+defm output : LongShort<"o", "output", "Output file">;
+
+defm input_format : LongShort<"J", "input-format", "Input format">;
+
+defm output_format : LongShort<"O", "output-format", "Output format">;
+
+defm preprocessor : Long<"preprocessor", "Custom preprocessor command">;
+defm preprocessor_arg : Long<"preprocessor-arg", "Preprocessor command argument">;
+
+defm target : LongShort<"F", "target", "Target BFD format name">;
+
+defm include_dir : LongShort<"I", "include-dir", "Include directory">;
+defm include_alias : LongAlias<"include", include_dir>;
+
+defm define : LongShort<"D", "define", "Define to pass to the preprocessor">;
+
+defm undef : LongShort<"U", "undefine", "Undefine to pass to the preprocessor">;
+
+defm codepage : LongShort<"c", "codepage", "Default codepage to use">;
+
+defm language : LongShort<"l", "language", "Default language to use (0x0-0xffff)">;
+
+defm verbose : F<"v", "verbose", "Enable verbose output">;
+defm version : F<"V", "version", "Display version">;
+
+defm help : F<"h", "help", "Display this message and exit">;
+
+// Print (but do not run) the commands to run for preprocessing
+def _HASH_HASH_HASH : Flag<["-"], "###">;
+
+def no_preprocess : Flag<["--"], "no-preprocess">;
+
+// Unimplemented options for compatibility
+def use_temp_file: Flag<["--"], "use-temp-file">;

llvm/tools/llvm-rc/llvm-rc.cpp

 
 #include "ResourceFileWriter.h"
 #include "ResourceScriptCppFilter.h"
 #include "ResourceScriptParser.h"
 #include "ResourceScriptStmt.h"
 #include "ResourceScriptToken.h"
 
 #include "llvm/ADT/Triple.h"
+#include "llvm/Object/WindowsResource.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"

 #undef OPTION
 };
 
 class RcOptTable : public opt::OptTable {
 public:
   RcOptTable() : OptTable(InfoTable, /* IgnoreCase = */ true) {}
 };
 
+enum Windres_ID {
+  WINDRES_INVALID = 0, // This is not a correct option ID.
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  WINDRES_##ID,
+#include "WindresOpts.inc"
+#undef OPTION
+};
+
+#define PREFIX(NAME, VALUE) const char *const WINDRES_##NAME[] = VALUE;
+#include "WindresOpts.inc"
+#undef PREFIX
+
+static const opt::OptTable::Info WindresInfoTable[] = {
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  {                                                                            \
+      WINDRES_##PREFIX, NAME,         HELPTEXT,                                \
+      METAVAR,          WINDRES_##ID, opt::Option::KIND##Class,                \
+      PARAM,            FLAGS,        WINDRES_##GROUP,                         \
+      WINDRES_##ALIAS,  ALIASARGS,    VALUES},
+#include "WindresOpts.inc"
+#undef OPTION
+};
+
+class WindresOptTable : public opt::OptTable {
+public:
+  WindresOptTable() : OptTable(WindresInfoTable, /* IgnoreCase = */ false) {}
+};
+
 static ExitOnError ExitOnErr;
 static FileRemover TempPreprocFile;
+static FileRemover TempResFile;
 
 LLVM_ATTRIBUTE_NORETURN static void fatalError(const Twine &Message) {
   errs() << Message << "\n";
   exit(1);
 }
 
 std::string createTempFile(const Twine &Prefix, StringRef Suffix) {
   std::error_code EC;
ErrorOr<std::string> findClang(const char *Argv0) {
   for (const auto *Name : {"clang", "clang-cl"}) {
     Path = sys::findProgramByName(Name);
     if (Path)
       return Path;
   }
   return Path;
 }
 
-std::string getClangClTriple() {
-  Triple T(sys::getDefaultTargetTriple());
-  switch (T.getArch()) {
+Triple::ArchType getDefaultArch(Triple::ArchType Arch) {
+  switch (Arch) {
   case Triple::x86:
   case Triple::x86_64:
   case Triple::arm:
   case Triple::thumb:
   case Triple::aarch64:
     // These work properly with the clang driver, setting the expected
     // defines such as _WIN32 etc.
-    break;
+    return Arch;
   default:
     // Other archs aren't set up for use with windows as target OS, (clang
     // doesn't define e.g. _WIN32 etc), so set a reasonable default arch.
-    T.setArch(Triple::x86_64);
-    break;
-  }
+    return Triple::x86_64;
+  }
+
+std::string getClangClTriple() {
+  Triple T(sys::getDefaultTargetTriple());
+  T.setArch(getDefaultArch(T.getArch()));
   T.setOS(Triple::Win32);
   T.setVendor(Triple::PC);
   T.setEnvironment(Triple::MSVC);
   T.setObjectFormat(Triple::COFF);
   return T.str();
 }
 
-bool preprocess(StringRef Src, StringRef Dst, opt::InputArgList &InputArgs,
+std::string getMingwTriple() {
+  Triple T(sys::getDefaultTargetTriple());
+  T.setArch(getDefaultArch(T.getArch()));
+  if (T.isWindowsGNUEnvironment())
+    return T.str();
+  // Write out the literal form of the vendor/env here, instead of
+  // constructing them with enum values (which end up with them in
+  // normalized form). The literal form of the triple can matter for
+  // finding include files.
+  return (Twine(T.getArchName()) + "-w64-mingw32").str();
+}
+
+enum Format { Rc, Res, Coff, Unknown };
+
+struct RcOptions {
+  bool Preprocess = true;
+  bool PrintCmdAndExit = false;
+  std::string Triple;
+  std::vector<std::string> PreprocessCmd;
+  std::vector<std::string> PreprocessArgs;
+
+  std::string InputFile;
+  Format InputFormat = Rc;
+  std::string OutputFile;
+  Format OutputFormat = Res;
+
+  bool BeVerbose = false;
+  WriterParams Params;
+  bool AppendNull = false;
+  bool IsDryRun = false;
+  // Set the default language; choose en-US arbitrarily.
+  unsigned LangId = (/*PrimaryLangId*/ 0x09) | (/*SubLangId*/ 0x01 << 10);
+};
+
+bool preprocess(StringRef Src, StringRef Dst, const RcOptions &Opts,
                 const char *Argv0) {
   std::string Clang;
-  if (InputArgs.hasArg(OPT__HASH_HASH_HASH)) {
+  if (Opts.PrintCmdAndExit) {
     Clang = "clang";
   } else {
     ErrorOr<std::string> ClangOrErr = findClang(Argv0);
     if (ClangOrErr) {
       Clang = *ClangOrErr;
     } else {
       errs() << "llvm-rc: Unable to find clang, skipping preprocessing."
              << "\n";
       errs() << "Pass -no-cpp to disable preprocessing. This will be an error "
                 "in the future."
              << "\n";
       return false;
     }
   }
-  std::string PreprocTriple = getClangClTriple();
 
   SmallVector<StringRef, 8> Args = {
-      Clang, "--driver-mode=gcc", "-target", PreprocTriple, "-E",
-      "-xc", "-DRC_INVOKED",      Src,       "-o",          Dst};
-  if (InputArgs.hasArg(OPT_noinclude)) {
-#ifdef _WIN32
-    ::_putenv("INCLUDE=");
-#else
-    ::unsetenv("INCLUDE");
-#endif
-  }
-  for (const auto *Arg :
-       InputArgs.filtered(OPT_includepath, OPT_define, OPT_undef)) {
-    switch (Arg->getOption().getID()) {
-    case OPT_includepath:
-      Args.push_back("-I");
-      break;
-    case OPT_define:
-      Args.push_back("-D");
-      break;
-    case OPT_undef:
-      Args.push_back("-U");
-      break;
-    }
-    Args.push_back(Arg->getValue());
-  }
-  if (InputArgs.hasArg(OPT__HASH_HASH_HASH) || InputArgs.hasArg(OPT_verbose)) {
+      Clang, "--driver-mode=gcc", "-target", Opts.Triple, "-E",
+      "-xc", "-DRC_INVOKED"};
+  if (!Opts.PreprocessCmd.empty()) {
+    Args.clear();
+    for (const auto &S : Opts.PreprocessCmd)
+      Args.push_back(S);
+  }
+  Args.push_back(Src);
+  Args.push_back("-o");
+  Args.push_back(Dst);
+  for (const auto &S : Opts.PreprocessArgs)
+    Args.push_back(S);
+  if (Opts.PrintCmdAndExit || Opts.BeVerbose) {
     for (const auto &A : Args) {
       outs() << " ";
-      sys::printArg(outs(), A, InputArgs.hasArg(OPT__HASH_HASH_HASH));
+      sys::printArg(outs(), A, Opts.PrintCmdAndExit);
     }
     outs() << "\n";
-    if (InputArgs.hasArg(OPT__HASH_HASH_HASH))
+    if (Opts.PrintCmdAndExit)
       exit(0);
   }
   // The llvm Support classes don't handle reading from stdout of a child
   // process; otherwise we could avoid using a temp file.
   int Res = sys::ExecuteAndWait(Clang, Args);
   if (Res) {
     fatalError("llvm-rc: Preprocessing failed.");
   }
   return true;
 }
 
-} // anonymous namespace
+static bool consume_back_lower(StringRef &S, const char *Str) {
+  if (!S.endswith_lower(Str))
+    return false;
+  S = S.drop_back(strlen(Str));
+  return true;
+}
 
-int main(int Argc, const char **Argv) {
-  InitLLVM X(Argc, Argv);
-  ExitOnErr.setBanner("llvm-rc: ");
+static std::pair<bool, std::string> isWindres(llvm::StringRef Argv0) {
+  StringRef ProgName = llvm::sys::path::stem(Argv0);
+  // x86_64-w64-mingw32-windres -> x86_64-w64-mingw32, windres
+  // llvm-rc -> "", llvm-rc
+  // aarch64-w64-mingw32-llvm-windres-10.exe -> aarch64-w64-mingw32, llvm-windres
+  ProgName = ProgName.rtrim("0123456789.-");
+  if (!consume_back_lower(ProgName, "windres"))
+    return std::make_pair<bool, std::string>(false, "");
+  consume_back_lower(ProgName, "llvm-");
+  consume_back_lower(ProgName, "-");
+  return std::make_pair<bool, std::string>(true, ProgName.str());
+}
+
+Format parseFormat(StringRef S) {
+  Format F = StringSwitch<Format>(S.lower())
+                 .Case("rc", Rc)
+                 .Case("res", Res)
+                 .Case("coff", Coff)
+                 .Default(Unknown);
+  if (F == Unknown)
+    fatalError("Unable to parse '" + Twine(S) + "' as a format");
+  return F;
+}
+
+void deduceFormat(Format &Dest, StringRef File) {
+  Format F = StringSwitch<Format>(sys::path::extension(File.lower()))
+                 .Case(".rc", Rc)
+                 .Case(".res", Res)
+                 .Case(".o", Coff)
+                 .Case(".obj", Coff)
+                 .Default(Unknown);
+  if (F != Unknown)
+    Dest = F;
+}
+
+std::string unescape(StringRef S) {
+  std::string Out;
+  Out.reserve(S.size());
+  for (int I = 0, E = S.size(); I < E; I++) {
+    if (S[I] == '\\') {
+      if (I + 1 < E)
+        Out.push_back(S[++I]);
+      else
+        fatalError("Unterminated escape");
+      continue;
+    }
+    Out.push_back(S[I]);
+  }
+  return Out;
+}
+
+std::vector<std::string> unescapeSplit(StringRef S) {
+  std::vector<std::string> OutArgs;
+  std::string Out;
+  bool InQuote = false;
+  for (int I = 0, E = S.size(); I < E; I++) {
+    if (S[I] == '\\') {
+      if (I + 1 < E)
+        Out.push_back(S[++I]);
+      else
+        fatalError("Unterminated escape");
+      continue;
+    }
+    if (S[I] == '"') {
+      InQuote = !InQuote;
+      continue;
+    }
+    if (S[I] == ' ' && !InQuote) {
+      OutArgs.push_back(Out);
+      Out.clear();
+      continue;
+    }
+    Out.push_back(S[I]);
+  }
+  if (InQuote)
+    fatalError("Unterminated quote");
+  if (!Out.empty())
+    OutArgs.push_back(Out);
+  return OutArgs;
+}
+
+RcOptions parseWindresOptions(ArrayRef<const char *> ArgsArr,
+                              ArrayRef<const char *> InputArgsArray,
+                              std::string Prefix) {
+  WindresOptTable T;
+  RcOptions Opts;
+  unsigned MAI, MAC;
+  opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
+
+  // The tool prints nothing when invoked with no command-line arguments.
+  if (InputArgs.hasArg(WINDRES_help)) {
+    T.PrintHelp(outs(), "windres [options] file...",
+                "LLVM windres (GNU windres compatible)", false, true);
+    exit(0);
+  }
+
+  if (InputArgs.hasArg(WINDRES_version)) {
+    outs() << "llvm-windres, compatible with GNU windres\n";
+    cl::PrintVersionMessage();
+    exit(0);
+  }
+
+  std::vector<std::string> FileArgs = InputArgs.getAllArgValues(WINDRES_INPUT);
+  FileArgs.insert(FileArgs.end(), InputArgsArray.begin(), InputArgsArray.end());
 
+  if (InputArgs.hasArg(WINDRES_input)) {
+    Opts.InputFile = InputArgs.getLastArgValue(WINDRES_input).str();
+  } else if (!FileArgs.empty()) {
+    Opts.InputFile = FileArgs.front();
+    FileArgs.erase(FileArgs.begin());
+  } else {
+    // TODO: GNU windres takes input on stdin in this case.
+    fatalError("Missing input file");
+  }
+
+  if (InputArgs.hasArg(WINDRES_output)) {
+    Opts.OutputFile = InputArgs.getLastArgValue(WINDRES_output).str();
+  } else if (!FileArgs.empty()) {
+    Opts.OutputFile = FileArgs.front();
+    FileArgs.erase(FileArgs.begin());
+  } else {
+    // TODO: GNU windres writes output in rc form to stdout in this case.
+    fatalError("Missing output file");
+  }
+
+  if (InputArgs.hasArg(WINDRES_input_format)) {
+    Opts.InputFormat =
+        parseFormat(InputArgs.getLastArgValue(WINDRES_input_format));
+  } else {
+    deduceFormat(Opts.InputFormat, Opts.InputFile);
+  }
+  if (Opts.InputFormat == Coff)
+    fatalError("Unsupported input format");
+
+  if (InputArgs.hasArg(WINDRES_output_format)) {
+    Opts.OutputFormat =
+        parseFormat(InputArgs.getLastArgValue(WINDRES_output_format));
+  } else {
+    // The default in windres differs from the default in RcOptions
+    Opts.OutputFormat = Coff;
+    deduceFormat(Opts.OutputFormat, Opts.OutputFile);
+  }
+  if (Opts.OutputFormat == Rc)
+    fatalError("Unsupported output format");
+  if (Opts.InputFormat == Opts.OutputFormat) {
+    outs() << "Nothing to do.\n";
+    exit(0);
+  }
+
+  Opts.PrintCmdAndExit = InputArgs.hasArg(WINDRES__HASH_HASH_HASH);
+  Opts.Preprocess = !InputArgs.hasArg(WINDRES_no_preprocess);
+  Triple TT(Prefix);
+  if (InputArgs.hasArg(WINDRES_target)) {
+    StringRef Value = InputArgs.getLastArgValue(WINDRES_target);
+    if (Value == "pe-i386")
+      Opts.Triple = "i686-w64-mingw32";
+    else if (Value == "pe-x86-64")
+      Opts.Triple = "x86_64-w64-mingw32";
+    else
+      // Implicit extension; if the --target value isn't one of the known
+      // BFD targets, allow setting the full triple string via this instead.
+      Opts.Triple = Value.str();
+  } else if (TT.getArch() != Triple::UnknownArch)
+    Opts.Triple = Prefix;
+  else
+    Opts.Triple = getMingwTriple();
+
+  for (const auto *Arg :
+       InputArgs.filtered(WINDRES_include_dir, WINDRES_define, WINDRES_undef,
+                          WINDRES_preprocessor_arg)) {
+    // GNU windres passes the arguments almost as-is on to popen() (it only
+    // backslash escapes spaces in the arguments), where a shell would
+    // unescape backslash escapes for quotes and similar. This means that
+    // when calling GNU windres, callers need to double escape chars like
+    // quotes, e.g. as -DSTRING=\\\"1.2.3\\\".
+    //
+    // Exactly how the arguments are interpreted depends on the platform
+    // though - but the cases where this matters (where callers would have
+    // done this double escaping) probably is confined to cases like these
+    // quoted string defines, and those happen to work the same across unix
+    // and windows.
+    std::string Unescaped = unescape(Arg->getValue());
+    switch (Arg->getOption().getID()) {
+    case WINDRES_include_dir:
+      // Technically, these are handled the same way as e.g. defines, but
+      // the way we consistently unescape the unix way breaks windows paths
+      // with single backslashes. Alternatively, our unescape function would
+      // need to mimic the platform specific command line parsing/unescaping
+      // logic.
+      Opts.Params.Include.push_back(Arg->getValue());
+      Opts.PreprocessArgs.push_back("-I");
+      Opts.PreprocessArgs.push_back(Arg->getValue());
+      break;
+    case WINDRES_define:
+      Opts.PreprocessArgs.push_back("-D");
+      Opts.PreprocessArgs.push_back(Unescaped);
+      break;
+    case WINDRES_undef:
+      Opts.PreprocessArgs.push_back("-U");
+      Opts.PreprocessArgs.push_back(Unescaped);
+      break;
+    case WINDRES_preprocessor_arg:
+      Opts.PreprocessArgs.push_back(Unescaped);
+      break;
+    }
+  }
+  if (InputArgs.hasArg(WINDRES_preprocessor))
+    Opts.PreprocessCmd =
+        unescapeSplit(InputArgs.getLastArgValue(WINDRES_preprocessor));
+
+  Opts.Params.CodePage = CpWin1252; // Different default
+  if (InputArgs.hasArg(WINDRES_codepage)) {
+    if (InputArgs.getLastArgValue(WINDRES_codepage)
+            .getAsInteger(10, Opts.Params.CodePage))
+      fatalError("Invalid code page: " +
+                 InputArgs.getLastArgValue(WINDRES_codepage));
+  }
+  if (InputArgs.hasArg(WINDRES_language)) {
+    if (InputArgs.getLastArgValue(WINDRES_language)
+            .getAsInteger(16, Opts.LangId))
+      fatalError("Invalid language id: " +
+                 InputArgs.getLastArgValue(WINDRES_language));
+  }
+
+  Opts.BeVerbose = InputArgs.hasArg(WINDRES_verbose);
+
+  return Opts;
+}
+
+RcOptions parseRcOptions(ArrayRef<const char *> ArgsArr,
+                         ArrayRef<const char *> InputArgsArray) {
   RcOptTable T;
+  RcOptions Opts;
   unsigned MAI, MAC;
-  const char **DashDash = std::find_if(
-      Argv + 1, Argv + Argc, [](StringRef Str) { return Str == "--"; });
-  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, DashDash);
-
   opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
 
   // The tool prints nothing when invoked with no command-line arguments.
   if (InputArgs.hasArg(OPT_help)) {
     T.PrintHelp(outs(), "rc [options] file...", "Resource Converter", false);
-    return 0;
+    exit(0);
   }
 
-  const bool BeVerbose = InputArgs.hasArg(OPT_verbose);
-
   std::vector<std::string> InArgsInfo = InputArgs.getAllArgValues(OPT_INPUT);
-  if (DashDash != Argv + Argc)
-    InArgsInfo.insert(InArgsInfo.end(), DashDash + 1, Argv + Argc);
+  InArgsInfo.insert(InArgsInfo.end(), InputArgsArray.begin(),
+                    InputArgsArray.end());
   if (InArgsInfo.size() != 1) {
     fatalError("Exactly one input file should be provided.");
   }
 
-  std::string PreprocessedFile = InArgsInfo[0];
-  if (!InputArgs.hasArg(OPT_no_preprocess)) {
+  Opts.PrintCmdAndExit = InputArgs.hasArg(OPT__HASH_HASH_HASH);
+  Opts.Triple = getClangClTriple();
+  for (const auto *Arg :
+       InputArgs.filtered(OPT_includepath, OPT_define, OPT_undef)) {
+    switch (Arg->getOption().getID()) {
+    case OPT_includepath:
+      Opts.PreprocessArgs.push_back("-I");
+      break;
+    case OPT_define:
+      Opts.PreprocessArgs.push_back("-D");
+      break;
+    case OPT_undef:
+      Opts.PreprocessArgs.push_back("-U");
+      break;
+    }
+    Opts.PreprocessArgs.push_back(Arg->getValue());
+  }
+
+  Opts.InputFile = InArgsInfo[0];
+  Opts.BeVerbose = InputArgs.hasArg(OPT_verbose);
+  Opts.Preprocess = !InputArgs.hasArg(OPT_no_preprocess);
+  Opts.Params.Include = InputArgs.getAllArgValues(OPT_includepath);
+  Opts.Params.NoInclude = InputArgs.hasArg(OPT_noinclude);
+  if (Opts.Params.NoInclude) {
+    // Clear the INLCUDE variable for the external preprocessor
+#ifdef _WIN32
+    ::_putenv("INCLUDE=");
+#else
+    ::unsetenv("INCLUDE");
+#endif
+  }
+  if (InputArgs.hasArg(OPT_codepage)) {
+    if (InputArgs.getLastArgValue(OPT_codepage)
+            .getAsInteger(10, Opts.Params.CodePage))
+      fatalError("Invalid code page: " +
+                 InputArgs.getLastArgValue(OPT_codepage));
+  }
+  Opts.IsDryRun = InputArgs.hasArg(OPT_dry_run);
+  auto OutArgsInfo = InputArgs.getAllArgValues(OPT_fileout);
+  if (OutArgsInfo.empty()) {
+    SmallString<128> OutputFile(Opts.InputFile);
+    llvm::sys::fs::make_absolute(OutputFile);
+    llvm::sys::path::replace_extension(OutputFile, "res");
+    OutArgsInfo.push_back(std::string(OutputFile.str()));
+  }
+  if (!Opts.IsDryRun) {
+    if (OutArgsInfo.size() != 1)
+      fatalError(
+          "No more than one output file should be provided (using /FO flag).");
+    Opts.OutputFile = OutArgsInfo[0];
+  }
+  Opts.AppendNull = InputArgs.hasArg(OPT_add_null);
+  if (InputArgs.hasArg(OPT_lang_id)) {
+    if (InputArgs.getLastArgValue(OPT_lang_id).getAsInteger(16, Opts.LangId))
+      fatalError("Invalid language id: " +
+                 InputArgs.getLastArgValue(OPT_lang_id));
+  }
+  return Opts;
+}
+
+RcOptions getOptions(const char *Argv0, ArrayRef<const char *> ArgsArr,
+                     ArrayRef<const char *> InputArgs) {
+  std::string Prefix;
+  bool IsWindres;
+  std::tie(IsWindres, Prefix) = isWindres(Argv0);
+  if (IsWindres)
+    return parseWindresOptions(ArgsArr, InputArgs, Prefix);
+  else
+    return parseRcOptions(ArgsArr, InputArgs);
+}
+
+void doRc(std::string Src, std::string Dest, RcOptions &Opts,
+          const char *Argv0) {
+  std::string PreprocessedFile = Src;
+  if (Opts.Preprocess) {
     std::string OutFile = createTempFile("preproc", "rc");
     TempPreprocFile.setFile(OutFile);
-    if (preprocess(InArgsInfo[0], OutFile, InputArgs, Argv[0]))
+    if (preprocess(Src, OutFile, Opts, Argv0))
       PreprocessedFile = OutFile;
   }
 
   // Read and tokenize the input file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> File =
       MemoryBuffer::getFile(PreprocessedFile);
   if (!File) {
-    fatalError("Error opening file '" + Twine(InArgsInfo[0]) +
+    fatalError("Error opening file '" + Twine(PreprocessedFile) +
                "': " + File.getError().message());
   }
 
   std::unique_ptr<MemoryBuffer> FileContents = std::move(*File);
   StringRef Contents = FileContents->getBuffer();
 
   std::string FilteredContents = filterCppOutput(Contents);
   std::vector<RCToken> Tokens = ExitOnErr(tokenizeRC(FilteredContents));
 
-  if (BeVerbose) {
+  if (Opts.BeVerbose) {
     const Twine TokenNames[] = {
 #define TOKEN(Name) #Name,
 #define SHORT_TOKEN(Name, Ch) #Name,
 #include "ResourceScriptTokenList.def"
     };
 
     for (const RCToken &Token : Tokens) {
       outs() << TokenNames[static_cast<int>(Token.kind())] << ": "
              << Token.value();
       if (Token.kind() == RCToken::Kind::Int)
         outs() << "; int value = " << Token.intValue();
 
       outs() << "\n";
     }
   }
 
-  WriterParams Params;
-  SmallString<128> InputFile(InArgsInfo[0]);
+  WriterParams &Params = Opts.Params;
+  SmallString<128> InputFile(Src);
   llvm::sys::fs::make_absolute(InputFile);
   Params.InputFilePath = InputFile;
-  Params.Include = InputArgs.getAllArgValues(OPT_includepath);
-  Params.NoInclude = InputArgs.hasArg(OPT_noinclude);
 
-  if (InputArgs.hasArg(OPT_codepage)) {
-    if (InputArgs.getLastArgValue(OPT_codepage)
-            .getAsInteger(10, Params.CodePage))
-      fatalError("Invalid code page: " +
-                 InputArgs.getLastArgValue(OPT_codepage));
-    switch (Params.CodePage) {
-    case CpAcp:
-    case CpWin1252:
-    case CpUtf8:
-      break;
-    default:
-      fatalError(
-          "Unsupported code page, only 0, 1252 and 65001 are supported!");
-    }
+    fatalError("Unsupported code page, only 0, 1252 and 65001 are supported!");
   }
 
   std::unique_ptr<ResourceFileWriter> Visitor;
-  bool IsDryRun = InputArgs.hasArg(OPT_dry_run);
-
-  if (!IsDryRun) {
-    auto OutArgsInfo = InputArgs.getAllArgValues(OPT_fileout);
-    if (OutArgsInfo.empty()) {
-      SmallString<128> OutputFile = InputFile;
-      llvm::sys::path::replace_extension(OutputFile, "res");
-      OutArgsInfo.push_back(std::string(OutputFile.str()));
-    }
-
-    if (OutArgsInfo.size() != 1)
-      fatalError(
-          "No more than one output file should be provided (using /FO flag).");
 
+  if (!Opts.IsDryRun) {
     std::error_code EC;
     auto FOut = std::make_unique<raw_fd_ostream>(
-        OutArgsInfo[0], EC, sys::fs::FA_Read | sys::fs::FA_Write);
+        Dest, EC, sys::fs::FA_Read | sys::fs::FA_Write);
     if (EC)
-      fatalError("Error opening output file '" + OutArgsInfo[0] +
-                 "': " + EC.message());
+      fatalError("Error opening output file '" + Dest + "': " + EC.message());
     Visitor = std::make_unique<ResourceFileWriter>(Params, std::move(FOut));
-    Visitor->AppendNull = InputArgs.hasArg(OPT_add_null);
+    Visitor->AppendNull = Opts.AppendNull;
 
     ExitOnErr(NullResource().visit(Visitor.get()));
 
-    // Set the default language; choose en-US arbitrarily.
-    unsigned PrimaryLangId = 0x09, SubLangId = 0x01;
-    if (InputArgs.hasArg(OPT_lang_id)) {
-      unsigned LangId;
-      if (InputArgs.getLastArgValue(OPT_lang_id).getAsInteger(16, LangId))
-        fatalError("Invalid language id: " +
-                   InputArgs.getLastArgValue(OPT_lang_id));
-      PrimaryLangId = LangId & 0x3ff;
-      SubLangId = LangId >> 10;
-    }
+    unsigned PrimaryLangId = Opts.LangId & 0x3ff;
+    unsigned SubLangId = Opts.LangId >> 10;
     ExitOnErr(LanguageResource(PrimaryLangId, SubLangId).visit(Visitor.get()));
   }
 
   rc::RCParser Parser{std::move(Tokens)};
   while (!Parser.isEof()) {
     auto Resource = ExitOnErr(Parser.parseSingleResource());
-    if (BeVerbose)
+    if (Opts.BeVerbose)
       Resource->log(outs());
-    if (!IsDryRun)
+    if (!Opts.IsDryRun)
       ExitOnErr(Resource->visit(Visitor.get()));
   }
 
   // STRINGTABLE resources come at the very end.
-  if (!IsDryRun)
+  if (!Opts.IsDryRun)
     ExitOnErr(Visitor->dumpAllStringTables());
+}
+
+void doCvtres(std::string Src, std::string Dest, std::string TargetTriple) {
+  object::WindowsResourceParser Parser;
+
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+      MemoryBuffer::getFile(Src);
+  if (!BufferOrErr)
+    fatalError("Error opening file '" + Twine(Src) +
+               "': " + BufferOrErr.getError().message());
+  std::unique_ptr<MemoryBuffer> &Buffer = BufferOrErr.get();
+  std::unique_ptr<object::WindowsResource> Binary =
+      ExitOnErr(object::WindowsResource::createWindowsResource(
+          Buffer->getMemBufferRef()));
+
+  std::vector<std::string> Duplicates;
+  ExitOnErr(Parser.parse(Binary.get(), Duplicates));
+  for (const auto &DupeDiag : Duplicates)
+    fatalError("Duplicate resources: " + DupeDiag);
+
+  Triple T(TargetTriple);
+  COFF::MachineTypes MachineType;
+  switch (T.getArch()) {
+  case Triple::x86:
+    MachineType = COFF::IMAGE_FILE_MACHINE_I386;
+    break;
+  case Triple::x86_64:
+    MachineType = COFF::IMAGE_FILE_MACHINE_AMD64;
+    break;
+  case Triple::arm:
+  case Triple::thumb:
+    MachineType = COFF::IMAGE_FILE_MACHINE_ARMNT;
+    break;
+  case Triple::aarch64:
+    MachineType = COFF::IMAGE_FILE_MACHINE_ARM64;
+    break;
+  default:
+    fatalError("Unsupported architecture in target '" + Twine(TargetTriple) +
+               "'");
+  }
+
+  std::unique_ptr<MemoryBuffer> OutputBuffer =
+      ExitOnErr(object::writeWindowsResourceCOFF(MachineType, Parser,
+                                                 /*DateTimeStamp*/ 0));
+  std::unique_ptr<FileOutputBuffer> FileBuffer =
+      ExitOnErr(FileOutputBuffer::create(Dest, OutputBuffer->getBufferSize()));
+  std::copy(OutputBuffer->getBufferStart(), OutputBuffer->getBufferEnd(),
+            FileBuffer->getBufferStart());
+  ExitOnErr(FileBuffer->commit());
+}
+
+} // anonymous namespace
+
+int main(int Argc, const char **Argv) {
+  InitLLVM X(Argc, Argv);
+  ExitOnErr.setBanner("llvm-rc: ");
+
+  const char **DashDash = std::find_if(
+      Argv + 1, Argv + Argc, [](StringRef Str) { return Str == "--"; });
+  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, DashDash);
+  ArrayRef<const char *> FileArgsArr;
+  if (DashDash != Argv + Argc)
+    FileArgsArr = makeArrayRef(DashDash + 1, Argv + Argc);
+
+  RcOptions Opts = getOptions(Argv[0], ArgsArr, FileArgsArr);
+
+  std::string ResFile = Opts.OutputFile;
+  if (Opts.InputFormat == Rc) {
+    if (Opts.OutputFormat == Coff) {
+      ResFile = createTempFile("rc", "res");
+      TempResFile.setFile(ResFile);
+    }
+    doRc(Opts.InputFile, ResFile, Opts, Argv[0]);
+  } else {
+    ResFile = Opts.InputFile;
+  }
+  if (Opts.OutputFormat == Coff) {
+    doCvtres(ResFile, Opts.OutputFile, Opts.Triple);
+  }
 
   return 0;
 }