Home | History | Annotate | Line # | Download | only in llvm-cvtres 
      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:
     66   CvtResOptTable() : OptTable(InfoTable, true) {}
     67 };
     68 }
     69 
     70 static LLVM_ATTRIBUTE_NORETURN 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 }
    235