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