lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp

   1 //===- DlltoolDriver.cpp - dlltool.exe-compatible driver ------------------===//
   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 // Defines an interface to a dlltool.exe-compatible driver.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/ToolDrivers/llvm-dlltool/DlltoolDriver.h"
  14 #include "llvm/Object/COFF.h"
  15 #include "llvm/Object/COFFImportFile.h"
  16 #include "llvm/Object/COFFModuleDefinition.h"
  17 #include "llvm/Option/Arg.h"
  18 #include "llvm/Option/ArgList.h"
  19 #include "llvm/Option/Option.h"
  20 #include "llvm/Support/Path.h"
  21
  22 #include <vector>
  23
  24 using namespace llvm;
  25 using namespace llvm::object;
  26 using namespace llvm::COFF;
  27
  28 namespace {
  29
  30 enum {
  31   OPT_INVALID = 0,
  32 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
  33 #include "Options.inc"
  34 #undef OPTION
  35 };
  36
  37 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
  38 #include "Options.inc"
  39 #undef PREFIX
  40
  41 static const llvm::opt::OptTable::Info InfoTable[] = {
  42 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
  43   {X1, X2, X10,         X11,         OPT_##ID, llvm::opt::Option::KIND##Class, \
  44    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
  45 #include "Options.inc"
  46 #undef OPTION
  47 };
  48
  49 class DllOptTable : public llvm::opt::OptTable {
  50 public:
  51   DllOptTable() : OptTable(InfoTable, false) {}
  52 };
  53
  54 } // namespace
  55
  56 // Opens a file. Path has to be resolved already.
  57 static std::unique_ptr<MemoryBuffer> openFile(const Twine &Path) {
  58   ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB = MemoryBuffer::getFile(Path);
  59
  60   if (std::error_code EC = MB.getError()) {
  61     llvm::errs() << "cannot open file " << Path << ": " << EC.message() << "\n";
  62     return nullptr;
  63   }
  64
  65   return std::move(*MB);
  66 }
  67
  68 static MachineTypes getEmulation(StringRef S) {
  69   return StringSwitch<MachineTypes>(S)
  70       .Case("i386", IMAGE_FILE_MACHINE_I386)
  71       .Case("i386:x86-64", IMAGE_FILE_MACHINE_AMD64)
  72       .Case("arm", IMAGE_FILE_MACHINE_ARMNT)
  73       .Case("arm64", IMAGE_FILE_MACHINE_ARM64)
  74       .Default(IMAGE_FILE_MACHINE_UNKNOWN);
  75 }
  76
  77 int llvm::dlltoolDriverMain(llvm::ArrayRef<const char *> ArgsArr) {
  78   DllOptTable Table;
  79   unsigned MissingIndex;
  80   unsigned MissingCount;
  81   llvm::opt::InputArgList Args =
  82       Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
  83   if (MissingCount) {
  84     llvm::errs() << Args.getArgString(MissingIndex) << ": missing argument\n";
  85     return 1;
  86   }
  87
  88   // Handle when no input or output is specified
  89   if (Args.hasArgNoClaim(OPT_INPUT) ||
  90       (!Args.hasArgNoClaim(OPT_d) && !Args.hasArgNoClaim(OPT_l))) {
  91     Table.PrintHelp(outs(), "llvm-dlltool [options] file...", "llvm-dlltool",
  92                     false);
  93     llvm::outs() << "\nTARGETS: i386, i386:x86-64, arm, arm64\n";
  94     return 1;
  95   }
  96
  97   if (!Args.hasArgNoClaim(OPT_m) && Args.hasArgNoClaim(OPT_d)) {
  98     llvm::errs() << "error: no target machine specified\n"
  99                  << "supported targets: i386, i386:x86-64, arm, arm64\n";
 100     return 1;
 101   }
 102
 103   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
 104     llvm::errs() << "ignoring unknown argument: " << Arg->getAsString(Args)
 105                  << "\n";
 106
 107   if (!Args.hasArg(OPT_d)) {
 108     llvm::errs() << "no definition file specified\n";
 109     return 1;
 110   }
 111
 112   std::unique_ptr<MemoryBuffer> MB =
 113       openFile(Args.getLastArg(OPT_d)->getValue());
 114   if (!MB)
 115     return 1;
 116
 117   if (!MB->getBufferSize()) {
 118     llvm::errs() << "definition file empty\n";
 119     return 1;
 120   }
 121
 122   COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN;
 123   if (auto *Arg = Args.getLastArg(OPT_m))
 124     Machine = getEmulation(Arg->getValue());
 125
 126   if (Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
 127     llvm::errs() << "unknown target\n";
 128     return 1;
 129   }
 130
 131   Expected<COFFModuleDefinition> Def =
 132       parseCOFFModuleDefinition(*MB, Machine, true);
 133
 134   if (!Def) {
 135     llvm::errs() << "error parsing definition\n"
 136                  << errorToErrorCode(Def.takeError()).message();
 137     return 1;
 138   }
 139
 140   // Do this after the parser because parseCOFFModuleDefinition sets OutputFile.
 141   if (auto *Arg = Args.getLastArg(OPT_D))
 142     Def->OutputFile = Arg->getValue();
 143
 144   if (Def->OutputFile.empty()) {
 145     llvm::errs() << "no DLL name specified\n";
 146     return 1;
 147   }
 148
 149   std::string Path = Args.getLastArgValue(OPT_l);
 150
 151   // If ExtName is set (if the "ExtName = Name" syntax was used), overwrite
 152   // Name with ExtName and clear ExtName. When only creating an import
 153   // library and not linking, the internal name is irrelevant. This avoids
 154   // cases where writeImportLibrary tries to transplant decoration from
 155   // symbol decoration onto ExtName.
 156   for (COFFShortExport& E : Def->Exports) {
 157     if (!E.ExtName.empty()) {
 158       E.Name = E.ExtName;
 159       E.ExtName.clear();
 160     }
 161   }
 162
 163   if (Machine == IMAGE_FILE_MACHINE_I386 && Args.getLastArg(OPT_k)) {
 164     for (COFFShortExport& E : Def->Exports) {
 165       if (!E.AliasTarget.empty() || (!E.Name.empty() && E.Name[0] == '?'))
 166         continue;
 167       E.SymbolName = E.Name;
 168       // Trim off the trailing decoration. Symbols will always have a
 169       // starting prefix here (either _ for cdecl/stdcall, @ for fastcall
 170       // or ? for C++ functions). Vectorcall functions won't have any
 171       // fixed prefix, but the function base name will still be at least
 172       // one char.
 173       E.Name = E.Name.substr(0, E.Name.find('@', 1));
 174       // By making sure E.SymbolName != E.Name for decorated symbols,
 175       // writeImportLibrary writes these symbols with the type
 176       // IMPORT_NAME_UNDECORATE.
 177     }
 178   }
 179
 180   if (!Path.empty() &&
 181       writeImportLibrary(Def->OutputFile, Path, Def->Exports, Machine, true))
 182     return 1;
 183   return 0;
 184 }