contrib/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp

   1 //===- DlltoolDriver.cpp - dlltool.exe-compatible driver ------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Defines an interface to a dlltool.exe-compatible driver.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/ToolDrivers/llvm-dlltool/DlltoolDriver.h"
  15 #include "llvm/Object/ArchiveWriter.h"
  16 #include "llvm/Object/COFF.h"
  17 #include "llvm/Object/COFFImportFile.h"
  18 #include "llvm/Object/COFFModuleDefinition.h"
  19 #include "llvm/Option/Arg.h"
  20 #include "llvm/Option/ArgList.h"
  21 #include "llvm/Option/Option.h"
  22 #include "llvm/Support/Path.h"
  23
  24 #include <string>
  25 #include <vector>
  26
  27 using namespace llvm;
  28 using namespace llvm::object;
  29 using namespace llvm::COFF;
  30
  31 namespace {
  32
  33 enum {
  34   OPT_INVALID = 0,
  35 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
  36 #include "Options.inc"
  37 #undef OPTION
  38 };
  39
  40 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
  41 #include "Options.inc"
  42 #undef PREFIX
  43
  44 static const llvm::opt::OptTable::Info infoTable[] = {
  45 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
  46   {X1, X2, X10,         X11,         OPT_##ID, llvm::opt::Option::KIND##Class, \
  47    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
  48 #include "Options.inc"
  49 #undef OPTION
  50 };
  51
  52 class DllOptTable : public llvm::opt::OptTable {
  53 public:
  54   DllOptTable() : OptTable(infoTable, false) {}
  55 };
  56
  57 } // namespace
  58
  59 std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
  60
  61 // Opens a file. Path has to be resolved already.
  62 // Newly created memory buffers are owned by this driver.
  63 MemoryBufferRef openFile(StringRef Path) {
  64   ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB = MemoryBuffer::getFile(Path);
  65
  66   if (std::error_code EC = MB.getError())
  67     llvm::errs() << "fail openFile: " << EC.message() << "\n";
  68
  69   MemoryBufferRef MBRef = MB.get()->getMemBufferRef();
  70   OwningMBs.push_back(std::move(MB.get())); // take ownership
  71   return MBRef;
  72 }
  73
  74 static MachineTypes getEmulation(StringRef S) {
  75   return StringSwitch<MachineTypes>(S)
  76       .Case("i386", IMAGE_FILE_MACHINE_I386)
  77       .Case("i386:x86-64", IMAGE_FILE_MACHINE_AMD64)
  78       .Case("arm", IMAGE_FILE_MACHINE_ARMNT)
  79       .Default(IMAGE_FILE_MACHINE_UNKNOWN);
  80 }
  81
  82 static std::string getImplibPath(std::string Path) {
  83   SmallString<128> Out = StringRef("lib");
  84   Out.append(Path);
  85   sys::path::replace_extension(Out, ".a");
  86   return Out.str();
  87 }
  88
  89 int llvm::dlltoolDriverMain(llvm::ArrayRef<const char *> ArgsArr) {
  90   DllOptTable Table;
  91   unsigned MissingIndex;
  92   unsigned MissingCount;
  93   llvm::opt::InputArgList Args =
  94       Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
  95   if (MissingCount) {
  96     llvm::errs() << Args.getArgString(MissingIndex) << ": missing argument\n";
  97     return 1;
  98   }
  99
 100   // Handle when no input or output is specified
 101   if (Args.hasArgNoClaim(OPT_INPUT) ||
 102       (!Args.hasArgNoClaim(OPT_d) && !Args.hasArgNoClaim(OPT_l))) {
 103     Table.PrintHelp(outs(), ArgsArr[0], "dlltool", false);
 104     llvm::outs() << "\nTARGETS: i386, i386:x86-64, arm\n";
 105     return 1;
 106   }
 107
 108   if (!Args.hasArgNoClaim(OPT_m) && Args.hasArgNoClaim(OPT_d)) {
 109     llvm::errs() << "error: no target machine specified\n"
 110                  << "supported targets: i386, i386:x86-64, arm\n";
 111     return 1;
 112   }
 113
 114   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
 115     llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n";
 116
 117   MemoryBufferRef MB;
 118   if (auto *Arg = Args.getLastArg(OPT_d))
 119     MB = openFile(Arg->getValue());
 120
 121   if (!MB.getBufferSize()) {
 122     llvm::errs() << "definition file empty\n";
 123     return 1;
 124   }
 125
 126   COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN;
 127   if (auto *Arg = Args.getLastArg(OPT_m))
 128     Machine = getEmulation(Arg->getValue());
 129
 130   if (Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
 131     llvm::errs() << "unknown target\n";
 132     return 1;
 133   }
 134
 135   Expected<COFFModuleDefinition> Def =
 136       parseCOFFModuleDefinition(MB, Machine, true);
 137
 138   if (!Def) {
 139     llvm::errs() << "error parsing definition\n"
 140                  << errorToErrorCode(Def.takeError()).message();
 141     return 1;
 142   }
 143
 144   // Do this after the parser because parseCOFFModuleDefinition sets OutputFile.
 145   if (auto *Arg = Args.getLastArg(OPT_D))
 146     Def->OutputFile = Arg->getValue();
 147
 148   if (Def->OutputFile.empty()) {
 149     llvm::errs() << "no output file specified\n";
 150     return 1;
 151   }
 152
 153   std::string Path = Args.getLastArgValue(OPT_l);
 154   if (Path.empty())
 155     Path = getImplibPath(Def->OutputFile);
 156
 157   if (writeImportLibrary(Def->OutputFile, Path, Def->Exports, Machine))
 158     return 1;
 159   return 0;
 160 }