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

   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 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:
  66   CvtResOptTable() : OptTable(InfoTable, true) {}
  67 };
  68 }
  69
  70 [[noreturn]] static void reportError(Twine Msg) {
  71   errs() << Msg;
  72   exit(1);
  73 }
  74
  75 static void reportError(StringRef Input, std::error_code EC) {
  76   reportError(Twine(Input) + ": " + EC.message() + ".\n");
  77 }
  78
  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
  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
  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
 101 template <typename T> T error(Expected<T> EC) {
 102   if (!EC)
 103     error(EC.takeError());
 104   return std::move(EC.get());
 105 }
 106
 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
 113 template <typename T> T error(StringRef Input, ErrorOr<T> &&EC) {
 114   return error(Input, errorOrToExpected(std::move(EC)));
 115 }
 116
 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 }