1 //===- llvm-cvtres.cpp - Serialize .res files into .obj ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Serialize .res files into .obj files. This is intended to be a
10 // platform-independent port of Microsoft's cvtres.exe.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/BinaryFormat/Magic.h"
15 #include "llvm/Object/Binary.h"
16 #include "llvm/Object/WindowsMachineFlag.h"
17 #include "llvm/Object/WindowsResource.h"
18 #include "llvm/Option/Arg.h"
19 #include "llvm/Option/ArgList.h"
20 #include "llvm/Option/Option.h"
21 #include "llvm/Support/BinaryStreamError.h"
22 #include "llvm/Support/Error.h"
23 #include "llvm/Support/InitLLVM.h"
24 #include "llvm/Support/ManagedStatic.h"
25 #include "llvm/Support/Path.h"
26 #include "llvm/Support/PrettyStackTrace.h"
27 #include "llvm/Support/Process.h"
28 #include "llvm/Support/ScopedPrinter.h"
29 #include "llvm/Support/Signals.h"
30 #include "llvm/Support/raw_ostream.h"
31
32 #include <system_error>
33
34 using namespace llvm;
35 using namespace object;
36
37 namespace {
38
39 enum ID {
40 OPT_INVALID = 0, // This is not an option ID.
41 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
42 HELPTEXT, METAVAR, VALUES) \
43 OPT_##ID,
44 #include "Opts.inc"
45 #undef OPTION
46 };
47
48 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
49 #include "Opts.inc"
50 #undef PREFIX
51
52 static const opt::OptTable::Info InfoTable[] = {
53 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
54 HELPTEXT, METAVAR, VALUES) \
55 { \
56 PREFIX, NAME, HELPTEXT, \
57 METAVAR, OPT_##ID, opt::Option::KIND##Class, \
58 PARAM, FLAGS, OPT_##GROUP, \
59 OPT_##ALIAS, ALIASARGS, VALUES},
60 #include "Opts.inc"
61 #undef OPTION
62 };
63
64 class CvtResOptTable : public opt::OptTable {
65 public:
CvtResOptTable()66 CvtResOptTable() : OptTable(InfoTable, true) {}
67 };
68 }
69
reportError(Twine Msg)70 static LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
71 errs() << Msg;
72 exit(1);
73 }
74
reportError(StringRef Input,std::error_code EC)75 static void reportError(StringRef Input, std::error_code EC) {
76 reportError(Twine(Input) + ": " + EC.message() + ".\n");
77 }
78
error(StringRef Input,Error EC)79 static void error(StringRef Input, Error EC) {
80 if (!EC)
81 return;
82 handleAllErrors(std::move(EC), [&](const ErrorInfoBase &EI) {
83 reportError(Twine(Input) + ": " + EI.message() + ".\n");
84 });
85 }
86
error(Error EC)87 static void error(Error EC) {
88 if (!EC)
89 return;
90 handleAllErrors(std::move(EC),
91 [&](const ErrorInfoBase &EI) { reportError(EI.message()); });
92 }
93
getTime()94 static uint32_t getTime() {
95 std::time_t Now = time(nullptr);
96 if (Now < 0 || !isUInt<32>(Now))
97 return UINT32_MAX;
98 return static_cast<uint32_t>(Now);
99 }
100
error(Expected<T> EC)101 template <typename T> T error(Expected<T> EC) {
102 if (!EC)
103 error(EC.takeError());
104 return std::move(EC.get());
105 }
106
error(StringRef Input,Expected<T> EC)107 template <typename T> T error(StringRef Input, Expected<T> EC) {
108 if (!EC)
109 error(Input, EC.takeError());
110 return std::move(EC.get());
111 }
112
error(StringRef Input,ErrorOr<T> && EC)113 template <typename T> T error(StringRef Input, ErrorOr<T> &&EC) {
114 return error(Input, errorOrToExpected(std::move(EC)));
115 }
116
main(int Argc,const char ** Argv)117 int main(int Argc, const char **Argv) {
118 InitLLVM X(Argc, Argv);
119
120 CvtResOptTable T;
121 unsigned MAI, MAC;
122 ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1);
123 opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
124
125 if (InputArgs.hasArg(OPT_HELP)) {
126 T.printHelp(outs(), "llvm-cvtres [options] file...", "Resource Converter");
127 return 0;
128 }
129
130 bool Verbose = InputArgs.hasArg(OPT_VERBOSE);
131
132 COFF::MachineTypes MachineType;
133
134 if (opt::Arg *Arg = InputArgs.getLastArg(OPT_MACHINE)) {
135 MachineType = getMachineType(Arg->getValue());
136 if (MachineType == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
137 reportError(Twine("Unsupported machine architecture ") + Arg->getValue() +
138 "\n");
139 }
140 } else {
141 if (Verbose)
142 outs() << "Machine architecture not specified; assumed X64.\n";
143 MachineType = COFF::IMAGE_FILE_MACHINE_AMD64;
144 }
145
146 std::vector<std::string> InputFiles = InputArgs.getAllArgValues(OPT_INPUT);
147
148 if (InputFiles.size() == 0) {
149 reportError("No input file specified.\n");
150 }
151
152 SmallString<128> OutputFile;
153
154 if (opt::Arg *Arg = InputArgs.getLastArg(OPT_OUT)) {
155 OutputFile = Arg->getValue();
156 } else {
157 OutputFile = sys::path::filename(StringRef(InputFiles[0]));
158 sys::path::replace_extension(OutputFile, ".obj");
159 }
160
161 uint32_t DateTimeStamp;
162 if (llvm::opt::Arg *Arg = InputArgs.getLastArg(OPT_TIMESTAMP)) {
163 StringRef Value(Arg->getValue());
164 if (Value.getAsInteger(0, DateTimeStamp))
165 reportError(Twine("invalid timestamp: ") + Value +
166 ". Expected 32-bit integer\n");
167 } else {
168 DateTimeStamp = getTime();
169 }
170
171 if (Verbose)
172 outs() << "Machine: " << machineToStr(MachineType) << '\n';
173
174 WindowsResourceParser Parser;
175
176 for (const auto &File : InputFiles) {
177 std::unique_ptr<MemoryBuffer> Buffer = error(
178 File, MemoryBuffer::getFileOrSTDIN(File, /*IsText=*/false,
179 /*RequiresNullTerminator=*/false));
180 file_magic Type = identify_magic(Buffer->getMemBufferRef().getBuffer());
181 if (Type != file_magic::windows_resource)
182 reportError(File + ": unrecognized file format.\n");
183 std::unique_ptr<WindowsResource> Binary = error(
184 File,
185 WindowsResource::createWindowsResource(Buffer->getMemBufferRef()));
186
187 WindowsResource *RF = Binary.get();
188
189 if (Verbose) {
190 int EntryNumber = 0;
191 ResourceEntryRef Entry = error(RF->getHeadEntry());
192 bool End = false;
193 while (!End) {
194 error(Entry.moveNext(End));
195 EntryNumber++;
196 }
197 outs() << "Number of resources: " << EntryNumber << "\n";
198 }
199
200 std::vector<std::string> Duplicates;
201 error(Parser.parse(RF, Duplicates));
202 for (const auto& DupeDiag : Duplicates)
203 reportError(DupeDiag);
204 }
205
206 if (Verbose) {
207 Parser.printTree(outs());
208 }
209
210 std::unique_ptr<MemoryBuffer> OutputBuffer =
211 error(llvm::object::writeWindowsResourceCOFF(MachineType, Parser,
212 DateTimeStamp));
213 auto FileOrErr =
214 FileOutputBuffer::create(OutputFile, OutputBuffer->getBufferSize());
215 if (!FileOrErr)
216 reportError(OutputFile, errorToErrorCode(FileOrErr.takeError()));
217 std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
218 std::copy(OutputBuffer->getBufferStart(), OutputBuffer->getBufferEnd(),
219 FileBuffer->getBufferStart());
220 error(FileBuffer->commit());
221
222 if (Verbose) {
223 std::unique_ptr<MemoryBuffer> Buffer =
224 error(OutputFile,
225 MemoryBuffer::getFileOrSTDIN(OutputFile, /*IsText=*/false,
226 /*RequiresNullTerminator=*/false));
227
228 ScopedPrinter W(errs());
229 W.printBinaryBlock("Output File Raw Data",
230 Buffer->getMemBufferRef().getBuffer());
231 }
232
233 return 0;
234 }
235