LLVM  6.0.0svn
DlltoolDriver.cpp
Go to the documentation of this file.
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 
16 #include "llvm/Object/COFF.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 // Opens a file. Path has to be resolved already.
60 static std::unique_ptr<MemoryBuffer> openFile(const Twine &Path) {
62 
63  if (std::error_code EC = MB.getError()) {
64  llvm::errs() << "cannot open file " << Path << ": " << EC.message() << "\n";
65  return nullptr;
66  }
67 
68  return std::move(*MB);
69 }
70 
73  .Case("i386", IMAGE_FILE_MACHINE_I386)
74  .Case("i386:x86-64", IMAGE_FILE_MACHINE_AMD64)
78 }
79 
80 static std::string getImplibPath(StringRef Path) {
81  SmallString<128> Out = StringRef("lib");
82  Out.append(Path);
84  return Out.str();
85 }
86 
88  DllOptTable Table;
89  unsigned MissingIndex;
90  unsigned MissingCount;
92  Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
93  if (MissingCount) {
94  llvm::errs() << Args.getArgString(MissingIndex) << ": missing argument\n";
95  return 1;
96  }
97 
98  // Handle when no input or output is specified
99  if (Args.hasArgNoClaim(OPT_INPUT) ||
100  (!Args.hasArgNoClaim(OPT_d) && !Args.hasArgNoClaim(OPT_l))) {
101  Table.PrintHelp(outs(), ArgsArr[0], "dlltool", false);
102  llvm::outs() << "\nTARGETS: i386, i386:x86-64, arm, arm64\n";
103  return 1;
104  }
105 
106  if (!Args.hasArgNoClaim(OPT_m) && Args.hasArgNoClaim(OPT_d)) {
107  llvm::errs() << "error: no target machine specified\n"
108  << "supported targets: i386, i386:x86-64, arm, arm64\n";
109  return 1;
110  }
111 
112  for (auto *Arg : Args.filtered(OPT_UNKNOWN))
113  llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n";
114 
115  if (!Args.hasArg(OPT_d)) {
116  llvm::errs() << "no definition file specified\n";
117  return 1;
118  }
119 
120  std::unique_ptr<MemoryBuffer> MB =
121  openFile(Args.getLastArg(OPT_d)->getValue());
122  if (!MB)
123  return 1;
124 
125  if (!MB->getBufferSize()) {
126  llvm::errs() << "definition file empty\n";
127  return 1;
128  }
129 
131  if (auto *Arg = Args.getLastArg(OPT_m))
132  Machine = getEmulation(Arg->getValue());
133 
134  if (Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
135  llvm::errs() << "unknown target\n";
136  return 1;
137  }
138 
140  parseCOFFModuleDefinition(*MB, Machine, true);
141 
142  if (!Def) {
143  llvm::errs() << "error parsing definition\n"
144  << errorToErrorCode(Def.takeError()).message();
145  return 1;
146  }
147 
148  // Do this after the parser because parseCOFFModuleDefinition sets OutputFile.
149  if (auto *Arg = Args.getLastArg(OPT_D))
150  Def->OutputFile = Arg->getValue();
151 
152  if (Def->OutputFile.empty()) {
153  llvm::errs() << "no output file specified\n";
154  return 1;
155  }
156 
157  std::string Path = Args.getLastArgValue(OPT_l);
158  if (Path.empty())
159  Path = getImplibPath(Def->OutputFile);
160 
161  if (Machine == IMAGE_FILE_MACHINE_I386 && Args.getLastArg(OPT_k)) {
162  for (COFFShortExport& E : Def->Exports) {
163  if (E.isWeak() || (!E.Name.empty() && E.Name[0] == '?'))
164  continue;
165  E.SymbolName = E.Name;
166  // Trim off the trailing decoration. Symbols will always have a
167  // starting prefix here (either _ for cdecl/stdcall, @ for fastcall
168  // or ? for C++ functions). Vectorcall functions won't have any
169  // fixed prefix, but the function base name will still be at least
170  // one char.
171  E.Name = E.Name.substr(0, E.Name.find('@', 1));
172  // By making sure E.SymbolName != E.Name for decorated symbols,
173  // writeImportLibrary writes these symbols with the type
174  // IMPORT_NAME_UNDECORATE.
175  }
176  }
177 
178  if (writeImportLibrary(Def->OutputFile, Path, Def->Exports, Machine, true))
179  return 1;
180  return 0;
181 }
Represents either an error or a value T.
Definition: ErrorOr.h:69
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
iterator_range< filtered_iterator< sizeof...(OptSpecifiers)> > filtered(OptSpecifiers ...Ids) const
Definition: ArgList.h:209
Error takeError()
Take ownership of the stored error.
Definition: Error.h:537
Expected< COFFModuleDefinition > parseCOFFModuleDefinition(MemoryBufferRef MB, COFF::MachineTypes Machine, bool MingwDef=false)
const char * getArgString(unsigned Index) const override
getArgString - Return the input argument string at Index.
Definition: ArgList.h:411
static MachineTypes getEmulation(StringRef S)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
int dlltoolDriverMain(ArrayRef< const char *> ArgsArr)
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:267
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Case(const char(&S)[N], const T &Value)
Definition: StringSwitch.h:74
bool hasArg(OptSpecifiers ...Ids) const
Definition: ArgList.h:248
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:363
void append(in_iter S, in_iter E)
Append from an iterator pair.
Definition: SmallString.h:75
raw_ostream & outs()
This returns a reference to a raw_ostream for standard output.
bool hasArgNoClaim(OptSpecifiers ...Ids) const
hasArg - Does the arg list contain any option matching Id.
Definition: ArgList.h:244
Error writeImportLibrary(StringRef ImportName, StringRef Path, ArrayRef< COFFShortExport > Exports, COFF::MachineTypes Machine, bool MakeWeakAliases)
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:43
Provide access to the Option info table.
Definition: OptTable.h:39
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
std::error_code getError() const
Definition: ErrorOr.h:172
LLVM_ATTRIBUTE_ALWAYS_INLINE R Default(const T &Value) const
Definition: StringSwitch.h:244
Arg * getLastArg(OptSpecifiers ...Ids) const
Return the last argument matching Id, or null.
Definition: ArgList.h:254
void replace_extension(SmallVectorImpl< char > &path, const Twine &extension, Style style=Style::native)
Replace the file extension of path with extension.
Definition: Path.cpp:490
Defines the llvm::Arg class for parsed arguments.
static std::string getImplibPath(StringRef Path)
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:179
StringRef getLastArgValue(OptSpecifier Id, StringRef Default="") const
getLastArgValue - Return the value of the last argument, or a default.
Definition: ArgList.cpp:86
amdgpu Simplify well known AMD library false Value Value * Arg
Entry for a single option instance in the option data table.
Definition: OptTable.h:42
static std::unique_ptr< MemoryBuffer > openFile(const Twine &Path)
MachineTypes
Definition: COFF.h:94
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
const char * getValue(unsigned N=0) const
Definition: Arg.h:96
std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition: Error.cpp:84
constexpr char Args[]
Key for Kernel::Metadata::mArgs.