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/ADT/StringSwitch.h"
  15 #include "llvm/Object/Binary.h"
  16 #include "llvm/Object/WindowsResource.h"
  17 #include "llvm/Option/Arg.h"
  18 #include "llvm/Option/ArgList.h"
  19 #include "llvm/Option/Option.h"
  20 #include "llvm/Support/BinaryStreamError.h"
  21 #include "llvm/Support/Error.h"
  22 #include "llvm/Support/InitLLVM.h"
  23 #include "llvm/Support/ManagedStatic.h"
  24 #include "llvm/Support/Path.h"
  25 #include "llvm/Support/PrettyStackTrace.h"
  26 #include "llvm/Support/Process.h"
  27 #include "llvm/Support/Signals.h"
  28 #include "llvm/Support/raw_ostream.h"
  29
  30 #include <system_error>
  31
  32 using namespace llvm;
  33 using namespace object;
  34
  35 namespace {
  36
  37 enum ID {
  38   OPT_INVALID = 0, // This is not an option ID.
  39 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  40                HELPTEXT, METAVAR, VALUES)                                      \
  41   OPT_##ID,
  42 #include "Opts.inc"
  43 #undef OPTION
  44 };
  45
  46 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
  47 #include "Opts.inc"
  48 #undef PREFIX
  49
  50 static const opt::OptTable::Info InfoTable[] = {
  51 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  52                HELPTEXT, METAVAR, VALUES)                                      \
  53   {                                                                            \
  54       PREFIX,      NAME,      HELPTEXT,                                        \
  55       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
  56       PARAM,       FLAGS,     OPT_##GROUP,                                     \
  57       OPT_##ALIAS, ALIASARGS, VALUES},
  58 #include "Opts.inc"
  59 #undef OPTION
  60 };
  61
  62 class CvtResOptTable : public opt::OptTable {
  63 public:
  64   CvtResOptTable() : OptTable(InfoTable, true) {}
  65 };
  66 }
  67
  68 LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
  69   errs() << Msg;
  70   exit(1);
  71 }
  72
  73 static void reportError(StringRef Input, std::error_code EC) {
  74   reportError(Twine(Input) + ": " + EC.message() + ".\n");
  75 }
  76
  77 void error(std::error_code EC) {
  78   if (!EC)
  79     return;
  80   reportError(EC.message() + ".\n");
  81 }
  82
  83 void error(Error EC) {
  84   if (!EC)
  85     return;
  86   handleAllErrors(std::move(EC),
  87                   [&](const ErrorInfoBase &EI) { reportError(EI.message()); });
  88 }
  89
  90 template <typename T> T error(Expected<T> EC) {
  91   if (!EC)
  92     error(EC.takeError());
  93   return std::move(EC.get());
  94 }
  95
  96 int main(int Argc, const char **Argv) {
  97   InitLLVM X(Argc, Argv);
  98
  99   CvtResOptTable T;
 100   unsigned MAI, MAC;
 101   ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1);
 102   opt::InputArgList InputArgs = T.ParseArgs(ArgsArr, MAI, MAC);
 103
 104   if (InputArgs.hasArg(OPT_HELP)) {
 105     T.PrintHelp(outs(), "llvm-cvtres [options] file...", "Resource Converter", false);
 106     return 0;
 107   }
 108
 109   bool Verbose = InputArgs.hasArg(OPT_VERBOSE);
 110
 111   COFF::MachineTypes MachineType;
 112
 113   if (InputArgs.hasArg(OPT_MACHINE)) {
 114     std::string MachineString = InputArgs.getLastArgValue(OPT_MACHINE).upper();
 115     MachineType = StringSwitch<COFF::MachineTypes>(MachineString)
 116                       .Case("ARM", COFF::IMAGE_FILE_MACHINE_ARMNT)
 117                       .Case("ARM64", COFF::IMAGE_FILE_MACHINE_ARM64)
 118                       .Case("X64", COFF::IMAGE_FILE_MACHINE_AMD64)
 119                       .Case("X86", COFF::IMAGE_FILE_MACHINE_I386)
 120                       .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
 121     if (MachineType == COFF::IMAGE_FILE_MACHINE_UNKNOWN)
 122       reportError("Unsupported machine architecture");
 123   } else {
 124     if (Verbose)
 125       outs() << "Machine architecture not specified; assumed X64.\n";
 126     MachineType = COFF::IMAGE_FILE_MACHINE_AMD64;
 127   }
 128
 129   std::vector<std::string> InputFiles = InputArgs.getAllArgValues(OPT_INPUT);
 130
 131   if (InputFiles.size() == 0) {
 132     reportError("No input file specified.\n");
 133   }
 134
 135   SmallString<128> OutputFile;
 136
 137   if (InputArgs.hasArg(OPT_OUT)) {
 138     OutputFile = InputArgs.getLastArgValue(OPT_OUT);
 139   } else {
 140     OutputFile = sys::path::filename(StringRef(InputFiles[0]));
 141     sys::path::replace_extension(OutputFile, ".obj");
 142   }
 143
 144   if (Verbose) {
 145     outs() << "Machine: ";
 146     switch (MachineType) {
 147     case COFF::IMAGE_FILE_MACHINE_ARM64:
 148       outs() << "ARM64\n";
 149       break;
 150     case COFF::IMAGE_FILE_MACHINE_ARMNT:
 151       outs() << "ARM\n";
 152       break;
 153     case COFF::IMAGE_FILE_MACHINE_I386:
 154       outs() << "X86\n";
 155       break;
 156     default:
 157       outs() << "X64\n";
 158     }
 159   }
 160
 161   WindowsResourceParser Parser;
 162
 163   for (const auto &File : InputFiles) {
 164     Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File);
 165     if (!BinaryOrErr)
 166       reportError(File, errorToErrorCode(BinaryOrErr.takeError()));
 167
 168     Binary &Binary = *BinaryOrErr.get().getBinary();
 169
 170     WindowsResource *RF = dyn_cast<WindowsResource>(&Binary);
 171     if (!RF)
 172       reportError(File + ": unrecognized file format.\n");
 173
 174     if (Verbose) {
 175       int EntryNumber = 0;
 176       ResourceEntryRef Entry = error(RF->getHeadEntry());
 177       bool End = false;
 178       while (!End) {
 179         error(Entry.moveNext(End));
 180         EntryNumber++;
 181       }
 182       outs() << "Number of resources: " << EntryNumber << "\n";
 183     }
 184
 185     error(Parser.parse(RF));
 186   }
 187
 188   if (Verbose) {
 189     Parser.printTree(outs());
 190   }
 191
 192   std::unique_ptr<MemoryBuffer> OutputBuffer =
 193       error(llvm::object::writeWindowsResourceCOFF(MachineType, Parser));
 194   auto FileOrErr =
 195       FileOutputBuffer::create(OutputFile, OutputBuffer->getBufferSize());
 196   if (!FileOrErr)
 197     reportError(OutputFile, errorToErrorCode(FileOrErr.takeError()));
 198   std::unique_ptr<FileOutputBuffer> FileBuffer = std::move(*FileOrErr);
 199   std::copy(OutputBuffer->getBufferStart(), OutputBuffer->getBufferEnd(),
 200             FileBuffer->getBufferStart());
 201   error(FileBuffer->commit());
 202
 203   if (Verbose) {
 204     Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(OutputFile);
 205     if (!BinaryOrErr)
 206       reportError(OutputFile, errorToErrorCode(BinaryOrErr.takeError()));
 207     Binary &Binary = *BinaryOrErr.get().getBinary();
 208     ScopedPrinter W(errs());
 209     W.printBinaryBlock("Output File Raw Data", Binary.getData());
 210   }
 211
 212   return 0;
 213 }