File: | clang/lib/Driver/Driver.cpp |
Warning: | line 1860, column 17 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===--- Driver.cpp - Clang GCC 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 | #include "clang/Driver/Driver.h" | |||
10 | #include "InputInfo.h" | |||
11 | #include "ToolChains/AIX.h" | |||
12 | #include "ToolChains/AMDGPU.h" | |||
13 | #include "ToolChains/AVR.h" | |||
14 | #include "ToolChains/Ananas.h" | |||
15 | #include "ToolChains/BareMetal.h" | |||
16 | #include "ToolChains/Clang.h" | |||
17 | #include "ToolChains/CloudABI.h" | |||
18 | #include "ToolChains/Contiki.h" | |||
19 | #include "ToolChains/CrossWindows.h" | |||
20 | #include "ToolChains/Cuda.h" | |||
21 | #include "ToolChains/Darwin.h" | |||
22 | #include "ToolChains/DragonFly.h" | |||
23 | #include "ToolChains/FreeBSD.h" | |||
24 | #include "ToolChains/Fuchsia.h" | |||
25 | #include "ToolChains/Gnu.h" | |||
26 | #include "ToolChains/HIP.h" | |||
27 | #include "ToolChains/Haiku.h" | |||
28 | #include "ToolChains/Hexagon.h" | |||
29 | #include "ToolChains/Hurd.h" | |||
30 | #include "ToolChains/Lanai.h" | |||
31 | #include "ToolChains/Linux.h" | |||
32 | #include "ToolChains/MSP430.h" | |||
33 | #include "ToolChains/MSVC.h" | |||
34 | #include "ToolChains/MinGW.h" | |||
35 | #include "ToolChains/Minix.h" | |||
36 | #include "ToolChains/MipsLinux.h" | |||
37 | #include "ToolChains/Myriad.h" | |||
38 | #include "ToolChains/NaCl.h" | |||
39 | #include "ToolChains/NetBSD.h" | |||
40 | #include "ToolChains/OpenBSD.h" | |||
41 | #include "ToolChains/PS4CPU.h" | |||
42 | #include "ToolChains/PPCLinux.h" | |||
43 | #include "ToolChains/RISCVToolchain.h" | |||
44 | #include "ToolChains/Solaris.h" | |||
45 | #include "ToolChains/TCE.h" | |||
46 | #include "ToolChains/WebAssembly.h" | |||
47 | #include "ToolChains/XCore.h" | |||
48 | #include "clang/Basic/Version.h" | |||
49 | #include "clang/Config/config.h" | |||
50 | #include "clang/Driver/Action.h" | |||
51 | #include "clang/Driver/Compilation.h" | |||
52 | #include "clang/Driver/DriverDiagnostic.h" | |||
53 | #include "clang/Driver/Job.h" | |||
54 | #include "clang/Driver/Options.h" | |||
55 | #include "clang/Driver/SanitizerArgs.h" | |||
56 | #include "clang/Driver/Tool.h" | |||
57 | #include "clang/Driver/ToolChain.h" | |||
58 | #include "llvm/ADT/ArrayRef.h" | |||
59 | #include "llvm/ADT/STLExtras.h" | |||
60 | #include "llvm/ADT/SmallSet.h" | |||
61 | #include "llvm/ADT/StringExtras.h" | |||
62 | #include "llvm/ADT/StringSet.h" | |||
63 | #include "llvm/ADT/StringSwitch.h" | |||
64 | #include "llvm/Config/llvm-config.h" | |||
65 | #include "llvm/Option/Arg.h" | |||
66 | #include "llvm/Option/ArgList.h" | |||
67 | #include "llvm/Option/OptSpecifier.h" | |||
68 | #include "llvm/Option/OptTable.h" | |||
69 | #include "llvm/Option/Option.h" | |||
70 | #include "llvm/Support/CommandLine.h" | |||
71 | #include "llvm/Support/ErrorHandling.h" | |||
72 | #include "llvm/Support/FileSystem.h" | |||
73 | #include "llvm/Support/FormatVariadic.h" | |||
74 | #include "llvm/Support/Path.h" | |||
75 | #include "llvm/Support/PrettyStackTrace.h" | |||
76 | #include "llvm/Support/Process.h" | |||
77 | #include "llvm/Support/Program.h" | |||
78 | #include "llvm/Support/StringSaver.h" | |||
79 | #include "llvm/Support/TargetRegistry.h" | |||
80 | #include "llvm/Support/VirtualFileSystem.h" | |||
81 | #include "llvm/Support/raw_ostream.h" | |||
82 | #include <map> | |||
83 | #include <memory> | |||
84 | #include <utility> | |||
85 | #if LLVM_ON_UNIX1 | |||
86 | #include <unistd.h> // getpid | |||
87 | #include <sysexits.h> // EX_IOERR | |||
88 | #endif | |||
89 | ||||
90 | using namespace clang::driver; | |||
91 | using namespace clang; | |||
92 | using namespace llvm::opt; | |||
93 | ||||
94 | // static | |||
95 | std::string Driver::GetResourcesPath(StringRef BinaryPath, | |||
96 | StringRef CustomResourceDir) { | |||
97 | // Since the resource directory is embedded in the module hash, it's important | |||
98 | // that all places that need it call this function, so that they get the | |||
99 | // exact same string ("a/../b/" and "b/" get different hashes, for example). | |||
100 | ||||
101 | // Dir is bin/ or lib/, depending on where BinaryPath is. | |||
102 | std::string Dir = llvm::sys::path::parent_path(BinaryPath); | |||
103 | ||||
104 | SmallString<128> P(Dir); | |||
105 | if (CustomResourceDir != "") { | |||
106 | llvm::sys::path::append(P, CustomResourceDir); | |||
107 | } else { | |||
108 | // On Windows, libclang.dll is in bin/. | |||
109 | // On non-Windows, libclang.so/.dylib is in lib/. | |||
110 | // With a static-library build of libclang, LibClangPath will contain the | |||
111 | // path of the embedding binary, which for LLVM binaries will be in bin/. | |||
112 | // ../lib gets us to lib/ in both cases. | |||
113 | P = llvm::sys::path::parent_path(Dir); | |||
114 | llvm::sys::path::append(P, Twine("lib") + CLANG_LIBDIR_SUFFIX"", "clang", | |||
115 | CLANG_VERSION_STRING"10.0.0"); | |||
116 | } | |||
117 | ||||
118 | return P.str(); | |||
119 | } | |||
120 | ||||
121 | Driver::Driver(StringRef ClangExecutable, StringRef TargetTriple, | |||
122 | DiagnosticsEngine &Diags, | |||
123 | IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) | |||
124 | : Diags(Diags), VFS(std::move(VFS)), Mode(GCCMode), | |||
125 | SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone), LTOMode(LTOK_None), | |||
126 | ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT""), | |||
127 | DriverTitle("clang LLVM compiler"), CCPrintOptionsFilename(nullptr), | |||
128 | CCPrintHeadersFilename(nullptr), CCLogDiagnosticsFilename(nullptr), | |||
129 | CCCPrintBindings(false), CCPrintOptions(false), CCPrintHeaders(false), | |||
130 | CCLogDiagnostics(false), CCGenDiagnostics(false), | |||
131 | TargetTriple(TargetTriple), CCCGenericGCCName(""), Saver(Alloc), | |||
132 | CheckInputsExist(true), GenReproducer(false), | |||
133 | SuppressMissingInputWarning(false) { | |||
134 | ||||
135 | // Provide a sane fallback if no VFS is specified. | |||
136 | if (!this->VFS) | |||
137 | this->VFS = llvm::vfs::getRealFileSystem(); | |||
138 | ||||
139 | Name = llvm::sys::path::filename(ClangExecutable); | |||
140 | Dir = llvm::sys::path::parent_path(ClangExecutable); | |||
141 | InstalledDir = Dir; // Provide a sensible default installed dir. | |||
142 | ||||
143 | #if defined(CLANG_CONFIG_FILE_SYSTEM_DIR) | |||
144 | SystemConfigDir = CLANG_CONFIG_FILE_SYSTEM_DIR; | |||
145 | #endif | |||
146 | #if defined(CLANG_CONFIG_FILE_USER_DIR) | |||
147 | UserConfigDir = CLANG_CONFIG_FILE_USER_DIR; | |||
148 | #endif | |||
149 | ||||
150 | // Compute the path to the resource directory. | |||
151 | ResourceDir = GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR""); | |||
152 | } | |||
153 | ||||
154 | void Driver::ParseDriverMode(StringRef ProgramName, | |||
155 | ArrayRef<const char *> Args) { | |||
156 | if (ClangNameParts.isEmpty()) | |||
157 | ClangNameParts = ToolChain::getTargetAndModeFromProgramName(ProgramName); | |||
158 | setDriverModeFromOption(ClangNameParts.DriverMode); | |||
159 | ||||
160 | for (const char *ArgPtr : Args) { | |||
161 | // Ignore nullptrs, they are the response file's EOL markers. | |||
162 | if (ArgPtr == nullptr) | |||
163 | continue; | |||
164 | const StringRef Arg = ArgPtr; | |||
165 | setDriverModeFromOption(Arg); | |||
166 | } | |||
167 | } | |||
168 | ||||
169 | void Driver::setDriverModeFromOption(StringRef Opt) { | |||
170 | const std::string OptName = | |||
171 | getOpts().getOption(options::OPT_driver_mode).getPrefixedName(); | |||
172 | if (!Opt.startswith(OptName)) | |||
173 | return; | |||
174 | StringRef Value = Opt.drop_front(OptName.size()); | |||
175 | ||||
176 | if (auto M = llvm::StringSwitch<llvm::Optional<DriverMode>>(Value) | |||
177 | .Case("gcc", GCCMode) | |||
178 | .Case("g++", GXXMode) | |||
179 | .Case("cpp", CPPMode) | |||
180 | .Case("cl", CLMode) | |||
181 | .Case("flang", FlangMode) | |||
182 | .Default(None)) | |||
183 | Mode = *M; | |||
184 | else | |||
185 | Diag(diag::err_drv_unsupported_option_argument) << OptName << Value; | |||
186 | } | |||
187 | ||||
188 | InputArgList Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings, | |||
189 | bool IsClCompatMode, | |||
190 | bool &ContainsError) { | |||
191 | llvm::PrettyStackTraceString CrashInfo("Command line argument parsing"); | |||
192 | ContainsError = false; | |||
193 | ||||
194 | unsigned IncludedFlagsBitmask; | |||
195 | unsigned ExcludedFlagsBitmask; | |||
196 | std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = | |||
197 | getIncludeExcludeOptionFlagMasks(IsClCompatMode); | |||
198 | ||||
199 | unsigned MissingArgIndex, MissingArgCount; | |||
200 | InputArgList Args = | |||
201 | getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount, | |||
202 | IncludedFlagsBitmask, ExcludedFlagsBitmask); | |||
203 | ||||
204 | // Check for missing argument error. | |||
205 | if (MissingArgCount) { | |||
206 | Diag(diag::err_drv_missing_argument) | |||
207 | << Args.getArgString(MissingArgIndex) << MissingArgCount; | |||
208 | ContainsError |= | |||
209 | Diags.getDiagnosticLevel(diag::err_drv_missing_argument, | |||
210 | SourceLocation()) > DiagnosticsEngine::Warning; | |||
211 | } | |||
212 | ||||
213 | // Check for unsupported options. | |||
214 | for (const Arg *A : Args) { | |||
215 | if (A->getOption().hasFlag(options::Unsupported)) { | |||
216 | unsigned DiagID; | |||
217 | auto ArgString = A->getAsString(Args); | |||
218 | std::string Nearest; | |||
219 | if (getOpts().findNearest( | |||
220 | ArgString, Nearest, IncludedFlagsBitmask, | |||
221 | ExcludedFlagsBitmask | options::Unsupported) > 1) { | |||
222 | DiagID = diag::err_drv_unsupported_opt; | |||
223 | Diag(DiagID) << ArgString; | |||
224 | } else { | |||
225 | DiagID = diag::err_drv_unsupported_opt_with_suggestion; | |||
226 | Diag(DiagID) << ArgString << Nearest; | |||
227 | } | |||
228 | ContainsError |= Diags.getDiagnosticLevel(DiagID, SourceLocation()) > | |||
229 | DiagnosticsEngine::Warning; | |||
230 | continue; | |||
231 | } | |||
232 | ||||
233 | // Warn about -mcpu= without an argument. | |||
234 | if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue("")) { | |||
235 | Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args); | |||
236 | ContainsError |= Diags.getDiagnosticLevel( | |||
237 | diag::warn_drv_empty_joined_argument, | |||
238 | SourceLocation()) > DiagnosticsEngine::Warning; | |||
239 | } | |||
240 | } | |||
241 | ||||
242 | for (const Arg *A : Args.filtered(options::OPT_UNKNOWN)) { | |||
243 | unsigned DiagID; | |||
244 | auto ArgString = A->getAsString(Args); | |||
245 | std::string Nearest; | |||
246 | if (getOpts().findNearest( | |||
247 | ArgString, Nearest, IncludedFlagsBitmask, ExcludedFlagsBitmask) > 1) { | |||
248 | DiagID = IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl | |||
249 | : diag::err_drv_unknown_argument; | |||
250 | Diags.Report(DiagID) << ArgString; | |||
251 | } else { | |||
252 | DiagID = IsCLMode() | |||
253 | ? diag::warn_drv_unknown_argument_clang_cl_with_suggestion | |||
254 | : diag::err_drv_unknown_argument_with_suggestion; | |||
255 | Diags.Report(DiagID) << ArgString << Nearest; | |||
256 | } | |||
257 | ContainsError |= Diags.getDiagnosticLevel(DiagID, SourceLocation()) > | |||
258 | DiagnosticsEngine::Warning; | |||
259 | } | |||
260 | ||||
261 | return Args; | |||
262 | } | |||
263 | ||||
264 | // Determine which compilation mode we are in. We look for options which | |||
265 | // affect the phase, starting with the earliest phases, and record which | |||
266 | // option we used to determine the final phase. | |||
267 | phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, | |||
268 | Arg **FinalPhaseArg) const { | |||
269 | Arg *PhaseArg = nullptr; | |||
270 | phases::ID FinalPhase; | |||
271 | ||||
272 | // -{E,EP,P,M,MM} only run the preprocessor. | |||
273 | if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) || | |||
274 | (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) || | |||
275 | (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) || | |||
276 | (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) { | |||
277 | FinalPhase = phases::Preprocess; | |||
278 | ||||
279 | // --precompile only runs up to precompilation. | |||
280 | } else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) { | |||
281 | FinalPhase = phases::Precompile; | |||
282 | ||||
283 | // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler. | |||
284 | } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || | |||
285 | (PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus)) || | |||
286 | (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) || | |||
287 | (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) || | |||
288 | (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) || | |||
289 | (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) || | |||
290 | (PhaseArg = DAL.getLastArg(options::OPT__migrate)) || | |||
291 | (PhaseArg = DAL.getLastArg(options::OPT__analyze)) || | |||
292 | (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) { | |||
293 | FinalPhase = phases::Compile; | |||
294 | ||||
295 | // -S only runs up to the backend. | |||
296 | } else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) { | |||
297 | FinalPhase = phases::Backend; | |||
298 | ||||
299 | // -c compilation only runs up to the assembler. | |||
300 | } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) { | |||
301 | FinalPhase = phases::Assemble; | |||
302 | ||||
303 | // Otherwise do everything. | |||
304 | } else | |||
305 | FinalPhase = phases::Link; | |||
306 | ||||
307 | if (FinalPhaseArg) | |||
308 | *FinalPhaseArg = PhaseArg; | |||
309 | ||||
310 | return FinalPhase; | |||
311 | } | |||
312 | ||||
313 | static Arg *MakeInputArg(DerivedArgList &Args, const OptTable &Opts, | |||
314 | StringRef Value, bool Claim = true) { | |||
315 | Arg *A = new Arg(Opts.getOption(options::OPT_INPUT), Value, | |||
316 | Args.getBaseArgs().MakeIndex(Value), Value.data()); | |||
317 | Args.AddSynthesizedArg(A); | |||
318 | if (Claim) | |||
319 | A->claim(); | |||
320 | return A; | |||
321 | } | |||
322 | ||||
323 | DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { | |||
324 | const llvm::opt::OptTable &Opts = getOpts(); | |||
325 | DerivedArgList *DAL = new DerivedArgList(Args); | |||
326 | ||||
327 | bool HasNostdlib = Args.hasArg(options::OPT_nostdlib); | |||
328 | bool HasNostdlibxx = Args.hasArg(options::OPT_nostdlibxx); | |||
329 | bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs); | |||
330 | for (Arg *A : Args) { | |||
331 | // Unfortunately, we have to parse some forwarding options (-Xassembler, | |||
332 | // -Xlinker, -Xpreprocessor) because we either integrate their functionality | |||
333 | // (assembler and preprocessor), or bypass a previous driver ('collect2'). | |||
334 | ||||
335 | // Rewrite linker options, to replace --no-demangle with a custom internal | |||
336 | // option. | |||
337 | if ((A->getOption().matches(options::OPT_Wl_COMMA) || | |||
338 | A->getOption().matches(options::OPT_Xlinker)) && | |||
339 | A->containsValue("--no-demangle")) { | |||
340 | // Add the rewritten no-demangle argument. | |||
341 | DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_Xlinker__no_demangle)); | |||
342 | ||||
343 | // Add the remaining values as Xlinker arguments. | |||
344 | for (StringRef Val : A->getValues()) | |||
345 | if (Val != "--no-demangle") | |||
346 | DAL->AddSeparateArg(A, Opts.getOption(options::OPT_Xlinker), Val); | |||
347 | ||||
348 | continue; | |||
349 | } | |||
350 | ||||
351 | // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by | |||
352 | // some build systems. We don't try to be complete here because we don't | |||
353 | // care to encourage this usage model. | |||
354 | if (A->getOption().matches(options::OPT_Wp_COMMA) && | |||
355 | (A->getValue(0) == StringRef("-MD") || | |||
356 | A->getValue(0) == StringRef("-MMD"))) { | |||
357 | // Rewrite to -MD/-MMD along with -MF. | |||
358 | if (A->getValue(0) == StringRef("-MD")) | |||
359 | DAL->AddFlagArg(A, Opts.getOption(options::OPT_MD)); | |||
360 | else | |||
361 | DAL->AddFlagArg(A, Opts.getOption(options::OPT_MMD)); | |||
362 | if (A->getNumValues() == 2) | |||
363 | DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue(1)); | |||
364 | continue; | |||
365 | } | |||
366 | ||||
367 | // Rewrite reserved library names. | |||
368 | if (A->getOption().matches(options::OPT_l)) { | |||
369 | StringRef Value = A->getValue(); | |||
370 | ||||
371 | // Rewrite unless -nostdlib is present. | |||
372 | if (!HasNostdlib && !HasNodefaultlib && !HasNostdlibxx && | |||
373 | Value == "stdc++") { | |||
374 | DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_stdcxx)); | |||
375 | continue; | |||
376 | } | |||
377 | ||||
378 | // Rewrite unconditionally. | |||
379 | if (Value == "cc_kext") { | |||
380 | DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_cckext)); | |||
381 | continue; | |||
382 | } | |||
383 | } | |||
384 | ||||
385 | // Pick up inputs via the -- option. | |||
386 | if (A->getOption().matches(options::OPT__DASH_DASH)) { | |||
387 | A->claim(); | |||
388 | for (StringRef Val : A->getValues()) | |||
389 | DAL->append(MakeInputArg(*DAL, Opts, Val, false)); | |||
390 | continue; | |||
391 | } | |||
392 | ||||
393 | DAL->append(A); | |||
394 | } | |||
395 | ||||
396 | // Enforce -static if -miamcu is present. | |||
397 | if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) | |||
398 | DAL->AddFlagArg(0, Opts.getOption(options::OPT_static)); | |||
399 | ||||
400 | // Add a default value of -mlinker-version=, if one was given and the user | |||
401 | // didn't specify one. | |||
402 | #if defined(HOST_LINK_VERSION) | |||
403 | if (!Args.hasArg(options::OPT_mlinker_version_EQ) && | |||
404 | strlen(HOST_LINK_VERSION) > 0) { | |||
405 | DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mlinker_version_EQ), | |||
406 | HOST_LINK_VERSION); | |||
407 | DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim(); | |||
408 | } | |||
409 | #endif | |||
410 | ||||
411 | return DAL; | |||
412 | } | |||
413 | ||||
414 | /// Compute target triple from args. | |||
415 | /// | |||
416 | /// This routine provides the logic to compute a target triple from various | |||
417 | /// args passed to the driver and the default triple string. | |||
418 | static llvm::Triple computeTargetTriple(const Driver &D, | |||
419 | StringRef TargetTriple, | |||
420 | const ArgList &Args, | |||
421 | StringRef DarwinArchName = "") { | |||
422 | // FIXME: Already done in Compilation *Driver::BuildCompilation | |||
423 | if (const Arg *A = Args.getLastArg(options::OPT_target)) | |||
424 | TargetTriple = A->getValue(); | |||
425 | ||||
426 | llvm::Triple Target(llvm::Triple::normalize(TargetTriple)); | |||
427 | ||||
428 | // GNU/Hurd's triples should have been -hurd-gnu*, but were historically made | |||
429 | // -gnu* only, and we can not change this, so we have to detect that case as | |||
430 | // being the Hurd OS. | |||
431 | if (TargetTriple.find("-unknown-gnu") != StringRef::npos || | |||
432 | TargetTriple.find("-pc-gnu") != StringRef::npos) | |||
433 | Target.setOSName("hurd"); | |||
434 | ||||
435 | // Handle Apple-specific options available here. | |||
436 | if (Target.isOSBinFormatMachO()) { | |||
437 | // If an explicit Darwin arch name is given, that trumps all. | |||
438 | if (!DarwinArchName.empty()) { | |||
439 | tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName); | |||
440 | return Target; | |||
441 | } | |||
442 | ||||
443 | // Handle the Darwin '-arch' flag. | |||
444 | if (Arg *A = Args.getLastArg(options::OPT_arch)) { | |||
445 | StringRef ArchName = A->getValue(); | |||
446 | tools::darwin::setTripleTypeForMachOArchName(Target, ArchName); | |||
447 | } | |||
448 | } | |||
449 | ||||
450 | // Handle pseudo-target flags '-mlittle-endian'/'-EL' and | |||
451 | // '-mbig-endian'/'-EB'. | |||
452 | if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian, | |||
453 | options::OPT_mbig_endian)) { | |||
454 | if (A->getOption().matches(options::OPT_mlittle_endian)) { | |||
455 | llvm::Triple LE = Target.getLittleEndianArchVariant(); | |||
456 | if (LE.getArch() != llvm::Triple::UnknownArch) | |||
457 | Target = std::move(LE); | |||
458 | } else { | |||
459 | llvm::Triple BE = Target.getBigEndianArchVariant(); | |||
460 | if (BE.getArch() != llvm::Triple::UnknownArch) | |||
461 | Target = std::move(BE); | |||
462 | } | |||
463 | } | |||
464 | ||||
465 | // Skip further flag support on OSes which don't support '-m32' or '-m64'. | |||
466 | if (Target.getArch() == llvm::Triple::tce || | |||
467 | Target.getOS() == llvm::Triple::Minix) | |||
468 | return Target; | |||
469 | ||||
470 | // Handle pseudo-target flags '-m64', '-mx32', '-m32' and '-m16'. | |||
471 | Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32, | |||
472 | options::OPT_m32, options::OPT_m16); | |||
473 | if (A) { | |||
474 | llvm::Triple::ArchType AT = llvm::Triple::UnknownArch; | |||
475 | ||||
476 | if (A->getOption().matches(options::OPT_m64)) { | |||
477 | AT = Target.get64BitArchVariant().getArch(); | |||
478 | if (Target.getEnvironment() == llvm::Triple::GNUX32) | |||
479 | Target.setEnvironment(llvm::Triple::GNU); | |||
480 | } else if (A->getOption().matches(options::OPT_mx32) && | |||
481 | Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) { | |||
482 | AT = llvm::Triple::x86_64; | |||
483 | Target.setEnvironment(llvm::Triple::GNUX32); | |||
484 | } else if (A->getOption().matches(options::OPT_m32)) { | |||
485 | AT = Target.get32BitArchVariant().getArch(); | |||
486 | if (Target.getEnvironment() == llvm::Triple::GNUX32) | |||
487 | Target.setEnvironment(llvm::Triple::GNU); | |||
488 | } else if (A->getOption().matches(options::OPT_m16) && | |||
489 | Target.get32BitArchVariant().getArch() == llvm::Triple::x86) { | |||
490 | AT = llvm::Triple::x86; | |||
491 | Target.setEnvironment(llvm::Triple::CODE16); | |||
492 | } | |||
493 | ||||
494 | if (AT != llvm::Triple::UnknownArch && AT != Target.getArch()) | |||
495 | Target.setArch(AT); | |||
496 | } | |||
497 | ||||
498 | // Handle -miamcu flag. | |||
499 | if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) { | |||
500 | if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86) | |||
501 | D.Diag(diag::err_drv_unsupported_opt_for_target) << "-miamcu" | |||
502 | << Target.str(); | |||
503 | ||||
504 | if (A && !A->getOption().matches(options::OPT_m32)) | |||
505 | D.Diag(diag::err_drv_argument_not_allowed_with) | |||
506 | << "-miamcu" << A->getBaseArg().getAsString(Args); | |||
507 | ||||
508 | Target.setArch(llvm::Triple::x86); | |||
509 | Target.setArchName("i586"); | |||
510 | Target.setEnvironment(llvm::Triple::UnknownEnvironment); | |||
511 | Target.setEnvironmentName(""); | |||
512 | Target.setOS(llvm::Triple::ELFIAMCU); | |||
513 | Target.setVendor(llvm::Triple::UnknownVendor); | |||
514 | Target.setVendorName("intel"); | |||
515 | } | |||
516 | ||||
517 | // If target is MIPS adjust the target triple | |||
518 | // accordingly to provided ABI name. | |||
519 | A = Args.getLastArg(options::OPT_mabi_EQ); | |||
520 | if (A && Target.isMIPS()) { | |||
521 | StringRef ABIName = A->getValue(); | |||
522 | if (ABIName == "32") { | |||
523 | Target = Target.get32BitArchVariant(); | |||
524 | if (Target.getEnvironment() == llvm::Triple::GNUABI64 || | |||
525 | Target.getEnvironment() == llvm::Triple::GNUABIN32) | |||
526 | Target.setEnvironment(llvm::Triple::GNU); | |||
527 | } else if (ABIName == "n32") { | |||
528 | Target = Target.get64BitArchVariant(); | |||
529 | if (Target.getEnvironment() == llvm::Triple::GNU || | |||
530 | Target.getEnvironment() == llvm::Triple::GNUABI64) | |||
531 | Target.setEnvironment(llvm::Triple::GNUABIN32); | |||
532 | } else if (ABIName == "64") { | |||
533 | Target = Target.get64BitArchVariant(); | |||
534 | if (Target.getEnvironment() == llvm::Triple::GNU || | |||
535 | Target.getEnvironment() == llvm::Triple::GNUABIN32) | |||
536 | Target.setEnvironment(llvm::Triple::GNUABI64); | |||
537 | } | |||
538 | } | |||
539 | ||||
540 | // If target is RISC-V adjust the target triple according to | |||
541 | // provided architecture name | |||
542 | A = Args.getLastArg(options::OPT_march_EQ); | |||
543 | if (A && Target.isRISCV()) { | |||
544 | StringRef ArchName = A->getValue(); | |||
545 | if (ArchName.startswith_lower("rv32")) | |||
546 | Target.setArch(llvm::Triple::riscv32); | |||
547 | else if (ArchName.startswith_lower("rv64")) | |||
548 | Target.setArch(llvm::Triple::riscv64); | |||
549 | } | |||
550 | ||||
551 | return Target; | |||
552 | } | |||
553 | ||||
554 | // Parse the LTO options and record the type of LTO compilation | |||
555 | // based on which -f(no-)?lto(=.*)? option occurs last. | |||
556 | void Driver::setLTOMode(const llvm::opt::ArgList &Args) { | |||
557 | LTOMode = LTOK_None; | |||
558 | if (!Args.hasFlag(options::OPT_flto, options::OPT_flto_EQ, | |||
559 | options::OPT_fno_lto, false)) | |||
560 | return; | |||
561 | ||||
562 | StringRef LTOName("full"); | |||
563 | ||||
564 | const Arg *A = Args.getLastArg(options::OPT_flto_EQ); | |||
565 | if (A) | |||
566 | LTOName = A->getValue(); | |||
567 | ||||
568 | LTOMode = llvm::StringSwitch<LTOKind>(LTOName) | |||
569 | .Case("full", LTOK_Full) | |||
570 | .Case("thin", LTOK_Thin) | |||
571 | .Default(LTOK_Unknown); | |||
572 | ||||
573 | if (LTOMode == LTOK_Unknown) { | |||
574 | assert(A)((A) ? static_cast<void> (0) : __assert_fail ("A", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 574, __PRETTY_FUNCTION__)); | |||
575 | Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName() | |||
576 | << A->getValue(); | |||
577 | } | |||
578 | } | |||
579 | ||||
580 | /// Compute the desired OpenMP runtime from the flags provided. | |||
581 | Driver::OpenMPRuntimeKind Driver::getOpenMPRuntime(const ArgList &Args) const { | |||
582 | StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME"libomp"); | |||
583 | ||||
584 | const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ); | |||
585 | if (A) | |||
586 | RuntimeName = A->getValue(); | |||
587 | ||||
588 | auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName) | |||
589 | .Case("libomp", OMPRT_OMP) | |||
590 | .Case("libgomp", OMPRT_GOMP) | |||
591 | .Case("libiomp5", OMPRT_IOMP5) | |||
592 | .Default(OMPRT_Unknown); | |||
593 | ||||
594 | if (RT == OMPRT_Unknown) { | |||
595 | if (A) | |||
596 | Diag(diag::err_drv_unsupported_option_argument) | |||
597 | << A->getOption().getName() << A->getValue(); | |||
598 | else | |||
599 | // FIXME: We could use a nicer diagnostic here. | |||
600 | Diag(diag::err_drv_unsupported_opt) << "-fopenmp"; | |||
601 | } | |||
602 | ||||
603 | return RT; | |||
604 | } | |||
605 | ||||
606 | void Driver::CreateOffloadingDeviceToolChains(Compilation &C, | |||
607 | InputList &Inputs) { | |||
608 | ||||
609 | // | |||
610 | // CUDA/HIP | |||
611 | // | |||
612 | // We need to generate a CUDA/HIP toolchain if any of the inputs has a CUDA | |||
613 | // or HIP type. However, mixed CUDA/HIP compilation is not supported. | |||
614 | bool IsCuda = | |||
615 | llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) { | |||
616 | return types::isCuda(I.first); | |||
617 | }); | |||
618 | bool IsHIP = | |||
619 | llvm::any_of(Inputs, | |||
620 | [](std::pair<types::ID, const llvm::opt::Arg *> &I) { | |||
621 | return types::isHIP(I.first); | |||
622 | }) || | |||
623 | C.getInputArgs().hasArg(options::OPT_hip_link); | |||
624 | if (IsCuda && IsHIP) { | |||
625 | Diag(clang::diag::err_drv_mix_cuda_hip); | |||
626 | return; | |||
627 | } | |||
628 | if (IsCuda) { | |||
629 | const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>(); | |||
630 | const llvm::Triple &HostTriple = HostTC->getTriple(); | |||
631 | StringRef DeviceTripleStr; | |||
632 | auto OFK = Action::OFK_Cuda; | |||
633 | DeviceTripleStr = | |||
634 | HostTriple.isArch64Bit() ? "nvptx64-nvidia-cuda" : "nvptx-nvidia-cuda"; | |||
635 | llvm::Triple CudaTriple(DeviceTripleStr); | |||
636 | // Use the CUDA and host triples as the key into the ToolChains map, | |||
637 | // because the device toolchain we create depends on both. | |||
638 | auto &CudaTC = ToolChains[CudaTriple.str() + "/" + HostTriple.str()]; | |||
639 | if (!CudaTC) { | |||
640 | CudaTC = std::make_unique<toolchains::CudaToolChain>( | |||
641 | *this, CudaTriple, *HostTC, C.getInputArgs(), OFK); | |||
642 | } | |||
643 | C.addOffloadDeviceToolChain(CudaTC.get(), OFK); | |||
644 | } else if (IsHIP) { | |||
645 | const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>(); | |||
646 | const llvm::Triple &HostTriple = HostTC->getTriple(); | |||
647 | StringRef DeviceTripleStr; | |||
648 | auto OFK = Action::OFK_HIP; | |||
649 | DeviceTripleStr = "amdgcn-amd-amdhsa"; | |||
650 | llvm::Triple HIPTriple(DeviceTripleStr); | |||
651 | // Use the HIP and host triples as the key into the ToolChains map, | |||
652 | // because the device toolchain we create depends on both. | |||
653 | auto &HIPTC = ToolChains[HIPTriple.str() + "/" + HostTriple.str()]; | |||
654 | if (!HIPTC) { | |||
655 | HIPTC = std::make_unique<toolchains::HIPToolChain>( | |||
656 | *this, HIPTriple, *HostTC, C.getInputArgs()); | |||
657 | } | |||
658 | C.addOffloadDeviceToolChain(HIPTC.get(), OFK); | |||
659 | } | |||
660 | ||||
661 | // | |||
662 | // OpenMP | |||
663 | // | |||
664 | // We need to generate an OpenMP toolchain if the user specified targets with | |||
665 | // the -fopenmp-targets option. | |||
666 | if (Arg *OpenMPTargets = | |||
667 | C.getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) { | |||
668 | if (OpenMPTargets->getNumValues()) { | |||
669 | // We expect that -fopenmp-targets is always used in conjunction with the | |||
670 | // option -fopenmp specifying a valid runtime with offloading support, | |||
671 | // i.e. libomp or libiomp. | |||
672 | bool HasValidOpenMPRuntime = C.getInputArgs().hasFlag( | |||
673 | options::OPT_fopenmp, options::OPT_fopenmp_EQ, | |||
674 | options::OPT_fno_openmp, false); | |||
675 | if (HasValidOpenMPRuntime) { | |||
676 | OpenMPRuntimeKind OpenMPKind = getOpenMPRuntime(C.getInputArgs()); | |||
677 | HasValidOpenMPRuntime = | |||
678 | OpenMPKind == OMPRT_OMP || OpenMPKind == OMPRT_IOMP5; | |||
679 | } | |||
680 | ||||
681 | if (HasValidOpenMPRuntime) { | |||
682 | llvm::StringMap<const char *> FoundNormalizedTriples; | |||
683 | for (const char *Val : OpenMPTargets->getValues()) { | |||
684 | llvm::Triple TT(Val); | |||
685 | std::string NormalizedName = TT.normalize(); | |||
686 | ||||
687 | // Make sure we don't have a duplicate triple. | |||
688 | auto Duplicate = FoundNormalizedTriples.find(NormalizedName); | |||
689 | if (Duplicate != FoundNormalizedTriples.end()) { | |||
690 | Diag(clang::diag::warn_drv_omp_offload_target_duplicate) | |||
691 | << Val << Duplicate->second; | |||
692 | continue; | |||
693 | } | |||
694 | ||||
695 | // Store the current triple so that we can check for duplicates in the | |||
696 | // following iterations. | |||
697 | FoundNormalizedTriples[NormalizedName] = Val; | |||
698 | ||||
699 | // If the specified target is invalid, emit a diagnostic. | |||
700 | if (TT.getArch() == llvm::Triple::UnknownArch) | |||
701 | Diag(clang::diag::err_drv_invalid_omp_target) << Val; | |||
702 | else { | |||
703 | const ToolChain *TC; | |||
704 | // CUDA toolchains have to be selected differently. They pair host | |||
705 | // and device in their implementation. | |||
706 | if (TT.isNVPTX()) { | |||
707 | const ToolChain *HostTC = | |||
708 | C.getSingleOffloadToolChain<Action::OFK_Host>(); | |||
709 | assert(HostTC && "Host toolchain should be always defined.")((HostTC && "Host toolchain should be always defined." ) ? static_cast<void> (0) : __assert_fail ("HostTC && \"Host toolchain should be always defined.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 709, __PRETTY_FUNCTION__)); | |||
710 | auto &CudaTC = | |||
711 | ToolChains[TT.str() + "/" + HostTC->getTriple().normalize()]; | |||
712 | if (!CudaTC) | |||
713 | CudaTC = std::make_unique<toolchains::CudaToolChain>( | |||
714 | *this, TT, *HostTC, C.getInputArgs(), Action::OFK_OpenMP); | |||
715 | TC = CudaTC.get(); | |||
716 | } else | |||
717 | TC = &getToolChain(C.getInputArgs(), TT); | |||
718 | C.addOffloadDeviceToolChain(TC, Action::OFK_OpenMP); | |||
719 | } | |||
720 | } | |||
721 | } else | |||
722 | Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets); | |||
723 | } else | |||
724 | Diag(clang::diag::warn_drv_empty_joined_argument) | |||
725 | << OpenMPTargets->getAsString(C.getInputArgs()); | |||
726 | } | |||
727 | ||||
728 | // | |||
729 | // TODO: Add support for other offloading programming models here. | |||
730 | // | |||
731 | } | |||
732 | ||||
733 | /// Looks the given directories for the specified file. | |||
734 | /// | |||
735 | /// \param[out] FilePath File path, if the file was found. | |||
736 | /// \param[in] Dirs Directories used for the search. | |||
737 | /// \param[in] FileName Name of the file to search for. | |||
738 | /// \return True if file was found. | |||
739 | /// | |||
740 | /// Looks for file specified by FileName sequentially in directories specified | |||
741 | /// by Dirs. | |||
742 | /// | |||
743 | static bool searchForFile(SmallVectorImpl<char> &FilePath, | |||
744 | ArrayRef<std::string> Dirs, | |||
745 | StringRef FileName) { | |||
746 | SmallString<128> WPath; | |||
747 | for (const std::string &Dir : Dirs) { | |||
748 | if (Dir.empty()) | |||
749 | continue; | |||
750 | WPath.clear(); | |||
751 | llvm::sys::path::append(WPath, Dir, FileName); | |||
752 | llvm::sys::path::native(WPath); | |||
753 | if (llvm::sys::fs::is_regular_file(WPath)) { | |||
754 | FilePath = std::move(WPath); | |||
755 | return true; | |||
756 | } | |||
757 | } | |||
758 | return false; | |||
759 | } | |||
760 | ||||
761 | bool Driver::readConfigFile(StringRef FileName) { | |||
762 | // Try reading the given file. | |||
763 | SmallVector<const char *, 32> NewCfgArgs; | |||
764 | if (!llvm::cl::readConfigFile(FileName, Saver, NewCfgArgs)) { | |||
765 | Diag(diag::err_drv_cannot_read_config_file) << FileName; | |||
766 | return true; | |||
767 | } | |||
768 | ||||
769 | // Read options from config file. | |||
770 | llvm::SmallString<128> CfgFileName(FileName); | |||
771 | llvm::sys::path::native(CfgFileName); | |||
772 | ConfigFile = CfgFileName.str(); | |||
773 | bool ContainErrors; | |||
774 | CfgOptions = std::make_unique<InputArgList>( | |||
775 | ParseArgStrings(NewCfgArgs, IsCLMode(), ContainErrors)); | |||
776 | if (ContainErrors) { | |||
777 | CfgOptions.reset(); | |||
778 | return true; | |||
779 | } | |||
780 | ||||
781 | if (CfgOptions->hasArg(options::OPT_config)) { | |||
782 | CfgOptions.reset(); | |||
783 | Diag(diag::err_drv_nested_config_file); | |||
784 | return true; | |||
785 | } | |||
786 | ||||
787 | // Claim all arguments that come from a configuration file so that the driver | |||
788 | // does not warn on any that is unused. | |||
789 | for (Arg *A : *CfgOptions) | |||
790 | A->claim(); | |||
791 | return false; | |||
792 | } | |||
793 | ||||
794 | bool Driver::loadConfigFile() { | |||
795 | std::string CfgFileName; | |||
796 | bool FileSpecifiedExplicitly = false; | |||
797 | ||||
798 | // Process options that change search path for config files. | |||
799 | if (CLOptions) { | |||
800 | if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) { | |||
801 | SmallString<128> CfgDir; | |||
802 | CfgDir.append( | |||
803 | CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ)); | |||
804 | if (!CfgDir.empty()) { | |||
805 | if (llvm::sys::fs::make_absolute(CfgDir).value() != 0) | |||
806 | SystemConfigDir.clear(); | |||
807 | else | |||
808 | SystemConfigDir = std::string(CfgDir.begin(), CfgDir.end()); | |||
809 | } | |||
810 | } | |||
811 | if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) { | |||
812 | SmallString<128> CfgDir; | |||
813 | CfgDir.append( | |||
814 | CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ)); | |||
815 | if (!CfgDir.empty()) { | |||
816 | if (llvm::sys::fs::make_absolute(CfgDir).value() != 0) | |||
817 | UserConfigDir.clear(); | |||
818 | else | |||
819 | UserConfigDir = std::string(CfgDir.begin(), CfgDir.end()); | |||
820 | } | |||
821 | } | |||
822 | } | |||
823 | ||||
824 | // First try to find config file specified in command line. | |||
825 | if (CLOptions) { | |||
826 | std::vector<std::string> ConfigFiles = | |||
827 | CLOptions->getAllArgValues(options::OPT_config); | |||
828 | if (ConfigFiles.size() > 1) { | |||
829 | Diag(diag::err_drv_duplicate_config); | |||
830 | return true; | |||
831 | } | |||
832 | ||||
833 | if (!ConfigFiles.empty()) { | |||
834 | CfgFileName = ConfigFiles.front(); | |||
835 | assert(!CfgFileName.empty())((!CfgFileName.empty()) ? static_cast<void> (0) : __assert_fail ("!CfgFileName.empty()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 835, __PRETTY_FUNCTION__)); | |||
836 | ||||
837 | // If argument contains directory separator, treat it as a path to | |||
838 | // configuration file. | |||
839 | if (llvm::sys::path::has_parent_path(CfgFileName)) { | |||
840 | SmallString<128> CfgFilePath; | |||
841 | if (llvm::sys::path::is_relative(CfgFileName)) | |||
842 | llvm::sys::fs::current_path(CfgFilePath); | |||
843 | llvm::sys::path::append(CfgFilePath, CfgFileName); | |||
844 | if (!llvm::sys::fs::is_regular_file(CfgFilePath)) { | |||
845 | Diag(diag::err_drv_config_file_not_exist) << CfgFilePath; | |||
846 | return true; | |||
847 | } | |||
848 | return readConfigFile(CfgFilePath); | |||
849 | } | |||
850 | ||||
851 | FileSpecifiedExplicitly = true; | |||
852 | } | |||
853 | } | |||
854 | ||||
855 | // If config file is not specified explicitly, try to deduce configuration | |||
856 | // from executable name. For instance, an executable 'armv7l-clang' will | |||
857 | // search for config file 'armv7l-clang.cfg'. | |||
858 | if (CfgFileName.empty() && !ClangNameParts.TargetPrefix.empty()) | |||
859 | CfgFileName = ClangNameParts.TargetPrefix + '-' + ClangNameParts.ModeSuffix; | |||
860 | ||||
861 | if (CfgFileName.empty()) | |||
862 | return false; | |||
863 | ||||
864 | // Determine architecture part of the file name, if it is present. | |||
865 | StringRef CfgFileArch = CfgFileName; | |||
866 | size_t ArchPrefixLen = CfgFileArch.find('-'); | |||
867 | if (ArchPrefixLen == StringRef::npos) | |||
868 | ArchPrefixLen = CfgFileArch.size(); | |||
869 | llvm::Triple CfgTriple; | |||
870 | CfgFileArch = CfgFileArch.take_front(ArchPrefixLen); | |||
871 | CfgTriple = llvm::Triple(llvm::Triple::normalize(CfgFileArch)); | |||
872 | if (CfgTriple.getArch() == llvm::Triple::ArchType::UnknownArch) | |||
873 | ArchPrefixLen = 0; | |||
874 | ||||
875 | if (!StringRef(CfgFileName).endswith(".cfg")) | |||
876 | CfgFileName += ".cfg"; | |||
877 | ||||
878 | // If config file starts with architecture name and command line options | |||
879 | // redefine architecture (with options like -m32 -LE etc), try finding new | |||
880 | // config file with that architecture. | |||
881 | SmallString<128> FixedConfigFile; | |||
882 | size_t FixedArchPrefixLen = 0; | |||
883 | if (ArchPrefixLen) { | |||
884 | // Get architecture name from config file name like 'i386.cfg' or | |||
885 | // 'armv7l-clang.cfg'. | |||
886 | // Check if command line options changes effective triple. | |||
887 | llvm::Triple EffectiveTriple = computeTargetTriple(*this, | |||
888 | CfgTriple.getTriple(), *CLOptions); | |||
889 | if (CfgTriple.getArch() != EffectiveTriple.getArch()) { | |||
890 | FixedConfigFile = EffectiveTriple.getArchName(); | |||
891 | FixedArchPrefixLen = FixedConfigFile.size(); | |||
892 | // Append the rest of original file name so that file name transforms | |||
893 | // like: i386-clang.cfg -> x86_64-clang.cfg. | |||
894 | if (ArchPrefixLen < CfgFileName.size()) | |||
895 | FixedConfigFile += CfgFileName.substr(ArchPrefixLen); | |||
896 | } | |||
897 | } | |||
898 | ||||
899 | // Prepare list of directories where config file is searched for. | |||
900 | SmallVector<std::string, 3> CfgFileSearchDirs; | |||
901 | CfgFileSearchDirs.push_back(UserConfigDir); | |||
902 | CfgFileSearchDirs.push_back(SystemConfigDir); | |||
903 | CfgFileSearchDirs.push_back(Dir); | |||
904 | ||||
905 | // Try to find config file. First try file with corrected architecture. | |||
906 | llvm::SmallString<128> CfgFilePath; | |||
907 | if (!FixedConfigFile.empty()) { | |||
908 | if (searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile)) | |||
909 | return readConfigFile(CfgFilePath); | |||
910 | // If 'x86_64-clang.cfg' was not found, try 'x86_64.cfg'. | |||
911 | FixedConfigFile.resize(FixedArchPrefixLen); | |||
912 | FixedConfigFile.append(".cfg"); | |||
913 | if (searchForFile(CfgFilePath, CfgFileSearchDirs, FixedConfigFile)) | |||
914 | return readConfigFile(CfgFilePath); | |||
915 | } | |||
916 | ||||
917 | // Then try original file name. | |||
918 | if (searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName)) | |||
919 | return readConfigFile(CfgFilePath); | |||
920 | ||||
921 | // Finally try removing driver mode part: 'x86_64-clang.cfg' -> 'x86_64.cfg'. | |||
922 | if (!ClangNameParts.ModeSuffix.empty() && | |||
923 | !ClangNameParts.TargetPrefix.empty()) { | |||
924 | CfgFileName.assign(ClangNameParts.TargetPrefix); | |||
925 | CfgFileName.append(".cfg"); | |||
926 | if (searchForFile(CfgFilePath, CfgFileSearchDirs, CfgFileName)) | |||
927 | return readConfigFile(CfgFilePath); | |||
928 | } | |||
929 | ||||
930 | // Report error but only if config file was specified explicitly, by option | |||
931 | // --config. If it was deduced from executable name, it is not an error. | |||
932 | if (FileSpecifiedExplicitly) { | |||
933 | Diag(diag::err_drv_config_file_not_found) << CfgFileName; | |||
934 | for (const std::string &SearchDir : CfgFileSearchDirs) | |||
935 | if (!SearchDir.empty()) | |||
936 | Diag(diag::note_drv_config_file_searched_in) << SearchDir; | |||
937 | return true; | |||
938 | } | |||
939 | ||||
940 | return false; | |||
941 | } | |||
942 | ||||
943 | Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { | |||
944 | llvm::PrettyStackTraceString CrashInfo("Compilation construction"); | |||
945 | ||||
946 | // FIXME: Handle environment options which affect driver behavior, somewhere | |||
947 | // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS. | |||
948 | ||||
949 | if (Optional<std::string> CompilerPathValue = | |||
950 | llvm::sys::Process::GetEnv("COMPILER_PATH")) { | |||
951 | StringRef CompilerPath = *CompilerPathValue; | |||
952 | while (!CompilerPath.empty()) { | |||
953 | std::pair<StringRef, StringRef> Split = | |||
954 | CompilerPath.split(llvm::sys::EnvPathSeparator); | |||
955 | PrefixDirs.push_back(Split.first); | |||
956 | CompilerPath = Split.second; | |||
957 | } | |||
958 | } | |||
959 | ||||
960 | // We look for the driver mode option early, because the mode can affect | |||
961 | // how other options are parsed. | |||
962 | ParseDriverMode(ClangExecutable, ArgList.slice(1)); | |||
963 | ||||
964 | // FIXME: What are we going to do with -V and -b? | |||
965 | ||||
966 | // Arguments specified in command line. | |||
967 | bool ContainsError; | |||
968 | CLOptions = std::make_unique<InputArgList>( | |||
969 | ParseArgStrings(ArgList.slice(1), IsCLMode(), ContainsError)); | |||
970 | ||||
971 | // Try parsing configuration file. | |||
972 | if (!ContainsError) | |||
973 | ContainsError = loadConfigFile(); | |||
974 | bool HasConfigFile = !ContainsError && (CfgOptions.get() != nullptr); | |||
975 | ||||
976 | // All arguments, from both config file and command line. | |||
977 | InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions) | |||
978 | : std::move(*CLOptions)); | |||
979 | ||||
980 | // The args for config files or /clang: flags belong to different InputArgList | |||
981 | // objects than Args. This copies an Arg from one of those other InputArgLists | |||
982 | // to the ownership of Args. | |||
983 | auto appendOneArg = [&Args](const Arg *Opt, const Arg *BaseArg) { | |||
984 | unsigned Index = Args.MakeIndex(Opt->getSpelling()); | |||
985 | Arg *Copy = new llvm::opt::Arg(Opt->getOption(), Opt->getSpelling(), | |||
986 | Index, BaseArg); | |||
987 | Copy->getValues() = Opt->getValues(); | |||
988 | if (Opt->isClaimed()) | |||
989 | Copy->claim(); | |||
990 | Args.append(Copy); | |||
991 | }; | |||
992 | ||||
993 | if (HasConfigFile) | |||
994 | for (auto *Opt : *CLOptions) { | |||
995 | if (Opt->getOption().matches(options::OPT_config)) | |||
996 | continue; | |||
997 | const Arg *BaseArg = &Opt->getBaseArg(); | |||
998 | if (BaseArg == Opt) | |||
999 | BaseArg = nullptr; | |||
1000 | appendOneArg(Opt, BaseArg); | |||
1001 | } | |||
1002 | ||||
1003 | // In CL mode, look for any pass-through arguments | |||
1004 | if (IsCLMode() && !ContainsError) { | |||
1005 | SmallVector<const char *, 16> CLModePassThroughArgList; | |||
1006 | for (const auto *A : Args.filtered(options::OPT__SLASH_clang)) { | |||
1007 | A->claim(); | |||
1008 | CLModePassThroughArgList.push_back(A->getValue()); | |||
1009 | } | |||
1010 | ||||
1011 | if (!CLModePassThroughArgList.empty()) { | |||
1012 | // Parse any pass through args using default clang processing rather | |||
1013 | // than clang-cl processing. | |||
1014 | auto CLModePassThroughOptions = std::make_unique<InputArgList>( | |||
1015 | ParseArgStrings(CLModePassThroughArgList, false, ContainsError)); | |||
1016 | ||||
1017 | if (!ContainsError) | |||
1018 | for (auto *Opt : *CLModePassThroughOptions) { | |||
1019 | appendOneArg(Opt, nullptr); | |||
1020 | } | |||
1021 | } | |||
1022 | } | |||
1023 | ||||
1024 | // Check for working directory option before accessing any files | |||
1025 | if (Arg *WD = Args.getLastArg(options::OPT_working_directory)) | |||
1026 | if (VFS->setCurrentWorkingDirectory(WD->getValue())) | |||
1027 | Diag(diag::err_drv_unable_to_set_working_directory) << WD->getValue(); | |||
1028 | ||||
1029 | // FIXME: This stuff needs to go into the Compilation, not the driver. | |||
1030 | bool CCCPrintPhases; | |||
1031 | ||||
1032 | // Silence driver warnings if requested | |||
1033 | Diags.setIgnoreAllWarnings(Args.hasArg(options::OPT_w)); | |||
1034 | ||||
1035 | // -no-canonical-prefixes is used very early in main. | |||
1036 | Args.ClaimAllArgs(options::OPT_no_canonical_prefixes); | |||
1037 | ||||
1038 | // Ignore -pipe. | |||
1039 | Args.ClaimAllArgs(options::OPT_pipe); | |||
1040 | ||||
1041 | // Extract -ccc args. | |||
1042 | // | |||
1043 | // FIXME: We need to figure out where this behavior should live. Most of it | |||
1044 | // should be outside in the client; the parts that aren't should have proper | |||
1045 | // options, either by introducing new ones or by overloading gcc ones like -V | |||
1046 | // or -b. | |||
1047 | CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases); | |||
1048 | CCCPrintBindings = Args.hasArg(options::OPT_ccc_print_bindings); | |||
1049 | if (const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name)) | |||
1050 | CCCGenericGCCName = A->getValue(); | |||
1051 | GenReproducer = Args.hasFlag(options::OPT_gen_reproducer, | |||
1052 | options::OPT_fno_crash_diagnostics, | |||
1053 | !!::getenv("FORCE_CLANG_DIAGNOSTICS_CRASH")); | |||
1054 | // FIXME: TargetTriple is used by the target-prefixed calls to as/ld | |||
1055 | // and getToolChain is const. | |||
1056 | if (IsCLMode()) { | |||
1057 | // clang-cl targets MSVC-style Win32. | |||
1058 | llvm::Triple T(TargetTriple); | |||
1059 | T.setOS(llvm::Triple::Win32); | |||
1060 | T.setVendor(llvm::Triple::PC); | |||
1061 | T.setEnvironment(llvm::Triple::MSVC); | |||
1062 | T.setObjectFormat(llvm::Triple::COFF); | |||
1063 | TargetTriple = T.str(); | |||
1064 | } | |||
1065 | if (const Arg *A = Args.getLastArg(options::OPT_target)) | |||
1066 | TargetTriple = A->getValue(); | |||
1067 | if (const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir)) | |||
1068 | Dir = InstalledDir = A->getValue(); | |||
1069 | for (const Arg *A : Args.filtered(options::OPT_B)) { | |||
1070 | A->claim(); | |||
1071 | PrefixDirs.push_back(A->getValue(0)); | |||
1072 | } | |||
1073 | if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) | |||
1074 | SysRoot = A->getValue(); | |||
1075 | if (const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ)) | |||
1076 | DyldPrefix = A->getValue(); | |||
1077 | ||||
1078 | if (const Arg *A = Args.getLastArg(options::OPT_resource_dir)) | |||
1079 | ResourceDir = A->getValue(); | |||
1080 | ||||
1081 | if (const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) { | |||
1082 | SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue()) | |||
1083 | .Case("cwd", SaveTempsCwd) | |||
1084 | .Case("obj", SaveTempsObj) | |||
1085 | .Default(SaveTempsCwd); | |||
1086 | } | |||
1087 | ||||
1088 | setLTOMode(Args); | |||
1089 | ||||
1090 | // Process -fembed-bitcode= flags. | |||
1091 | if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) { | |||
1092 | StringRef Name = A->getValue(); | |||
1093 | unsigned Model = llvm::StringSwitch<unsigned>(Name) | |||
1094 | .Case("off", EmbedNone) | |||
1095 | .Case("all", EmbedBitcode) | |||
1096 | .Case("bitcode", EmbedBitcode) | |||
1097 | .Case("marker", EmbedMarker) | |||
1098 | .Default(~0U); | |||
1099 | if (Model == ~0U) { | |||
1100 | Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) | |||
1101 | << Name; | |||
1102 | } else | |||
1103 | BitcodeEmbed = static_cast<BitcodeEmbedMode>(Model); | |||
1104 | } | |||
1105 | ||||
1106 | std::unique_ptr<llvm::opt::InputArgList> UArgs = | |||
1107 | std::make_unique<InputArgList>(std::move(Args)); | |||
1108 | ||||
1109 | // Perform the default argument translations. | |||
1110 | DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs); | |||
1111 | ||||
1112 | // Owned by the host. | |||
1113 | const ToolChain &TC = getToolChain( | |||
1114 | *UArgs, computeTargetTriple(*this, TargetTriple, *UArgs)); | |||
1115 | ||||
1116 | // The compilation takes ownership of Args. | |||
1117 | Compilation *C = new Compilation(*this, TC, UArgs.release(), TranslatedArgs, | |||
1118 | ContainsError); | |||
1119 | ||||
1120 | if (!HandleImmediateArgs(*C)) | |||
1121 | return C; | |||
1122 | ||||
1123 | // Construct the list of inputs. | |||
1124 | InputList Inputs; | |||
1125 | BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs); | |||
1126 | ||||
1127 | // Populate the tool chains for the offloading devices, if any. | |||
1128 | CreateOffloadingDeviceToolChains(*C, Inputs); | |||
1129 | ||||
1130 | // Construct the list of abstract actions to perform for this compilation. On | |||
1131 | // MachO targets this uses the driver-driver and universal actions. | |||
1132 | if (TC.getTriple().isOSBinFormatMachO()) | |||
1133 | BuildUniversalActions(*C, C->getDefaultToolChain(), Inputs); | |||
1134 | else | |||
1135 | BuildActions(*C, C->getArgs(), Inputs, C->getActions()); | |||
1136 | ||||
1137 | if (CCCPrintPhases) { | |||
1138 | PrintActions(*C); | |||
1139 | return C; | |||
1140 | } | |||
1141 | ||||
1142 | BuildJobs(*C); | |||
1143 | ||||
1144 | return C; | |||
1145 | } | |||
1146 | ||||
1147 | static void printArgList(raw_ostream &OS, const llvm::opt::ArgList &Args) { | |||
1148 | llvm::opt::ArgStringList ASL; | |||
1149 | for (const auto *A : Args) | |||
1150 | A->render(Args, ASL); | |||
1151 | ||||
1152 | for (auto I = ASL.begin(), E = ASL.end(); I != E; ++I) { | |||
1153 | if (I != ASL.begin()) | |||
1154 | OS << ' '; | |||
1155 | Command::printArg(OS, *I, true); | |||
1156 | } | |||
1157 | OS << '\n'; | |||
1158 | } | |||
1159 | ||||
1160 | bool Driver::getCrashDiagnosticFile(StringRef ReproCrashFilename, | |||
1161 | SmallString<128> &CrashDiagDir) { | |||
1162 | using namespace llvm::sys; | |||
1163 | assert(llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() &&((llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() && "Only knows about .crash files on Darwin") ? static_cast< void> (0) : __assert_fail ("llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() && \"Only knows about .crash files on Darwin\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 1164, __PRETTY_FUNCTION__)) | |||
1164 | "Only knows about .crash files on Darwin")((llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() && "Only knows about .crash files on Darwin") ? static_cast< void> (0) : __assert_fail ("llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin() && \"Only knows about .crash files on Darwin\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 1164, __PRETTY_FUNCTION__)); | |||
1165 | ||||
1166 | // The .crash file can be found on at ~/Library/Logs/DiagnosticReports/ | |||
1167 | // (or /Library/Logs/DiagnosticReports for root) and has the filename pattern | |||
1168 | // clang-<VERSION>_<YYYY-MM-DD-HHMMSS>_<hostname>.crash. | |||
1169 | path::home_directory(CrashDiagDir); | |||
1170 | if (CrashDiagDir.startswith("/var/root")) | |||
1171 | CrashDiagDir = "/"; | |||
1172 | path::append(CrashDiagDir, "Library/Logs/DiagnosticReports"); | |||
1173 | int PID = | |||
1174 | #if LLVM_ON_UNIX1 | |||
1175 | getpid(); | |||
1176 | #else | |||
1177 | 0; | |||
1178 | #endif | |||
1179 | std::error_code EC; | |||
1180 | fs::file_status FileStatus; | |||
1181 | TimePoint<> LastAccessTime; | |||
1182 | SmallString<128> CrashFilePath; | |||
1183 | // Lookup the .crash files and get the one generated by a subprocess spawned | |||
1184 | // by this driver invocation. | |||
1185 | for (fs::directory_iterator File(CrashDiagDir, EC), FileEnd; | |||
1186 | File != FileEnd && !EC; File.increment(EC)) { | |||
1187 | StringRef FileName = path::filename(File->path()); | |||
1188 | if (!FileName.startswith(Name)) | |||
1189 | continue; | |||
1190 | if (fs::status(File->path(), FileStatus)) | |||
1191 | continue; | |||
1192 | llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CrashFile = | |||
1193 | llvm::MemoryBuffer::getFile(File->path()); | |||
1194 | if (!CrashFile) | |||
1195 | continue; | |||
1196 | // The first line should start with "Process:", otherwise this isn't a real | |||
1197 | // .crash file. | |||
1198 | StringRef Data = CrashFile.get()->getBuffer(); | |||
1199 | if (!Data.startswith("Process:")) | |||
1200 | continue; | |||
1201 | // Parse parent process pid line, e.g: "Parent Process: clang-4.0 [79141]" | |||
1202 | size_t ParentProcPos = Data.find("Parent Process:"); | |||
1203 | if (ParentProcPos == StringRef::npos) | |||
1204 | continue; | |||
1205 | size_t LineEnd = Data.find_first_of("\n", ParentProcPos); | |||
1206 | if (LineEnd == StringRef::npos) | |||
1207 | continue; | |||
1208 | StringRef ParentProcess = Data.slice(ParentProcPos+15, LineEnd).trim(); | |||
1209 | int OpenBracket = -1, CloseBracket = -1; | |||
1210 | for (size_t i = 0, e = ParentProcess.size(); i < e; ++i) { | |||
1211 | if (ParentProcess[i] == '[') | |||
1212 | OpenBracket = i; | |||
1213 | if (ParentProcess[i] == ']') | |||
1214 | CloseBracket = i; | |||
1215 | } | |||
1216 | // Extract the parent process PID from the .crash file and check whether | |||
1217 | // it matches this driver invocation pid. | |||
1218 | int CrashPID; | |||
1219 | if (OpenBracket < 0 || CloseBracket < 0 || | |||
1220 | ParentProcess.slice(OpenBracket + 1, CloseBracket) | |||
1221 | .getAsInteger(10, CrashPID) || CrashPID != PID) { | |||
1222 | continue; | |||
1223 | } | |||
1224 | ||||
1225 | // Found a .crash file matching the driver pid. To avoid getting an older | |||
1226 | // and misleading crash file, continue looking for the most recent. | |||
1227 | // FIXME: the driver can dispatch multiple cc1 invocations, leading to | |||
1228 | // multiple crashes poiting to the same parent process. Since the driver | |||
1229 | // does not collect pid information for the dispatched invocation there's | |||
1230 | // currently no way to distinguish among them. | |||
1231 | const auto FileAccessTime = FileStatus.getLastModificationTime(); | |||
1232 | if (FileAccessTime > LastAccessTime) { | |||
1233 | CrashFilePath.assign(File->path()); | |||
1234 | LastAccessTime = FileAccessTime; | |||
1235 | } | |||
1236 | } | |||
1237 | ||||
1238 | // If found, copy it over to the location of other reproducer files. | |||
1239 | if (!CrashFilePath.empty()) { | |||
1240 | EC = fs::copy_file(CrashFilePath, ReproCrashFilename); | |||
1241 | if (EC) | |||
1242 | return false; | |||
1243 | return true; | |||
1244 | } | |||
1245 | ||||
1246 | return false; | |||
1247 | } | |||
1248 | ||||
1249 | // When clang crashes, produce diagnostic information including the fully | |||
1250 | // preprocessed source file(s). Request that the developer attach the | |||
1251 | // diagnostic information to a bug report. | |||
1252 | void Driver::generateCompilationDiagnostics( | |||
1253 | Compilation &C, const Command &FailingCommand, | |||
1254 | StringRef AdditionalInformation, CompilationDiagnosticReport *Report) { | |||
1255 | if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics)) | |||
1256 | return; | |||
1257 | ||||
1258 | // Don't try to generate diagnostics for link or dsymutil jobs. | |||
1259 | if (FailingCommand.getCreator().isLinkJob() || | |||
1260 | FailingCommand.getCreator().isDsymutilJob()) | |||
1261 | return; | |||
1262 | ||||
1263 | // Print the version of the compiler. | |||
1264 | PrintVersion(C, llvm::errs()); | |||
1265 | ||||
1266 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1267 | << "PLEASE submit a bug report to " BUG_REPORT_URL"https://bugs.llvm.org/" " and include the " | |||
1268 | "crash backtrace, preprocessed source, and associated run script."; | |||
1269 | ||||
1270 | // Suppress driver output and emit preprocessor output to temp file. | |||
1271 | Mode = CPPMode; | |||
1272 | CCGenDiagnostics = true; | |||
1273 | ||||
1274 | // Save the original job command(s). | |||
1275 | Command Cmd = FailingCommand; | |||
1276 | ||||
1277 | // Keep track of whether we produce any errors while trying to produce | |||
1278 | // preprocessed sources. | |||
1279 | DiagnosticErrorTrap Trap(Diags); | |||
1280 | ||||
1281 | // Suppress tool output. | |||
1282 | C.initCompilationForDiagnostics(); | |||
1283 | ||||
1284 | // Construct the list of inputs. | |||
1285 | InputList Inputs; | |||
1286 | BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs); | |||
1287 | ||||
1288 | for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) { | |||
1289 | bool IgnoreInput = false; | |||
1290 | ||||
1291 | // Ignore input from stdin or any inputs that cannot be preprocessed. | |||
1292 | // Check type first as not all linker inputs have a value. | |||
1293 | if (types::getPreprocessedType(it->first) == types::TY_INVALID) { | |||
1294 | IgnoreInput = true; | |||
1295 | } else if (!strcmp(it->second->getValue(), "-")) { | |||
1296 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1297 | << "Error generating preprocessed source(s) - " | |||
1298 | "ignoring input from stdin."; | |||
1299 | IgnoreInput = true; | |||
1300 | } | |||
1301 | ||||
1302 | if (IgnoreInput) { | |||
1303 | it = Inputs.erase(it); | |||
1304 | ie = Inputs.end(); | |||
1305 | } else { | |||
1306 | ++it; | |||
1307 | } | |||
1308 | } | |||
1309 | ||||
1310 | if (Inputs.empty()) { | |||
1311 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1312 | << "Error generating preprocessed source(s) - " | |||
1313 | "no preprocessable inputs."; | |||
1314 | return; | |||
1315 | } | |||
1316 | ||||
1317 | // Don't attempt to generate preprocessed files if multiple -arch options are | |||
1318 | // used, unless they're all duplicates. | |||
1319 | llvm::StringSet<> ArchNames; | |||
1320 | for (const Arg *A : C.getArgs()) { | |||
1321 | if (A->getOption().matches(options::OPT_arch)) { | |||
1322 | StringRef ArchName = A->getValue(); | |||
1323 | ArchNames.insert(ArchName); | |||
1324 | } | |||
1325 | } | |||
1326 | if (ArchNames.size() > 1) { | |||
1327 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1328 | << "Error generating preprocessed source(s) - cannot generate " | |||
1329 | "preprocessed source with multiple -arch options."; | |||
1330 | return; | |||
1331 | } | |||
1332 | ||||
1333 | // Construct the list of abstract actions to perform for this compilation. On | |||
1334 | // Darwin OSes this uses the driver-driver and builds universal actions. | |||
1335 | const ToolChain &TC = C.getDefaultToolChain(); | |||
1336 | if (TC.getTriple().isOSBinFormatMachO()) | |||
1337 | BuildUniversalActions(C, TC, Inputs); | |||
1338 | else | |||
1339 | BuildActions(C, C.getArgs(), Inputs, C.getActions()); | |||
1340 | ||||
1341 | BuildJobs(C); | |||
1342 | ||||
1343 | // If there were errors building the compilation, quit now. | |||
1344 | if (Trap.hasErrorOccurred()) { | |||
1345 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1346 | << "Error generating preprocessed source(s)."; | |||
1347 | return; | |||
1348 | } | |||
1349 | ||||
1350 | // Generate preprocessed output. | |||
1351 | SmallVector<std::pair<int, const Command *>, 4> FailingCommands; | |||
1352 | C.ExecuteJobs(C.getJobs(), FailingCommands); | |||
1353 | ||||
1354 | // If any of the preprocessing commands failed, clean up and exit. | |||
1355 | if (!FailingCommands.empty()) { | |||
1356 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1357 | << "Error generating preprocessed source(s)."; | |||
1358 | return; | |||
1359 | } | |||
1360 | ||||
1361 | const ArgStringList &TempFiles = C.getTempFiles(); | |||
1362 | if (TempFiles.empty()) { | |||
1363 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1364 | << "Error generating preprocessed source(s)."; | |||
1365 | return; | |||
1366 | } | |||
1367 | ||||
1368 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1369 | << "\n********************\n\n" | |||
1370 | "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n" | |||
1371 | "Preprocessed source(s) and associated run script(s) are located at:"; | |||
1372 | ||||
1373 | SmallString<128> VFS; | |||
1374 | SmallString<128> ReproCrashFilename; | |||
1375 | for (const char *TempFile : TempFiles) { | |||
1376 | Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile; | |||
1377 | if (Report) | |||
1378 | Report->TemporaryFiles.push_back(TempFile); | |||
1379 | if (ReproCrashFilename.empty()) { | |||
1380 | ReproCrashFilename = TempFile; | |||
1381 | llvm::sys::path::replace_extension(ReproCrashFilename, ".crash"); | |||
1382 | } | |||
1383 | if (StringRef(TempFile).endswith(".cache")) { | |||
1384 | // In some cases (modules) we'll dump extra data to help with reproducing | |||
1385 | // the crash into a directory next to the output. | |||
1386 | VFS = llvm::sys::path::filename(TempFile); | |||
1387 | llvm::sys::path::append(VFS, "vfs", "vfs.yaml"); | |||
1388 | } | |||
1389 | } | |||
1390 | ||||
1391 | // Assume associated files are based off of the first temporary file. | |||
1392 | CrashReportInfo CrashInfo(TempFiles[0], VFS); | |||
1393 | ||||
1394 | llvm::SmallString<128> Script(CrashInfo.Filename); | |||
1395 | llvm::sys::path::replace_extension(Script, "sh"); | |||
1396 | std::error_code EC; | |||
1397 | llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::CD_CreateNew); | |||
1398 | if (EC) { | |||
1399 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1400 | << "Error generating run script: " << Script << " " << EC.message(); | |||
1401 | } else { | |||
1402 | ScriptOS << "# Crash reproducer for " << getClangFullVersion() << "\n" | |||
1403 | << "# Driver args: "; | |||
1404 | printArgList(ScriptOS, C.getInputArgs()); | |||
1405 | ScriptOS << "# Original command: "; | |||
1406 | Cmd.Print(ScriptOS, "\n", /*Quote=*/true); | |||
1407 | Cmd.Print(ScriptOS, "\n", /*Quote=*/true, &CrashInfo); | |||
1408 | if (!AdditionalInformation.empty()) | |||
1409 | ScriptOS << "\n# Additional information: " << AdditionalInformation | |||
1410 | << "\n"; | |||
1411 | if (Report) | |||
1412 | Report->TemporaryFiles.push_back(Script.str()); | |||
1413 | Diag(clang::diag::note_drv_command_failed_diag_msg) << Script; | |||
1414 | } | |||
1415 | ||||
1416 | // On darwin, provide information about the .crash diagnostic report. | |||
1417 | if (llvm::Triple(llvm::sys::getProcessTriple()).isOSDarwin()) { | |||
1418 | SmallString<128> CrashDiagDir; | |||
1419 | if (getCrashDiagnosticFile(ReproCrashFilename, CrashDiagDir)) { | |||
1420 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1421 | << ReproCrashFilename.str(); | |||
1422 | } else { // Suggest a directory for the user to look for .crash files. | |||
1423 | llvm::sys::path::append(CrashDiagDir, Name); | |||
1424 | CrashDiagDir += "_<YYYY-MM-DD-HHMMSS>_<hostname>.crash"; | |||
1425 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1426 | << "Crash backtrace is located in"; | |||
1427 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1428 | << CrashDiagDir.str(); | |||
1429 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1430 | << "(choose the .crash file that corresponds to your crash)"; | |||
1431 | } | |||
1432 | } | |||
1433 | ||||
1434 | for (const auto &A : C.getArgs().filtered(options::OPT_frewrite_map_file, | |||
1435 | options::OPT_frewrite_map_file_EQ)) | |||
1436 | Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue(); | |||
1437 | ||||
1438 | Diag(clang::diag::note_drv_command_failed_diag_msg) | |||
1439 | << "\n\n********************"; | |||
1440 | } | |||
1441 | ||||
1442 | void Driver::setUpResponseFiles(Compilation &C, Command &Cmd) { | |||
1443 | // Since commandLineFitsWithinSystemLimits() may underestimate system's | |||
1444 | // capacity if the tool does not support response files, there is a chance/ | |||
1445 | // that things will just work without a response file, so we silently just | |||
1446 | // skip it. | |||
1447 | if (Cmd.getCreator().getResponseFilesSupport() == Tool::RF_None || | |||
1448 | llvm::sys::commandLineFitsWithinSystemLimits(Cmd.getExecutable(), | |||
1449 | Cmd.getArguments())) | |||
1450 | return; | |||
1451 | ||||
1452 | std::string TmpName = GetTemporaryPath("response", "txt"); | |||
1453 | Cmd.setResponseFile(C.addTempFile(C.getArgs().MakeArgString(TmpName))); | |||
1454 | } | |||
1455 | ||||
1456 | int Driver::ExecuteCompilation( | |||
1457 | Compilation &C, | |||
1458 | SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) { | |||
1459 | // Just print if -### was present. | |||
1460 | if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { | |||
1461 | C.getJobs().Print(llvm::errs(), "\n", true); | |||
1462 | return 0; | |||
1463 | } | |||
1464 | ||||
1465 | // If there were errors building the compilation, quit now. | |||
1466 | if (Diags.hasErrorOccurred()) | |||
1467 | return 1; | |||
1468 | ||||
1469 | // Set up response file names for each command, if necessary | |||
1470 | for (auto &Job : C.getJobs()) | |||
1471 | setUpResponseFiles(C, Job); | |||
1472 | ||||
1473 | C.ExecuteJobs(C.getJobs(), FailingCommands); | |||
1474 | ||||
1475 | // If the command succeeded, we are done. | |||
1476 | if (FailingCommands.empty()) | |||
1477 | return 0; | |||
1478 | ||||
1479 | // Otherwise, remove result files and print extra information about abnormal | |||
1480 | // failures. | |||
1481 | int Res = 0; | |||
1482 | for (const auto &CmdPair : FailingCommands) { | |||
1483 | int CommandRes = CmdPair.first; | |||
1484 | const Command *FailingCommand = CmdPair.second; | |||
1485 | ||||
1486 | // Remove result files if we're not saving temps. | |||
1487 | if (!isSaveTempsEnabled()) { | |||
1488 | const JobAction *JA = cast<JobAction>(&FailingCommand->getSource()); | |||
1489 | C.CleanupFileMap(C.getResultFiles(), JA, true); | |||
1490 | ||||
1491 | // Failure result files are valid unless we crashed. | |||
1492 | if (CommandRes < 0) | |||
1493 | C.CleanupFileMap(C.getFailureResultFiles(), JA, true); | |||
1494 | } | |||
1495 | ||||
1496 | #if LLVM_ON_UNIX1 | |||
1497 | // llvm/lib/Support/Unix/Signals.inc will exit with a special return code | |||
1498 | // for SIGPIPE. Do not print diagnostics for this case. | |||
1499 | if (CommandRes == EX_IOERR74) { | |||
1500 | Res = CommandRes; | |||
1501 | continue; | |||
1502 | } | |||
1503 | #endif | |||
1504 | ||||
1505 | // Print extra information about abnormal failures, if possible. | |||
1506 | // | |||
1507 | // This is ad-hoc, but we don't want to be excessively noisy. If the result | |||
1508 | // status was 1, assume the command failed normally. In particular, if it | |||
1509 | // was the compiler then assume it gave a reasonable error code. Failures | |||
1510 | // in other tools are less common, and they generally have worse | |||
1511 | // diagnostics, so always print the diagnostic there. | |||
1512 | const Tool &FailingTool = FailingCommand->getCreator(); | |||
1513 | ||||
1514 | if (!FailingCommand->getCreator().hasGoodDiagnostics() || CommandRes != 1) { | |||
1515 | // FIXME: See FIXME above regarding result code interpretation. | |||
1516 | if (CommandRes < 0) | |||
1517 | Diag(clang::diag::err_drv_command_signalled) | |||
1518 | << FailingTool.getShortName(); | |||
1519 | else | |||
1520 | Diag(clang::diag::err_drv_command_failed) | |||
1521 | << FailingTool.getShortName() << CommandRes; | |||
1522 | } | |||
1523 | } | |||
1524 | return Res; | |||
1525 | } | |||
1526 | ||||
1527 | void Driver::PrintHelp(bool ShowHidden) const { | |||
1528 | unsigned IncludedFlagsBitmask; | |||
1529 | unsigned ExcludedFlagsBitmask; | |||
1530 | std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = | |||
1531 | getIncludeExcludeOptionFlagMasks(IsCLMode()); | |||
1532 | ||||
1533 | ExcludedFlagsBitmask |= options::NoDriverOption; | |||
1534 | if (!ShowHidden) | |||
1535 | ExcludedFlagsBitmask |= HelpHidden; | |||
1536 | ||||
1537 | std::string Usage = llvm::formatv("{0} [options] file...", Name).str(); | |||
1538 | getOpts().PrintHelp(llvm::outs(), Usage.c_str(), DriverTitle.c_str(), | |||
1539 | IncludedFlagsBitmask, ExcludedFlagsBitmask, | |||
1540 | /*ShowAllAliases=*/false); | |||
1541 | } | |||
1542 | ||||
1543 | void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const { | |||
1544 | // FIXME: The following handlers should use a callback mechanism, we don't | |||
1545 | // know what the client would like to do. | |||
1546 | OS << getClangFullVersion() << '\n'; | |||
1547 | const ToolChain &TC = C.getDefaultToolChain(); | |||
1548 | OS << "Target: " << TC.getTripleString() << '\n'; | |||
1549 | ||||
1550 | // Print the threading model. | |||
1551 | if (Arg *A = C.getArgs().getLastArg(options::OPT_mthread_model)) { | |||
1552 | // Don't print if the ToolChain would have barfed on it already | |||
1553 | if (TC.isThreadModelSupported(A->getValue())) | |||
1554 | OS << "Thread model: " << A->getValue(); | |||
1555 | } else | |||
1556 | OS << "Thread model: " << TC.getThreadModel(); | |||
1557 | OS << '\n'; | |||
1558 | ||||
1559 | // Print out the install directory. | |||
1560 | OS << "InstalledDir: " << InstalledDir << '\n'; | |||
1561 | ||||
1562 | // If configuration file was used, print its path. | |||
1563 | if (!ConfigFile.empty()) | |||
1564 | OS << "Configuration file: " << ConfigFile << '\n'; | |||
1565 | } | |||
1566 | ||||
1567 | /// PrintDiagnosticCategories - Implement the --print-diagnostic-categories | |||
1568 | /// option. | |||
1569 | static void PrintDiagnosticCategories(raw_ostream &OS) { | |||
1570 | // Skip the empty category. | |||
1571 | for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); i != max; | |||
1572 | ++i) | |||
1573 | OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n'; | |||
1574 | } | |||
1575 | ||||
1576 | void Driver::HandleAutocompletions(StringRef PassedFlags) const { | |||
1577 | if (PassedFlags == "") | |||
1578 | return; | |||
1579 | // Print out all options that start with a given argument. This is used for | |||
1580 | // shell autocompletion. | |||
1581 | std::vector<std::string> SuggestedCompletions; | |||
1582 | std::vector<std::string> Flags; | |||
1583 | ||||
1584 | unsigned short DisableFlags = | |||
1585 | options::NoDriverOption | options::Unsupported | options::Ignored; | |||
1586 | ||||
1587 | // Distinguish "--autocomplete=-someflag" and "--autocomplete=-someflag," | |||
1588 | // because the latter indicates that the user put space before pushing tab | |||
1589 | // which should end up in a file completion. | |||
1590 | const bool HasSpace = PassedFlags.endswith(","); | |||
1591 | ||||
1592 | // Parse PassedFlags by "," as all the command-line flags are passed to this | |||
1593 | // function separated by "," | |||
1594 | StringRef TargetFlags = PassedFlags; | |||
1595 | while (TargetFlags != "") { | |||
1596 | StringRef CurFlag; | |||
1597 | std::tie(CurFlag, TargetFlags) = TargetFlags.split(","); | |||
1598 | Flags.push_back(std::string(CurFlag)); | |||
1599 | } | |||
1600 | ||||
1601 | // We want to show cc1-only options only when clang is invoked with -cc1 or | |||
1602 | // -Xclang. | |||
1603 | if (llvm::is_contained(Flags, "-Xclang") || llvm::is_contained(Flags, "-cc1")) | |||
1604 | DisableFlags &= ~options::NoDriverOption; | |||
1605 | ||||
1606 | const llvm::opt::OptTable &Opts = getOpts(); | |||
1607 | StringRef Cur; | |||
1608 | Cur = Flags.at(Flags.size() - 1); | |||
1609 | StringRef Prev; | |||
1610 | if (Flags.size() >= 2) { | |||
1611 | Prev = Flags.at(Flags.size() - 2); | |||
1612 | SuggestedCompletions = Opts.suggestValueCompletions(Prev, Cur); | |||
1613 | } | |||
1614 | ||||
1615 | if (SuggestedCompletions.empty()) | |||
1616 | SuggestedCompletions = Opts.suggestValueCompletions(Cur, ""); | |||
1617 | ||||
1618 | // If Flags were empty, it means the user typed `clang [tab]` where we should | |||
1619 | // list all possible flags. If there was no value completion and the user | |||
1620 | // pressed tab after a space, we should fall back to a file completion. | |||
1621 | // We're printing a newline to be consistent with what we print at the end of | |||
1622 | // this function. | |||
1623 | if (SuggestedCompletions.empty() && HasSpace && !Flags.empty()) { | |||
1624 | llvm::outs() << '\n'; | |||
1625 | return; | |||
1626 | } | |||
1627 | ||||
1628 | // When flag ends with '=' and there was no value completion, return empty | |||
1629 | // string and fall back to the file autocompletion. | |||
1630 | if (SuggestedCompletions.empty() && !Cur.endswith("=")) { | |||
1631 | // If the flag is in the form of "--autocomplete=-foo", | |||
1632 | // we were requested to print out all option names that start with "-foo". | |||
1633 | // For example, "--autocomplete=-fsyn" is expanded to "-fsyntax-only". | |||
1634 | SuggestedCompletions = Opts.findByPrefix(Cur, DisableFlags); | |||
1635 | ||||
1636 | // We have to query the -W flags manually as they're not in the OptTable. | |||
1637 | // TODO: Find a good way to add them to OptTable instead and them remove | |||
1638 | // this code. | |||
1639 | for (StringRef S : DiagnosticIDs::getDiagnosticFlags()) | |||
1640 | if (S.startswith(Cur)) | |||
1641 | SuggestedCompletions.push_back(S); | |||
1642 | } | |||
1643 | ||||
1644 | // Sort the autocomplete candidates so that shells print them out in a | |||
1645 | // deterministic order. We could sort in any way, but we chose | |||
1646 | // case-insensitive sorting for consistency with the -help option | |||
1647 | // which prints out options in the case-insensitive alphabetical order. | |||
1648 | llvm::sort(SuggestedCompletions, [](StringRef A, StringRef B) { | |||
1649 | if (int X = A.compare_lower(B)) | |||
1650 | return X < 0; | |||
1651 | return A.compare(B) > 0; | |||
1652 | }); | |||
1653 | ||||
1654 | llvm::outs() << llvm::join(SuggestedCompletions, "\n") << '\n'; | |||
1655 | } | |||
1656 | ||||
1657 | bool Driver::HandleImmediateArgs(const Compilation &C) { | |||
1658 | // The order these options are handled in gcc is all over the place, but we | |||
1659 | // don't expect inconsistencies w.r.t. that to matter in practice. | |||
1660 | ||||
1661 | if (C.getArgs().hasArg(options::OPT_dumpmachine)) { | |||
1662 | llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n'; | |||
1663 | return false; | |||
1664 | } | |||
1665 | ||||
1666 | if (C.getArgs().hasArg(options::OPT_dumpversion)) { | |||
1667 | // Since -dumpversion is only implemented for pedantic GCC compatibility, we | |||
1668 | // return an answer which matches our definition of __VERSION__. | |||
1669 | llvm::outs() << CLANG_VERSION_STRING"10.0.0" << "\n"; | |||
1670 | return false; | |||
1671 | } | |||
1672 | ||||
1673 | if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) { | |||
1674 | PrintDiagnosticCategories(llvm::outs()); | |||
1675 | return false; | |||
1676 | } | |||
1677 | ||||
1678 | if (C.getArgs().hasArg(options::OPT_help) || | |||
1679 | C.getArgs().hasArg(options::OPT__help_hidden)) { | |||
1680 | PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden)); | |||
1681 | return false; | |||
1682 | } | |||
1683 | ||||
1684 | if (C.getArgs().hasArg(options::OPT__version)) { | |||
1685 | // Follow gcc behavior and use stdout for --version and stderr for -v. | |||
1686 | PrintVersion(C, llvm::outs()); | |||
1687 | return false; | |||
1688 | } | |||
1689 | ||||
1690 | if (C.getArgs().hasArg(options::OPT_v) || | |||
1691 | C.getArgs().hasArg(options::OPT__HASH_HASH_HASH) || | |||
1692 | C.getArgs().hasArg(options::OPT_print_supported_cpus)) { | |||
1693 | PrintVersion(C, llvm::errs()); | |||
1694 | SuppressMissingInputWarning = true; | |||
1695 | } | |||
1696 | ||||
1697 | if (C.getArgs().hasArg(options::OPT_v)) { | |||
1698 | if (!SystemConfigDir.empty()) | |||
1699 | llvm::errs() << "System configuration file directory: " | |||
1700 | << SystemConfigDir << "\n"; | |||
1701 | if (!UserConfigDir.empty()) | |||
1702 | llvm::errs() << "User configuration file directory: " | |||
1703 | << UserConfigDir << "\n"; | |||
1704 | } | |||
1705 | ||||
1706 | const ToolChain &TC = C.getDefaultToolChain(); | |||
1707 | ||||
1708 | if (C.getArgs().hasArg(options::OPT_v)) | |||
1709 | TC.printVerboseInfo(llvm::errs()); | |||
1710 | ||||
1711 | if (C.getArgs().hasArg(options::OPT_print_resource_dir)) { | |||
1712 | llvm::outs() << ResourceDir << '\n'; | |||
1713 | return false; | |||
1714 | } | |||
1715 | ||||
1716 | if (C.getArgs().hasArg(options::OPT_print_search_dirs)) { | |||
1717 | llvm::outs() << "programs: ="; | |||
1718 | bool separator = false; | |||
1719 | for (const std::string &Path : TC.getProgramPaths()) { | |||
1720 | if (separator) | |||
1721 | llvm::outs() << llvm::sys::EnvPathSeparator; | |||
1722 | llvm::outs() << Path; | |||
1723 | separator = true; | |||
1724 | } | |||
1725 | llvm::outs() << "\n"; | |||
1726 | llvm::outs() << "libraries: =" << ResourceDir; | |||
1727 | ||||
1728 | StringRef sysroot = C.getSysRoot(); | |||
1729 | ||||
1730 | for (const std::string &Path : TC.getFilePaths()) { | |||
1731 | // Always print a separator. ResourceDir was the first item shown. | |||
1732 | llvm::outs() << llvm::sys::EnvPathSeparator; | |||
1733 | // Interpretation of leading '=' is needed only for NetBSD. | |||
1734 | if (Path[0] == '=') | |||
1735 | llvm::outs() << sysroot << Path.substr(1); | |||
1736 | else | |||
1737 | llvm::outs() << Path; | |||
1738 | } | |||
1739 | llvm::outs() << "\n"; | |||
1740 | return false; | |||
1741 | } | |||
1742 | ||||
1743 | // FIXME: The following handlers should use a callback mechanism, we don't | |||
1744 | // know what the client would like to do. | |||
1745 | if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) { | |||
1746 | llvm::outs() << GetFilePath(A->getValue(), TC) << "\n"; | |||
1747 | return false; | |||
1748 | } | |||
1749 | ||||
1750 | if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) { | |||
1751 | StringRef ProgName = A->getValue(); | |||
1752 | ||||
1753 | // Null program name cannot have a path. | |||
1754 | if (! ProgName.empty()) | |||
1755 | llvm::outs() << GetProgramPath(ProgName, TC); | |||
1756 | ||||
1757 | llvm::outs() << "\n"; | |||
1758 | return false; | |||
1759 | } | |||
1760 | ||||
1761 | if (Arg *A = C.getArgs().getLastArg(options::OPT_autocomplete)) { | |||
1762 | StringRef PassedFlags = A->getValue(); | |||
1763 | HandleAutocompletions(PassedFlags); | |||
1764 | return false; | |||
1765 | } | |||
1766 | ||||
1767 | if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) { | |||
1768 | ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(C.getArgs()); | |||
1769 | const llvm::Triple Triple(TC.ComputeEffectiveClangTriple(C.getArgs())); | |||
1770 | RegisterEffectiveTriple TripleRAII(TC, Triple); | |||
1771 | switch (RLT) { | |||
1772 | case ToolChain::RLT_CompilerRT: | |||
1773 | llvm::outs() << TC.getCompilerRT(C.getArgs(), "builtins") << "\n"; | |||
1774 | break; | |||
1775 | case ToolChain::RLT_Libgcc: | |||
1776 | llvm::outs() << GetFilePath("libgcc.a", TC) << "\n"; | |||
1777 | break; | |||
1778 | } | |||
1779 | return false; | |||
1780 | } | |||
1781 | ||||
1782 | if (C.getArgs().hasArg(options::OPT_print_multi_lib)) { | |||
1783 | for (const Multilib &Multilib : TC.getMultilibs()) | |||
1784 | llvm::outs() << Multilib << "\n"; | |||
1785 | return false; | |||
1786 | } | |||
1787 | ||||
1788 | if (C.getArgs().hasArg(options::OPT_print_multi_directory)) { | |||
1789 | const Multilib &Multilib = TC.getMultilib(); | |||
1790 | if (Multilib.gccSuffix().empty()) | |||
1791 | llvm::outs() << ".\n"; | |||
1792 | else { | |||
1793 | StringRef Suffix(Multilib.gccSuffix()); | |||
1794 | assert(Suffix.front() == '/')((Suffix.front() == '/') ? static_cast<void> (0) : __assert_fail ("Suffix.front() == '/'", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 1794, __PRETTY_FUNCTION__)); | |||
1795 | llvm::outs() << Suffix.substr(1) << "\n"; | |||
1796 | } | |||
1797 | return false; | |||
1798 | } | |||
1799 | ||||
1800 | if (C.getArgs().hasArg(options::OPT_print_target_triple)) { | |||
1801 | llvm::outs() << TC.getTripleString() << "\n"; | |||
1802 | return false; | |||
1803 | } | |||
1804 | ||||
1805 | if (C.getArgs().hasArg(options::OPT_print_effective_triple)) { | |||
1806 | const llvm::Triple Triple(TC.ComputeEffectiveClangTriple(C.getArgs())); | |||
1807 | llvm::outs() << Triple.getTriple() << "\n"; | |||
1808 | return false; | |||
1809 | } | |||
1810 | ||||
1811 | return true; | |||
1812 | } | |||
1813 | ||||
1814 | enum { | |||
1815 | TopLevelAction = 0, | |||
1816 | HeadSibAction = 1, | |||
1817 | OtherSibAction = 2, | |||
1818 | }; | |||
1819 | ||||
1820 | // Display an action graph human-readably. Action A is the "sink" node | |||
1821 | // and latest-occuring action. Traversal is in pre-order, visiting the | |||
1822 | // inputs to each action before printing the action itself. | |||
1823 | static unsigned PrintActions1(const Compilation &C, Action *A, | |||
1824 | std::map<Action *, unsigned> &Ids, | |||
1825 | Twine Indent = {}, int Kind = TopLevelAction) { | |||
1826 | if (Ids.count(A)) // A was already visited. | |||
1827 | return Ids[A]; | |||
1828 | ||||
1829 | std::string str; | |||
1830 | llvm::raw_string_ostream os(str); | |||
1831 | ||||
1832 | auto getSibIndent = [](int K) -> Twine { | |||
1833 | return (K == HeadSibAction) ? " " : (K == OtherSibAction) ? "| " : ""; | |||
1834 | }; | |||
1835 | ||||
1836 | Twine SibIndent = Indent + getSibIndent(Kind); | |||
1837 | int SibKind = HeadSibAction; | |||
1838 | os << Action::getClassName(A->getKind()) << ", "; | |||
1839 | if (InputAction *IA = dyn_cast<InputAction>(A)) { | |||
1840 | os << "\"" << IA->getInputArg().getValue() << "\""; | |||
1841 | } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) { | |||
1842 | os << '"' << BIA->getArchName() << '"' << ", {" | |||
1843 | << PrintActions1(C, *BIA->input_begin(), Ids, SibIndent, SibKind) << "}"; | |||
1844 | } else if (OffloadAction *OA = dyn_cast<OffloadAction>(A)) { | |||
1845 | bool IsFirst = true; | |||
1846 | OA->doOnEachDependence( | |||
1847 | [&](Action *A, const ToolChain *TC, const char *BoundArch) { | |||
1848 | // E.g. for two CUDA device dependences whose bound arch is sm_20 and | |||
1849 | // sm_35 this will generate: | |||
1850 | // "cuda-device" (nvptx64-nvidia-cuda:sm_20) {#ID}, "cuda-device" | |||
1851 | // (nvptx64-nvidia-cuda:sm_35) {#ID} | |||
1852 | if (!IsFirst) | |||
| ||||
1853 | os << ", "; | |||
1854 | os << '"'; | |||
1855 | if (TC) | |||
1856 | os << A->getOffloadingKindPrefix(); | |||
1857 | else | |||
1858 | os << "host"; | |||
1859 | os << " ("; | |||
1860 | os << TC->getTriple().normalize(); | |||
| ||||
1861 | ||||
1862 | if (BoundArch) | |||
1863 | os << ":" << BoundArch; | |||
1864 | os << ")"; | |||
1865 | os << '"'; | |||
1866 | os << " {" << PrintActions1(C, A, Ids, SibIndent, SibKind) << "}"; | |||
1867 | IsFirst = false; | |||
1868 | SibKind = OtherSibAction; | |||
1869 | }); | |||
1870 | } else { | |||
1871 | const ActionList *AL = &A->getInputs(); | |||
1872 | ||||
1873 | if (AL->size()) { | |||
1874 | const char *Prefix = "{"; | |||
1875 | for (Action *PreRequisite : *AL) { | |||
1876 | os << Prefix << PrintActions1(C, PreRequisite, Ids, SibIndent, SibKind); | |||
1877 | Prefix = ", "; | |||
1878 | SibKind = OtherSibAction; | |||
1879 | } | |||
1880 | os << "}"; | |||
1881 | } else | |||
1882 | os << "{}"; | |||
1883 | } | |||
1884 | ||||
1885 | // Append offload info for all options other than the offloading action | |||
1886 | // itself (e.g. (cuda-device, sm_20) or (cuda-host)). | |||
1887 | std::string offload_str; | |||
1888 | llvm::raw_string_ostream offload_os(offload_str); | |||
1889 | if (!isa<OffloadAction>(A)) { | |||
1890 | auto S = A->getOffloadingKindPrefix(); | |||
1891 | if (!S.empty()) { | |||
1892 | offload_os << ", (" << S; | |||
1893 | if (A->getOffloadingArch()) | |||
1894 | offload_os << ", " << A->getOffloadingArch(); | |||
1895 | offload_os << ")"; | |||
1896 | } | |||
1897 | } | |||
1898 | ||||
1899 | auto getSelfIndent = [](int K) -> Twine { | |||
1900 | return (K == HeadSibAction) ? "+- " : (K == OtherSibAction) ? "|- " : ""; | |||
1901 | }; | |||
1902 | ||||
1903 | unsigned Id = Ids.size(); | |||
1904 | Ids[A] = Id; | |||
1905 | llvm::errs() << Indent + getSelfIndent(Kind) << Id << ": " << os.str() << ", " | |||
1906 | << types::getTypeName(A->getType()) << offload_os.str() << "\n"; | |||
1907 | ||||
1908 | return Id; | |||
1909 | } | |||
1910 | ||||
1911 | // Print the action graphs in a compilation C. | |||
1912 | // For example "clang -c file1.c file2.c" is composed of two subgraphs. | |||
1913 | void Driver::PrintActions(const Compilation &C) const { | |||
1914 | std::map<Action *, unsigned> Ids; | |||
1915 | for (Action *A : C.getActions()) | |||
1916 | PrintActions1(C, A, Ids); | |||
1917 | } | |||
1918 | ||||
1919 | /// Check whether the given input tree contains any compilation or | |||
1920 | /// assembly actions. | |||
1921 | static bool ContainsCompileOrAssembleAction(const Action *A) { | |||
1922 | if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) || | |||
1923 | isa<AssembleJobAction>(A)) | |||
1924 | return true; | |||
1925 | ||||
1926 | for (const Action *Input : A->inputs()) | |||
1927 | if (ContainsCompileOrAssembleAction(Input)) | |||
1928 | return true; | |||
1929 | ||||
1930 | return false; | |||
1931 | } | |||
1932 | ||||
1933 | void Driver::BuildUniversalActions(Compilation &C, const ToolChain &TC, | |||
1934 | const InputList &BAInputs) const { | |||
1935 | DerivedArgList &Args = C.getArgs(); | |||
1936 | ActionList &Actions = C.getActions(); | |||
1937 | llvm::PrettyStackTraceString CrashInfo("Building universal build actions"); | |||
1938 | // Collect the list of architectures. Duplicates are allowed, but should only | |||
1939 | // be handled once (in the order seen). | |||
1940 | llvm::StringSet<> ArchNames; | |||
1941 | SmallVector<const char *, 4> Archs; | |||
1942 | for (Arg *A : Args) { | |||
1943 | if (A->getOption().matches(options::OPT_arch)) { | |||
1944 | // Validate the option here; we don't save the type here because its | |||
1945 | // particular spelling may participate in other driver choices. | |||
1946 | llvm::Triple::ArchType Arch = | |||
1947 | tools::darwin::getArchTypeForMachOArchName(A->getValue()); | |||
1948 | if (Arch == llvm::Triple::UnknownArch) { | |||
1949 | Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args); | |||
1950 | continue; | |||
1951 | } | |||
1952 | ||||
1953 | A->claim(); | |||
1954 | if (ArchNames.insert(A->getValue()).second) | |||
1955 | Archs.push_back(A->getValue()); | |||
1956 | } | |||
1957 | } | |||
1958 | ||||
1959 | // When there is no explicit arch for this platform, make sure we still bind | |||
1960 | // the architecture (to the default) so that -Xarch_ is handled correctly. | |||
1961 | if (!Archs.size()) | |||
1962 | Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName())); | |||
1963 | ||||
1964 | ActionList SingleActions; | |||
1965 | BuildActions(C, Args, BAInputs, SingleActions); | |||
1966 | ||||
1967 | // Add in arch bindings for every top level action, as well as lipo and | |||
1968 | // dsymutil steps if needed. | |||
1969 | for (Action* Act : SingleActions) { | |||
1970 | // Make sure we can lipo this kind of output. If not (and it is an actual | |||
1971 | // output) then we disallow, since we can't create an output file with the | |||
1972 | // right name without overwriting it. We could remove this oddity by just | |||
1973 | // changing the output names to include the arch, which would also fix | |||
1974 | // -save-temps. Compatibility wins for now. | |||
1975 | ||||
1976 | if (Archs.size() > 1 && !types::canLipoType(Act->getType())) | |||
1977 | Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) | |||
1978 | << types::getTypeName(Act->getType()); | |||
1979 | ||||
1980 | ActionList Inputs; | |||
1981 | for (unsigned i = 0, e = Archs.size(); i != e; ++i) | |||
1982 | Inputs.push_back(C.MakeAction<BindArchAction>(Act, Archs[i])); | |||
1983 | ||||
1984 | // Lipo if necessary, we do it this way because we need to set the arch flag | |||
1985 | // so that -Xarch_ gets overwritten. | |||
1986 | if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing) | |||
1987 | Actions.append(Inputs.begin(), Inputs.end()); | |||
1988 | else | |||
1989 | Actions.push_back(C.MakeAction<LipoJobAction>(Inputs, Act->getType())); | |||
1990 | ||||
1991 | // Handle debug info queries. | |||
1992 | Arg *A = Args.getLastArg(options::OPT_g_Group); | |||
1993 | bool enablesDebugInfo = A && !A->getOption().matches(options::OPT_g0) && | |||
1994 | !A->getOption().matches(options::OPT_gstabs); | |||
1995 | if ((enablesDebugInfo || willEmitRemarks(Args)) && | |||
1996 | ContainsCompileOrAssembleAction(Actions.back())) { | |||
1997 | ||||
1998 | // Add a 'dsymutil' step if necessary, when debug info is enabled and we | |||
1999 | // have a compile input. We need to run 'dsymutil' ourselves in such cases | |||
2000 | // because the debug info will refer to a temporary object file which | |||
2001 | // will be removed at the end of the compilation process. | |||
2002 | if (Act->getType() == types::TY_Image) { | |||
2003 | ActionList Inputs; | |||
2004 | Inputs.push_back(Actions.back()); | |||
2005 | Actions.pop_back(); | |||
2006 | Actions.push_back( | |||
2007 | C.MakeAction<DsymutilJobAction>(Inputs, types::TY_dSYM)); | |||
2008 | } | |||
2009 | ||||
2010 | // Verify the debug info output. | |||
2011 | if (Args.hasArg(options::OPT_verify_debug_info)) { | |||
2012 | Action* LastAction = Actions.back(); | |||
2013 | Actions.pop_back(); | |||
2014 | Actions.push_back(C.MakeAction<VerifyDebugInfoJobAction>( | |||
2015 | LastAction, types::TY_Nothing)); | |||
2016 | } | |||
2017 | } | |||
2018 | } | |||
2019 | } | |||
2020 | ||||
2021 | bool Driver::DiagnoseInputExistence(const DerivedArgList &Args, StringRef Value, | |||
2022 | types::ID Ty, bool TypoCorrect) const { | |||
2023 | if (!getCheckInputsExist()) | |||
2024 | return true; | |||
2025 | ||||
2026 | // stdin always exists. | |||
2027 | if (Value == "-") | |||
2028 | return true; | |||
2029 | ||||
2030 | if (getVFS().exists(Value)) | |||
2031 | return true; | |||
2032 | ||||
2033 | if (IsCLMode()) { | |||
2034 | if (!llvm::sys::path::is_absolute(Twine(Value)) && | |||
2035 | llvm::sys::Process::FindInEnvPath("LIB", Value)) | |||
2036 | return true; | |||
2037 | ||||
2038 | if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) { | |||
2039 | // Arguments to the /link flag might cause the linker to search for object | |||
2040 | // and library files in paths we don't know about. Don't error in such | |||
2041 | // cases. | |||
2042 | return true; | |||
2043 | } | |||
2044 | } | |||
2045 | ||||
2046 | if (TypoCorrect) { | |||
2047 | // Check if the filename is a typo for an option flag. OptTable thinks | |||
2048 | // that all args that are not known options and that start with / are | |||
2049 | // filenames, but e.g. `/diagnostic:caret` is more likely a typo for | |||
2050 | // the option `/diagnostics:caret` than a reference to a file in the root | |||
2051 | // directory. | |||
2052 | unsigned IncludedFlagsBitmask; | |||
2053 | unsigned ExcludedFlagsBitmask; | |||
2054 | std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = | |||
2055 | getIncludeExcludeOptionFlagMasks(IsCLMode()); | |||
2056 | std::string Nearest; | |||
2057 | if (getOpts().findNearest(Value, Nearest, IncludedFlagsBitmask, | |||
2058 | ExcludedFlagsBitmask) <= 1) { | |||
2059 | Diag(clang::diag::err_drv_no_such_file_with_suggestion) | |||
2060 | << Value << Nearest; | |||
2061 | return false; | |||
2062 | } | |||
2063 | } | |||
2064 | ||||
2065 | Diag(clang::diag::err_drv_no_such_file) << Value; | |||
2066 | return false; | |||
2067 | } | |||
2068 | ||||
2069 | // Construct a the list of inputs and their types. | |||
2070 | void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args, | |||
2071 | InputList &Inputs) const { | |||
2072 | const llvm::opt::OptTable &Opts = getOpts(); | |||
2073 | // Track the current user specified (-x) input. We also explicitly track the | |||
2074 | // argument used to set the type; we only want to claim the type when we | |||
2075 | // actually use it, so we warn about unused -x arguments. | |||
2076 | types::ID InputType = types::TY_Nothing; | |||
2077 | Arg *InputTypeArg = nullptr; | |||
2078 | ||||
2079 | // The last /TC or /TP option sets the input type to C or C++ globally. | |||
2080 | if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC, | |||
2081 | options::OPT__SLASH_TP)) { | |||
2082 | InputTypeArg = TCTP; | |||
2083 | InputType = TCTP->getOption().matches(options::OPT__SLASH_TC) | |||
2084 | ? types::TY_C | |||
2085 | : types::TY_CXX; | |||
2086 | ||||
2087 | Arg *Previous = nullptr; | |||
2088 | bool ShowNote = false; | |||
2089 | for (Arg *A : | |||
2090 | Args.filtered(options::OPT__SLASH_TC, options::OPT__SLASH_TP)) { | |||
2091 | if (Previous) { | |||
2092 | Diag(clang::diag::warn_drv_overriding_flag_option) | |||
2093 | << Previous->getSpelling() << A->getSpelling(); | |||
2094 | ShowNote = true; | |||
2095 | } | |||
2096 | Previous = A; | |||
2097 | } | |||
2098 | if (ShowNote) | |||
2099 | Diag(clang::diag::note_drv_t_option_is_global); | |||
2100 | ||||
2101 | // No driver mode exposes -x and /TC or /TP; we don't support mixing them. | |||
2102 | assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed")((!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed" ) ? static_cast<void> (0) : __assert_fail ("!Args.hasArg(options::OPT_x) && \"-x and /TC or /TP is not allowed\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2102, __PRETTY_FUNCTION__)); | |||
2103 | } | |||
2104 | ||||
2105 | for (Arg *A : Args) { | |||
2106 | if (A->getOption().getKind() == Option::InputClass) { | |||
2107 | const char *Value = A->getValue(); | |||
2108 | types::ID Ty = types::TY_INVALID; | |||
2109 | ||||
2110 | // Infer the input type if necessary. | |||
2111 | if (InputType == types::TY_Nothing) { | |||
2112 | // If there was an explicit arg for this, claim it. | |||
2113 | if (InputTypeArg) | |||
2114 | InputTypeArg->claim(); | |||
2115 | ||||
2116 | // stdin must be handled specially. | |||
2117 | if (memcmp(Value, "-", 2) == 0) { | |||
2118 | // If running with -E, treat as a C input (this changes the builtin | |||
2119 | // macros, for example). This may be overridden by -ObjC below. | |||
2120 | // | |||
2121 | // Otherwise emit an error but still use a valid type to avoid | |||
2122 | // spurious errors (e.g., no inputs). | |||
2123 | if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP()) | |||
2124 | Diag(IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl | |||
2125 | : clang::diag::err_drv_unknown_stdin_type); | |||
2126 | Ty = types::TY_C; | |||
2127 | } else { | |||
2128 | // Otherwise lookup by extension. | |||
2129 | // Fallback is C if invoked as C preprocessor, C++ if invoked with | |||
2130 | // clang-cl /E, or Object otherwise. | |||
2131 | // We use a host hook here because Darwin at least has its own | |||
2132 | // idea of what .s is. | |||
2133 | if (const char *Ext = strrchr(Value, '.')) | |||
2134 | Ty = TC.LookupTypeForExtension(Ext + 1); | |||
2135 | ||||
2136 | if (Ty == types::TY_INVALID) { | |||
2137 | if (CCCIsCPP()) | |||
2138 | Ty = types::TY_C; | |||
2139 | else if (IsCLMode() && Args.hasArgNoClaim(options::OPT_E)) | |||
2140 | Ty = types::TY_CXX; | |||
2141 | else | |||
2142 | Ty = types::TY_Object; | |||
2143 | } | |||
2144 | ||||
2145 | // If the driver is invoked as C++ compiler (like clang++ or c++) it | |||
2146 | // should autodetect some input files as C++ for g++ compatibility. | |||
2147 | if (CCCIsCXX()) { | |||
2148 | types::ID OldTy = Ty; | |||
2149 | Ty = types::lookupCXXTypeForCType(Ty); | |||
2150 | ||||
2151 | if (Ty != OldTy) | |||
2152 | Diag(clang::diag::warn_drv_treating_input_as_cxx) | |||
2153 | << getTypeName(OldTy) << getTypeName(Ty); | |||
2154 | } | |||
2155 | ||||
2156 | // If running with -fthinlto-index=, extensions that normally identify | |||
2157 | // native object files actually identify LLVM bitcode files. | |||
2158 | if (Args.hasArgNoClaim(options::OPT_fthinlto_index_EQ) && | |||
2159 | Ty == types::TY_Object) | |||
2160 | Ty = types::TY_LLVM_BC; | |||
2161 | } | |||
2162 | ||||
2163 | // -ObjC and -ObjC++ override the default language, but only for "source | |||
2164 | // files". We just treat everything that isn't a linker input as a | |||
2165 | // source file. | |||
2166 | // | |||
2167 | // FIXME: Clean this up if we move the phase sequence into the type. | |||
2168 | if (Ty != types::TY_Object) { | |||
2169 | if (Args.hasArg(options::OPT_ObjC)) | |||
2170 | Ty = types::TY_ObjC; | |||
2171 | else if (Args.hasArg(options::OPT_ObjCXX)) | |||
2172 | Ty = types::TY_ObjCXX; | |||
2173 | } | |||
2174 | } else { | |||
2175 | assert(InputTypeArg && "InputType set w/o InputTypeArg")((InputTypeArg && "InputType set w/o InputTypeArg") ? static_cast<void> (0) : __assert_fail ("InputTypeArg && \"InputType set w/o InputTypeArg\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2175, __PRETTY_FUNCTION__)); | |||
2176 | if (!InputTypeArg->getOption().matches(options::OPT_x)) { | |||
2177 | // If emulating cl.exe, make sure that /TC and /TP don't affect input | |||
2178 | // object files. | |||
2179 | const char *Ext = strrchr(Value, '.'); | |||
2180 | if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object) | |||
2181 | Ty = types::TY_Object; | |||
2182 | } | |||
2183 | if (Ty == types::TY_INVALID) { | |||
2184 | Ty = InputType; | |||
2185 | InputTypeArg->claim(); | |||
2186 | } | |||
2187 | } | |||
2188 | ||||
2189 | if (DiagnoseInputExistence(Args, Value, Ty, /*TypoCorrect=*/true)) | |||
2190 | Inputs.push_back(std::make_pair(Ty, A)); | |||
2191 | ||||
2192 | } else if (A->getOption().matches(options::OPT__SLASH_Tc)) { | |||
2193 | StringRef Value = A->getValue(); | |||
2194 | if (DiagnoseInputExistence(Args, Value, types::TY_C, | |||
2195 | /*TypoCorrect=*/false)) { | |||
2196 | Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); | |||
2197 | Inputs.push_back(std::make_pair(types::TY_C, InputArg)); | |||
2198 | } | |||
2199 | A->claim(); | |||
2200 | } else if (A->getOption().matches(options::OPT__SLASH_Tp)) { | |||
2201 | StringRef Value = A->getValue(); | |||
2202 | if (DiagnoseInputExistence(Args, Value, types::TY_CXX, | |||
2203 | /*TypoCorrect=*/false)) { | |||
2204 | Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); | |||
2205 | Inputs.push_back(std::make_pair(types::TY_CXX, InputArg)); | |||
2206 | } | |||
2207 | A->claim(); | |||
2208 | } else if (A->getOption().hasFlag(options::LinkerInput)) { | |||
2209 | // Just treat as object type, we could make a special type for this if | |||
2210 | // necessary. | |||
2211 | Inputs.push_back(std::make_pair(types::TY_Object, A)); | |||
2212 | ||||
2213 | } else if (A->getOption().matches(options::OPT_x)) { | |||
2214 | InputTypeArg = A; | |||
2215 | InputType = types::lookupTypeForTypeSpecifier(A->getValue()); | |||
2216 | A->claim(); | |||
2217 | ||||
2218 | // Follow gcc behavior and treat as linker input for invalid -x | |||
2219 | // options. Its not clear why we shouldn't just revert to unknown; but | |||
2220 | // this isn't very important, we might as well be bug compatible. | |||
2221 | if (!InputType) { | |||
2222 | Diag(clang::diag::err_drv_unknown_language) << A->getValue(); | |||
2223 | InputType = types::TY_Object; | |||
2224 | } | |||
2225 | } else if (A->getOption().getID() == options::OPT_U) { | |||
2226 | assert(A->getNumValues() == 1 && "The /U option has one value.")((A->getNumValues() == 1 && "The /U option has one value." ) ? static_cast<void> (0) : __assert_fail ("A->getNumValues() == 1 && \"The /U option has one value.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2226, __PRETTY_FUNCTION__)); | |||
2227 | StringRef Val = A->getValue(0); | |||
2228 | if (Val.find_first_of("/\\") != StringRef::npos) { | |||
2229 | // Warn about e.g. "/Users/me/myfile.c". | |||
2230 | Diag(diag::warn_slash_u_filename) << Val; | |||
2231 | Diag(diag::note_use_dashdash); | |||
2232 | } | |||
2233 | } | |||
2234 | } | |||
2235 | if (CCCIsCPP() && Inputs.empty()) { | |||
2236 | // If called as standalone preprocessor, stdin is processed | |||
2237 | // if no other input is present. | |||
2238 | Arg *A = MakeInputArg(Args, Opts, "-"); | |||
2239 | Inputs.push_back(std::make_pair(types::TY_C, A)); | |||
2240 | } | |||
2241 | } | |||
2242 | ||||
2243 | namespace { | |||
2244 | /// Provides a convenient interface for different programming models to generate | |||
2245 | /// the required device actions. | |||
2246 | class OffloadingActionBuilder final { | |||
2247 | /// Flag used to trace errors in the builder. | |||
2248 | bool IsValid = false; | |||
2249 | ||||
2250 | /// The compilation that is using this builder. | |||
2251 | Compilation &C; | |||
2252 | ||||
2253 | /// Map between an input argument and the offload kinds used to process it. | |||
2254 | std::map<const Arg *, unsigned> InputArgToOffloadKindMap; | |||
2255 | ||||
2256 | /// Builder interface. It doesn't build anything or keep any state. | |||
2257 | class DeviceActionBuilder { | |||
2258 | public: | |||
2259 | typedef const llvm::SmallVectorImpl<phases::ID> PhasesTy; | |||
2260 | ||||
2261 | enum ActionBuilderReturnCode { | |||
2262 | // The builder acted successfully on the current action. | |||
2263 | ABRT_Success, | |||
2264 | // The builder didn't have to act on the current action. | |||
2265 | ABRT_Inactive, | |||
2266 | // The builder was successful and requested the host action to not be | |||
2267 | // generated. | |||
2268 | ABRT_Ignore_Host, | |||
2269 | }; | |||
2270 | ||||
2271 | protected: | |||
2272 | /// Compilation associated with this builder. | |||
2273 | Compilation &C; | |||
2274 | ||||
2275 | /// Tool chains associated with this builder. The same programming | |||
2276 | /// model may have associated one or more tool chains. | |||
2277 | SmallVector<const ToolChain *, 2> ToolChains; | |||
2278 | ||||
2279 | /// The derived arguments associated with this builder. | |||
2280 | DerivedArgList &Args; | |||
2281 | ||||
2282 | /// The inputs associated with this builder. | |||
2283 | const Driver::InputList &Inputs; | |||
2284 | ||||
2285 | /// The associated offload kind. | |||
2286 | Action::OffloadKind AssociatedOffloadKind = Action::OFK_None; | |||
2287 | ||||
2288 | public: | |||
2289 | DeviceActionBuilder(Compilation &C, DerivedArgList &Args, | |||
2290 | const Driver::InputList &Inputs, | |||
2291 | Action::OffloadKind AssociatedOffloadKind) | |||
2292 | : C(C), Args(Args), Inputs(Inputs), | |||
2293 | AssociatedOffloadKind(AssociatedOffloadKind) {} | |||
2294 | virtual ~DeviceActionBuilder() {} | |||
2295 | ||||
2296 | /// Fill up the array \a DA with all the device dependences that should be | |||
2297 | /// added to the provided host action \a HostAction. By default it is | |||
2298 | /// inactive. | |||
2299 | virtual ActionBuilderReturnCode | |||
2300 | getDeviceDependences(OffloadAction::DeviceDependences &DA, | |||
2301 | phases::ID CurPhase, phases::ID FinalPhase, | |||
2302 | PhasesTy &Phases) { | |||
2303 | return ABRT_Inactive; | |||
2304 | } | |||
2305 | ||||
2306 | /// Update the state to include the provided host action \a HostAction as a | |||
2307 | /// dependency of the current device action. By default it is inactive. | |||
2308 | virtual ActionBuilderReturnCode addDeviceDepences(Action *HostAction) { | |||
2309 | return ABRT_Inactive; | |||
2310 | } | |||
2311 | ||||
2312 | /// Append top level actions generated by the builder. | |||
2313 | virtual void appendTopLevelActions(ActionList &AL) {} | |||
2314 | ||||
2315 | /// Append linker actions generated by the builder. | |||
2316 | virtual void appendLinkActions(ActionList &AL) {} | |||
2317 | ||||
2318 | /// Append linker actions generated by the builder. | |||
2319 | virtual void appendLinkDependences(OffloadAction::DeviceDependences &DA) {} | |||
2320 | ||||
2321 | /// Initialize the builder. Return true if any initialization errors are | |||
2322 | /// found. | |||
2323 | virtual bool initialize() { return false; } | |||
2324 | ||||
2325 | /// Return true if the builder can use bundling/unbundling. | |||
2326 | virtual bool canUseBundlerUnbundler() const { return false; } | |||
2327 | ||||
2328 | /// Return true if this builder is valid. We have a valid builder if we have | |||
2329 | /// associated device tool chains. | |||
2330 | bool isValid() { return !ToolChains.empty(); } | |||
2331 | ||||
2332 | /// Return the associated offload kind. | |||
2333 | Action::OffloadKind getAssociatedOffloadKind() { | |||
2334 | return AssociatedOffloadKind; | |||
2335 | } | |||
2336 | }; | |||
2337 | ||||
2338 | /// Base class for CUDA/HIP action builder. It injects device code in | |||
2339 | /// the host backend action. | |||
2340 | class CudaActionBuilderBase : public DeviceActionBuilder { | |||
2341 | protected: | |||
2342 | /// Flags to signal if the user requested host-only or device-only | |||
2343 | /// compilation. | |||
2344 | bool CompileHostOnly = false; | |||
2345 | bool CompileDeviceOnly = false; | |||
2346 | bool EmitLLVM = false; | |||
2347 | bool EmitAsm = false; | |||
2348 | ||||
2349 | /// List of GPU architectures to use in this compilation. | |||
2350 | SmallVector<CudaArch, 4> GpuArchList; | |||
2351 | ||||
2352 | /// The CUDA actions for the current input. | |||
2353 | ActionList CudaDeviceActions; | |||
2354 | ||||
2355 | /// The CUDA fat binary if it was generated for the current input. | |||
2356 | Action *CudaFatBinary = nullptr; | |||
2357 | ||||
2358 | /// Flag that is set to true if this builder acted on the current input. | |||
2359 | bool IsActive = false; | |||
2360 | ||||
2361 | /// Flag for -fgpu-rdc. | |||
2362 | bool Relocatable = false; | |||
2363 | ||||
2364 | /// Default GPU architecture if there's no one specified. | |||
2365 | CudaArch DefaultCudaArch = CudaArch::UNKNOWN; | |||
2366 | ||||
2367 | public: | |||
2368 | CudaActionBuilderBase(Compilation &C, DerivedArgList &Args, | |||
2369 | const Driver::InputList &Inputs, | |||
2370 | Action::OffloadKind OFKind) | |||
2371 | : DeviceActionBuilder(C, Args, Inputs, OFKind) {} | |||
2372 | ||||
2373 | ActionBuilderReturnCode addDeviceDepences(Action *HostAction) override { | |||
2374 | // While generating code for CUDA, we only depend on the host input action | |||
2375 | // to trigger the creation of all the CUDA device actions. | |||
2376 | ||||
2377 | // If we are dealing with an input action, replicate it for each GPU | |||
2378 | // architecture. If we are in host-only mode we return 'success' so that | |||
2379 | // the host uses the CUDA offload kind. | |||
2380 | if (auto *IA = dyn_cast<InputAction>(HostAction)) { | |||
2381 | assert(!GpuArchList.empty() &&((!GpuArchList.empty() && "We should have at least one GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("!GpuArchList.empty() && \"We should have at least one GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2382, __PRETTY_FUNCTION__)) | |||
2382 | "We should have at least one GPU architecture.")((!GpuArchList.empty() && "We should have at least one GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("!GpuArchList.empty() && \"We should have at least one GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2382, __PRETTY_FUNCTION__)); | |||
2383 | ||||
2384 | // If the host input is not CUDA or HIP, we don't need to bother about | |||
2385 | // this input. | |||
2386 | if (IA->getType() != types::TY_CUDA && | |||
2387 | IA->getType() != types::TY_HIP) { | |||
2388 | // The builder will ignore this input. | |||
2389 | IsActive = false; | |||
2390 | return ABRT_Inactive; | |||
2391 | } | |||
2392 | ||||
2393 | // Set the flag to true, so that the builder acts on the current input. | |||
2394 | IsActive = true; | |||
2395 | ||||
2396 | if (CompileHostOnly) | |||
2397 | return ABRT_Success; | |||
2398 | ||||
2399 | // Replicate inputs for each GPU architecture. | |||
2400 | auto Ty = IA->getType() == types::TY_HIP ? types::TY_HIP_DEVICE | |||
2401 | : types::TY_CUDA_DEVICE; | |||
2402 | for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) { | |||
2403 | CudaDeviceActions.push_back( | |||
2404 | C.MakeAction<InputAction>(IA->getInputArg(), Ty)); | |||
2405 | } | |||
2406 | ||||
2407 | return ABRT_Success; | |||
2408 | } | |||
2409 | ||||
2410 | // If this is an unbundling action use it as is for each CUDA toolchain. | |||
2411 | if (auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) { | |||
2412 | ||||
2413 | // If -fgpu-rdc is disabled, should not unbundle since there is no | |||
2414 | // device code to link. | |||
2415 | if (!Relocatable) | |||
2416 | return ABRT_Inactive; | |||
2417 | ||||
2418 | CudaDeviceActions.clear(); | |||
2419 | auto *IA = cast<InputAction>(UA->getInputs().back()); | |||
2420 | std::string FileName = IA->getInputArg().getAsString(Args); | |||
2421 | // Check if the type of the file is the same as the action. Do not | |||
2422 | // unbundle it if it is not. Do not unbundle .so files, for example, | |||
2423 | // which are not object files. | |||
2424 | if (IA->getType() == types::TY_Object && | |||
2425 | (!llvm::sys::path::has_extension(FileName) || | |||
2426 | types::lookupTypeForExtension( | |||
2427 | llvm::sys::path::extension(FileName).drop_front()) != | |||
2428 | types::TY_Object)) | |||
2429 | return ABRT_Inactive; | |||
2430 | ||||
2431 | for (auto Arch : GpuArchList) { | |||
2432 | CudaDeviceActions.push_back(UA); | |||
2433 | UA->registerDependentActionInfo(ToolChains[0], CudaArchToString(Arch), | |||
2434 | AssociatedOffloadKind); | |||
2435 | } | |||
2436 | return ABRT_Success; | |||
2437 | } | |||
2438 | ||||
2439 | return IsActive ? ABRT_Success : ABRT_Inactive; | |||
2440 | } | |||
2441 | ||||
2442 | void appendTopLevelActions(ActionList &AL) override { | |||
2443 | // Utility to append actions to the top level list. | |||
2444 | auto AddTopLevel = [&](Action *A, CudaArch BoundArch) { | |||
2445 | OffloadAction::DeviceDependences Dep; | |||
2446 | Dep.add(*A, *ToolChains.front(), CudaArchToString(BoundArch), | |||
2447 | AssociatedOffloadKind); | |||
2448 | AL.push_back(C.MakeAction<OffloadAction>(Dep, A->getType())); | |||
2449 | }; | |||
2450 | ||||
2451 | // If we have a fat binary, add it to the list. | |||
2452 | if (CudaFatBinary) { | |||
2453 | AddTopLevel(CudaFatBinary, CudaArch::UNKNOWN); | |||
2454 | CudaDeviceActions.clear(); | |||
2455 | CudaFatBinary = nullptr; | |||
2456 | return; | |||
2457 | } | |||
2458 | ||||
2459 | if (CudaDeviceActions.empty()) | |||
2460 | return; | |||
2461 | ||||
2462 | // If we have CUDA actions at this point, that's because we have a have | |||
2463 | // partial compilation, so we should have an action for each GPU | |||
2464 | // architecture. | |||
2465 | assert(CudaDeviceActions.size() == GpuArchList.size() &&((CudaDeviceActions.size() == GpuArchList.size() && "Expecting one action per GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("CudaDeviceActions.size() == GpuArchList.size() && \"Expecting one action per GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2466, __PRETTY_FUNCTION__)) | |||
2466 | "Expecting one action per GPU architecture.")((CudaDeviceActions.size() == GpuArchList.size() && "Expecting one action per GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("CudaDeviceActions.size() == GpuArchList.size() && \"Expecting one action per GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2466, __PRETTY_FUNCTION__)); | |||
2467 | assert(ToolChains.size() == 1 &&((ToolChains.size() == 1 && "Expecting to have a sing CUDA toolchain." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == 1 && \"Expecting to have a sing CUDA toolchain.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2468, __PRETTY_FUNCTION__)) | |||
2468 | "Expecting to have a sing CUDA toolchain.")((ToolChains.size() == 1 && "Expecting to have a sing CUDA toolchain." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == 1 && \"Expecting to have a sing CUDA toolchain.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2468, __PRETTY_FUNCTION__)); | |||
2469 | for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) | |||
2470 | AddTopLevel(CudaDeviceActions[I], GpuArchList[I]); | |||
2471 | ||||
2472 | CudaDeviceActions.clear(); | |||
2473 | } | |||
2474 | ||||
2475 | bool initialize() override { | |||
2476 | assert(AssociatedOffloadKind == Action::OFK_Cuda ||((AssociatedOffloadKind == Action::OFK_Cuda || AssociatedOffloadKind == Action::OFK_HIP) ? static_cast<void> (0) : __assert_fail ("AssociatedOffloadKind == Action::OFK_Cuda || AssociatedOffloadKind == Action::OFK_HIP" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2477, __PRETTY_FUNCTION__)) | |||
2477 | AssociatedOffloadKind == Action::OFK_HIP)((AssociatedOffloadKind == Action::OFK_Cuda || AssociatedOffloadKind == Action::OFK_HIP) ? static_cast<void> (0) : __assert_fail ("AssociatedOffloadKind == Action::OFK_Cuda || AssociatedOffloadKind == Action::OFK_HIP" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2477, __PRETTY_FUNCTION__)); | |||
2478 | ||||
2479 | // We don't need to support CUDA. | |||
2480 | if (AssociatedOffloadKind == Action::OFK_Cuda && | |||
2481 | !C.hasOffloadToolChain<Action::OFK_Cuda>()) | |||
2482 | return false; | |||
2483 | ||||
2484 | // We don't need to support HIP. | |||
2485 | if (AssociatedOffloadKind == Action::OFK_HIP && | |||
2486 | !C.hasOffloadToolChain<Action::OFK_HIP>()) | |||
2487 | return false; | |||
2488 | ||||
2489 | Relocatable = Args.hasFlag(options::OPT_fgpu_rdc, | |||
2490 | options::OPT_fno_gpu_rdc, /*Default=*/false); | |||
2491 | ||||
2492 | const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>(); | |||
2493 | assert(HostTC && "No toolchain for host compilation.")((HostTC && "No toolchain for host compilation.") ? static_cast <void> (0) : __assert_fail ("HostTC && \"No toolchain for host compilation.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2493, __PRETTY_FUNCTION__)); | |||
2494 | if (HostTC->getTriple().isNVPTX() || | |||
2495 | HostTC->getTriple().getArch() == llvm::Triple::amdgcn) { | |||
2496 | // We do not support targeting NVPTX/AMDGCN for host compilation. Throw | |||
2497 | // an error and abort pipeline construction early so we don't trip | |||
2498 | // asserts that assume device-side compilation. | |||
2499 | C.getDriver().Diag(diag::err_drv_cuda_host_arch) | |||
2500 | << HostTC->getTriple().getArchName(); | |||
2501 | return true; | |||
2502 | } | |||
2503 | ||||
2504 | ToolChains.push_back( | |||
2505 | AssociatedOffloadKind == Action::OFK_Cuda | |||
2506 | ? C.getSingleOffloadToolChain<Action::OFK_Cuda>() | |||
2507 | : C.getSingleOffloadToolChain<Action::OFK_HIP>()); | |||
2508 | ||||
2509 | Arg *PartialCompilationArg = Args.getLastArg( | |||
2510 | options::OPT_cuda_host_only, options::OPT_cuda_device_only, | |||
2511 | options::OPT_cuda_compile_host_device); | |||
2512 | CompileHostOnly = PartialCompilationArg && | |||
2513 | PartialCompilationArg->getOption().matches( | |||
2514 | options::OPT_cuda_host_only); | |||
2515 | CompileDeviceOnly = PartialCompilationArg && | |||
2516 | PartialCompilationArg->getOption().matches( | |||
2517 | options::OPT_cuda_device_only); | |||
2518 | EmitLLVM = Args.getLastArg(options::OPT_emit_llvm); | |||
2519 | EmitAsm = Args.getLastArg(options::OPT_S); | |||
2520 | ||||
2521 | // Collect all cuda_gpu_arch parameters, removing duplicates. | |||
2522 | std::set<CudaArch> GpuArchs; | |||
2523 | bool Error = false; | |||
2524 | for (Arg *A : Args) { | |||
2525 | if (!(A->getOption().matches(options::OPT_cuda_gpu_arch_EQ) || | |||
2526 | A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ))) | |||
2527 | continue; | |||
2528 | A->claim(); | |||
2529 | ||||
2530 | const StringRef ArchStr = A->getValue(); | |||
2531 | if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ) && | |||
2532 | ArchStr == "all") { | |||
2533 | GpuArchs.clear(); | |||
2534 | continue; | |||
2535 | } | |||
2536 | CudaArch Arch = StringToCudaArch(ArchStr); | |||
2537 | if (Arch == CudaArch::UNKNOWN) { | |||
2538 | C.getDriver().Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr; | |||
2539 | Error = true; | |||
2540 | } else if (A->getOption().matches(options::OPT_cuda_gpu_arch_EQ)) | |||
2541 | GpuArchs.insert(Arch); | |||
2542 | else if (A->getOption().matches(options::OPT_no_cuda_gpu_arch_EQ)) | |||
2543 | GpuArchs.erase(Arch); | |||
2544 | else | |||
2545 | llvm_unreachable("Unexpected option.")::llvm::llvm_unreachable_internal("Unexpected option.", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2545); | |||
2546 | } | |||
2547 | ||||
2548 | // Collect list of GPUs remaining in the set. | |||
2549 | for (CudaArch Arch : GpuArchs) | |||
2550 | GpuArchList.push_back(Arch); | |||
2551 | ||||
2552 | // Default to sm_20 which is the lowest common denominator for | |||
2553 | // supported GPUs. sm_20 code should work correctly, if | |||
2554 | // suboptimally, on all newer GPUs. | |||
2555 | if (GpuArchList.empty()) | |||
2556 | GpuArchList.push_back(DefaultCudaArch); | |||
2557 | ||||
2558 | return Error; | |||
2559 | } | |||
2560 | }; | |||
2561 | ||||
2562 | /// \brief CUDA action builder. It injects device code in the host backend | |||
2563 | /// action. | |||
2564 | class CudaActionBuilder final : public CudaActionBuilderBase { | |||
2565 | public: | |||
2566 | CudaActionBuilder(Compilation &C, DerivedArgList &Args, | |||
2567 | const Driver::InputList &Inputs) | |||
2568 | : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_Cuda) { | |||
2569 | DefaultCudaArch = CudaArch::SM_20; | |||
2570 | } | |||
2571 | ||||
2572 | ActionBuilderReturnCode | |||
2573 | getDeviceDependences(OffloadAction::DeviceDependences &DA, | |||
2574 | phases::ID CurPhase, phases::ID FinalPhase, | |||
2575 | PhasesTy &Phases) override { | |||
2576 | if (!IsActive) | |||
2577 | return ABRT_Inactive; | |||
2578 | ||||
2579 | // If we don't have more CUDA actions, we don't have any dependences to | |||
2580 | // create for the host. | |||
2581 | if (CudaDeviceActions.empty()) | |||
2582 | return ABRT_Success; | |||
2583 | ||||
2584 | assert(CudaDeviceActions.size() == GpuArchList.size() &&((CudaDeviceActions.size() == GpuArchList.size() && "Expecting one action per GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("CudaDeviceActions.size() == GpuArchList.size() && \"Expecting one action per GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2585, __PRETTY_FUNCTION__)) | |||
2585 | "Expecting one action per GPU architecture.")((CudaDeviceActions.size() == GpuArchList.size() && "Expecting one action per GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("CudaDeviceActions.size() == GpuArchList.size() && \"Expecting one action per GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2585, __PRETTY_FUNCTION__)); | |||
2586 | assert(!CompileHostOnly &&((!CompileHostOnly && "Not expecting CUDA actions in host-only compilation." ) ? static_cast<void> (0) : __assert_fail ("!CompileHostOnly && \"Not expecting CUDA actions in host-only compilation.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2587, __PRETTY_FUNCTION__)) | |||
2587 | "Not expecting CUDA actions in host-only compilation.")((!CompileHostOnly && "Not expecting CUDA actions in host-only compilation." ) ? static_cast<void> (0) : __assert_fail ("!CompileHostOnly && \"Not expecting CUDA actions in host-only compilation.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2587, __PRETTY_FUNCTION__)); | |||
2588 | ||||
2589 | // If we are generating code for the device or we are in a backend phase, | |||
2590 | // we attempt to generate the fat binary. We compile each arch to ptx and | |||
2591 | // assemble to cubin, then feed the cubin *and* the ptx into a device | |||
2592 | // "link" action, which uses fatbinary to combine these cubins into one | |||
2593 | // fatbin. The fatbin is then an input to the host action if not in | |||
2594 | // device-only mode. | |||
2595 | if (CompileDeviceOnly || CurPhase == phases::Backend) { | |||
2596 | ActionList DeviceActions; | |||
2597 | for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) { | |||
2598 | // Produce the device action from the current phase up to the assemble | |||
2599 | // phase. | |||
2600 | for (auto Ph : Phases) { | |||
2601 | // Skip the phases that were already dealt with. | |||
2602 | if (Ph < CurPhase) | |||
2603 | continue; | |||
2604 | // We have to be consistent with the host final phase. | |||
2605 | if (Ph > FinalPhase) | |||
2606 | break; | |||
2607 | ||||
2608 | CudaDeviceActions[I] = C.getDriver().ConstructPhaseAction( | |||
2609 | C, Args, Ph, CudaDeviceActions[I], Action::OFK_Cuda); | |||
2610 | ||||
2611 | if (Ph == phases::Assemble) | |||
2612 | break; | |||
2613 | } | |||
2614 | ||||
2615 | // If we didn't reach the assemble phase, we can't generate the fat | |||
2616 | // binary. We don't need to generate the fat binary if we are not in | |||
2617 | // device-only mode. | |||
2618 | if (!isa<AssembleJobAction>(CudaDeviceActions[I]) || | |||
2619 | CompileDeviceOnly) | |||
2620 | continue; | |||
2621 | ||||
2622 | Action *AssembleAction = CudaDeviceActions[I]; | |||
2623 | assert(AssembleAction->getType() == types::TY_Object)((AssembleAction->getType() == types::TY_Object) ? static_cast <void> (0) : __assert_fail ("AssembleAction->getType() == types::TY_Object" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2623, __PRETTY_FUNCTION__)); | |||
2624 | assert(AssembleAction->getInputs().size() == 1)((AssembleAction->getInputs().size() == 1) ? static_cast< void> (0) : __assert_fail ("AssembleAction->getInputs().size() == 1" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2624, __PRETTY_FUNCTION__)); | |||
2625 | ||||
2626 | Action *BackendAction = AssembleAction->getInputs()[0]; | |||
2627 | assert(BackendAction->getType() == types::TY_PP_Asm)((BackendAction->getType() == types::TY_PP_Asm) ? static_cast <void> (0) : __assert_fail ("BackendAction->getType() == types::TY_PP_Asm" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2627, __PRETTY_FUNCTION__)); | |||
2628 | ||||
2629 | for (auto &A : {AssembleAction, BackendAction}) { | |||
2630 | OffloadAction::DeviceDependences DDep; | |||
2631 | DDep.add(*A, *ToolChains.front(), CudaArchToString(GpuArchList[I]), | |||
2632 | Action::OFK_Cuda); | |||
2633 | DeviceActions.push_back( | |||
2634 | C.MakeAction<OffloadAction>(DDep, A->getType())); | |||
2635 | } | |||
2636 | } | |||
2637 | ||||
2638 | // We generate the fat binary if we have device input actions. | |||
2639 | if (!DeviceActions.empty()) { | |||
2640 | CudaFatBinary = | |||
2641 | C.MakeAction<LinkJobAction>(DeviceActions, types::TY_CUDA_FATBIN); | |||
2642 | ||||
2643 | if (!CompileDeviceOnly) { | |||
2644 | DA.add(*CudaFatBinary, *ToolChains.front(), /*BoundArch=*/nullptr, | |||
2645 | Action::OFK_Cuda); | |||
2646 | // Clear the fat binary, it is already a dependence to an host | |||
2647 | // action. | |||
2648 | CudaFatBinary = nullptr; | |||
2649 | } | |||
2650 | ||||
2651 | // Remove the CUDA actions as they are already connected to an host | |||
2652 | // action or fat binary. | |||
2653 | CudaDeviceActions.clear(); | |||
2654 | } | |||
2655 | ||||
2656 | // We avoid creating host action in device-only mode. | |||
2657 | return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success; | |||
2658 | } else if (CurPhase > phases::Backend) { | |||
2659 | // If we are past the backend phase and still have a device action, we | |||
2660 | // don't have to do anything as this action is already a device | |||
2661 | // top-level action. | |||
2662 | return ABRT_Success; | |||
2663 | } | |||
2664 | ||||
2665 | assert(CurPhase < phases::Backend && "Generating single CUDA "((CurPhase < phases::Backend && "Generating single CUDA " "instructions should only occur " "before the backend phase!" ) ? static_cast<void> (0) : __assert_fail ("CurPhase < phases::Backend && \"Generating single CUDA \" \"instructions should only occur \" \"before the backend phase!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2667, __PRETTY_FUNCTION__)) | |||
2666 | "instructions should only occur "((CurPhase < phases::Backend && "Generating single CUDA " "instructions should only occur " "before the backend phase!" ) ? static_cast<void> (0) : __assert_fail ("CurPhase < phases::Backend && \"Generating single CUDA \" \"instructions should only occur \" \"before the backend phase!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2667, __PRETTY_FUNCTION__)) | |||
2667 | "before the backend phase!")((CurPhase < phases::Backend && "Generating single CUDA " "instructions should only occur " "before the backend phase!" ) ? static_cast<void> (0) : __assert_fail ("CurPhase < phases::Backend && \"Generating single CUDA \" \"instructions should only occur \" \"before the backend phase!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2667, __PRETTY_FUNCTION__)); | |||
2668 | ||||
2669 | // By default, we produce an action for each device arch. | |||
2670 | for (Action *&A : CudaDeviceActions) | |||
2671 | A = C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A); | |||
2672 | ||||
2673 | return ABRT_Success; | |||
2674 | } | |||
2675 | }; | |||
2676 | /// \brief HIP action builder. It injects device code in the host backend | |||
2677 | /// action. | |||
2678 | class HIPActionBuilder final : public CudaActionBuilderBase { | |||
2679 | /// The linker inputs obtained for each device arch. | |||
2680 | SmallVector<ActionList, 8> DeviceLinkerInputs; | |||
2681 | ||||
2682 | public: | |||
2683 | HIPActionBuilder(Compilation &C, DerivedArgList &Args, | |||
2684 | const Driver::InputList &Inputs) | |||
2685 | : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_HIP) { | |||
2686 | DefaultCudaArch = CudaArch::GFX803; | |||
2687 | } | |||
2688 | ||||
2689 | bool canUseBundlerUnbundler() const override { return true; } | |||
2690 | ||||
2691 | ActionBuilderReturnCode | |||
2692 | getDeviceDependences(OffloadAction::DeviceDependences &DA, | |||
2693 | phases::ID CurPhase, phases::ID FinalPhase, | |||
2694 | PhasesTy &Phases) override { | |||
2695 | // amdgcn does not support linking of object files, therefore we skip | |||
2696 | // backend and assemble phases to output LLVM IR. Except for generating | |||
2697 | // non-relocatable device coee, where we generate fat binary for device | |||
2698 | // code and pass to host in Backend phase. | |||
2699 | if (CudaDeviceActions.empty() || | |||
2700 | (CurPhase == phases::Backend && Relocatable) || | |||
2701 | CurPhase == phases::Assemble) | |||
2702 | return ABRT_Success; | |||
2703 | ||||
2704 | assert(((CurPhase == phases::Link && Relocatable) ||((((CurPhase == phases::Link && Relocatable) || CudaDeviceActions .size() == GpuArchList.size()) && "Expecting one action per GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("((CurPhase == phases::Link && Relocatable) || CudaDeviceActions.size() == GpuArchList.size()) && \"Expecting one action per GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2706, __PRETTY_FUNCTION__)) | |||
2705 | CudaDeviceActions.size() == GpuArchList.size()) &&((((CurPhase == phases::Link && Relocatable) || CudaDeviceActions .size() == GpuArchList.size()) && "Expecting one action per GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("((CurPhase == phases::Link && Relocatable) || CudaDeviceActions.size() == GpuArchList.size()) && \"Expecting one action per GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2706, __PRETTY_FUNCTION__)) | |||
2706 | "Expecting one action per GPU architecture.")((((CurPhase == phases::Link && Relocatable) || CudaDeviceActions .size() == GpuArchList.size()) && "Expecting one action per GPU architecture." ) ? static_cast<void> (0) : __assert_fail ("((CurPhase == phases::Link && Relocatable) || CudaDeviceActions.size() == GpuArchList.size()) && \"Expecting one action per GPU architecture.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2706, __PRETTY_FUNCTION__)); | |||
2707 | assert(!CompileHostOnly &&((!CompileHostOnly && "Not expecting CUDA actions in host-only compilation." ) ? static_cast<void> (0) : __assert_fail ("!CompileHostOnly && \"Not expecting CUDA actions in host-only compilation.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2708, __PRETTY_FUNCTION__)) | |||
2708 | "Not expecting CUDA actions in host-only compilation.")((!CompileHostOnly && "Not expecting CUDA actions in host-only compilation." ) ? static_cast<void> (0) : __assert_fail ("!CompileHostOnly && \"Not expecting CUDA actions in host-only compilation.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2708, __PRETTY_FUNCTION__)); | |||
2709 | ||||
2710 | if (!Relocatable && CurPhase == phases::Backend && !EmitLLVM && | |||
2711 | !EmitAsm) { | |||
2712 | // If we are in backend phase, we attempt to generate the fat binary. | |||
2713 | // We compile each arch to IR and use a link action to generate code | |||
2714 | // object containing ISA. Then we use a special "link" action to create | |||
2715 | // a fat binary containing all the code objects for different GPU's. | |||
2716 | // The fat binary is then an input to the host action. | |||
2717 | for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) { | |||
2718 | // Create a link action to link device IR with device library | |||
2719 | // and generate ISA. | |||
2720 | ActionList AL; | |||
2721 | AL.push_back(CudaDeviceActions[I]); | |||
2722 | CudaDeviceActions[I] = | |||
2723 | C.MakeAction<LinkJobAction>(AL, types::TY_Image); | |||
2724 | ||||
2725 | // OffloadingActionBuilder propagates device arch until an offload | |||
2726 | // action. Since the next action for creating fatbin does | |||
2727 | // not have device arch, whereas the above link action and its input | |||
2728 | // have device arch, an offload action is needed to stop the null | |||
2729 | // device arch of the next action being propagated to the above link | |||
2730 | // action. | |||
2731 | OffloadAction::DeviceDependences DDep; | |||
2732 | DDep.add(*CudaDeviceActions[I], *ToolChains.front(), | |||
2733 | CudaArchToString(GpuArchList[I]), AssociatedOffloadKind); | |||
2734 | CudaDeviceActions[I] = C.MakeAction<OffloadAction>( | |||
2735 | DDep, CudaDeviceActions[I]->getType()); | |||
2736 | } | |||
2737 | // Create HIP fat binary with a special "link" action. | |||
2738 | CudaFatBinary = | |||
2739 | C.MakeAction<LinkJobAction>(CudaDeviceActions, | |||
2740 | types::TY_HIP_FATBIN); | |||
2741 | ||||
2742 | if (!CompileDeviceOnly) { | |||
2743 | DA.add(*CudaFatBinary, *ToolChains.front(), /*BoundArch=*/nullptr, | |||
2744 | AssociatedOffloadKind); | |||
2745 | // Clear the fat binary, it is already a dependence to an host | |||
2746 | // action. | |||
2747 | CudaFatBinary = nullptr; | |||
2748 | } | |||
2749 | ||||
2750 | // Remove the CUDA actions as they are already connected to an host | |||
2751 | // action or fat binary. | |||
2752 | CudaDeviceActions.clear(); | |||
2753 | ||||
2754 | return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success; | |||
2755 | } else if (CurPhase == phases::Link) { | |||
2756 | // Save CudaDeviceActions to DeviceLinkerInputs for each GPU subarch. | |||
2757 | // This happens to each device action originated from each input file. | |||
2758 | // Later on, device actions in DeviceLinkerInputs are used to create | |||
2759 | // device link actions in appendLinkDependences and the created device | |||
2760 | // link actions are passed to the offload action as device dependence. | |||
2761 | DeviceLinkerInputs.resize(CudaDeviceActions.size()); | |||
2762 | auto LI = DeviceLinkerInputs.begin(); | |||
2763 | for (auto *A : CudaDeviceActions) { | |||
2764 | LI->push_back(A); | |||
2765 | ++LI; | |||
2766 | } | |||
2767 | ||||
2768 | // We will pass the device action as a host dependence, so we don't | |||
2769 | // need to do anything else with them. | |||
2770 | CudaDeviceActions.clear(); | |||
2771 | return ABRT_Success; | |||
2772 | } | |||
2773 | ||||
2774 | // By default, we produce an action for each device arch. | |||
2775 | for (Action *&A : CudaDeviceActions) | |||
2776 | A = C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A, | |||
2777 | AssociatedOffloadKind); | |||
2778 | ||||
2779 | return (CompileDeviceOnly && CurPhase == FinalPhase) ? ABRT_Ignore_Host | |||
2780 | : ABRT_Success; | |||
2781 | } | |||
2782 | ||||
2783 | void appendLinkDependences(OffloadAction::DeviceDependences &DA) override { | |||
2784 | // Append a new link action for each device. | |||
2785 | unsigned I = 0; | |||
2786 | for (auto &LI : DeviceLinkerInputs) { | |||
2787 | auto *DeviceLinkAction = | |||
2788 | C.MakeAction<LinkJobAction>(LI, types::TY_Image); | |||
2789 | DA.add(*DeviceLinkAction, *ToolChains[0], | |||
2790 | CudaArchToString(GpuArchList[I]), AssociatedOffloadKind); | |||
2791 | ++I; | |||
2792 | } | |||
2793 | } | |||
2794 | }; | |||
2795 | ||||
2796 | /// OpenMP action builder. The host bitcode is passed to the device frontend | |||
2797 | /// and all the device linked images are passed to the host link phase. | |||
2798 | class OpenMPActionBuilder final : public DeviceActionBuilder { | |||
2799 | /// The OpenMP actions for the current input. | |||
2800 | ActionList OpenMPDeviceActions; | |||
2801 | ||||
2802 | /// The linker inputs obtained for each toolchain. | |||
2803 | SmallVector<ActionList, 8> DeviceLinkerInputs; | |||
2804 | ||||
2805 | public: | |||
2806 | OpenMPActionBuilder(Compilation &C, DerivedArgList &Args, | |||
2807 | const Driver::InputList &Inputs) | |||
2808 | : DeviceActionBuilder(C, Args, Inputs, Action::OFK_OpenMP) {} | |||
2809 | ||||
2810 | ActionBuilderReturnCode | |||
2811 | getDeviceDependences(OffloadAction::DeviceDependences &DA, | |||
2812 | phases::ID CurPhase, phases::ID FinalPhase, | |||
2813 | PhasesTy &Phases) override { | |||
2814 | if (OpenMPDeviceActions.empty()) | |||
2815 | return ABRT_Inactive; | |||
2816 | ||||
2817 | // We should always have an action for each input. | |||
2818 | assert(OpenMPDeviceActions.size() == ToolChains.size() &&((OpenMPDeviceActions.size() == ToolChains.size() && "Number of OpenMP actions and toolchains do not match." ) ? static_cast<void> (0) : __assert_fail ("OpenMPDeviceActions.size() == ToolChains.size() && \"Number of OpenMP actions and toolchains do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2819, __PRETTY_FUNCTION__)) | |||
2819 | "Number of OpenMP actions and toolchains do not match.")((OpenMPDeviceActions.size() == ToolChains.size() && "Number of OpenMP actions and toolchains do not match." ) ? static_cast<void> (0) : __assert_fail ("OpenMPDeviceActions.size() == ToolChains.size() && \"Number of OpenMP actions and toolchains do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2819, __PRETTY_FUNCTION__)); | |||
2820 | ||||
2821 | // The host only depends on device action in the linking phase, when all | |||
2822 | // the device images have to be embedded in the host image. | |||
2823 | if (CurPhase == phases::Link) { | |||
2824 | assert(ToolChains.size() == DeviceLinkerInputs.size() &&((ToolChains.size() == DeviceLinkerInputs.size() && "Toolchains and linker inputs sizes do not match." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == DeviceLinkerInputs.size() && \"Toolchains and linker inputs sizes do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2825, __PRETTY_FUNCTION__)) | |||
2825 | "Toolchains and linker inputs sizes do not match.")((ToolChains.size() == DeviceLinkerInputs.size() && "Toolchains and linker inputs sizes do not match." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == DeviceLinkerInputs.size() && \"Toolchains and linker inputs sizes do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2825, __PRETTY_FUNCTION__)); | |||
2826 | auto LI = DeviceLinkerInputs.begin(); | |||
2827 | for (auto *A : OpenMPDeviceActions) { | |||
2828 | LI->push_back(A); | |||
2829 | ++LI; | |||
2830 | } | |||
2831 | ||||
2832 | // We passed the device action as a host dependence, so we don't need to | |||
2833 | // do anything else with them. | |||
2834 | OpenMPDeviceActions.clear(); | |||
2835 | return ABRT_Success; | |||
2836 | } | |||
2837 | ||||
2838 | // By default, we produce an action for each device arch. | |||
2839 | for (Action *&A : OpenMPDeviceActions) | |||
2840 | A = C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A); | |||
2841 | ||||
2842 | return ABRT_Success; | |||
2843 | } | |||
2844 | ||||
2845 | ActionBuilderReturnCode addDeviceDepences(Action *HostAction) override { | |||
2846 | ||||
2847 | // If this is an input action replicate it for each OpenMP toolchain. | |||
2848 | if (auto *IA = dyn_cast<InputAction>(HostAction)) { | |||
2849 | OpenMPDeviceActions.clear(); | |||
2850 | for (unsigned I = 0; I < ToolChains.size(); ++I) | |||
2851 | OpenMPDeviceActions.push_back( | |||
2852 | C.MakeAction<InputAction>(IA->getInputArg(), IA->getType())); | |||
2853 | return ABRT_Success; | |||
2854 | } | |||
2855 | ||||
2856 | // If this is an unbundling action use it as is for each OpenMP toolchain. | |||
2857 | if (auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) { | |||
2858 | OpenMPDeviceActions.clear(); | |||
2859 | auto *IA = cast<InputAction>(UA->getInputs().back()); | |||
2860 | std::string FileName = IA->getInputArg().getAsString(Args); | |||
2861 | // Check if the type of the file is the same as the action. Do not | |||
2862 | // unbundle it if it is not. Do not unbundle .so files, for example, | |||
2863 | // which are not object files. | |||
2864 | if (IA->getType() == types::TY_Object && | |||
2865 | (!llvm::sys::path::has_extension(FileName) || | |||
2866 | types::lookupTypeForExtension( | |||
2867 | llvm::sys::path::extension(FileName).drop_front()) != | |||
2868 | types::TY_Object)) | |||
2869 | return ABRT_Inactive; | |||
2870 | for (unsigned I = 0; I < ToolChains.size(); ++I) { | |||
2871 | OpenMPDeviceActions.push_back(UA); | |||
2872 | UA->registerDependentActionInfo( | |||
2873 | ToolChains[I], /*BoundArch=*/StringRef(), Action::OFK_OpenMP); | |||
2874 | } | |||
2875 | return ABRT_Success; | |||
2876 | } | |||
2877 | ||||
2878 | // When generating code for OpenMP we use the host compile phase result as | |||
2879 | // a dependence to the device compile phase so that it can learn what | |||
2880 | // declarations should be emitted. However, this is not the only use for | |||
2881 | // the host action, so we prevent it from being collapsed. | |||
2882 | if (isa<CompileJobAction>(HostAction)) { | |||
2883 | HostAction->setCannotBeCollapsedWithNextDependentAction(); | |||
2884 | assert(ToolChains.size() == OpenMPDeviceActions.size() &&((ToolChains.size() == OpenMPDeviceActions.size() && "Toolchains and device action sizes do not match." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == OpenMPDeviceActions.size() && \"Toolchains and device action sizes do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2885, __PRETTY_FUNCTION__)) | |||
2885 | "Toolchains and device action sizes do not match.")((ToolChains.size() == OpenMPDeviceActions.size() && "Toolchains and device action sizes do not match." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == OpenMPDeviceActions.size() && \"Toolchains and device action sizes do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2885, __PRETTY_FUNCTION__)); | |||
2886 | OffloadAction::HostDependence HDep( | |||
2887 | *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(), | |||
2888 | /*BoundArch=*/nullptr, Action::OFK_OpenMP); | |||
2889 | auto TC = ToolChains.begin(); | |||
2890 | for (Action *&A : OpenMPDeviceActions) { | |||
2891 | assert(isa<CompileJobAction>(A))((isa<CompileJobAction>(A)) ? static_cast<void> ( 0) : __assert_fail ("isa<CompileJobAction>(A)", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2891, __PRETTY_FUNCTION__)); | |||
2892 | OffloadAction::DeviceDependences DDep; | |||
2893 | DDep.add(*A, **TC, /*BoundArch=*/nullptr, Action::OFK_OpenMP); | |||
2894 | A = C.MakeAction<OffloadAction>(HDep, DDep); | |||
2895 | ++TC; | |||
2896 | } | |||
2897 | } | |||
2898 | return ABRT_Success; | |||
2899 | } | |||
2900 | ||||
2901 | void appendTopLevelActions(ActionList &AL) override { | |||
2902 | if (OpenMPDeviceActions.empty()) | |||
2903 | return; | |||
2904 | ||||
2905 | // We should always have an action for each input. | |||
2906 | assert(OpenMPDeviceActions.size() == ToolChains.size() &&((OpenMPDeviceActions.size() == ToolChains.size() && "Number of OpenMP actions and toolchains do not match." ) ? static_cast<void> (0) : __assert_fail ("OpenMPDeviceActions.size() == ToolChains.size() && \"Number of OpenMP actions and toolchains do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2907, __PRETTY_FUNCTION__)) | |||
2907 | "Number of OpenMP actions and toolchains do not match.")((OpenMPDeviceActions.size() == ToolChains.size() && "Number of OpenMP actions and toolchains do not match." ) ? static_cast<void> (0) : __assert_fail ("OpenMPDeviceActions.size() == ToolChains.size() && \"Number of OpenMP actions and toolchains do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2907, __PRETTY_FUNCTION__)); | |||
2908 | ||||
2909 | // Append all device actions followed by the proper offload action. | |||
2910 | auto TI = ToolChains.begin(); | |||
2911 | for (auto *A : OpenMPDeviceActions) { | |||
2912 | OffloadAction::DeviceDependences Dep; | |||
2913 | Dep.add(*A, **TI, /*BoundArch=*/nullptr, Action::OFK_OpenMP); | |||
2914 | AL.push_back(C.MakeAction<OffloadAction>(Dep, A->getType())); | |||
2915 | ++TI; | |||
2916 | } | |||
2917 | // We no longer need the action stored in this builder. | |||
2918 | OpenMPDeviceActions.clear(); | |||
2919 | } | |||
2920 | ||||
2921 | void appendLinkActions(ActionList &AL) override { | |||
2922 | assert(ToolChains.size() == DeviceLinkerInputs.size() &&((ToolChains.size() == DeviceLinkerInputs.size() && "Toolchains and linker inputs sizes do not match." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == DeviceLinkerInputs.size() && \"Toolchains and linker inputs sizes do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2923, __PRETTY_FUNCTION__)) | |||
2923 | "Toolchains and linker inputs sizes do not match.")((ToolChains.size() == DeviceLinkerInputs.size() && "Toolchains and linker inputs sizes do not match." ) ? static_cast<void> (0) : __assert_fail ("ToolChains.size() == DeviceLinkerInputs.size() && \"Toolchains and linker inputs sizes do not match.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 2923, __PRETTY_FUNCTION__)); | |||
2924 | ||||
2925 | // Append a new link action for each device. | |||
2926 | auto TC = ToolChains.begin(); | |||
2927 | for (auto &LI : DeviceLinkerInputs) { | |||
2928 | auto *DeviceLinkAction = | |||
2929 | C.MakeAction<LinkJobAction>(LI, types::TY_Image); | |||
2930 | OffloadAction::DeviceDependences DeviceLinkDeps; | |||
2931 | DeviceLinkDeps.add(*DeviceLinkAction, **TC, /*BoundArch=*/nullptr, | |||
2932 | Action::OFK_OpenMP); | |||
2933 | AL.push_back(C.MakeAction<OffloadAction>(DeviceLinkDeps, | |||
2934 | DeviceLinkAction->getType())); | |||
2935 | ++TC; | |||
2936 | } | |||
2937 | DeviceLinkerInputs.clear(); | |||
2938 | } | |||
2939 | ||||
2940 | void appendLinkDependences(OffloadAction::DeviceDependences &DA) override {} | |||
2941 | ||||
2942 | bool initialize() override { | |||
2943 | // Get the OpenMP toolchains. If we don't get any, the action builder will | |||
2944 | // know there is nothing to do related to OpenMP offloading. | |||
2945 | auto OpenMPTCRange = C.getOffloadToolChains<Action::OFK_OpenMP>(); | |||
2946 | for (auto TI = OpenMPTCRange.first, TE = OpenMPTCRange.second; TI != TE; | |||
2947 | ++TI) | |||
2948 | ToolChains.push_back(TI->second); | |||
2949 | ||||
2950 | DeviceLinkerInputs.resize(ToolChains.size()); | |||
2951 | return false; | |||
2952 | } | |||
2953 | ||||
2954 | bool canUseBundlerUnbundler() const override { | |||
2955 | // OpenMP should use bundled files whenever possible. | |||
2956 | return true; | |||
2957 | } | |||
2958 | }; | |||
2959 | ||||
2960 | /// | |||
2961 | /// TODO: Add the implementation for other specialized builders here. | |||
2962 | /// | |||
2963 | ||||
2964 | /// Specialized builders being used by this offloading action builder. | |||
2965 | SmallVector<DeviceActionBuilder *, 4> SpecializedBuilders; | |||
2966 | ||||
2967 | /// Flag set to true if all valid builders allow file bundling/unbundling. | |||
2968 | bool CanUseBundler; | |||
2969 | ||||
2970 | public: | |||
2971 | OffloadingActionBuilder(Compilation &C, DerivedArgList &Args, | |||
2972 | const Driver::InputList &Inputs) | |||
2973 | : C(C) { | |||
2974 | // Create a specialized builder for each device toolchain. | |||
2975 | ||||
2976 | IsValid = true; | |||
2977 | ||||
2978 | // Create a specialized builder for CUDA. | |||
2979 | SpecializedBuilders.push_back(new CudaActionBuilder(C, Args, Inputs)); | |||
2980 | ||||
2981 | // Create a specialized builder for HIP. | |||
2982 | SpecializedBuilders.push_back(new HIPActionBuilder(C, Args, Inputs)); | |||
2983 | ||||
2984 | // Create a specialized builder for OpenMP. | |||
2985 | SpecializedBuilders.push_back(new OpenMPActionBuilder(C, Args, Inputs)); | |||
2986 | ||||
2987 | // | |||
2988 | // TODO: Build other specialized builders here. | |||
2989 | // | |||
2990 | ||||
2991 | // Initialize all the builders, keeping track of errors. If all valid | |||
2992 | // builders agree that we can use bundling, set the flag to true. | |||
2993 | unsigned ValidBuilders = 0u; | |||
2994 | unsigned ValidBuildersSupportingBundling = 0u; | |||
2995 | for (auto *SB : SpecializedBuilders) { | |||
2996 | IsValid = IsValid && !SB->initialize(); | |||
2997 | ||||
2998 | // Update the counters if the builder is valid. | |||
2999 | if (SB->isValid()) { | |||
3000 | ++ValidBuilders; | |||
3001 | if (SB->canUseBundlerUnbundler()) | |||
3002 | ++ValidBuildersSupportingBundling; | |||
3003 | } | |||
3004 | } | |||
3005 | CanUseBundler = | |||
3006 | ValidBuilders && ValidBuilders == ValidBuildersSupportingBundling; | |||
3007 | } | |||
3008 | ||||
3009 | ~OffloadingActionBuilder() { | |||
3010 | for (auto *SB : SpecializedBuilders) | |||
3011 | delete SB; | |||
3012 | } | |||
3013 | ||||
3014 | /// Generate an action that adds device dependences (if any) to a host action. | |||
3015 | /// If no device dependence actions exist, just return the host action \a | |||
3016 | /// HostAction. If an error is found or if no builder requires the host action | |||
3017 | /// to be generated, return nullptr. | |||
3018 | Action * | |||
3019 | addDeviceDependencesToHostAction(Action *HostAction, const Arg *InputArg, | |||
3020 | phases::ID CurPhase, phases::ID FinalPhase, | |||
3021 | DeviceActionBuilder::PhasesTy &Phases) { | |||
3022 | if (!IsValid) | |||
3023 | return nullptr; | |||
3024 | ||||
3025 | if (SpecializedBuilders.empty()) | |||
3026 | return HostAction; | |||
3027 | ||||
3028 | assert(HostAction && "Invalid host action!")((HostAction && "Invalid host action!") ? static_cast <void> (0) : __assert_fail ("HostAction && \"Invalid host action!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3028, __PRETTY_FUNCTION__)); | |||
3029 | ||||
3030 | OffloadAction::DeviceDependences DDeps; | |||
3031 | // Check if all the programming models agree we should not emit the host | |||
3032 | // action. Also, keep track of the offloading kinds employed. | |||
3033 | auto &OffloadKind = InputArgToOffloadKindMap[InputArg]; | |||
3034 | unsigned InactiveBuilders = 0u; | |||
3035 | unsigned IgnoringBuilders = 0u; | |||
3036 | for (auto *SB : SpecializedBuilders) { | |||
3037 | if (!SB->isValid()) { | |||
3038 | ++InactiveBuilders; | |||
3039 | continue; | |||
3040 | } | |||
3041 | ||||
3042 | auto RetCode = | |||
3043 | SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases); | |||
3044 | ||||
3045 | // If the builder explicitly says the host action should be ignored, | |||
3046 | // we need to increment the variable that tracks the builders that request | |||
3047 | // the host object to be ignored. | |||
3048 | if (RetCode == DeviceActionBuilder::ABRT_Ignore_Host) | |||
3049 | ++IgnoringBuilders; | |||
3050 | ||||
3051 | // Unless the builder was inactive for this action, we have to record the | |||
3052 | // offload kind because the host will have to use it. | |||
3053 | if (RetCode != DeviceActionBuilder::ABRT_Inactive) | |||
3054 | OffloadKind |= SB->getAssociatedOffloadKind(); | |||
3055 | } | |||
3056 | ||||
3057 | // If all builders agree that the host object should be ignored, just return | |||
3058 | // nullptr. | |||
3059 | if (IgnoringBuilders && | |||
3060 | SpecializedBuilders.size() == (InactiveBuilders + IgnoringBuilders)) | |||
3061 | return nullptr; | |||
3062 | ||||
3063 | if (DDeps.getActions().empty()) | |||
3064 | return HostAction; | |||
3065 | ||||
3066 | // We have dependences we need to bundle together. We use an offload action | |||
3067 | // for that. | |||
3068 | OffloadAction::HostDependence HDep( | |||
3069 | *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(), | |||
3070 | /*BoundArch=*/nullptr, DDeps); | |||
3071 | return C.MakeAction<OffloadAction>(HDep, DDeps); | |||
3072 | } | |||
3073 | ||||
3074 | /// Generate an action that adds a host dependence to a device action. The | |||
3075 | /// results will be kept in this action builder. Return true if an error was | |||
3076 | /// found. | |||
3077 | bool addHostDependenceToDeviceActions(Action *&HostAction, | |||
3078 | const Arg *InputArg) { | |||
3079 | if (!IsValid) | |||
3080 | return true; | |||
3081 | ||||
3082 | // If we are supporting bundling/unbundling and the current action is an | |||
3083 | // input action of non-source file, we replace the host action by the | |||
3084 | // unbundling action. The bundler tool has the logic to detect if an input | |||
3085 | // is a bundle or not and if the input is not a bundle it assumes it is a | |||
3086 | // host file. Therefore it is safe to create an unbundling action even if | |||
3087 | // the input is not a bundle. | |||
3088 | if (CanUseBundler && isa<InputAction>(HostAction) && | |||
3089 | InputArg->getOption().getKind() == llvm::opt::Option::InputClass && | |||
3090 | !types::isSrcFile(HostAction->getType())) { | |||
3091 | auto UnbundlingHostAction = | |||
3092 | C.MakeAction<OffloadUnbundlingJobAction>(HostAction); | |||
3093 | UnbundlingHostAction->registerDependentActionInfo( | |||
3094 | C.getSingleOffloadToolChain<Action::OFK_Host>(), | |||
3095 | /*BoundArch=*/StringRef(), Action::OFK_Host); | |||
3096 | HostAction = UnbundlingHostAction; | |||
3097 | } | |||
3098 | ||||
3099 | assert(HostAction && "Invalid host action!")((HostAction && "Invalid host action!") ? static_cast <void> (0) : __assert_fail ("HostAction && \"Invalid host action!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3099, __PRETTY_FUNCTION__)); | |||
3100 | ||||
3101 | // Register the offload kinds that are used. | |||
3102 | auto &OffloadKind = InputArgToOffloadKindMap[InputArg]; | |||
3103 | for (auto *SB : SpecializedBuilders) { | |||
3104 | if (!SB->isValid()) | |||
3105 | continue; | |||
3106 | ||||
3107 | auto RetCode = SB->addDeviceDepences(HostAction); | |||
3108 | ||||
3109 | // Host dependences for device actions are not compatible with that same | |||
3110 | // action being ignored. | |||
3111 | assert(RetCode != DeviceActionBuilder::ABRT_Ignore_Host &&((RetCode != DeviceActionBuilder::ABRT_Ignore_Host && "Host dependence not expected to be ignored.!") ? static_cast <void> (0) : __assert_fail ("RetCode != DeviceActionBuilder::ABRT_Ignore_Host && \"Host dependence not expected to be ignored.!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3112, __PRETTY_FUNCTION__)) | |||
3112 | "Host dependence not expected to be ignored.!")((RetCode != DeviceActionBuilder::ABRT_Ignore_Host && "Host dependence not expected to be ignored.!") ? static_cast <void> (0) : __assert_fail ("RetCode != DeviceActionBuilder::ABRT_Ignore_Host && \"Host dependence not expected to be ignored.!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3112, __PRETTY_FUNCTION__)); | |||
3113 | ||||
3114 | // Unless the builder was inactive for this action, we have to record the | |||
3115 | // offload kind because the host will have to use it. | |||
3116 | if (RetCode != DeviceActionBuilder::ABRT_Inactive) | |||
3117 | OffloadKind |= SB->getAssociatedOffloadKind(); | |||
3118 | } | |||
3119 | ||||
3120 | // Do not use unbundler if the Host does not depend on device action. | |||
3121 | if (OffloadKind == Action::OFK_None && CanUseBundler) | |||
3122 | if (auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) | |||
3123 | HostAction = UA->getInputs().back(); | |||
3124 | ||||
3125 | return false; | |||
3126 | } | |||
3127 | ||||
3128 | /// Add the offloading top level actions to the provided action list. This | |||
3129 | /// function can replace the host action by a bundling action if the | |||
3130 | /// programming models allow it. | |||
3131 | bool appendTopLevelActions(ActionList &AL, Action *HostAction, | |||
3132 | const Arg *InputArg) { | |||
3133 | // Get the device actions to be appended. | |||
3134 | ActionList OffloadAL; | |||
3135 | for (auto *SB : SpecializedBuilders) { | |||
3136 | if (!SB->isValid()) | |||
3137 | continue; | |||
3138 | SB->appendTopLevelActions(OffloadAL); | |||
3139 | } | |||
3140 | ||||
3141 | // If we can use the bundler, replace the host action by the bundling one in | |||
3142 | // the resulting list. Otherwise, just append the device actions. For | |||
3143 | // device only compilation, HostAction is a null pointer, therefore only do | |||
3144 | // this when HostAction is not a null pointer. | |||
3145 | if (CanUseBundler && HostAction && | |||
3146 | HostAction->getType() != types::TY_Nothing && !OffloadAL.empty()) { | |||
3147 | // Add the host action to the list in order to create the bundling action. | |||
3148 | OffloadAL.push_back(HostAction); | |||
3149 | ||||
3150 | // We expect that the host action was just appended to the action list | |||
3151 | // before this method was called. | |||
3152 | assert(HostAction == AL.back() && "Host action not in the list??")((HostAction == AL.back() && "Host action not in the list??" ) ? static_cast<void> (0) : __assert_fail ("HostAction == AL.back() && \"Host action not in the list??\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3152, __PRETTY_FUNCTION__)); | |||
3153 | HostAction = C.MakeAction<OffloadBundlingJobAction>(OffloadAL); | |||
3154 | AL.back() = HostAction; | |||
3155 | } else | |||
3156 | AL.append(OffloadAL.begin(), OffloadAL.end()); | |||
3157 | ||||
3158 | // Propagate to the current host action (if any) the offload information | |||
3159 | // associated with the current input. | |||
3160 | if (HostAction) | |||
3161 | HostAction->propagateHostOffloadInfo(InputArgToOffloadKindMap[InputArg], | |||
3162 | /*BoundArch=*/nullptr); | |||
3163 | return false; | |||
3164 | } | |||
3165 | ||||
3166 | Action* makeHostLinkAction() { | |||
3167 | // Build a list of device linking actions. | |||
3168 | ActionList DeviceAL; | |||
3169 | for (DeviceActionBuilder *SB : SpecializedBuilders) { | |||
3170 | if (!SB->isValid()) | |||
3171 | continue; | |||
3172 | SB->appendLinkActions(DeviceAL); | |||
3173 | } | |||
3174 | ||||
3175 | if (DeviceAL.empty()) | |||
3176 | return nullptr; | |||
3177 | ||||
3178 | // Create wrapper bitcode from the result of device link actions and compile | |||
3179 | // it to an object which will be added to the host link command. | |||
3180 | auto *BC = C.MakeAction<OffloadWrapperJobAction>(DeviceAL, types::TY_LLVM_BC); | |||
3181 | auto *ASM = C.MakeAction<BackendJobAction>(BC, types::TY_PP_Asm); | |||
3182 | return C.MakeAction<AssembleJobAction>(ASM, types::TY_Object); | |||
3183 | } | |||
3184 | ||||
3185 | /// Processes the host linker action. This currently consists of replacing it | |||
3186 | /// with an offload action if there are device link objects and propagate to | |||
3187 | /// the host action all the offload kinds used in the current compilation. The | |||
3188 | /// resulting action is returned. | |||
3189 | Action *processHostLinkAction(Action *HostAction) { | |||
3190 | // Add all the dependences from the device linking actions. | |||
3191 | OffloadAction::DeviceDependences DDeps; | |||
3192 | for (auto *SB : SpecializedBuilders) { | |||
3193 | if (!SB->isValid()) | |||
3194 | continue; | |||
3195 | ||||
3196 | SB->appendLinkDependences(DDeps); | |||
3197 | } | |||
3198 | ||||
3199 | // Calculate all the offload kinds used in the current compilation. | |||
3200 | unsigned ActiveOffloadKinds = 0u; | |||
3201 | for (auto &I : InputArgToOffloadKindMap) | |||
3202 | ActiveOffloadKinds |= I.second; | |||
3203 | ||||
3204 | // If we don't have device dependencies, we don't have to create an offload | |||
3205 | // action. | |||
3206 | if (DDeps.getActions().empty()) { | |||
3207 | // Propagate all the active kinds to host action. Given that it is a link | |||
3208 | // action it is assumed to depend on all actions generated so far. | |||
3209 | HostAction->propagateHostOffloadInfo(ActiveOffloadKinds, | |||
3210 | /*BoundArch=*/nullptr); | |||
3211 | return HostAction; | |||
3212 | } | |||
3213 | ||||
3214 | // Create the offload action with all dependences. When an offload action | |||
3215 | // is created the kinds are propagated to the host action, so we don't have | |||
3216 | // to do that explicitly here. | |||
3217 | OffloadAction::HostDependence HDep( | |||
3218 | *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(), | |||
3219 | /*BoundArch*/ nullptr, ActiveOffloadKinds); | |||
3220 | return C.MakeAction<OffloadAction>(HDep, DDeps); | |||
3221 | } | |||
3222 | }; | |||
3223 | } // anonymous namespace. | |||
3224 | ||||
3225 | void Driver::handleArguments(Compilation &C, DerivedArgList &Args, | |||
3226 | const InputList &Inputs, | |||
3227 | ActionList &Actions) const { | |||
3228 | ||||
3229 | // Ignore /Yc/Yu if both /Yc and /Yu passed but with different filenames. | |||
3230 | Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc); | |||
3231 | Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu); | |||
3232 | if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) { | |||
3233 | Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl); | |||
3234 | Args.eraseArg(options::OPT__SLASH_Yc); | |||
3235 | Args.eraseArg(options::OPT__SLASH_Yu); | |||
3236 | YcArg = YuArg = nullptr; | |||
3237 | } | |||
3238 | if (YcArg && Inputs.size() > 1) { | |||
3239 | Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl); | |||
3240 | Args.eraseArg(options::OPT__SLASH_Yc); | |||
3241 | YcArg = nullptr; | |||
3242 | } | |||
3243 | ||||
3244 | Arg *FinalPhaseArg; | |||
3245 | phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg); | |||
3246 | ||||
3247 | if (FinalPhase == phases::Link) { | |||
3248 | if (Args.hasArg(options::OPT_emit_llvm)) | |||
3249 | Diag(clang::diag::err_drv_emit_llvm_link); | |||
3250 | if (IsCLMode() && LTOMode != LTOK_None && | |||
3251 | !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower("lld")) | |||
3252 | Diag(clang::diag::err_drv_lto_without_lld); | |||
3253 | } | |||
3254 | ||||
3255 | if (FinalPhase == phases::Preprocess || Args.hasArg(options::OPT__SLASH_Y_)) { | |||
3256 | // If only preprocessing or /Y- is used, all pch handling is disabled. | |||
3257 | // Rather than check for it everywhere, just remove clang-cl pch-related | |||
3258 | // flags here. | |||
3259 | Args.eraseArg(options::OPT__SLASH_Fp); | |||
3260 | Args.eraseArg(options::OPT__SLASH_Yc); | |||
3261 | Args.eraseArg(options::OPT__SLASH_Yu); | |||
3262 | YcArg = YuArg = nullptr; | |||
3263 | } | |||
3264 | ||||
3265 | unsigned LastPLSize = 0; | |||
3266 | for (auto &I : Inputs) { | |||
3267 | types::ID InputType = I.first; | |||
3268 | const Arg *InputArg = I.second; | |||
3269 | ||||
3270 | llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL; | |||
3271 | types::getCompilationPhases(InputType, PL); | |||
3272 | LastPLSize = PL.size(); | |||
3273 | ||||
3274 | // If the first step comes after the final phase we are doing as part of | |||
3275 | // this compilation, warn the user about it. | |||
3276 | phases::ID InitialPhase = PL[0]; | |||
3277 | if (InitialPhase > FinalPhase) { | |||
3278 | if (InputArg->isClaimed()) | |||
3279 | continue; | |||
3280 | ||||
3281 | // Claim here to avoid the more general unused warning. | |||
3282 | InputArg->claim(); | |||
3283 | ||||
3284 | // Suppress all unused style warnings with -Qunused-arguments | |||
3285 | if (Args.hasArg(options::OPT_Qunused_arguments)) | |||
3286 | continue; | |||
3287 | ||||
3288 | // Special case when final phase determined by binary name, rather than | |||
3289 | // by a command-line argument with a corresponding Arg. | |||
3290 | if (CCCIsCPP()) | |||
3291 | Diag(clang::diag::warn_drv_input_file_unused_by_cpp) | |||
3292 | << InputArg->getAsString(Args) << getPhaseName(InitialPhase); | |||
3293 | // Special case '-E' warning on a previously preprocessed file to make | |||
3294 | // more sense. | |||
3295 | else if (InitialPhase == phases::Compile && | |||
3296 | (Args.getLastArg(options::OPT__SLASH_EP, | |||
3297 | options::OPT__SLASH_P) || | |||
3298 | Args.getLastArg(options::OPT_E) || | |||
3299 | Args.getLastArg(options::OPT_M, options::OPT_MM)) && | |||
3300 | getPreprocessedType(InputType) == types::TY_INVALID) | |||
3301 | Diag(clang::diag::warn_drv_preprocessed_input_file_unused) | |||
3302 | << InputArg->getAsString(Args) << !!FinalPhaseArg | |||
3303 | << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); | |||
3304 | else | |||
3305 | Diag(clang::diag::warn_drv_input_file_unused) | |||
3306 | << InputArg->getAsString(Args) << getPhaseName(InitialPhase) | |||
3307 | << !!FinalPhaseArg | |||
3308 | << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); | |||
3309 | continue; | |||
3310 | } | |||
3311 | ||||
3312 | if (YcArg) { | |||
3313 | // Add a separate precompile phase for the compile phase. | |||
3314 | if (FinalPhase >= phases::Compile) { | |||
3315 | const types::ID HeaderType = lookupHeaderTypeForSourceType(InputType); | |||
3316 | llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PCHPL; | |||
3317 | types::getCompilationPhases(HeaderType, PCHPL); | |||
3318 | // Build the pipeline for the pch file. | |||
3319 | Action *ClangClPch = C.MakeAction<InputAction>(*InputArg, HeaderType); | |||
3320 | for (phases::ID Phase : PCHPL) | |||
3321 | ClangClPch = ConstructPhaseAction(C, Args, Phase, ClangClPch); | |||
3322 | assert(ClangClPch)((ClangClPch) ? static_cast<void> (0) : __assert_fail ( "ClangClPch", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3322, __PRETTY_FUNCTION__)); | |||
3323 | Actions.push_back(ClangClPch); | |||
3324 | // The driver currently exits after the first failed command. This | |||
3325 | // relies on that behavior, to make sure if the pch generation fails, | |||
3326 | // the main compilation won't run. | |||
3327 | // FIXME: If the main compilation fails, the PCH generation should | |||
3328 | // probably not be considered successful either. | |||
3329 | } | |||
3330 | } | |||
3331 | } | |||
3332 | ||||
3333 | // If we are linking, claim any options which are obviously only used for | |||
3334 | // compilation. | |||
3335 | // FIXME: Understand why the last Phase List length is used here. | |||
3336 | if (FinalPhase == phases::Link && LastPLSize == 1) { | |||
3337 | Args.ClaimAllArgs(options::OPT_CompileOnly_Group); | |||
3338 | Args.ClaimAllArgs(options::OPT_cl_compile_Group); | |||
3339 | } | |||
3340 | } | |||
3341 | ||||
3342 | void Driver::BuildActions(Compilation &C, DerivedArgList &Args, | |||
3343 | const InputList &Inputs, ActionList &Actions) const { | |||
3344 | llvm::PrettyStackTraceString CrashInfo("Building compilation actions"); | |||
3345 | ||||
3346 | if (!SuppressMissingInputWarning && Inputs.empty()) { | |||
3347 | Diag(clang::diag::err_drv_no_input_files); | |||
3348 | return; | |||
3349 | } | |||
3350 | ||||
3351 | // Reject -Z* at the top level, these options should never have been exposed | |||
3352 | // by gcc. | |||
3353 | if (Arg *A = Args.getLastArg(options::OPT_Z_Joined)) | |||
3354 | Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args); | |||
3355 | ||||
3356 | // Diagnose misuse of /Fo. | |||
3357 | if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) { | |||
3358 | StringRef V = A->getValue(); | |||
3359 | if (Inputs.size() > 1 && !V.empty() && | |||
3360 | !llvm::sys::path::is_separator(V.back())) { | |||
3361 | // Check whether /Fo tries to name an output file for multiple inputs. | |||
3362 | Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) | |||
3363 | << A->getSpelling() << V; | |||
3364 | Args.eraseArg(options::OPT__SLASH_Fo); | |||
3365 | } | |||
3366 | } | |||
3367 | ||||
3368 | // Diagnose misuse of /Fa. | |||
3369 | if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) { | |||
3370 | StringRef V = A->getValue(); | |||
3371 | if (Inputs.size() > 1 && !V.empty() && | |||
3372 | !llvm::sys::path::is_separator(V.back())) { | |||
3373 | // Check whether /Fa tries to name an asm file for multiple inputs. | |||
3374 | Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) | |||
3375 | << A->getSpelling() << V; | |||
3376 | Args.eraseArg(options::OPT__SLASH_Fa); | |||
3377 | } | |||
3378 | } | |||
3379 | ||||
3380 | // Diagnose misuse of /o. | |||
3381 | if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) { | |||
3382 | if (A->getValue()[0] == '\0') { | |||
3383 | // It has to have a value. | |||
3384 | Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1; | |||
3385 | Args.eraseArg(options::OPT__SLASH_o); | |||
3386 | } | |||
3387 | } | |||
3388 | ||||
3389 | handleArguments(C, Args, Inputs, Actions); | |||
3390 | ||||
3391 | // Builder to be used to build offloading actions. | |||
3392 | OffloadingActionBuilder OffloadBuilder(C, Args, Inputs); | |||
3393 | ||||
3394 | // Construct the actions to perform. | |||
3395 | HeaderModulePrecompileJobAction *HeaderModuleAction = nullptr; | |||
3396 | ActionList LinkerInputs; | |||
3397 | ActionList MergerInputs; | |||
3398 | ||||
3399 | for (auto &I : Inputs) { | |||
3400 | types::ID InputType = I.first; | |||
3401 | const Arg *InputArg = I.second; | |||
3402 | ||||
3403 | llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL; | |||
3404 | types::getCompilationPhases(*this, Args, InputType, PL); | |||
3405 | if (PL.empty()) | |||
3406 | continue; | |||
3407 | ||||
3408 | llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> FullPL; | |||
3409 | types::getCompilationPhases(InputType, FullPL); | |||
3410 | ||||
3411 | // Build the pipeline for this file. | |||
3412 | Action *Current = C.MakeAction<InputAction>(*InputArg, InputType); | |||
3413 | ||||
3414 | // Use the current host action in any of the offloading actions, if | |||
3415 | // required. | |||
3416 | if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg)) | |||
3417 | break; | |||
3418 | ||||
3419 | for (phases::ID Phase : PL) { | |||
3420 | ||||
3421 | // Add any offload action the host action depends on. | |||
3422 | Current = OffloadBuilder.addDeviceDependencesToHostAction( | |||
3423 | Current, InputArg, Phase, PL.back(), FullPL); | |||
3424 | if (!Current) | |||
3425 | break; | |||
3426 | ||||
3427 | // Queue linker inputs. | |||
3428 | if (Phase == phases::Link) { | |||
3429 | assert(Phase == PL.back() && "linking must be final compilation step.")((Phase == PL.back() && "linking must be final compilation step." ) ? static_cast<void> (0) : __assert_fail ("Phase == PL.back() && \"linking must be final compilation step.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3429, __PRETTY_FUNCTION__)); | |||
3430 | LinkerInputs.push_back(Current); | |||
3431 | Current = nullptr; | |||
3432 | break; | |||
3433 | } | |||
3434 | ||||
3435 | // TODO: Consider removing this because the merged may not end up being | |||
3436 | // the final Phase in the pipeline. Perhaps the merged could just merge | |||
3437 | // and then pass an artifact of some sort to the Link Phase. | |||
3438 | // Queue merger inputs. | |||
3439 | if (Phase == phases::IfsMerge) { | |||
3440 | assert(Phase == PL.back() && "merging must be final compilation step.")((Phase == PL.back() && "merging must be final compilation step." ) ? static_cast<void> (0) : __assert_fail ("Phase == PL.back() && \"merging must be final compilation step.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3440, __PRETTY_FUNCTION__)); | |||
3441 | MergerInputs.push_back(Current); | |||
3442 | Current = nullptr; | |||
3443 | break; | |||
3444 | } | |||
3445 | ||||
3446 | // Each precompiled header file after a module file action is a module | |||
3447 | // header of that same module file, rather than being compiled to a | |||
3448 | // separate PCH. | |||
3449 | if (Phase == phases::Precompile && HeaderModuleAction && | |||
3450 | getPrecompiledType(InputType) == types::TY_PCH) { | |||
3451 | HeaderModuleAction->addModuleHeaderInput(Current); | |||
3452 | Current = nullptr; | |||
3453 | break; | |||
3454 | } | |||
3455 | ||||
3456 | // FIXME: Should we include any prior module file outputs as inputs of | |||
3457 | // later actions in the same command line? | |||
3458 | ||||
3459 | // Otherwise construct the appropriate action. | |||
3460 | Action *NewCurrent = ConstructPhaseAction(C, Args, Phase, Current); | |||
3461 | ||||
3462 | // We didn't create a new action, so we will just move to the next phase. | |||
3463 | if (NewCurrent == Current) | |||
3464 | continue; | |||
3465 | ||||
3466 | if (auto *HMA = dyn_cast<HeaderModulePrecompileJobAction>(NewCurrent)) | |||
3467 | HeaderModuleAction = HMA; | |||
3468 | ||||
3469 | Current = NewCurrent; | |||
3470 | ||||
3471 | // Use the current host action in any of the offloading actions, if | |||
3472 | // required. | |||
3473 | if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg)) | |||
3474 | break; | |||
3475 | ||||
3476 | if (Current->getType() == types::TY_Nothing) | |||
3477 | break; | |||
3478 | } | |||
3479 | ||||
3480 | // If we ended with something, add to the output list. | |||
3481 | if (Current) | |||
3482 | Actions.push_back(Current); | |||
3483 | ||||
3484 | // Add any top level actions generated for offloading. | |||
3485 | OffloadBuilder.appendTopLevelActions(Actions, Current, InputArg); | |||
3486 | } | |||
3487 | ||||
3488 | // Add a link action if necessary. | |||
3489 | if (!LinkerInputs.empty()) { | |||
3490 | if (Action *Wrapper = OffloadBuilder.makeHostLinkAction()) | |||
3491 | LinkerInputs.push_back(Wrapper); | |||
3492 | Action *LA = C.MakeAction<LinkJobAction>(LinkerInputs, types::TY_Image); | |||
3493 | LA = OffloadBuilder.processHostLinkAction(LA); | |||
3494 | Actions.push_back(LA); | |||
3495 | } | |||
3496 | ||||
3497 | // Add an interface stubs merge action if necessary. | |||
3498 | if (!MergerInputs.empty()) | |||
3499 | Actions.push_back( | |||
3500 | C.MakeAction<IfsMergeJobAction>(MergerInputs, types::TY_Image)); | |||
3501 | ||||
3502 | if (Args.hasArg(options::OPT_emit_interface_stubs)) { | |||
3503 | llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PhaseList; | |||
3504 | if (Args.hasArg(options::OPT_c)) { | |||
3505 | llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> CompilePhaseList; | |||
3506 | types::getCompilationPhases(types::TY_IFS_CPP, CompilePhaseList); | |||
3507 | llvm::copy_if(CompilePhaseList, std::back_inserter(PhaseList), | |||
3508 | [&](phases::ID Phase) { return Phase <= phases::Compile; }); | |||
3509 | } else { | |||
3510 | types::getCompilationPhases(types::TY_IFS_CPP, PhaseList); | |||
3511 | } | |||
3512 | ||||
3513 | ActionList MergerInputs; | |||
3514 | ||||
3515 | for (auto &I : Inputs) { | |||
3516 | types::ID InputType = I.first; | |||
3517 | const Arg *InputArg = I.second; | |||
3518 | ||||
3519 | // Currently clang and the llvm assembler do not support generating symbol | |||
3520 | // stubs from assembly, so we skip the input on asm files. For ifs files | |||
3521 | // we rely on the normal pipeline setup in the pipeline setup code above. | |||
3522 | if (InputType == types::TY_IFS || InputType == types::TY_PP_Asm || | |||
3523 | InputType == types::TY_Asm) | |||
3524 | continue; | |||
3525 | ||||
3526 | Action *Current = C.MakeAction<InputAction>(*InputArg, InputType); | |||
3527 | ||||
3528 | for (auto Phase : PhaseList) { | |||
3529 | switch (Phase) { | |||
3530 | default: | |||
3531 | llvm_unreachable(::llvm::llvm_unreachable_internal("IFS Pipeline can only consist of Compile followed by IfsMerge." , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3532) | |||
3532 | "IFS Pipeline can only consist of Compile followed by IfsMerge.")::llvm::llvm_unreachable_internal("IFS Pipeline can only consist of Compile followed by IfsMerge." , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3532); | |||
3533 | case phases::Compile: { | |||
3534 | // Only IfsMerge (llvm-ifs) can handle .o files by looking for ifs | |||
3535 | // files where the .o file is located. The compile action can not | |||
3536 | // handle this. | |||
3537 | if (InputType == types::TY_Object) | |||
3538 | break; | |||
3539 | ||||
3540 | Current = C.MakeAction<CompileJobAction>(Current, types::TY_IFS_CPP); | |||
3541 | break; | |||
3542 | } | |||
3543 | case phases::IfsMerge: { | |||
3544 | assert(Phase == PhaseList.back() &&((Phase == PhaseList.back() && "merging must be final compilation step." ) ? static_cast<void> (0) : __assert_fail ("Phase == PhaseList.back() && \"merging must be final compilation step.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3545, __PRETTY_FUNCTION__)) | |||
3545 | "merging must be final compilation step.")((Phase == PhaseList.back() && "merging must be final compilation step." ) ? static_cast<void> (0) : __assert_fail ("Phase == PhaseList.back() && \"merging must be final compilation step.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3545, __PRETTY_FUNCTION__)); | |||
3546 | MergerInputs.push_back(Current); | |||
3547 | Current = nullptr; | |||
3548 | break; | |||
3549 | } | |||
3550 | } | |||
3551 | } | |||
3552 | ||||
3553 | // If we ended with something, add to the output list. | |||
3554 | if (Current) | |||
3555 | Actions.push_back(Current); | |||
3556 | } | |||
3557 | ||||
3558 | // Add an interface stubs merge action if necessary. | |||
3559 | if (!MergerInputs.empty()) | |||
3560 | Actions.push_back( | |||
3561 | C.MakeAction<IfsMergeJobAction>(MergerInputs, types::TY_Image)); | |||
3562 | } | |||
3563 | ||||
3564 | // If --print-supported-cpus, -mcpu=? or -mtune=? is specified, build a custom | |||
3565 | // Compile phase that prints out supported cpu models and quits. | |||
3566 | if (Arg *A = Args.getLastArg(options::OPT_print_supported_cpus)) { | |||
3567 | // Use the -mcpu=? flag as the dummy input to cc1. | |||
3568 | Actions.clear(); | |||
3569 | Action *InputAc = C.MakeAction<InputAction>(*A, types::TY_C); | |||
3570 | Actions.push_back( | |||
3571 | C.MakeAction<PrecompileJobAction>(InputAc, types::TY_Nothing)); | |||
3572 | for (auto &I : Inputs) | |||
3573 | I.second->claim(); | |||
3574 | } | |||
3575 | ||||
3576 | // Claim ignored clang-cl options. | |||
3577 | Args.ClaimAllArgs(options::OPT_cl_ignored_Group); | |||
3578 | ||||
3579 | // Claim --cuda-host-only and --cuda-compile-host-device, which may be passed | |||
3580 | // to non-CUDA compilations and should not trigger warnings there. | |||
3581 | Args.ClaimAllArgs(options::OPT_cuda_host_only); | |||
3582 | Args.ClaimAllArgs(options::OPT_cuda_compile_host_device); | |||
3583 | } | |||
3584 | ||||
3585 | Action *Driver::ConstructPhaseAction( | |||
3586 | Compilation &C, const ArgList &Args, phases::ID Phase, Action *Input, | |||
3587 | Action::OffloadKind TargetDeviceOffloadKind) const { | |||
3588 | llvm::PrettyStackTraceString CrashInfo("Constructing phase actions"); | |||
3589 | ||||
3590 | // Some types skip the assembler phase (e.g., llvm-bc), but we can't | |||
3591 | // encode this in the steps because the intermediate type depends on | |||
3592 | // arguments. Just special case here. | |||
3593 | if (Phase == phases::Assemble && Input->getType() != types::TY_PP_Asm) | |||
3594 | return Input; | |||
3595 | ||||
3596 | // Build the appropriate action. | |||
3597 | switch (Phase) { | |||
3598 | case phases::Link: | |||
3599 | llvm_unreachable("link action invalid here.")::llvm::llvm_unreachable_internal("link action invalid here." , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3599); | |||
3600 | case phases::IfsMerge: | |||
3601 | llvm_unreachable("ifsmerge action invalid here.")::llvm::llvm_unreachable_internal("ifsmerge action invalid here." , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3601); | |||
3602 | case phases::Preprocess: { | |||
3603 | types::ID OutputTy; | |||
3604 | // -M and -MM specify the dependency file name by altering the output type, | |||
3605 | // -if -MD and -MMD are not specified. | |||
3606 | if (Args.hasArg(options::OPT_M, options::OPT_MM) && | |||
3607 | !Args.hasArg(options::OPT_MD, options::OPT_MMD)) { | |||
3608 | OutputTy = types::TY_Dependencies; | |||
3609 | } else { | |||
3610 | OutputTy = Input->getType(); | |||
3611 | if (!Args.hasFlag(options::OPT_frewrite_includes, | |||
3612 | options::OPT_fno_rewrite_includes, false) && | |||
3613 | !Args.hasFlag(options::OPT_frewrite_imports, | |||
3614 | options::OPT_fno_rewrite_imports, false) && | |||
3615 | !CCGenDiagnostics) | |||
3616 | OutputTy = types::getPreprocessedType(OutputTy); | |||
3617 | assert(OutputTy != types::TY_INVALID &&((OutputTy != types::TY_INVALID && "Cannot preprocess this input type!" ) ? static_cast<void> (0) : __assert_fail ("OutputTy != types::TY_INVALID && \"Cannot preprocess this input type!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3618, __PRETTY_FUNCTION__)) | |||
3618 | "Cannot preprocess this input type!")((OutputTy != types::TY_INVALID && "Cannot preprocess this input type!" ) ? static_cast<void> (0) : __assert_fail ("OutputTy != types::TY_INVALID && \"Cannot preprocess this input type!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3618, __PRETTY_FUNCTION__)); | |||
3619 | } | |||
3620 | return C.MakeAction<PreprocessJobAction>(Input, OutputTy); | |||
3621 | } | |||
3622 | case phases::Precompile: { | |||
3623 | types::ID OutputTy = getPrecompiledType(Input->getType()); | |||
3624 | assert(OutputTy != types::TY_INVALID &&((OutputTy != types::TY_INVALID && "Cannot precompile this input type!" ) ? static_cast<void> (0) : __assert_fail ("OutputTy != types::TY_INVALID && \"Cannot precompile this input type!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3625, __PRETTY_FUNCTION__)) | |||
3625 | "Cannot precompile this input type!")((OutputTy != types::TY_INVALID && "Cannot precompile this input type!" ) ? static_cast<void> (0) : __assert_fail ("OutputTy != types::TY_INVALID && \"Cannot precompile this input type!\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3625, __PRETTY_FUNCTION__)); | |||
3626 | ||||
3627 | // If we're given a module name, precompile header file inputs as a | |||
3628 | // module, not as a precompiled header. | |||
3629 | const char *ModName = nullptr; | |||
3630 | if (OutputTy == types::TY_PCH) { | |||
3631 | if (Arg *A = Args.getLastArg(options::OPT_fmodule_name_EQ)) | |||
3632 | ModName = A->getValue(); | |||
3633 | if (ModName) | |||
3634 | OutputTy = types::TY_ModuleFile; | |||
3635 | } | |||
3636 | ||||
3637 | if (Args.hasArg(options::OPT_fsyntax_only)) { | |||
3638 | // Syntax checks should not emit a PCH file | |||
3639 | OutputTy = types::TY_Nothing; | |||
3640 | } | |||
3641 | ||||
3642 | if (ModName) | |||
3643 | return C.MakeAction<HeaderModulePrecompileJobAction>(Input, OutputTy, | |||
3644 | ModName); | |||
3645 | return C.MakeAction<PrecompileJobAction>(Input, OutputTy); | |||
3646 | } | |||
3647 | case phases::Compile: { | |||
3648 | if (Args.hasArg(options::OPT_fsyntax_only)) | |||
3649 | return C.MakeAction<CompileJobAction>(Input, types::TY_Nothing); | |||
3650 | if (Args.hasArg(options::OPT_rewrite_objc)) | |||
3651 | return C.MakeAction<CompileJobAction>(Input, types::TY_RewrittenObjC); | |||
3652 | if (Args.hasArg(options::OPT_rewrite_legacy_objc)) | |||
3653 | return C.MakeAction<CompileJobAction>(Input, | |||
3654 | types::TY_RewrittenLegacyObjC); | |||
3655 | if (Args.hasArg(options::OPT__analyze)) | |||
3656 | return C.MakeAction<AnalyzeJobAction>(Input, types::TY_Plist); | |||
3657 | if (Args.hasArg(options::OPT__migrate)) | |||
3658 | return C.MakeAction<MigrateJobAction>(Input, types::TY_Remap); | |||
3659 | if (Args.hasArg(options::OPT_emit_ast)) | |||
3660 | return C.MakeAction<CompileJobAction>(Input, types::TY_AST); | |||
3661 | if (Args.hasArg(options::OPT_module_file_info)) | |||
3662 | return C.MakeAction<CompileJobAction>(Input, types::TY_ModuleFile); | |||
3663 | if (Args.hasArg(options::OPT_verify_pch)) | |||
3664 | return C.MakeAction<VerifyPCHJobAction>(Input, types::TY_Nothing); | |||
3665 | return C.MakeAction<CompileJobAction>(Input, types::TY_LLVM_BC); | |||
3666 | } | |||
3667 | case phases::Backend: { | |||
3668 | if (isUsingLTO() && TargetDeviceOffloadKind == Action::OFK_None) { | |||
3669 | types::ID Output = | |||
3670 | Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; | |||
3671 | return C.MakeAction<BackendJobAction>(Input, Output); | |||
3672 | } | |||
3673 | if (Args.hasArg(options::OPT_emit_llvm)) { | |||
3674 | types::ID Output = | |||
3675 | Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC; | |||
3676 | return C.MakeAction<BackendJobAction>(Input, Output); | |||
3677 | } | |||
3678 | return C.MakeAction<BackendJobAction>(Input, types::TY_PP_Asm); | |||
3679 | } | |||
3680 | case phases::Assemble: | |||
3681 | return C.MakeAction<AssembleJobAction>(std::move(Input), types::TY_Object); | |||
3682 | } | |||
3683 | ||||
3684 | llvm_unreachable("invalid phase in ConstructPhaseAction")::llvm::llvm_unreachable_internal("invalid phase in ConstructPhaseAction" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3684); | |||
3685 | } | |||
3686 | ||||
3687 | void Driver::BuildJobs(Compilation &C) const { | |||
3688 | llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); | |||
3689 | ||||
3690 | Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o); | |||
3691 | ||||
3692 | // It is an error to provide a -o option if we are making multiple output | |||
3693 | // files. There are exceptions: | |||
3694 | // | |||
3695 | // IfsMergeJob: when generating interface stubs enabled we want to be able to | |||
3696 | // generate the stub file at the same time that we generate the real | |||
3697 | // library/a.out. So when a .o, .so, etc are the output, with clang interface | |||
3698 | // stubs there will also be a .ifs and .ifso at the same location. | |||
3699 | // | |||
3700 | // CompileJob of type TY_IFS_CPP: when generating interface stubs is enabled | |||
3701 | // and -c is passed, we still want to be able to generate a .ifs file while | |||
3702 | // we are also generating .o files. So we allow more than one output file in | |||
3703 | // this case as well. | |||
3704 | // | |||
3705 | if (FinalOutput) { | |||
3706 | unsigned NumOutputs = 0; | |||
3707 | unsigned NumIfsOutputs = 0; | |||
3708 | for (const Action *A : C.getActions()) | |||
3709 | if (A->getType() != types::TY_Nothing && | |||
3710 | !(A->getKind() == Action::IfsMergeJobClass || | |||
3711 | (A->getType() == clang::driver::types::TY_IFS_CPP && | |||
3712 | A->getKind() == clang::driver::Action::CompileJobClass && | |||
3713 | 0 == NumIfsOutputs++) || | |||
3714 | (A->getKind() == Action::BindArchClass && A->getInputs().size() && | |||
3715 | A->getInputs().front()->getKind() == Action::IfsMergeJobClass))) | |||
3716 | ++NumOutputs; | |||
3717 | ||||
3718 | if (NumOutputs > 1) { | |||
3719 | Diag(clang::diag::err_drv_output_argument_with_multiple_files); | |||
3720 | FinalOutput = nullptr; | |||
3721 | } | |||
3722 | } | |||
3723 | ||||
3724 | // Collect the list of architectures. | |||
3725 | llvm::StringSet<> ArchNames; | |||
3726 | if (C.getDefaultToolChain().getTriple().isOSBinFormatMachO()) | |||
3727 | for (const Arg *A : C.getArgs()) | |||
3728 | if (A->getOption().matches(options::OPT_arch)) | |||
3729 | ArchNames.insert(A->getValue()); | |||
3730 | ||||
3731 | // Set of (Action, canonical ToolChain triple) pairs we've built jobs for. | |||
3732 | std::map<std::pair<const Action *, std::string>, InputInfo> CachedResults; | |||
3733 | for (Action *A : C.getActions()) { | |||
3734 | // If we are linking an image for multiple archs then the linker wants | |||
3735 | // -arch_multiple and -final_output <final image name>. Unfortunately, this | |||
3736 | // doesn't fit in cleanly because we have to pass this information down. | |||
3737 | // | |||
3738 | // FIXME: This is a hack; find a cleaner way to integrate this into the | |||
3739 | // process. | |||
3740 | const char *LinkingOutput = nullptr; | |||
3741 | if (isa<LipoJobAction>(A)) { | |||
3742 | if (FinalOutput) | |||
3743 | LinkingOutput = FinalOutput->getValue(); | |||
3744 | else | |||
3745 | LinkingOutput = getDefaultImageName(); | |||
3746 | } | |||
3747 | ||||
3748 | BuildJobsForAction(C, A, &C.getDefaultToolChain(), | |||
3749 | /*BoundArch*/ StringRef(), | |||
3750 | /*AtTopLevel*/ true, | |||
3751 | /*MultipleArchs*/ ArchNames.size() > 1, | |||
3752 | /*LinkingOutput*/ LinkingOutput, CachedResults, | |||
3753 | /*TargetDeviceOffloadKind*/ Action::OFK_None); | |||
3754 | } | |||
3755 | ||||
3756 | // If the user passed -Qunused-arguments or there were errors, don't warn | |||
3757 | // about any unused arguments. | |||
3758 | if (Diags.hasErrorOccurred() || | |||
3759 | C.getArgs().hasArg(options::OPT_Qunused_arguments)) | |||
3760 | return; | |||
3761 | ||||
3762 | // Claim -### here. | |||
3763 | (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH); | |||
3764 | ||||
3765 | // Claim --driver-mode, --rsp-quoting, it was handled earlier. | |||
3766 | (void)C.getArgs().hasArg(options::OPT_driver_mode); | |||
3767 | (void)C.getArgs().hasArg(options::OPT_rsp_quoting); | |||
3768 | ||||
3769 | for (Arg *A : C.getArgs()) { | |||
3770 | // FIXME: It would be nice to be able to send the argument to the | |||
3771 | // DiagnosticsEngine, so that extra values, position, and so on could be | |||
3772 | // printed. | |||
3773 | if (!A->isClaimed()) { | |||
3774 | if (A->getOption().hasFlag(options::NoArgumentUnused)) | |||
3775 | continue; | |||
3776 | ||||
3777 | // Suppress the warning automatically if this is just a flag, and it is an | |||
3778 | // instance of an argument we already claimed. | |||
3779 | const Option &Opt = A->getOption(); | |||
3780 | if (Opt.getKind() == Option::FlagClass) { | |||
3781 | bool DuplicateClaimed = false; | |||
3782 | ||||
3783 | for (const Arg *AA : C.getArgs().filtered(&Opt)) { | |||
3784 | if (AA->isClaimed()) { | |||
3785 | DuplicateClaimed = true; | |||
3786 | break; | |||
3787 | } | |||
3788 | } | |||
3789 | ||||
3790 | if (DuplicateClaimed) | |||
3791 | continue; | |||
3792 | } | |||
3793 | ||||
3794 | // In clang-cl, don't mention unknown arguments here since they have | |||
3795 | // already been warned about. | |||
3796 | if (!IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN)) | |||
3797 | Diag(clang::diag::warn_drv_unused_argument) | |||
3798 | << A->getAsString(C.getArgs()); | |||
3799 | } | |||
3800 | } | |||
3801 | } | |||
3802 | ||||
3803 | namespace { | |||
3804 | /// Utility class to control the collapse of dependent actions and select the | |||
3805 | /// tools accordingly. | |||
3806 | class ToolSelector final { | |||
3807 | /// The tool chain this selector refers to. | |||
3808 | const ToolChain &TC; | |||
3809 | ||||
3810 | /// The compilation this selector refers to. | |||
3811 | const Compilation &C; | |||
3812 | ||||
3813 | /// The base action this selector refers to. | |||
3814 | const JobAction *BaseAction; | |||
3815 | ||||
3816 | /// Set to true if the current toolchain refers to host actions. | |||
3817 | bool IsHostSelector; | |||
3818 | ||||
3819 | /// Set to true if save-temps and embed-bitcode functionalities are active. | |||
3820 | bool SaveTemps; | |||
3821 | bool EmbedBitcode; | |||
3822 | ||||
3823 | /// Get previous dependent action or null if that does not exist. If | |||
3824 | /// \a CanBeCollapsed is false, that action must be legal to collapse or | |||
3825 | /// null will be returned. | |||
3826 | const JobAction *getPrevDependentAction(const ActionList &Inputs, | |||
3827 | ActionList &SavedOffloadAction, | |||
3828 | bool CanBeCollapsed = true) { | |||
3829 | // An option can be collapsed only if it has a single input. | |||
3830 | if (Inputs.size() != 1) | |||
3831 | return nullptr; | |||
3832 | ||||
3833 | Action *CurAction = *Inputs.begin(); | |||
3834 | if (CanBeCollapsed && | |||
3835 | !CurAction->isCollapsingWithNextDependentActionLegal()) | |||
3836 | return nullptr; | |||
3837 | ||||
3838 | // If the input action is an offload action. Look through it and save any | |||
3839 | // offload action that can be dropped in the event of a collapse. | |||
3840 | if (auto *OA = dyn_cast<OffloadAction>(CurAction)) { | |||
3841 | // If the dependent action is a device action, we will attempt to collapse | |||
3842 | // only with other device actions. Otherwise, we would do the same but | |||
3843 | // with host actions only. | |||
3844 | if (!IsHostSelector) { | |||
3845 | if (OA->hasSingleDeviceDependence(/*DoNotConsiderHostActions=*/true)) { | |||
3846 | CurAction = | |||
3847 | OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true); | |||
3848 | if (CanBeCollapsed && | |||
3849 | !CurAction->isCollapsingWithNextDependentActionLegal()) | |||
3850 | return nullptr; | |||
3851 | SavedOffloadAction.push_back(OA); | |||
3852 | return dyn_cast<JobAction>(CurAction); | |||
3853 | } | |||
3854 | } else if (OA->hasHostDependence()) { | |||
3855 | CurAction = OA->getHostDependence(); | |||
3856 | if (CanBeCollapsed && | |||
3857 | !CurAction->isCollapsingWithNextDependentActionLegal()) | |||
3858 | return nullptr; | |||
3859 | SavedOffloadAction.push_back(OA); | |||
3860 | return dyn_cast<JobAction>(CurAction); | |||
3861 | } | |||
3862 | return nullptr; | |||
3863 | } | |||
3864 | ||||
3865 | return dyn_cast<JobAction>(CurAction); | |||
3866 | } | |||
3867 | ||||
3868 | /// Return true if an assemble action can be collapsed. | |||
3869 | bool canCollapseAssembleAction() const { | |||
3870 | return TC.useIntegratedAs() && !SaveTemps && | |||
3871 | !C.getArgs().hasArg(options::OPT_via_file_asm) && | |||
3872 | !C.getArgs().hasArg(options::OPT__SLASH_FA) && | |||
3873 | !C.getArgs().hasArg(options::OPT__SLASH_Fa); | |||
3874 | } | |||
3875 | ||||
3876 | /// Return true if a preprocessor action can be collapsed. | |||
3877 | bool canCollapsePreprocessorAction() const { | |||
3878 | return !C.getArgs().hasArg(options::OPT_no_integrated_cpp) && | |||
3879 | !C.getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps && | |||
3880 | !C.getArgs().hasArg(options::OPT_rewrite_objc); | |||
3881 | } | |||
3882 | ||||
3883 | /// Struct that relates an action with the offload actions that would be | |||
3884 | /// collapsed with it. | |||
3885 | struct JobActionInfo final { | |||
3886 | /// The action this info refers to. | |||
3887 | const JobAction *JA = nullptr; | |||
3888 | /// The offload actions we need to take care off if this action is | |||
3889 | /// collapsed. | |||
3890 | ActionList SavedOffloadAction; | |||
3891 | }; | |||
3892 | ||||
3893 | /// Append collapsed offload actions from the give nnumber of elements in the | |||
3894 | /// action info array. | |||
3895 | static void AppendCollapsedOffloadAction(ActionList &CollapsedOffloadAction, | |||
3896 | ArrayRef<JobActionInfo> &ActionInfo, | |||
3897 | unsigned ElementNum) { | |||
3898 | assert(ElementNum <= ActionInfo.size() && "Invalid number of elements.")((ElementNum <= ActionInfo.size() && "Invalid number of elements." ) ? static_cast<void> (0) : __assert_fail ("ElementNum <= ActionInfo.size() && \"Invalid number of elements.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 3898, __PRETTY_FUNCTION__)); | |||
3899 | for (unsigned I = 0; I < ElementNum; ++I) | |||
3900 | CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(), | |||
3901 | ActionInfo[I].SavedOffloadAction.end()); | |||
3902 | } | |||
3903 | ||||
3904 | /// Functions that attempt to perform the combining. They detect if that is | |||
3905 | /// legal, and if so they update the inputs \a Inputs and the offload action | |||
3906 | /// that were collapsed in \a CollapsedOffloadAction. A tool that deals with | |||
3907 | /// the combined action is returned. If the combining is not legal or if the | |||
3908 | /// tool does not exist, null is returned. | |||
3909 | /// Currently three kinds of collapsing are supported: | |||
3910 | /// - Assemble + Backend + Compile; | |||
3911 | /// - Assemble + Backend ; | |||
3912 | /// - Backend + Compile. | |||
3913 | const Tool * | |||
3914 | combineAssembleBackendCompile(ArrayRef<JobActionInfo> ActionInfo, | |||
3915 | ActionList &Inputs, | |||
3916 | ActionList &CollapsedOffloadAction) { | |||
3917 | if (ActionInfo.size() < 3 || !canCollapseAssembleAction()) | |||
3918 | return nullptr; | |||
3919 | auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA); | |||
3920 | auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA); | |||
3921 | auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[2].JA); | |||
3922 | if (!AJ || !BJ || !CJ) | |||
3923 | return nullptr; | |||
3924 | ||||
3925 | // Get compiler tool. | |||
3926 | const Tool *T = TC.SelectTool(*CJ); | |||
3927 | if (!T) | |||
3928 | return nullptr; | |||
3929 | ||||
3930 | // When using -fembed-bitcode, it is required to have the same tool (clang) | |||
3931 | // for both CompilerJA and BackendJA. Otherwise, combine two stages. | |||
3932 | if (EmbedBitcode) { | |||
3933 | const Tool *BT = TC.SelectTool(*BJ); | |||
3934 | if (BT == T) | |||
3935 | return nullptr; | |||
3936 | } | |||
3937 | ||||
3938 | if (!T->hasIntegratedAssembler()) | |||
3939 | return nullptr; | |||
3940 | ||||
3941 | Inputs = CJ->getInputs(); | |||
3942 | AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo, | |||
3943 | /*NumElements=*/3); | |||
3944 | return T; | |||
3945 | } | |||
3946 | const Tool *combineAssembleBackend(ArrayRef<JobActionInfo> ActionInfo, | |||
3947 | ActionList &Inputs, | |||
3948 | ActionList &CollapsedOffloadAction) { | |||
3949 | if (ActionInfo.size() < 2 || !canCollapseAssembleAction()) | |||
3950 | return nullptr; | |||
3951 | auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA); | |||
3952 | auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA); | |||
3953 | if (!AJ || !BJ) | |||
3954 | return nullptr; | |||
3955 | ||||
3956 | // Get backend tool. | |||
3957 | const Tool *T = TC.SelectTool(*BJ); | |||
3958 | if (!T) | |||
3959 | return nullptr; | |||
3960 | ||||
3961 | if (!T->hasIntegratedAssembler()) | |||
3962 | return nullptr; | |||
3963 | ||||
3964 | Inputs = BJ->getInputs(); | |||
3965 | AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo, | |||
3966 | /*NumElements=*/2); | |||
3967 | return T; | |||
3968 | } | |||
3969 | const Tool *combineBackendCompile(ArrayRef<JobActionInfo> ActionInfo, | |||
3970 | ActionList &Inputs, | |||
3971 | ActionList &CollapsedOffloadAction) { | |||
3972 | if (ActionInfo.size() < 2) | |||
3973 | return nullptr; | |||
3974 | auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[0].JA); | |||
3975 | auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[1].JA); | |||
3976 | if (!BJ || !CJ) | |||
3977 | return nullptr; | |||
3978 | ||||
3979 | // Check if the initial input (to the compile job or its predessor if one | |||
3980 | // exists) is LLVM bitcode. In that case, no preprocessor step is required | |||
3981 | // and we can still collapse the compile and backend jobs when we have | |||
3982 | // -save-temps. I.e. there is no need for a separate compile job just to | |||
3983 | // emit unoptimized bitcode. | |||
3984 | bool InputIsBitcode = true; | |||
3985 | for (size_t i = 1; i < ActionInfo.size(); i++) | |||
3986 | if (ActionInfo[i].JA->getType() != types::TY_LLVM_BC && | |||
3987 | ActionInfo[i].JA->getType() != types::TY_LTO_BC) { | |||
3988 | InputIsBitcode = false; | |||
3989 | break; | |||
3990 | } | |||
3991 | if (!InputIsBitcode && !canCollapsePreprocessorAction()) | |||
3992 | return nullptr; | |||
3993 | ||||
3994 | // Get compiler tool. | |||
3995 | const Tool *T = TC.SelectTool(*CJ); | |||
3996 | if (!T) | |||
3997 | return nullptr; | |||
3998 | ||||
3999 | if (T->canEmitIR() && ((SaveTemps && !InputIsBitcode) || EmbedBitcode)) | |||
4000 | return nullptr; | |||
4001 | ||||
4002 | Inputs = CJ->getInputs(); | |||
4003 | AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo, | |||
4004 | /*NumElements=*/2); | |||
4005 | return T; | |||
4006 | } | |||
4007 | ||||
4008 | /// Updates the inputs if the obtained tool supports combining with | |||
4009 | /// preprocessor action, and the current input is indeed a preprocessor | |||
4010 | /// action. If combining results in the collapse of offloading actions, those | |||
4011 | /// are appended to \a CollapsedOffloadAction. | |||
4012 | void combineWithPreprocessor(const Tool *T, ActionList &Inputs, | |||
4013 | ActionList &CollapsedOffloadAction) { | |||
4014 | if (!T || !canCollapsePreprocessorAction() || !T->hasIntegratedCPP()) | |||
4015 | return; | |||
4016 | ||||
4017 | // Attempt to get a preprocessor action dependence. | |||
4018 | ActionList PreprocessJobOffloadActions; | |||
4019 | ActionList NewInputs; | |||
4020 | for (Action *A : Inputs) { | |||
4021 | auto *PJ = getPrevDependentAction({A}, PreprocessJobOffloadActions); | |||
4022 | if (!PJ || !isa<PreprocessJobAction>(PJ)) { | |||
4023 | NewInputs.push_back(A); | |||
4024 | continue; | |||
4025 | } | |||
4026 | ||||
4027 | // This is legal to combine. Append any offload action we found and add the | |||
4028 | // current input to preprocessor inputs. | |||
4029 | CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(), | |||
4030 | PreprocessJobOffloadActions.end()); | |||
4031 | NewInputs.append(PJ->input_begin(), PJ->input_end()); | |||
4032 | } | |||
4033 | Inputs = NewInputs; | |||
4034 | } | |||
4035 | ||||
4036 | public: | |||
4037 | ToolSelector(const JobAction *BaseAction, const ToolChain &TC, | |||
4038 | const Compilation &C, bool SaveTemps, bool EmbedBitcode) | |||
4039 | : TC(TC), C(C), BaseAction(BaseAction), SaveTemps(SaveTemps), | |||
4040 | EmbedBitcode(EmbedBitcode) { | |||
4041 | assert(BaseAction && "Invalid base action.")((BaseAction && "Invalid base action.") ? static_cast <void> (0) : __assert_fail ("BaseAction && \"Invalid base action.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 4041, __PRETTY_FUNCTION__)); | |||
4042 | IsHostSelector = BaseAction->getOffloadingDeviceKind() == Action::OFK_None; | |||
4043 | } | |||
4044 | ||||
4045 | /// Check if a chain of actions can be combined and return the tool that can | |||
4046 | /// handle the combination of actions. The pointer to the current inputs \a | |||
4047 | /// Inputs and the list of offload actions \a CollapsedOffloadActions | |||
4048 | /// connected to collapsed actions are updated accordingly. The latter enables | |||
4049 | /// the caller of the selector to process them afterwards instead of just | |||
4050 | /// dropping them. If no suitable tool is found, null will be returned. | |||
4051 | const Tool *getTool(ActionList &Inputs, | |||
4052 | ActionList &CollapsedOffloadAction) { | |||
4053 | // | |||
4054 | // Get the largest chain of actions that we could combine. | |||
4055 | // | |||
4056 | ||||
4057 | SmallVector<JobActionInfo, 5> ActionChain(1); | |||
4058 | ActionChain.back().JA = BaseAction; | |||
4059 | while (ActionChain.back().JA) { | |||
4060 | const Action *CurAction = ActionChain.back().JA; | |||
4061 | ||||
4062 | // Grow the chain by one element. | |||
4063 | ActionChain.resize(ActionChain.size() + 1); | |||
4064 | JobActionInfo &AI = ActionChain.back(); | |||
4065 | ||||
4066 | // Attempt to fill it with the | |||
4067 | AI.JA = | |||
4068 | getPrevDependentAction(CurAction->getInputs(), AI.SavedOffloadAction); | |||
4069 | } | |||
4070 | ||||
4071 | // Pop the last action info as it could not be filled. | |||
4072 | ActionChain.pop_back(); | |||
4073 | ||||
4074 | // | |||
4075 | // Attempt to combine actions. If all combining attempts failed, just return | |||
4076 | // the tool of the provided action. At the end we attempt to combine the | |||
4077 | // action with any preprocessor action it may depend on. | |||
4078 | // | |||
4079 | ||||
4080 | const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs, | |||
4081 | CollapsedOffloadAction); | |||
4082 | if (!T) | |||
4083 | T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction); | |||
4084 | if (!T) | |||
4085 | T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction); | |||
4086 | if (!T) { | |||
4087 | Inputs = BaseAction->getInputs(); | |||
4088 | T = TC.SelectTool(*BaseAction); | |||
4089 | } | |||
4090 | ||||
4091 | combineWithPreprocessor(T, Inputs, CollapsedOffloadAction); | |||
4092 | return T; | |||
4093 | } | |||
4094 | }; | |||
4095 | } | |||
4096 | ||||
4097 | /// Return a string that uniquely identifies the result of a job. The bound arch | |||
4098 | /// is not necessarily represented in the toolchain's triple -- for example, | |||
4099 | /// armv7 and armv7s both map to the same triple -- so we need both in our map. | |||
4100 | /// Also, we need to add the offloading device kind, as the same tool chain can | |||
4101 | /// be used for host and device for some programming models, e.g. OpenMP. | |||
4102 | static std::string GetTriplePlusArchString(const ToolChain *TC, | |||
4103 | StringRef BoundArch, | |||
4104 | Action::OffloadKind OffloadKind) { | |||
4105 | std::string TriplePlusArch = TC->getTriple().normalize(); | |||
4106 | if (!BoundArch.empty()) { | |||
4107 | TriplePlusArch += "-"; | |||
4108 | TriplePlusArch += BoundArch; | |||
4109 | } | |||
4110 | TriplePlusArch += "-"; | |||
4111 | TriplePlusArch += Action::GetOffloadKindName(OffloadKind); | |||
4112 | return TriplePlusArch; | |||
4113 | } | |||
4114 | ||||
4115 | InputInfo Driver::BuildJobsForAction( | |||
4116 | Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch, | |||
4117 | bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput, | |||
4118 | std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults, | |||
4119 | Action::OffloadKind TargetDeviceOffloadKind) const { | |||
4120 | std::pair<const Action *, std::string> ActionTC = { | |||
4121 | A, GetTriplePlusArchString(TC, BoundArch, TargetDeviceOffloadKind)}; | |||
4122 | auto CachedResult = CachedResults.find(ActionTC); | |||
4123 | if (CachedResult != CachedResults.end()) { | |||
4124 | return CachedResult->second; | |||
4125 | } | |||
4126 | InputInfo Result = BuildJobsForActionNoCache( | |||
4127 | C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput, | |||
4128 | CachedResults, TargetDeviceOffloadKind); | |||
4129 | CachedResults[ActionTC] = Result; | |||
4130 | return Result; | |||
4131 | } | |||
4132 | ||||
4133 | InputInfo Driver::BuildJobsForActionNoCache( | |||
4134 | Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch, | |||
4135 | bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput, | |||
4136 | std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults, | |||
4137 | Action::OffloadKind TargetDeviceOffloadKind) const { | |||
4138 | llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); | |||
4139 | ||||
4140 | InputInfoList OffloadDependencesInputInfo; | |||
4141 | bool BuildingForOffloadDevice = TargetDeviceOffloadKind != Action::OFK_None; | |||
4142 | if (const OffloadAction *OA = dyn_cast<OffloadAction>(A)) { | |||
4143 | // The 'Darwin' toolchain is initialized only when its arguments are | |||
4144 | // computed. Get the default arguments for OFK_None to ensure that | |||
4145 | // initialization is performed before processing the offload action. | |||
4146 | // FIXME: Remove when darwin's toolchain is initialized during construction. | |||
4147 | C.getArgsForToolChain(TC, BoundArch, Action::OFK_None); | |||
4148 | ||||
4149 | // The offload action is expected to be used in four different situations. | |||
4150 | // | |||
4151 | // a) Set a toolchain/architecture/kind for a host action: | |||
4152 | // Host Action 1 -> OffloadAction -> Host Action 2 | |||
4153 | // | |||
4154 | // b) Set a toolchain/architecture/kind for a device action; | |||
4155 | // Device Action 1 -> OffloadAction -> Device Action 2 | |||
4156 | // | |||
4157 | // c) Specify a device dependence to a host action; | |||
4158 | // Device Action 1 _ | |||
4159 | // \ | |||
4160 | // Host Action 1 ---> OffloadAction -> Host Action 2 | |||
4161 | // | |||
4162 | // d) Specify a host dependence to a device action. | |||
4163 | // Host Action 1 _ | |||
4164 | // \ | |||
4165 | // Device Action 1 ---> OffloadAction -> Device Action 2 | |||
4166 | // | |||
4167 | // For a) and b), we just return the job generated for the dependence. For | |||
4168 | // c) and d) we override the current action with the host/device dependence | |||
4169 | // if the current toolchain is host/device and set the offload dependences | |||
4170 | // info with the jobs obtained from the device/host dependence(s). | |||
4171 | ||||
4172 | // If there is a single device option, just generate the job for it. | |||
4173 | if (OA->hasSingleDeviceDependence()) { | |||
4174 | InputInfo DevA; | |||
4175 | OA->doOnEachDeviceDependence([&](Action *DepA, const ToolChain *DepTC, | |||
4176 | const char *DepBoundArch) { | |||
4177 | DevA = | |||
4178 | BuildJobsForAction(C, DepA, DepTC, DepBoundArch, AtTopLevel, | |||
4179 | /*MultipleArchs*/ !!DepBoundArch, LinkingOutput, | |||
4180 | CachedResults, DepA->getOffloadingDeviceKind()); | |||
4181 | }); | |||
4182 | return DevA; | |||
4183 | } | |||
4184 | ||||
4185 | // If 'Action 2' is host, we generate jobs for the device dependences and | |||
4186 | // override the current action with the host dependence. Otherwise, we | |||
4187 | // generate the host dependences and override the action with the device | |||
4188 | // dependence. The dependences can't therefore be a top-level action. | |||
4189 | OA->doOnEachDependence( | |||
4190 | /*IsHostDependence=*/BuildingForOffloadDevice, | |||
4191 | [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) { | |||
4192 | OffloadDependencesInputInfo.push_back(BuildJobsForAction( | |||
4193 | C, DepA, DepTC, DepBoundArch, /*AtTopLevel=*/false, | |||
4194 | /*MultipleArchs*/ !!DepBoundArch, LinkingOutput, CachedResults, | |||
4195 | DepA->getOffloadingDeviceKind())); | |||
4196 | }); | |||
4197 | ||||
4198 | A = BuildingForOffloadDevice | |||
4199 | ? OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true) | |||
4200 | : OA->getHostDependence(); | |||
4201 | } | |||
4202 | ||||
4203 | if (const InputAction *IA = dyn_cast<InputAction>(A)) { | |||
4204 | // FIXME: It would be nice to not claim this here; maybe the old scheme of | |||
4205 | // just using Args was better? | |||
4206 | const Arg &Input = IA->getInputArg(); | |||
4207 | Input.claim(); | |||
4208 | if (Input.getOption().matches(options::OPT_INPUT)) { | |||
4209 | const char *Name = Input.getValue(); | |||
4210 | return InputInfo(A, Name, /* _BaseInput = */ Name); | |||
4211 | } | |||
4212 | return InputInfo(A, &Input, /* _BaseInput = */ ""); | |||
4213 | } | |||
4214 | ||||
4215 | if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) { | |||
4216 | const ToolChain *TC; | |||
4217 | StringRef ArchName = BAA->getArchName(); | |||
4218 | ||||
4219 | if (!ArchName.empty()) | |||
4220 | TC = &getToolChain(C.getArgs(), | |||
4221 | computeTargetTriple(*this, TargetTriple, | |||
4222 | C.getArgs(), ArchName)); | |||
4223 | else | |||
4224 | TC = &C.getDefaultToolChain(); | |||
4225 | ||||
4226 | return BuildJobsForAction(C, *BAA->input_begin(), TC, ArchName, AtTopLevel, | |||
4227 | MultipleArchs, LinkingOutput, CachedResults, | |||
4228 | TargetDeviceOffloadKind); | |||
4229 | } | |||
4230 | ||||
4231 | ||||
4232 | ActionList Inputs = A->getInputs(); | |||
4233 | ||||
4234 | const JobAction *JA = cast<JobAction>(A); | |||
4235 | ActionList CollapsedOffloadActions; | |||
4236 | ||||
4237 | ToolSelector TS(JA, *TC, C, isSaveTempsEnabled(), | |||
4238 | embedBitcodeInObject() && !isUsingLTO()); | |||
4239 | const Tool *T = TS.getTool(Inputs, CollapsedOffloadActions); | |||
4240 | ||||
4241 | if (!T) | |||
4242 | return InputInfo(); | |||
4243 | ||||
4244 | // If we've collapsed action list that contained OffloadAction we | |||
4245 | // need to build jobs for host/device-side inputs it may have held. | |||
4246 | for (const auto *OA : CollapsedOffloadActions) | |||
4247 | cast<OffloadAction>(OA)->doOnEachDependence( | |||
4248 | /*IsHostDependence=*/BuildingForOffloadDevice, | |||
4249 | [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) { | |||
4250 | OffloadDependencesInputInfo.push_back(BuildJobsForAction( | |||
4251 | C, DepA, DepTC, DepBoundArch, /* AtTopLevel */ false, | |||
4252 | /*MultipleArchs=*/!!DepBoundArch, LinkingOutput, CachedResults, | |||
4253 | DepA->getOffloadingDeviceKind())); | |||
4254 | }); | |||
4255 | ||||
4256 | // Only use pipes when there is exactly one input. | |||
4257 | InputInfoList InputInfos; | |||
4258 | for (const Action *Input : Inputs) { | |||
4259 | // Treat dsymutil and verify sub-jobs as being at the top-level too, they | |||
4260 | // shouldn't get temporary output names. | |||
4261 | // FIXME: Clean this up. | |||
4262 | bool SubJobAtTopLevel = | |||
4263 | AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A)); | |||
4264 | InputInfos.push_back(BuildJobsForAction( | |||
4265 | C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput, | |||
4266 | CachedResults, A->getOffloadingDeviceKind())); | |||
4267 | } | |||
4268 | ||||
4269 | // Always use the first input as the base input. | |||
4270 | const char *BaseInput = InputInfos[0].getBaseInput(); | |||
4271 | ||||
4272 | // ... except dsymutil actions, which use their actual input as the base | |||
4273 | // input. | |||
4274 | if (JA->getType() == types::TY_dSYM) | |||
4275 | BaseInput = InputInfos[0].getFilename(); | |||
4276 | ||||
4277 | // ... and in header module compilations, which use the module name. | |||
4278 | if (auto *ModuleJA = dyn_cast<HeaderModulePrecompileJobAction>(JA)) | |||
4279 | BaseInput = ModuleJA->getModuleName(); | |||
4280 | ||||
4281 | // Append outputs of offload device jobs to the input list | |||
4282 | if (!OffloadDependencesInputInfo.empty()) | |||
4283 | InputInfos.append(OffloadDependencesInputInfo.begin(), | |||
4284 | OffloadDependencesInputInfo.end()); | |||
4285 | ||||
4286 | // Set the effective triple of the toolchain for the duration of this job. | |||
4287 | llvm::Triple EffectiveTriple; | |||
4288 | const ToolChain &ToolTC = T->getToolChain(); | |||
4289 | const ArgList &Args = | |||
4290 | C.getArgsForToolChain(TC, BoundArch, A->getOffloadingDeviceKind()); | |||
4291 | if (InputInfos.size() != 1) { | |||
4292 | EffectiveTriple = llvm::Triple(ToolTC.ComputeEffectiveClangTriple(Args)); | |||
4293 | } else { | |||
4294 | // Pass along the input type if it can be unambiguously determined. | |||
4295 | EffectiveTriple = llvm::Triple( | |||
4296 | ToolTC.ComputeEffectiveClangTriple(Args, InputInfos[0].getType())); | |||
4297 | } | |||
4298 | RegisterEffectiveTriple TripleRAII(ToolTC, EffectiveTriple); | |||
4299 | ||||
4300 | // Determine the place to write output to, if any. | |||
4301 | InputInfo Result; | |||
4302 | InputInfoList UnbundlingResults; | |||
4303 | if (auto *UA = dyn_cast<OffloadUnbundlingJobAction>(JA)) { | |||
4304 | // If we have an unbundling job, we need to create results for all the | |||
4305 | // outputs. We also update the results cache so that other actions using | |||
4306 | // this unbundling action can get the right results. | |||
4307 | for (auto &UI : UA->getDependentActionsInfo()) { | |||
4308 | assert(UI.DependentOffloadKind != Action::OFK_None &&((UI.DependentOffloadKind != Action::OFK_None && "Unbundling with no offloading??" ) ? static_cast<void> (0) : __assert_fail ("UI.DependentOffloadKind != Action::OFK_None && \"Unbundling with no offloading??\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 4309, __PRETTY_FUNCTION__)) | |||
4309 | "Unbundling with no offloading??")((UI.DependentOffloadKind != Action::OFK_None && "Unbundling with no offloading??" ) ? static_cast<void> (0) : __assert_fail ("UI.DependentOffloadKind != Action::OFK_None && \"Unbundling with no offloading??\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 4309, __PRETTY_FUNCTION__)); | |||
4310 | ||||
4311 | // Unbundling actions are never at the top level. When we generate the | |||
4312 | // offloading prefix, we also do that for the host file because the | |||
4313 | // unbundling action does not change the type of the output which can | |||
4314 | // cause a overwrite. | |||
4315 | std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix( | |||
4316 | UI.DependentOffloadKind, | |||
4317 | UI.DependentToolChain->getTriple().normalize(), | |||
4318 | /*CreatePrefixForHost=*/true); | |||
4319 | auto CurI = InputInfo( | |||
4320 | UA, | |||
4321 | GetNamedOutputPath(C, *UA, BaseInput, UI.DependentBoundArch, | |||
4322 | /*AtTopLevel=*/false, | |||
4323 | MultipleArchs || | |||
4324 | UI.DependentOffloadKind == Action::OFK_HIP, | |||
4325 | OffloadingPrefix), | |||
4326 | BaseInput); | |||
4327 | // Save the unbundling result. | |||
4328 | UnbundlingResults.push_back(CurI); | |||
4329 | ||||
4330 | // Get the unique string identifier for this dependence and cache the | |||
4331 | // result. | |||
4332 | StringRef Arch; | |||
4333 | if (TargetDeviceOffloadKind == Action::OFK_HIP) { | |||
4334 | if (UI.DependentOffloadKind == Action::OFK_Host) | |||
4335 | Arch = StringRef(); | |||
4336 | else | |||
4337 | Arch = UI.DependentBoundArch; | |||
4338 | } else | |||
4339 | Arch = BoundArch; | |||
4340 | ||||
4341 | CachedResults[{A, GetTriplePlusArchString(UI.DependentToolChain, Arch, | |||
4342 | UI.DependentOffloadKind)}] = | |||
4343 | CurI; | |||
4344 | } | |||
4345 | ||||
4346 | // Now that we have all the results generated, select the one that should be | |||
4347 | // returned for the current depending action. | |||
4348 | std::pair<const Action *, std::string> ActionTC = { | |||
4349 | A, GetTriplePlusArchString(TC, BoundArch, TargetDeviceOffloadKind)}; | |||
4350 | assert(CachedResults.find(ActionTC) != CachedResults.end() &&((CachedResults.find(ActionTC) != CachedResults.end() && "Result does not exist??") ? static_cast<void> (0) : __assert_fail ("CachedResults.find(ActionTC) != CachedResults.end() && \"Result does not exist??\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 4351, __PRETTY_FUNCTION__)) | |||
4351 | "Result does not exist??")((CachedResults.find(ActionTC) != CachedResults.end() && "Result does not exist??") ? static_cast<void> (0) : __assert_fail ("CachedResults.find(ActionTC) != CachedResults.end() && \"Result does not exist??\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 4351, __PRETTY_FUNCTION__)); | |||
4352 | Result = CachedResults[ActionTC]; | |||
4353 | } else if (JA->getType() == types::TY_Nothing) | |||
4354 | Result = InputInfo(A, BaseInput); | |||
4355 | else { | |||
4356 | // We only have to generate a prefix for the host if this is not a top-level | |||
4357 | // action. | |||
4358 | std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix( | |||
4359 | A->getOffloadingDeviceKind(), TC->getTriple().normalize(), | |||
4360 | /*CreatePrefixForHost=*/!!A->getOffloadingHostActiveKinds() && | |||
4361 | !AtTopLevel); | |||
4362 | if (isa<OffloadWrapperJobAction>(JA)) { | |||
4363 | OffloadingPrefix += "-wrapper"; | |||
4364 | if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) | |||
4365 | BaseInput = FinalOutput->getValue(); | |||
4366 | else | |||
4367 | BaseInput = getDefaultImageName(); | |||
4368 | } | |||
4369 | Result = InputInfo(A, GetNamedOutputPath(C, *JA, BaseInput, BoundArch, | |||
4370 | AtTopLevel, MultipleArchs, | |||
4371 | OffloadingPrefix), | |||
4372 | BaseInput); | |||
4373 | } | |||
4374 | ||||
4375 | if (CCCPrintBindings && !CCGenDiagnostics) { | |||
4376 | llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"' | |||
4377 | << " - \"" << T->getName() << "\", inputs: ["; | |||
4378 | for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) { | |||
4379 | llvm::errs() << InputInfos[i].getAsString(); | |||
4380 | if (i + 1 != e) | |||
4381 | llvm::errs() << ", "; | |||
4382 | } | |||
4383 | if (UnbundlingResults.empty()) | |||
4384 | llvm::errs() << "], output: " << Result.getAsString() << "\n"; | |||
4385 | else { | |||
4386 | llvm::errs() << "], outputs: ["; | |||
4387 | for (unsigned i = 0, e = UnbundlingResults.size(); i != e; ++i) { | |||
4388 | llvm::errs() << UnbundlingResults[i].getAsString(); | |||
4389 | if (i + 1 != e) | |||
4390 | llvm::errs() << ", "; | |||
4391 | } | |||
4392 | llvm::errs() << "] \n"; | |||
4393 | } | |||
4394 | } else { | |||
4395 | if (UnbundlingResults.empty()) | |||
4396 | T->ConstructJob( | |||
4397 | C, *JA, Result, InputInfos, | |||
4398 | C.getArgsForToolChain(TC, BoundArch, JA->getOffloadingDeviceKind()), | |||
4399 | LinkingOutput); | |||
4400 | else | |||
4401 | T->ConstructJobMultipleOutputs( | |||
4402 | C, *JA, UnbundlingResults, InputInfos, | |||
4403 | C.getArgsForToolChain(TC, BoundArch, JA->getOffloadingDeviceKind()), | |||
4404 | LinkingOutput); | |||
4405 | } | |||
4406 | return Result; | |||
4407 | } | |||
4408 | ||||
4409 | const char *Driver::getDefaultImageName() const { | |||
4410 | llvm::Triple Target(llvm::Triple::normalize(TargetTriple)); | |||
4411 | return Target.isOSWindows() ? "a.exe" : "a.out"; | |||
4412 | } | |||
4413 | ||||
4414 | /// Create output filename based on ArgValue, which could either be a | |||
4415 | /// full filename, filename without extension, or a directory. If ArgValue | |||
4416 | /// does not provide a filename, then use BaseName, and use the extension | |||
4417 | /// suitable for FileType. | |||
4418 | static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue, | |||
4419 | StringRef BaseName, | |||
4420 | types::ID FileType) { | |||
4421 | SmallString<128> Filename = ArgValue; | |||
4422 | ||||
4423 | if (ArgValue.empty()) { | |||
4424 | // If the argument is empty, output to BaseName in the current dir. | |||
4425 | Filename = BaseName; | |||
4426 | } else if (llvm::sys::path::is_separator(Filename.back())) { | |||
4427 | // If the argument is a directory, output to BaseName in that dir. | |||
4428 | llvm::sys::path::append(Filename, BaseName); | |||
4429 | } | |||
4430 | ||||
4431 | if (!llvm::sys::path::has_extension(ArgValue)) { | |||
4432 | // If the argument didn't provide an extension, then set it. | |||
4433 | const char *Extension = types::getTypeTempSuffix(FileType, true); | |||
4434 | ||||
4435 | if (FileType == types::TY_Image && | |||
4436 | Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) { | |||
4437 | // The output file is a dll. | |||
4438 | Extension = "dll"; | |||
4439 | } | |||
4440 | ||||
4441 | llvm::sys::path::replace_extension(Filename, Extension); | |||
4442 | } | |||
4443 | ||||
4444 | return Args.MakeArgString(Filename.c_str()); | |||
4445 | } | |||
4446 | ||||
4447 | const char *Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA, | |||
4448 | const char *BaseInput, | |||
4449 | StringRef BoundArch, bool AtTopLevel, | |||
4450 | bool MultipleArchs, | |||
4451 | StringRef OffloadingPrefix) const { | |||
4452 | llvm::PrettyStackTraceString CrashInfo("Computing output path"); | |||
4453 | // Output to a user requested destination? | |||
4454 | if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) { | |||
4455 | if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) | |||
4456 | return C.addResultFile(FinalOutput->getValue(), &JA); | |||
4457 | } | |||
4458 | ||||
4459 | // For /P, preprocess to file named after BaseInput. | |||
4460 | if (C.getArgs().hasArg(options::OPT__SLASH_P)) { | |||
4461 | assert(AtTopLevel && isa<PreprocessJobAction>(JA))((AtTopLevel && isa<PreprocessJobAction>(JA)) ? static_cast<void> (0) : __assert_fail ("AtTopLevel && isa<PreprocessJobAction>(JA)" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 4461, __PRETTY_FUNCTION__)); | |||
4462 | StringRef BaseName = llvm::sys::path::filename(BaseInput); | |||
4463 | StringRef NameArg; | |||
4464 | if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi)) | |||
4465 | NameArg = A->getValue(); | |||
4466 | return C.addResultFile( | |||
4467 | MakeCLOutputFilename(C.getArgs(), NameArg, BaseName, types::TY_PP_C), | |||
4468 | &JA); | |||
4469 | } | |||
4470 | ||||
4471 | // Default to writing to stdout? | |||
4472 | if (AtTopLevel && !CCGenDiagnostics && isa<PreprocessJobAction>(JA)) | |||
4473 | return "-"; | |||
4474 | ||||
4475 | // Is this the assembly listing for /FA? | |||
4476 | if (JA.getType() == types::TY_PP_Asm && | |||
4477 | (C.getArgs().hasArg(options::OPT__SLASH_FA) || | |||
4478 | C.getArgs().hasArg(options::OPT__SLASH_Fa))) { | |||
4479 | // Use /Fa and the input filename to determine the asm file name. | |||
4480 | StringRef BaseName = llvm::sys::path::filename(BaseInput); | |||
4481 | StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa); | |||
4482 | return C.addResultFile( | |||
4483 | MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, JA.getType()), | |||
4484 | &JA); | |||
4485 | } | |||
4486 | ||||
4487 | // Output to a temporary file? | |||
4488 | if ((!AtTopLevel && !isSaveTempsEnabled() && | |||
4489 | !C.getArgs().hasArg(options::OPT__SLASH_Fo)) || | |||
4490 | CCGenDiagnostics) { | |||
4491 | StringRef Name = llvm::sys::path::filename(BaseInput); | |||
4492 | std::pair<StringRef, StringRef> Split = Name.split('.'); | |||
4493 | SmallString<128> TmpName; | |||
4494 | const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode()); | |||
4495 | Arg *A = C.getArgs().getLastArg(options::OPT_fcrash_diagnostics_dir); | |||
4496 | if (CCGenDiagnostics && A) { | |||
4497 | SmallString<128> CrashDirectory(A->getValue()); | |||
4498 | if (!getVFS().exists(CrashDirectory)) | |||
4499 | llvm::sys::fs::create_directories(CrashDirectory); | |||
4500 | llvm::sys::path::append(CrashDirectory, Split.first); | |||
4501 | const char *Middle = Suffix ? "-%%%%%%." : "-%%%%%%"; | |||
4502 | std::error_code EC = llvm::sys::fs::createUniqueFile( | |||
4503 | CrashDirectory + Middle + Suffix, TmpName); | |||
4504 | if (EC) { | |||
4505 | Diag(clang::diag::err_unable_to_make_temp) << EC.message(); | |||
4506 | return ""; | |||
4507 | } | |||
4508 | } else { | |||
4509 | TmpName = GetTemporaryPath(Split.first, Suffix); | |||
4510 | } | |||
4511 | return C.addTempFile(C.getArgs().MakeArgString(TmpName)); | |||
4512 | } | |||
4513 | ||||
4514 | SmallString<128> BasePath(BaseInput); | |||
4515 | StringRef BaseName; | |||
4516 | ||||
4517 | // Dsymutil actions should use the full path. | |||
4518 | if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA)) | |||
4519 | BaseName = BasePath; | |||
4520 | else | |||
4521 | BaseName = llvm::sys::path::filename(BasePath); | |||
4522 | ||||
4523 | // Determine what the derived output name should be. | |||
4524 | const char *NamedOutput; | |||
4525 | ||||
4526 | if ((JA.getType() == types::TY_Object || JA.getType() == types::TY_LTO_BC) && | |||
4527 | C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) { | |||
4528 | // The /Fo or /o flag decides the object filename. | |||
4529 | StringRef Val = | |||
4530 | C.getArgs() | |||
4531 | .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o) | |||
4532 | ->getValue(); | |||
4533 | NamedOutput = | |||
4534 | MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Object); | |||
4535 | } else if (JA.getType() == types::TY_Image && | |||
4536 | C.getArgs().hasArg(options::OPT__SLASH_Fe, | |||
4537 | options::OPT__SLASH_o)) { | |||
4538 | // The /Fe or /o flag names the linked file. | |||
4539 | StringRef Val = | |||
4540 | C.getArgs() | |||
4541 | .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o) | |||
4542 | ->getValue(); | |||
4543 | NamedOutput = | |||
4544 | MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Image); | |||
4545 | } else if (JA.getType() == types::TY_Image) { | |||
4546 | if (IsCLMode()) { | |||
4547 | // clang-cl uses BaseName for the executable name. | |||
4548 | NamedOutput = | |||
4549 | MakeCLOutputFilename(C.getArgs(), "", BaseName, types::TY_Image); | |||
4550 | } else { | |||
4551 | SmallString<128> Output(getDefaultImageName()); | |||
4552 | // HIP image for device compilation with -fno-gpu-rdc is per compilation | |||
4553 | // unit. | |||
4554 | bool IsHIPNoRDC = JA.getOffloadingDeviceKind() == Action::OFK_HIP && | |||
4555 | !C.getArgs().hasFlag(options::OPT_fgpu_rdc, | |||
4556 | options::OPT_fno_gpu_rdc, false); | |||
4557 | if (IsHIPNoRDC) { | |||
4558 | Output = BaseName; | |||
4559 | llvm::sys::path::replace_extension(Output, ""); | |||
4560 | } | |||
4561 | Output += OffloadingPrefix; | |||
4562 | if (MultipleArchs && !BoundArch.empty()) { | |||
4563 | Output += "-"; | |||
4564 | Output.append(BoundArch); | |||
4565 | } | |||
4566 | if (IsHIPNoRDC) | |||
4567 | Output += ".out"; | |||
4568 | NamedOutput = C.getArgs().MakeArgString(Output.c_str()); | |||
4569 | } | |||
4570 | } else if (JA.getType() == types::TY_PCH && IsCLMode()) { | |||
4571 | NamedOutput = C.getArgs().MakeArgString(GetClPchPath(C, BaseName)); | |||
4572 | } else { | |||
4573 | const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode()); | |||
4574 | assert(Suffix && "All types used for output should have a suffix.")((Suffix && "All types used for output should have a suffix." ) ? static_cast<void> (0) : __assert_fail ("Suffix && \"All types used for output should have a suffix.\"" , "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Driver/Driver.cpp" , 4574, __PRETTY_FUNCTION__)); | |||
4575 | ||||
4576 | std::string::size_type End = std::string::npos; | |||
4577 | if (!types::appendSuffixForType(JA.getType())) | |||
4578 | End = BaseName.rfind('.'); | |||
4579 | SmallString<128> Suffixed(BaseName.substr(0, End)); | |||
4580 | Suffixed += OffloadingPrefix; | |||
4581 | if (MultipleArchs && !BoundArch.empty()) { | |||
4582 | Suffixed += "-"; | |||
4583 | Suffixed.append(BoundArch); | |||
4584 | } | |||
4585 | // When using both -save-temps and -emit-llvm, use a ".tmp.bc" suffix for | |||
4586 | // the unoptimized bitcode so that it does not get overwritten by the ".bc" | |||
4587 | // optimized bitcode output. | |||
4588 | if (!AtTopLevel && C.getArgs().hasArg(options::OPT_emit_llvm) && | |||
4589 | JA.getType() == types::TY_LLVM_BC) | |||
4590 | Suffixed += ".tmp"; | |||
4591 | Suffixed += '.'; | |||
4592 | Suffixed += Suffix; | |||
4593 | NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str()); | |||
4594 | } | |||
4595 | ||||
4596 | // Prepend object file path if -save-temps=obj | |||
4597 | if (!AtTopLevel && isSaveTempsObj() && C.getArgs().hasArg(options::OPT_o) && | |||
4598 | JA.getType() != types::TY_PCH) { | |||
4599 | Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o); | |||
4600 | SmallString<128> TempPath(FinalOutput->getValue()); | |||
4601 | llvm::sys::path::remove_filename(TempPath); | |||
4602 | StringRef OutputFileName = llvm::sys::path::filename(NamedOutput); | |||
4603 | llvm::sys::path::append(TempPath, OutputFileName); | |||
4604 | NamedOutput = C.getArgs().MakeArgString(TempPath.c_str()); | |||
4605 | } | |||
4606 | ||||
4607 | // If we're saving temps and the temp file conflicts with the input file, | |||
4608 | // then avoid overwriting input file. | |||
4609 | if (!AtTopLevel && isSaveTempsEnabled() && NamedOutput == BaseName) { | |||
4610 | bool SameFile = false; | |||
4611 | SmallString<256> Result; | |||
4612 | llvm::sys::fs::current_path(Result); | |||
4613 | llvm::sys::path::append(Result, BaseName); | |||
4614 | llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile); | |||
4615 | // Must share the same path to conflict. | |||
4616 | if (SameFile) { | |||
4617 | StringRef Name = llvm::sys::path::filename(BaseInput); | |||
4618 | std::pair<StringRef, StringRef> Split = Name.split('.'); | |||
4619 | std::string TmpName = GetTemporaryPath( | |||
4620 | Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode())); | |||
4621 | return C.addTempFile(C.getArgs().MakeArgString(TmpName)); | |||
4622 | } | |||
4623 | } | |||
4624 | ||||
4625 | // As an annoying special case, PCH generation doesn't strip the pathname. | |||
4626 | if (JA.getType() == types::TY_PCH && !IsCLMode()) { | |||
4627 | llvm::sys::path::remove_filename(BasePath); | |||
4628 | if (BasePath.empty()) | |||
4629 | BasePath = NamedOutput; | |||
4630 | else | |||
4631 | llvm::sys::path::append(BasePath, NamedOutput); | |||
4632 | return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA); | |||
4633 | } else { | |||
4634 | return C.addResultFile(NamedOutput, &JA); | |||
4635 | } | |||
4636 | } | |||
4637 | ||||
4638 | std::string Driver::GetFilePath(StringRef Name, const ToolChain &TC) const { | |||
4639 | // Search for Name in a list of paths. | |||
4640 | auto SearchPaths = [&](const llvm::SmallVectorImpl<std::string> &P) | |||
4641 | -> llvm::Optional<std::string> { | |||
4642 | // Respect a limited subset of the '-Bprefix' functionality in GCC by | |||
4643 | // attempting to use this prefix when looking for file paths. | |||
4644 | for (const auto &Dir : P) { | |||
4645 | if (Dir.empty()) | |||
4646 | continue; | |||
4647 | SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir); | |||
4648 | llvm::sys::path::append(P, Name); | |||
4649 | if (llvm::sys::fs::exists(Twine(P))) | |||
4650 | return P.str().str(); | |||
4651 | } | |||
4652 | return None; | |||
4653 | }; | |||
4654 | ||||
4655 | if (auto P = SearchPaths(PrefixDirs)) | |||
4656 | return *P; | |||
4657 | ||||
4658 | SmallString<128> R(ResourceDir); | |||
4659 | llvm::sys::path::append(R, Name); | |||
4660 | if (llvm::sys::fs::exists(Twine(R))) | |||
4661 | return R.str(); | |||
4662 | ||||
4663 | SmallString<128> P(TC.getCompilerRTPath()); | |||
4664 | llvm::sys::path::append(P, Name); | |||
4665 | if (llvm::sys::fs::exists(Twine(P))) | |||
4666 | return P.str(); | |||
4667 | ||||
4668 | SmallString<128> D(Dir); | |||
4669 | llvm::sys::path::append(D, "..", Name); | |||
4670 | if (llvm::sys::fs::exists(Twine(D))) | |||
4671 | return D.str(); | |||
4672 | ||||
4673 | if (auto P = SearchPaths(TC.getLibraryPaths())) | |||
4674 | return *P; | |||
4675 | ||||
4676 | if (auto P = SearchPaths(TC.getFilePaths())) | |||
4677 | return *P; | |||
4678 | ||||
4679 | return Name; | |||
4680 | } | |||
4681 | ||||
4682 | void Driver::generatePrefixedToolNames( | |||
4683 | StringRef Tool, const ToolChain &TC, | |||
4684 | SmallVectorImpl<std::string> &Names) const { | |||
4685 | // FIXME: Needs a better variable than TargetTriple | |||
4686 | Names.emplace_back((TargetTriple + "-" + Tool).str()); | |||
4687 | Names.emplace_back(Tool); | |||
4688 | ||||
4689 | // Allow the discovery of tools prefixed with LLVM's default target triple. | |||
4690 | std::string DefaultTargetTriple = llvm::sys::getDefaultTargetTriple(); | |||
4691 | if (DefaultTargetTriple != TargetTriple) | |||
4692 | Names.emplace_back((DefaultTargetTriple + "-" + Tool).str()); | |||
4693 | } | |||
4694 | ||||
4695 | static bool ScanDirForExecutable(SmallString<128> &Dir, | |||
4696 | ArrayRef<std::string> Names) { | |||
4697 | for (const auto &Name : Names) { | |||
4698 | llvm::sys::path::append(Dir, Name); | |||
4699 | if (llvm::sys::fs::can_execute(Twine(Dir))) | |||
4700 | return true; | |||
4701 | llvm::sys::path::remove_filename(Dir); | |||
4702 | } | |||
4703 | return false; | |||
4704 | } | |||
4705 | ||||
4706 | std::string Driver::GetProgramPath(StringRef Name, const ToolChain &TC) const { | |||
4707 | SmallVector<std::string, 2> TargetSpecificExecutables; | |||
4708 | generatePrefixedToolNames(Name, TC, TargetSpecificExecutables); | |||
4709 | ||||
4710 | // Respect a limited subset of the '-Bprefix' functionality in GCC by | |||
4711 | // attempting to use this prefix when looking for program paths. | |||
4712 | for (const auto &PrefixDir : PrefixDirs) { | |||
4713 | if (llvm::sys::fs::is_directory(PrefixDir)) { | |||
4714 | SmallString<128> P(PrefixDir); | |||
4715 | if (ScanDirForExecutable(P, TargetSpecificExecutables)) | |||
4716 | return P.str(); | |||
4717 | } else { | |||
4718 | SmallString<128> P((PrefixDir + Name).str()); | |||
4719 | if (llvm::sys::fs::can_execute(Twine(P))) | |||
4720 | return P.str(); | |||
4721 | } | |||
4722 | } | |||
4723 | ||||
4724 | const ToolChain::path_list &List = TC.getProgramPaths(); | |||
4725 | for (const auto &Path : List) { | |||
4726 | SmallString<128> P(Path); | |||
4727 | if (ScanDirForExecutable(P, TargetSpecificExecutables)) | |||
4728 | return P.str(); | |||
4729 | } | |||
4730 | ||||
4731 | // If all else failed, search the path. | |||
4732 | for (const auto &TargetSpecificExecutable : TargetSpecificExecutables) | |||
4733 | if (llvm::ErrorOr<std::string> P = | |||
4734 | llvm::sys::findProgramByName(TargetSpecificExecutable)) | |||
4735 | return *P; | |||
4736 | ||||
4737 | return Name; | |||
4738 | } | |||
4739 | ||||
4740 | std::string Driver::GetTemporaryPath(StringRef Prefix, StringRef Suffix) const { | |||
4741 | SmallString<128> Path; | |||
4742 | std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path); | |||
4743 | if (EC) { | |||
4744 | Diag(clang::diag::err_unable_to_make_temp) << EC.message(); | |||
4745 | return ""; | |||
4746 | } | |||
4747 | ||||
4748 | return Path.str(); | |||
4749 | } | |||
4750 | ||||
4751 | std::string Driver::GetTemporaryDirectory(StringRef Prefix) const { | |||
4752 | SmallString<128> Path; | |||
4753 | std::error_code EC = llvm::sys::fs::createUniqueDirectory(Prefix, Path); | |||
4754 | if (EC) { | |||
4755 | Diag(clang::diag::err_unable_to_make_temp) << EC.message(); | |||
4756 | return ""; | |||
4757 | } | |||
4758 | ||||
4759 | return Path.str(); | |||
4760 | } | |||
4761 | ||||
4762 | std::string Driver::GetClPchPath(Compilation &C, StringRef BaseName) const { | |||
4763 | SmallString<128> Output; | |||
4764 | if (Arg *FpArg = C.getArgs().getLastArg(options::OPT__SLASH_Fp)) { | |||
4765 | // FIXME: If anybody needs it, implement this obscure rule: | |||
4766 | // "If you specify a directory without a file name, the default file name | |||
4767 | // is VCx0.pch., where x is the major version of Visual C++ in use." | |||
4768 | Output = FpArg->getValue(); | |||
4769 | ||||
4770 | // "If you do not specify an extension as part of the path name, an | |||
4771 | // extension of .pch is assumed. " | |||
4772 | if (!llvm::sys::path::has_extension(Output)) | |||
4773 | Output += ".pch"; | |||
4774 | } else { | |||
4775 | if (Arg *YcArg = C.getArgs().getLastArg(options::OPT__SLASH_Yc)) | |||
4776 | Output = YcArg->getValue(); | |||
4777 | if (Output.empty()) | |||
4778 | Output = BaseName; | |||
4779 | llvm::sys::path::replace_extension(Output, ".pch"); | |||
4780 | } | |||
4781 | return Output.str(); | |||
4782 | } | |||
4783 | ||||
4784 | const ToolChain &Driver::getToolChain(const ArgList &Args, | |||
4785 | const llvm::Triple &Target) const { | |||
4786 | ||||
4787 | auto &TC = ToolChains[Target.str()]; | |||
4788 | if (!TC) { | |||
4789 | switch (Target.getOS()) { | |||
4790 | case llvm::Triple::AIX: | |||
4791 | TC = std::make_unique<toolchains::AIX>(*this, Target, Args); | |||
4792 | break; | |||
4793 | case llvm::Triple::Haiku: | |||
4794 | TC = std::make_unique<toolchains::Haiku>(*this, Target, Args); | |||
4795 | break; | |||
4796 | case llvm::Triple::Ananas: | |||
4797 | TC = std::make_unique<toolchains::Ananas>(*this, Target, Args); | |||
4798 | break; | |||
4799 | case llvm::Triple::CloudABI: | |||
4800 | TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args); | |||
4801 | break; | |||
4802 | case llvm::Triple::Darwin: | |||
4803 | case llvm::Triple::MacOSX: | |||
4804 | case llvm::Triple::IOS: | |||
4805 | case llvm::Triple::TvOS: | |||
4806 | case llvm::Triple::WatchOS: | |||
4807 | TC = std::make_unique<toolchains::DarwinClang>(*this, Target, Args); | |||
4808 | break; | |||
4809 | case llvm::Triple::DragonFly: | |||
4810 | TC = std::make_unique<toolchains::DragonFly>(*this, Target, Args); | |||
4811 | break; | |||
4812 | case llvm::Triple::OpenBSD: | |||
4813 | TC = std::make_unique<toolchains::OpenBSD>(*this, Target, Args); | |||
4814 | break; | |||
4815 | case llvm::Triple::NetBSD: | |||
4816 | TC = std::make_unique<toolchains::NetBSD>(*this, Target, Args); | |||
4817 | break; | |||
4818 | case llvm::Triple::FreeBSD: | |||
4819 | TC = std::make_unique<toolchains::FreeBSD>(*this, Target, Args); | |||
4820 | break; | |||
4821 | case llvm::Triple::Minix: | |||
4822 | TC = std::make_unique<toolchains::Minix>(*this, Target, Args); | |||
4823 | break; | |||
4824 | case llvm::Triple::Linux: | |||
4825 | case llvm::Triple::ELFIAMCU: | |||
4826 | if (Target.getArch() == llvm::Triple::hexagon) | |||
4827 | TC = std::make_unique<toolchains::HexagonToolChain>(*this, Target, | |||
4828 | Args); | |||
4829 | else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) && | |||
4830 | !Target.hasEnvironment()) | |||
4831 | TC = std::make_unique<toolchains::MipsLLVMToolChain>(*this, Target, | |||
4832 | Args); | |||
4833 | else if (Target.getArch() == llvm::Triple::ppc || | |||
4834 | Target.getArch() == llvm::Triple::ppc64 || | |||
4835 | Target.getArch() == llvm::Triple::ppc64le) | |||
4836 | TC = std::make_unique<toolchains::PPCLinuxToolChain>(*this, Target, | |||
4837 | Args); | |||
4838 | else | |||
4839 | TC = std::make_unique<toolchains::Linux>(*this, Target, Args); | |||
4840 | break; | |||
4841 | case llvm::Triple::NaCl: | |||
4842 | TC = std::make_unique<toolchains::NaClToolChain>(*this, Target, Args); | |||
4843 | break; | |||
4844 | case llvm::Triple::Fuchsia: | |||
4845 | TC = std::make_unique<toolchains::Fuchsia>(*this, Target, Args); | |||
4846 | break; | |||
4847 | case llvm::Triple::Solaris: | |||
4848 | TC = std::make_unique<toolchains::Solaris>(*this, Target, Args); | |||
4849 | break; | |||
4850 | case llvm::Triple::AMDHSA: | |||
4851 | case llvm::Triple::AMDPAL: | |||
4852 | case llvm::Triple::Mesa3D: | |||
4853 | TC = std::make_unique<toolchains::AMDGPUToolChain>(*this, Target, Args); | |||
4854 | break; | |||
4855 | case llvm::Triple::Win32: | |||
4856 | switch (Target.getEnvironment()) { | |||
4857 | default: | |||
4858 | if (Target.isOSBinFormatELF()) | |||
4859 | TC = std::make_unique<toolchains::Generic_ELF>(*this, Target, Args); | |||
4860 | else if (Target.isOSBinFormatMachO()) | |||
4861 | TC = std::make_unique<toolchains::MachO>(*this, Target, Args); | |||
4862 | else | |||
4863 | TC = std::make_unique<toolchains::Generic_GCC>(*this, Target, Args); | |||
4864 | break; | |||
4865 | case llvm::Triple::GNU: | |||
4866 | TC = std::make_unique<toolchains::MinGW>(*this, Target, Args); | |||
4867 | break; | |||
4868 | case llvm::Triple::Itanium: | |||
4869 | TC = std::make_unique<toolchains::CrossWindowsToolChain>(*this, Target, | |||
4870 | Args); | |||
4871 | break; | |||
4872 | case llvm::Triple::MSVC: | |||
4873 | case llvm::Triple::UnknownEnvironment: | |||
4874 | if (Args.getLastArgValue(options::OPT_fuse_ld_EQ) | |||
4875 | .startswith_lower("bfd")) | |||
4876 | TC = std::make_unique<toolchains::CrossWindowsToolChain>( | |||
4877 | *this, Target, Args); | |||
4878 | else | |||
4879 | TC = | |||
4880 | std::make_unique<toolchains::MSVCToolChain>(*this, Target, Args); | |||
4881 | break; | |||
4882 | } | |||
4883 | break; | |||
4884 | case llvm::Triple::PS4: | |||
4885 | TC = std::make_unique<toolchains::PS4CPU>(*this, Target, Args); | |||
4886 | break; | |||
4887 | case llvm::Triple::Contiki: | |||
4888 | TC = std::make_unique<toolchains::Contiki>(*this, Target, Args); | |||
4889 | break; | |||
4890 | case llvm::Triple::Hurd: | |||
4891 | TC = std::make_unique<toolchains::Hurd>(*this, Target, Args); | |||
4892 | break; | |||
4893 | default: | |||
4894 | // Of these targets, Hexagon is the only one that might have | |||
4895 | // an OS of Linux, in which case it got handled above already. | |||
4896 | switch (Target.getArch()) { | |||
4897 | case llvm::Triple::tce: | |||
4898 | TC = std::make_unique<toolchains::TCEToolChain>(*this, Target, Args); | |||
4899 | break; | |||
4900 | case llvm::Triple::tcele: | |||
4901 | TC = std::make_unique<toolchains::TCELEToolChain>(*this, Target, Args); | |||
4902 | break; | |||
4903 | case llvm::Triple::hexagon: | |||
4904 | TC = std::make_unique<toolchains::HexagonToolChain>(*this, Target, | |||
4905 | Args); | |||
4906 | break; | |||
4907 | case llvm::Triple::lanai: | |||
4908 | TC = std::make_unique<toolchains::LanaiToolChain>(*this, Target, Args); | |||
4909 | break; | |||
4910 | case llvm::Triple::xcore: | |||
4911 | TC = std::make_unique<toolchains::XCoreToolChain>(*this, Target, Args); | |||
4912 | break; | |||
4913 | case llvm::Triple::wasm32: | |||
4914 | case llvm::Triple::wasm64: | |||
4915 | TC = std::make_unique<toolchains::WebAssembly>(*this, Target, Args); | |||
4916 | break; | |||
4917 | case llvm::Triple::avr: | |||
4918 | TC = std::make_unique<toolchains::AVRToolChain>(*this, Target, Args); | |||
4919 | break; | |||
4920 | case llvm::Triple::msp430: | |||
4921 | TC = | |||
4922 | std::make_unique<toolchains::MSP430ToolChain>(*this, Target, Args); | |||
4923 | break; | |||
4924 | case llvm::Triple::riscv32: | |||
4925 | case llvm::Triple::riscv64: | |||
4926 | TC = std::make_unique<toolchains::RISCVToolChain>(*this, Target, Args); | |||
4927 | break; | |||
4928 | default: | |||
4929 | if (Target.getVendor() == llvm::Triple::Myriad) | |||
4930 | TC = std::make_unique<toolchains::MyriadToolChain>(*this, Target, | |||
4931 | Args); | |||
4932 | else if (toolchains::BareMetal::handlesTarget(Target)) | |||
4933 | TC = std::make_unique<toolchains::BareMetal>(*this, Target, Args); | |||
4934 | else if (Target.isOSBinFormatELF()) | |||
4935 | TC = std::make_unique<toolchains::Generic_ELF>(*this, Target, Args); | |||
4936 | else if (Target.isOSBinFormatMachO()) | |||
4937 | TC = std::make_unique<toolchains::MachO>(*this, Target, Args); | |||
4938 | else | |||
4939 | TC = std::make_unique<toolchains::Generic_GCC>(*this, Target, Args); | |||
4940 | } | |||
4941 | } | |||
4942 | } | |||
4943 | ||||
4944 | // Intentionally omitted from the switch above: llvm::Triple::CUDA. CUDA | |||
4945 | // compiles always need two toolchains, the CUDA toolchain and the host | |||
4946 | // toolchain. So the only valid way to create a CUDA toolchain is via | |||
4947 | // CreateOffloadingDeviceToolChains. | |||
4948 | ||||
4949 | return *TC; | |||
4950 | } | |||
4951 | ||||
4952 | bool Driver::ShouldUseClangCompiler(const JobAction &JA) const { | |||
4953 | // Say "no" if there is not exactly one input of a type clang understands. | |||
4954 | if (JA.size() != 1 || | |||
4955 | !types::isAcceptedByClang((*JA.input_begin())->getType())) | |||
4956 | return false; | |||
4957 | ||||
4958 | // And say "no" if this is not a kind of action clang understands. | |||
4959 | if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) && | |||
4960 | !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA)) | |||
4961 | return false; | |||
4962 | ||||
4963 | return true; | |||
4964 | } | |||
4965 | ||||
4966 | bool Driver::ShouldUseFlangCompiler(const JobAction &JA) const { | |||
4967 | // Say "no" if there is not exactly one input of a type flang understands. | |||
4968 | if (JA.size() != 1 || | |||
4969 | !types::isFortran((*JA.input_begin())->getType())) | |||
4970 | return false; | |||
4971 | ||||
4972 | // And say "no" if this is not a kind of action flang understands. | |||
4973 | if (!isa<PreprocessJobAction>(JA) && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA)) | |||
4974 | return false; | |||
4975 | ||||
4976 | return true; | |||
4977 | } | |||
4978 | ||||
4979 | /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the | |||
4980 | /// grouped values as integers. Numbers which are not provided are set to 0. | |||
4981 | /// | |||
4982 | /// \return True if the entire string was parsed (9.2), or all groups were | |||
4983 | /// parsed (10.3.5extrastuff). | |||
4984 | bool Driver::GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, | |||
4985 | unsigned &Micro, bool &HadExtra) { | |||
4986 | HadExtra = false; | |||
4987 | ||||
4988 | Major = Minor = Micro = 0; | |||
4989 | if (Str.empty()) | |||
4990 | return false; | |||
4991 | ||||
4992 | if (Str.consumeInteger(10, Major)) | |||
4993 | return false; | |||
4994 | if (Str.empty()) | |||
4995 | return true; | |||
4996 | if (Str[0] != '.') | |||
4997 | return false; | |||
4998 | ||||
4999 | Str = Str.drop_front(1); | |||
5000 | ||||
5001 | if (Str.consumeInteger(10, Minor)) | |||
5002 | return false; | |||
5003 | if (Str.empty()) | |||
5004 | return true; | |||
5005 | if (Str[0] != '.') | |||
5006 | return false; | |||
5007 | Str = Str.drop_front(1); | |||
5008 | ||||
5009 | if (Str.consumeInteger(10, Micro)) | |||
5010 | return false; | |||
5011 | if (!Str.empty()) | |||
5012 | HadExtra = true; | |||
5013 | return true; | |||
5014 | } | |||
5015 | ||||
5016 | /// Parse digits from a string \p Str and fulfill \p Digits with | |||
5017 | /// the parsed numbers. This method assumes that the max number of | |||
5018 | /// digits to look for is equal to Digits.size(). | |||
5019 | /// | |||
5020 | /// \return True if the entire string was parsed and there are | |||
5021 | /// no extra characters remaining at the end. | |||
5022 | bool Driver::GetReleaseVersion(StringRef Str, | |||
5023 | MutableArrayRef<unsigned> Digits) { | |||
5024 | if (Str.empty()) | |||
5025 | return false; | |||
5026 | ||||
5027 | unsigned CurDigit = 0; | |||
5028 | while (CurDigit < Digits.size()) { | |||
5029 | unsigned Digit; | |||
5030 | if (Str.consumeInteger(10, Digit)) | |||
5031 | return false; | |||
5032 | Digits[CurDigit] = Digit; | |||
5033 | if (Str.empty()) | |||
5034 | return true; | |||
5035 | if (Str[0] != '.') | |||
5036 | return false; | |||
5037 | Str = Str.drop_front(1); | |||
5038 | CurDigit++; | |||
5039 | } | |||
5040 | ||||
5041 | // More digits than requested, bail out... | |||
5042 | return false; | |||
5043 | } | |||
5044 | ||||
5045 | std::pair<unsigned, unsigned> | |||
5046 | Driver::getIncludeExcludeOptionFlagMasks(bool IsClCompatMode) const { | |||
5047 | unsigned IncludedFlagsBitmask = 0; | |||
5048 | unsigned ExcludedFlagsBitmask = options::NoDriverOption; | |||
5049 | ||||
5050 | if (IsClCompatMode) { | |||
5051 | // Include CL and Core options. | |||
5052 | IncludedFlagsBitmask |= options::CLOption; | |||
5053 | IncludedFlagsBitmask |= options::CoreOption; | |||
5054 | } else { | |||
5055 | ExcludedFlagsBitmask |= options::CLOption; | |||
5056 | } | |||
5057 | ||||
5058 | return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask); | |||
5059 | } | |||
5060 | ||||
5061 | bool clang::driver::isOptimizationLevelFast(const ArgList &Args) { | |||
5062 | return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group, false); | |||
5063 | } | |||
5064 | ||||
5065 | bool clang::driver::willEmitRemarks(const ArgList &Args) { | |||
5066 | // -fsave-optimization-record enables it. | |||
5067 | if (Args.hasFlag(options::OPT_fsave_optimization_record, | |||
5068 | options::OPT_fno_save_optimization_record, false)) | |||
5069 | return true; | |||
5070 | ||||
5071 | // -fsave-optimization-record=<format> enables it as well. | |||
5072 | if (Args.hasFlag(options::OPT_fsave_optimization_record_EQ, | |||
5073 | options::OPT_fno_save_optimization_record, false)) | |||
5074 | return true; | |||
5075 | ||||
5076 | // -foptimization-record-file alone enables it too. | |||
5077 | if (Args.hasFlag(options::OPT_foptimization_record_file_EQ, | |||
5078 | options::OPT_fno_save_optimization_record, false)) | |||
5079 | return true; | |||
5080 | ||||
5081 | // -foptimization-record-passes alone enables it too. | |||
5082 | if (Args.hasFlag(options::OPT_foptimization_record_passes_EQ, | |||
5083 | options::OPT_fno_save_optimization_record, false)) | |||
5084 | return true; | |||
5085 | return false; | |||
5086 | } |