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