1 //===- LibDriver.cpp - lib.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 lib.exe-compatible driver that also understands 10 // bitcode files. Used by llvm-lib and lld-link /lib. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/ToolDrivers/llvm-lib/LibDriver.h" 15 #include "llvm/ADT/STLExtras.h" 16 #include "llvm/BinaryFormat/COFF.h" 17 #include "llvm/BinaryFormat/Magic.h" 18 #include "llvm/Bitcode/BitcodeReader.h" 19 #include "llvm/Object/ArchiveWriter.h" 20 #include "llvm/Object/COFF.h" 21 #include "llvm/Option/Arg.h" 22 #include "llvm/Option/ArgList.h" 23 #include "llvm/Option/Option.h" 24 #include "llvm/Support/CommandLine.h" 25 #include "llvm/Support/Path.h" 26 #include "llvm/Support/Process.h" 27 #include "llvm/Support/StringSaver.h" 28 #include "llvm/Support/raw_ostream.h" 29 30 using namespace llvm; 31 32 namespace { 33 34 enum { 35 OPT_INVALID = 0, 36 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID, 37 #include "Options.inc" 38 #undef OPTION 39 }; 40 41 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE; 42 #include "Options.inc" 43 #undef PREFIX 44 45 static const opt::OptTable::Info InfoTable[] = { 46 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \ 47 {X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \ 48 X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12}, 49 #include "Options.inc" 50 #undef OPTION 51 }; 52 53 class LibOptTable : public opt::OptTable { 54 public: 55 LibOptTable() : OptTable(InfoTable, true) {} 56 }; 57 58 } 59 60 static std::string getOutputPath(opt::InputArgList *Args, 61 const NewArchiveMember &FirstMember) { 62 if (auto *Arg = Args->getLastArg(OPT_out)) 63 return Arg->getValue(); 64 SmallString<128> Val = StringRef(FirstMember.Buf->getBufferIdentifier()); 65 sys::path::replace_extension(Val, ".lib"); 66 return Val.str(); 67 } 68 69 static std::vector<StringRef> getSearchPaths(opt::InputArgList *Args, 70 StringSaver &Saver) { 71 std::vector<StringRef> Ret; 72 // Add current directory as first item of the search path. 73 Ret.push_back(""); 74 75 // Add /libpath flags. 76 for (auto *Arg : Args->filtered(OPT_libpath)) 77 Ret.push_back(Arg->getValue()); 78 79 // Add $LIB. 80 Optional<std::string> EnvOpt = sys::Process::GetEnv("LIB"); 81 if (!EnvOpt.hasValue()) 82 return Ret; 83 StringRef Env = Saver.save(*EnvOpt); 84 while (!Env.empty()) { 85 StringRef Path; 86 std::tie(Path, Env) = Env.split(';'); 87 Ret.push_back(Path); 88 } 89 return Ret; 90 } 91 92 static std::string findInputFile(StringRef File, ArrayRef<StringRef> Paths) { 93 for (StringRef Dir : Paths) { 94 SmallString<128> Path = Dir; 95 sys::path::append(Path, File); 96 if (sys::fs::exists(Path)) 97 return Path.str().str(); 98 } 99 return ""; 100 } 101 102 static void fatalOpenError(llvm::Error E, Twine File) { 103 if (!E) 104 return; 105 handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) { 106 llvm::errs() << "error opening '" << File << "': " << EIB.message() << '\n'; 107 exit(1); 108 }); 109 } 110 111 static void doList(opt::InputArgList& Args) { 112 // lib.exe prints the contents of the first archive file. 113 std::unique_ptr<MemoryBuffer> B; 114 for (auto *Arg : Args.filtered(OPT_INPUT)) { 115 // Create or open the archive object. 116 ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeBuf = 117 MemoryBuffer::getFile(Arg->getValue(), -1, false); 118 fatalOpenError(errorCodeToError(MaybeBuf.getError()), Arg->getValue()); 119 120 if (identify_magic(MaybeBuf.get()->getBuffer()) == file_magic::archive) { 121 B = std::move(MaybeBuf.get()); 122 break; 123 } 124 } 125 126 // lib.exe doesn't print an error if no .lib files are passed. 127 if (!B) 128 return; 129 130 Error Err = Error::success(); 131 object::Archive Archive(B.get()->getMemBufferRef(), Err); 132 fatalOpenError(std::move(Err), B->getBufferIdentifier()); 133 134 for (auto &C : Archive.children(Err)) { 135 Expected<StringRef> NameOrErr = C.getName(); 136 fatalOpenError(NameOrErr.takeError(), B->getBufferIdentifier()); 137 StringRef Name = NameOrErr.get(); 138 llvm::outs() << Name << '\n'; 139 } 140 fatalOpenError(std::move(Err), B->getBufferIdentifier()); 141 } 142 143 // Returns /machine's value. 144 COFF::MachineTypes llvm::getMachineType(StringRef S) { 145 return StringSwitch<COFF::MachineTypes>(S.lower()) 146 .Cases("x64", "amd64", COFF::IMAGE_FILE_MACHINE_AMD64) 147 .Cases("x86", "i386", COFF::IMAGE_FILE_MACHINE_I386) 148 .Case("arm", COFF::IMAGE_FILE_MACHINE_ARMNT) 149 .Case("arm64", COFF::IMAGE_FILE_MACHINE_ARM64) 150 .Default(COFF::IMAGE_FILE_MACHINE_UNKNOWN); 151 } 152 153 StringRef llvm::machineToStr(COFF::MachineTypes MT) { 154 switch (MT) { 155 case COFF::IMAGE_FILE_MACHINE_ARMNT: 156 return "arm"; 157 case COFF::IMAGE_FILE_MACHINE_ARM64: 158 return "arm64"; 159 case COFF::IMAGE_FILE_MACHINE_AMD64: 160 return "x64"; 161 case COFF::IMAGE_FILE_MACHINE_I386: 162 return "x86"; 163 default: 164 llvm_unreachable("unknown machine type"); 165 } 166 } 167 168 int llvm::libDriverMain(ArrayRef<const char *> ArgsArr) { 169 BumpPtrAllocator Alloc; 170 StringSaver Saver(Alloc); 171 172 // Parse command line arguments. 173 SmallVector<const char *, 20> NewArgs(ArgsArr.begin(), ArgsArr.end()); 174 cl::ExpandResponseFiles(Saver, cl::TokenizeWindowsCommandLine, NewArgs); 175 ArgsArr = NewArgs; 176 177 LibOptTable Table; 178 unsigned MissingIndex; 179 unsigned MissingCount; 180 opt::InputArgList Args = 181 Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount); 182 if (MissingCount) { 183 llvm::errs() << "missing arg value for \"" 184 << Args.getArgString(MissingIndex) << "\", expected " 185 << MissingCount 186 << (MissingCount == 1 ? " argument.\n" : " arguments.\n"); 187 return 1; 188 } 189 for (auto *Arg : Args.filtered(OPT_UNKNOWN)) 190 llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n"; 191 192 // Handle /help 193 if (Args.hasArg(OPT_help)) { 194 Table.PrintHelp(outs(), "llvm-lib [options] file...", "LLVM Lib"); 195 return 0; 196 } 197 198 // If no input files, silently do nothing to match lib.exe. 199 if (!Args.hasArgNoClaim(OPT_INPUT)) 200 return 0; 201 202 if (Args.hasArg(OPT_lst)) { 203 doList(Args); 204 return 0; 205 } 206 207 std::vector<StringRef> SearchPaths = getSearchPaths(&Args, Saver); 208 209 COFF::MachineTypes LibMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN; 210 std::string LibMachineSource; 211 if (auto *Arg = Args.getLastArg(OPT_machine)) { 212 LibMachine = getMachineType(Arg->getValue()); 213 if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) { 214 llvm::errs() << "unknown /machine: arg " << Arg->getValue() << '\n'; 215 return 1; 216 } 217 LibMachineSource = 218 std::string(" (from '/machine:") + Arg->getValue() + "' flag)"; 219 } 220 221 // Create a NewArchiveMember for each input file. 222 std::vector<NewArchiveMember> Members; 223 for (auto *Arg : Args.filtered(OPT_INPUT)) { 224 std::string Path = findInputFile(Arg->getValue(), SearchPaths); 225 if (Path.empty()) { 226 llvm::errs() << Arg->getValue() << ": no such file or directory\n"; 227 return 1; 228 } 229 230 Expected<NewArchiveMember> MOrErr = 231 NewArchiveMember::getFile(Saver.save(Path), /*Deterministic=*/true); 232 if (!MOrErr) { 233 handleAllErrors(MOrErr.takeError(), [&](const ErrorInfoBase &EIB) { 234 llvm::errs() << Arg->getValue() << ": " << EIB.message() << "\n"; 235 }); 236 return 1; 237 } 238 239 file_magic Magic = identify_magic(MOrErr->Buf->getBuffer()); 240 if (Magic != file_magic::coff_object && Magic != file_magic::bitcode && 241 Magic != file_magic::windows_resource) { 242 llvm::errs() << Arg->getValue() 243 << ": not a COFF object, bitcode or resource file\n"; 244 return 1; 245 } 246 247 // Check that all input files have the same machine type. 248 // Mixing normal objects and LTO bitcode files is fine as long as they 249 // have the same machine type. 250 // Doing this here duplicates the header parsing work that writeArchive() 251 // below does, but it's not a lot of work and it's a bit awkward to do 252 // in writeArchive() which needs to support many tools, can't assume the 253 // input is COFF, and doesn't have a good way to report errors. 254 COFF::MachineTypes FileMachine = COFF::IMAGE_FILE_MACHINE_UNKNOWN; 255 if (Magic == file_magic::coff_object) { 256 std::error_code EC; 257 object::COFFObjectFile Obj(*MOrErr->Buf, EC); 258 if (EC) { 259 llvm::errs() << Arg->getValue() << ": failed to open: " << EC.message() 260 << '\n'; 261 return 1; 262 } 263 uint16_t Machine = Obj.getMachine(); 264 if (Machine != COFF::IMAGE_FILE_MACHINE_I386 && 265 Machine != COFF::IMAGE_FILE_MACHINE_AMD64 && 266 Machine != COFF::IMAGE_FILE_MACHINE_ARMNT && 267 Machine != COFF::IMAGE_FILE_MACHINE_ARM64) { 268 llvm::errs() << Arg->getValue() << ": unknown machine: " << Machine 269 << '\n'; 270 return 1; 271 } 272 FileMachine = static_cast<COFF::MachineTypes>(Machine); 273 } else if (Magic == file_magic::bitcode) { 274 Expected<std::string> TripleStr = getBitcodeTargetTriple(*MOrErr->Buf); 275 if (!TripleStr) { 276 llvm::errs() << Arg->getValue() 277 << ": failed to get target triple from bitcode\n"; 278 return 1; 279 } 280 switch (Triple(*TripleStr).getArch()) { 281 case Triple::x86: 282 FileMachine = COFF::IMAGE_FILE_MACHINE_I386; 283 break; 284 case Triple::x86_64: 285 FileMachine = COFF::IMAGE_FILE_MACHINE_AMD64; 286 break; 287 case Triple::arm: 288 FileMachine = COFF::IMAGE_FILE_MACHINE_ARMNT; 289 break; 290 case Triple::aarch64: 291 FileMachine = COFF::IMAGE_FILE_MACHINE_ARM64; 292 break; 293 default: 294 llvm::errs() << Arg->getValue() << ": unknown arch in target triple " 295 << *TripleStr << '\n'; 296 return 1; 297 } 298 } 299 300 // FIXME: Once lld-link rejects multiple resource .obj files: 301 // Call convertResToCOFF() on .res files and add the resulting 302 // COFF file to the .lib output instead of adding the .res file, and remove 303 // this check. See PR42180. 304 if (FileMachine != COFF::IMAGE_FILE_MACHINE_UNKNOWN) { 305 if (LibMachine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) { 306 LibMachine = FileMachine; 307 LibMachineSource = std::string(" (inferred from earlier file '") + 308 Arg->getValue() + "')"; 309 } else if (LibMachine != FileMachine) { 310 llvm::errs() << Arg->getValue() << ": file machine type " 311 << machineToStr(FileMachine) 312 << " conflicts with library machine type " 313 << machineToStr(LibMachine) << LibMachineSource << '\n'; 314 return 1; 315 } 316 } 317 318 Members.emplace_back(std::move(*MOrErr)); 319 } 320 321 // Create an archive file. 322 std::string OutputPath = getOutputPath(&Args, Members[0]); 323 // llvm-lib uses relative paths for both regular and thin archives, unlike 324 // standard GNU ar, which only uses relative paths for thin archives and 325 // basenames for regular archives. 326 for (NewArchiveMember &Member : Members) { 327 if (sys::path::is_relative(Member.MemberName)) { 328 Expected<std::string> PathOrErr = 329 computeArchiveRelativePath(OutputPath, Member.MemberName); 330 if (PathOrErr) 331 Member.MemberName = Saver.save(*PathOrErr); 332 } 333 } 334 335 if (Error E = 336 writeArchive(OutputPath, Members, 337 /*WriteSymtab=*/true, object::Archive::K_GNU, 338 /*Deterministic*/ true, Args.hasArg(OPT_llvmlibthin))) { 339 handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) { 340 llvm::errs() << OutputPath << ": " << EI.message() << "\n"; 341 }); 342 return 1; 343 } 344 345 return 0; 346 } 347