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 Optional<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 return None; 69 } 70 71 MemoryBufferRef MBRef = MB.get()->getMemBufferRef(); 72 OwningMBs.push_back(std::move(MB.get())); // take ownership 73 return MBRef; 74 } 75 76 static MachineTypes getEmulation(StringRef S) { 77 return StringSwitch<MachineTypes>(S) 78 .Case("i386", IMAGE_FILE_MACHINE_I386) 79 .Case("i386:x86-64", IMAGE_FILE_MACHINE_AMD64) 80 .Case("arm", IMAGE_FILE_MACHINE_ARMNT) 81 .Default(IMAGE_FILE_MACHINE_UNKNOWN); 82 } 83 84 static std::string getImplibPath(std::string Path) { 85 SmallString<128> Out = StringRef("lib"); 86 Out.append(Path); 87 sys::path::replace_extension(Out, ".a"); 88 return Out.str(); 89 } 90 91 int llvm::dlltoolDriverMain(llvm::ArrayRef<const char *> ArgsArr) { 92 DllOptTable Table; 93 unsigned MissingIndex; 94 unsigned MissingCount; 95 llvm::opt::InputArgList Args = 96 Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount); 97 if (MissingCount) { 98 llvm::errs() << Args.getArgString(MissingIndex) << ": missing argument\n"; 99 return 1; 100 } 101 102 // Handle when no input or output is specified 103 if (Args.hasArgNoClaim(OPT_INPUT) || 104 (!Args.hasArgNoClaim(OPT_d) && !Args.hasArgNoClaim(OPT_l))) { 105 Table.PrintHelp(outs(), ArgsArr[0], "dlltool", false); 106 llvm::outs() << "\nTARGETS: i386, i386:x86-64, arm\n"; 107 return 1; 108 } 109 110 if (!Args.hasArgNoClaim(OPT_m) && Args.hasArgNoClaim(OPT_d)) { 111 llvm::errs() << "error: no target machine specified\n" 112 << "supported targets: i386, i386:x86-64, arm\n"; 113 return 1; 114 } 115 116 for (auto *Arg : Args.filtered(OPT_UNKNOWN)) 117 llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n"; 118 119 if (!Args.hasArg(OPT_d)) { 120 llvm::errs() << "no definition file specified\n"; 121 return 1; 122 } 123 124 Optional<MemoryBufferRef> MB = openFile(Args.getLastArg(OPT_d)->getValue()); 125 if (!MB) 126 return 1; 127 128 if (!MB->getBufferSize()) { 129 llvm::errs() << "definition file empty\n"; 130 return 1; 131 } 132 133 COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN; 134 if (auto *Arg = Args.getLastArg(OPT_m)) 135 Machine = getEmulation(Arg->getValue()); 136 137 if (Machine == IMAGE_FILE_MACHINE_UNKNOWN) { 138 llvm::errs() << "unknown target\n"; 139 return 1; 140 } 141 142 Expected<COFFModuleDefinition> Def = 143 parseCOFFModuleDefinition(*MB, Machine, true); 144 145 if (!Def) { 146 llvm::errs() << "error parsing definition\n" 147 << errorToErrorCode(Def.takeError()).message(); 148 return 1; 149 } 150 151 // Do this after the parser because parseCOFFModuleDefinition sets OutputFile. 152 if (auto *Arg = Args.getLastArg(OPT_D)) 153 Def->OutputFile = Arg->getValue(); 154 155 if (Def->OutputFile.empty()) { 156 llvm::errs() << "no output file specified\n"; 157 return 1; 158 } 159 160 std::string Path = Args.getLastArgValue(OPT_l); 161 if (Path.empty()) 162 Path = getImplibPath(Def->OutputFile); 163 164 if (Machine == IMAGE_FILE_MACHINE_I386 && Args.getLastArg(OPT_k)) { 165 for (COFFShortExport& E : Def->Exports) { 166 if (E.isWeak() || (!E.Name.empty() && E.Name[0] == '?')) 167 continue; 168 E.SymbolName = E.Name; 169 // Trim off the trailing decoration. Symbols will always have a 170 // starting prefix here (either _ for cdecl/stdcall, @ for fastcall 171 // or ? for C++ functions). (Vectorcall functions also will end up having 172 // a prefix here, even if they shouldn't.) 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 (writeImportLibrary(Def->OutputFile, Path, Def->Exports, Machine, true)) 181 return 1; 182 return 0; 183 } 184