clang  10.0.0git
Clang.cpp
Go to the documentation of this file.
1 //===-- Clang.cpp - Clang+LLVM ToolChain Implementations --------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "Clang.h"
10 #include "Arch/AArch64.h"
11 #include "Arch/ARM.h"
12 #include "Arch/Mips.h"
13 #include "Arch/PPC.h"
14 #include "Arch/RISCV.h"
15 #include "Arch/Sparc.h"
16 #include "Arch/SystemZ.h"
17 #include "Arch/X86.h"
18 #include "AMDGPU.h"
19 #include "CommonArgs.h"
20 #include "Hexagon.h"
21 #include "MSP430.h"
22 #include "InputInfo.h"
23 #include "PS4CPU.h"
24 #include "clang/Basic/CharInfo.h"
28 #include "clang/Basic/Version.h"
29 #include "clang/Driver/Distro.h"
31 #include "clang/Driver/Options.h"
33 #include "clang/Driver/XRayArgs.h"
34 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/Config/llvm-config.h"
36 #include "llvm/Option/ArgList.h"
37 #include "llvm/Support/CodeGen.h"
38 #include "llvm/Support/Compression.h"
39 #include "llvm/Support/FileSystem.h"
40 #include "llvm/Support/Path.h"
41 #include "llvm/Support/Process.h"
42 #include "llvm/Support/TargetParser.h"
43 #include "llvm/Support/YAMLParser.h"
44 
45 #ifdef LLVM_ON_UNIX
46 #include <unistd.h> // For getuid().
47 #endif
48 
49 using namespace clang::driver;
50 using namespace clang::driver::tools;
51 using namespace clang;
52 using namespace llvm::opt;
53 
54 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
55  if (Arg *A =
56  Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) {
57  if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
58  !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
59  D.Diag(clang::diag::err_drv_argument_only_allowed_with)
60  << A->getBaseArg().getAsString(Args)
61  << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
62  }
63  }
64 }
65 
66 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
67  // In gcc, only ARM checks this, but it seems reasonable to check universally.
68  if (Args.hasArg(options::OPT_static))
69  if (const Arg *A =
70  Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
71  D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
72  << "-static";
73 }
74 
75 // Add backslashes to escape spaces and other backslashes.
76 // This is used for the space-separated argument list specified with
77 // the -dwarf-debug-flags option.
78 static void EscapeSpacesAndBackslashes(const char *Arg,
79  SmallVectorImpl<char> &Res) {
80  for (; *Arg; ++Arg) {
81  switch (*Arg) {
82  default:
83  break;
84  case ' ':
85  case '\\':
86  Res.push_back('\\');
87  break;
88  }
89  Res.push_back(*Arg);
90  }
91 }
92 
93 // Quote target names for inclusion in GNU Make dependency files.
94 // Only the characters '$', '#', ' ', '\t' are quoted.
95 static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) {
96  for (unsigned i = 0, e = Target.size(); i != e; ++i) {
97  switch (Target[i]) {
98  case ' ':
99  case '\t':
100  // Escape the preceding backslashes
101  for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
102  Res.push_back('\\');
103 
104  // Escape the space/tab
105  Res.push_back('\\');
106  break;
107  case '$':
108  Res.push_back('$');
109  break;
110  case '#':
111  Res.push_back('\\');
112  break;
113  default:
114  break;
115  }
116 
117  Res.push_back(Target[i]);
118  }
119 }
120 
121 /// Apply \a Work on the current tool chain \a RegularToolChain and any other
122 /// offloading tool chain that is associated with the current action \a JA.
123 static void
125  const ToolChain &RegularToolChain,
126  llvm::function_ref<void(const ToolChain &)> Work) {
127  // Apply Work on the current/regular tool chain.
128  Work(RegularToolChain);
129 
130  // Apply Work on all the offloading tool chains associated with the current
131  // action.
136  else if (JA.isHostOffloading(Action::OFK_HIP))
138  else if (JA.isDeviceOffloading(Action::OFK_HIP))
140 
143  for (auto II = TCs.first, IE = TCs.second; II != IE; ++II)
144  Work(*II->second);
145  } else if (JA.isDeviceOffloading(Action::OFK_OpenMP))
147 
148  //
149  // TODO: Add support for other offloading programming models here.
150  //
151 }
152 
153 /// This is a helper function for validating the optional refinement step
154 /// parameter in reciprocal argument strings. Return false if there is an error
155 /// parsing the refinement step. Otherwise, return true and set the Position
156 /// of the refinement step in the input string.
157 static bool getRefinementStep(StringRef In, const Driver &D,
158  const Arg &A, size_t &Position) {
159  const char RefinementStepToken = ':';
160  Position = In.find(RefinementStepToken);
161  if (Position != StringRef::npos) {
162  StringRef Option = A.getOption().getName();
163  StringRef RefStep = In.substr(Position + 1);
164  // Allow exactly one numeric character for the additional refinement
165  // step parameter. This is reasonable for all currently-supported
166  // operations and architectures because we would expect that a larger value
167  // of refinement steps would cause the estimate "optimization" to
168  // under-perform the native operation. Also, if the estimate does not
169  // converge quickly, it probably will not ever converge, so further
170  // refinement steps will not produce a better answer.
171  if (RefStep.size() != 1) {
172  D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
173  return false;
174  }
175  char RefStepChar = RefStep[0];
176  if (RefStepChar < '0' || RefStepChar > '9') {
177  D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
178  return false;
179  }
180  }
181  return true;
182 }
183 
184 /// The -mrecip flag requires processing of many optional parameters.
185 static void ParseMRecip(const Driver &D, const ArgList &Args,
186  ArgStringList &OutStrings) {
187  StringRef DisabledPrefixIn = "!";
188  StringRef DisabledPrefixOut = "!";
189  StringRef EnabledPrefixOut = "";
190  StringRef Out = "-mrecip=";
191 
192  Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
193  if (!A)
194  return;
195 
196  unsigned NumOptions = A->getNumValues();
197  if (NumOptions == 0) {
198  // No option is the same as "all".
199  OutStrings.push_back(Args.MakeArgString(Out + "all"));
200  return;
201  }
202 
203  // Pass through "all", "none", or "default" with an optional refinement step.
204  if (NumOptions == 1) {
205  StringRef Val = A->getValue(0);
206  size_t RefStepLoc;
207  if (!getRefinementStep(Val, D, *A, RefStepLoc))
208  return;
209  StringRef ValBase = Val.slice(0, RefStepLoc);
210  if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
211  OutStrings.push_back(Args.MakeArgString(Out + Val));
212  return;
213  }
214  }
215 
216  // Each reciprocal type may be enabled or disabled individually.
217  // Check each input value for validity, concatenate them all back together,
218  // and pass through.
219 
220  llvm::StringMap<bool> OptionStrings;
221  OptionStrings.insert(std::make_pair("divd", false));
222  OptionStrings.insert(std::make_pair("divf", false));
223  OptionStrings.insert(std::make_pair("vec-divd", false));
224  OptionStrings.insert(std::make_pair("vec-divf", false));
225  OptionStrings.insert(std::make_pair("sqrtd", false));
226  OptionStrings.insert(std::make_pair("sqrtf", false));
227  OptionStrings.insert(std::make_pair("vec-sqrtd", false));
228  OptionStrings.insert(std::make_pair("vec-sqrtf", false));
229 
230  for (unsigned i = 0; i != NumOptions; ++i) {
231  StringRef Val = A->getValue(i);
232 
233  bool IsDisabled = Val.startswith(DisabledPrefixIn);
234  // Ignore the disablement token for string matching.
235  if (IsDisabled)
236  Val = Val.substr(1);
237 
238  size_t RefStep;
239  if (!getRefinementStep(Val, D, *A, RefStep))
240  return;
241 
242  StringRef ValBase = Val.slice(0, RefStep);
243  llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
244  if (OptionIter == OptionStrings.end()) {
245  // Try again specifying float suffix.
246  OptionIter = OptionStrings.find(ValBase.str() + 'f');
247  if (OptionIter == OptionStrings.end()) {
248  // The input name did not match any known option string.
249  D.Diag(diag::err_drv_unknown_argument) << Val;
250  return;
251  }
252  // The option was specified without a float or double suffix.
253  // Make sure that the double entry was not already specified.
254  // The float entry will be checked below.
255  if (OptionStrings[ValBase.str() + 'd']) {
256  D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
257  return;
258  }
259  }
260 
261  if (OptionIter->second == true) {
262  // Duplicate option specified.
263  D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
264  return;
265  }
266 
267  // Mark the matched option as found. Do not allow duplicate specifiers.
268  OptionIter->second = true;
269 
270  // If the precision was not specified, also mark the double entry as found.
271  if (ValBase.back() != 'f' && ValBase.back() != 'd')
272  OptionStrings[ValBase.str() + 'd'] = true;
273 
274  // Build the output string.
275  StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
276  Out = Args.MakeArgString(Out + Prefix + Val);
277  if (i != NumOptions - 1)
278  Out = Args.MakeArgString(Out + ",");
279  }
280 
281  OutStrings.push_back(Args.MakeArgString(Out));
282 }
283 
284 /// The -mprefer-vector-width option accepts either a positive integer
285 /// or the string "none".
286 static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args,
287  ArgStringList &CmdArgs) {
288  Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ);
289  if (!A)
290  return;
291 
292  StringRef Value = A->getValue();
293  if (Value == "none") {
294  CmdArgs.push_back("-mprefer-vector-width=none");
295  } else {
296  unsigned Width;
297  if (Value.getAsInteger(10, Width)) {
298  D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Value;
299  return;
300  }
301  CmdArgs.push_back(Args.MakeArgString("-mprefer-vector-width=" + Value));
302  }
303 }
304 
305 static void getWebAssemblyTargetFeatures(const ArgList &Args,
306  std::vector<StringRef> &Features) {
307  handleTargetFeaturesGroup(Args, Features, options::OPT_m_wasm_Features_Group);
308 }
309 
310 static void getTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple,
311  const ArgList &Args, ArgStringList &CmdArgs,
312  bool ForAS) {
313  const Driver &D = TC.getDriver();
314  std::vector<StringRef> Features;
315  switch (Triple.getArch()) {
316  default:
317  break;
318  case llvm::Triple::mips:
319  case llvm::Triple::mipsel:
320  case llvm::Triple::mips64:
321  case llvm::Triple::mips64el:
322  mips::getMIPSTargetFeatures(D, Triple, Args, Features);
323  break;
324 
325  case llvm::Triple::arm:
326  case llvm::Triple::armeb:
327  case llvm::Triple::thumb:
328  case llvm::Triple::thumbeb:
329  arm::getARMTargetFeatures(TC, Triple, Args, CmdArgs, Features, ForAS);
330  break;
331 
332  case llvm::Triple::ppc:
333  case llvm::Triple::ppc64:
334  case llvm::Triple::ppc64le:
335  ppc::getPPCTargetFeatures(D, Triple, Args, Features);
336  break;
337  case llvm::Triple::riscv32:
338  case llvm::Triple::riscv64:
339  riscv::getRISCVTargetFeatures(D, Triple, Args, Features);
340  break;
341  case llvm::Triple::systemz:
342  systemz::getSystemZTargetFeatures(Args, Features);
343  break;
344  case llvm::Triple::aarch64:
345  case llvm::Triple::aarch64_32:
346  case llvm::Triple::aarch64_be:
347  aarch64::getAArch64TargetFeatures(D, Triple, Args, Features);
348  break;
349  case llvm::Triple::x86:
350  case llvm::Triple::x86_64:
351  x86::getX86TargetFeatures(D, Triple, Args, Features);
352  break;
353  case llvm::Triple::hexagon:
354  hexagon::getHexagonTargetFeatures(D, Args, Features);
355  break;
356  case llvm::Triple::wasm32:
357  case llvm::Triple::wasm64:
358  getWebAssemblyTargetFeatures(Args, Features);
359  break;
360  case llvm::Triple::sparc:
361  case llvm::Triple::sparcel:
362  case llvm::Triple::sparcv9:
363  sparc::getSparcTargetFeatures(D, Args, Features);
364  break;
365  case llvm::Triple::r600:
366  case llvm::Triple::amdgcn:
367  amdgpu::getAMDGPUTargetFeatures(D, Args, Features);
368  break;
369  case llvm::Triple::msp430:
370  msp430::getMSP430TargetFeatures(D, Args, Features);
371  }
372 
373  // Find the last of each feature.
374  llvm::StringMap<unsigned> LastOpt;
375  for (unsigned I = 0, N = Features.size(); I < N; ++I) {
376  StringRef Name = Features[I];
377  assert(Name[0] == '-' || Name[0] == '+');
378  LastOpt[Name.drop_front(1)] = I;
379  }
380 
381  for (unsigned I = 0, N = Features.size(); I < N; ++I) {
382  // If this feature was overridden, ignore it.
383  StringRef Name = Features[I];
384  llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1));
385  assert(LastI != LastOpt.end());
386  unsigned Last = LastI->second;
387  if (Last != I)
388  continue;
389 
390  CmdArgs.push_back("-target-feature");
391  CmdArgs.push_back(Name.data());
392  }
393 }
394 
395 static bool
397  const llvm::Triple &Triple) {
398  // We use the zero-cost exception tables for Objective-C if the non-fragile
399  // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
400  // later.
401  if (runtime.isNonFragile())
402  return true;
403 
404  if (!Triple.isMacOSX())
405  return false;
406 
407  return (!Triple.isMacOSXVersionLT(10, 5) &&
408  (Triple.getArch() == llvm::Triple::x86_64 ||
409  Triple.getArch() == llvm::Triple::arm));
410 }
411 
412 /// Adds exception related arguments to the driver command arguments. There's a
413 /// master flag, -fexceptions and also language specific flags to enable/disable
414 /// C++ and Objective-C exceptions. This makes it possible to for example
415 /// disable C++ exceptions but enable Objective-C exceptions.
416 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
417  const ToolChain &TC, bool KernelOrKext,
418  const ObjCRuntime &objcRuntime,
419  ArgStringList &CmdArgs) {
420  const llvm::Triple &Triple = TC.getTriple();
421 
422  if (KernelOrKext) {
423  // -mkernel and -fapple-kext imply no exceptions, so claim exception related
424  // arguments now to avoid warnings about unused arguments.
425  Args.ClaimAllArgs(options::OPT_fexceptions);
426  Args.ClaimAllArgs(options::OPT_fno_exceptions);
427  Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
428  Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
429  Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
430  Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
431  return;
432  }
433 
434  // See if the user explicitly enabled exceptions.
435  bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
436  false);
437 
438  // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
439  // is not necessarily sensible, but follows GCC.
440  if (types::isObjC(InputType) &&
441  Args.hasFlag(options::OPT_fobjc_exceptions,
442  options::OPT_fno_objc_exceptions, true)) {
443  CmdArgs.push_back("-fobjc-exceptions");
444 
445  EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
446  }
447 
448  if (types::isCXX(InputType)) {
449  // Disable C++ EH by default on XCore and PS4.
450  bool CXXExceptionsEnabled =
451  Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU();
452  Arg *ExceptionArg = Args.getLastArg(
453  options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
454  options::OPT_fexceptions, options::OPT_fno_exceptions);
455  if (ExceptionArg)
456  CXXExceptionsEnabled =
457  ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
458  ExceptionArg->getOption().matches(options::OPT_fexceptions);
459 
460  if (CXXExceptionsEnabled) {
461  CmdArgs.push_back("-fcxx-exceptions");
462 
463  EH = true;
464  }
465  }
466 
467  if (EH)
468  CmdArgs.push_back("-fexceptions");
469 }
470 
471 static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC,
472  const JobAction &JA) {
473  bool Default = true;
474  if (TC.getTriple().isOSDarwin()) {
475  // The native darwin assembler doesn't support the linker_option directives,
476  // so we disable them if we think the .s file will be passed to it.
477  Default = TC.useIntegratedAs();
478  }
479  // The linker_option directives are intended for host compilation.
482  Default = false;
483  return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
484  Default);
485 }
486 
487 static bool ShouldDisableDwarfDirectory(const ArgList &Args,
488  const ToolChain &TC) {
489  bool UseDwarfDirectory =
490  Args.hasFlag(options::OPT_fdwarf_directory_asm,
491  options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs());
492  return !UseDwarfDirectory;
493 }
494 
495 // Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases
496 // to the corresponding DebugInfoKind.
498  assert(A.getOption().matches(options::OPT_gN_Group) &&
499  "Not a -g option that specifies a debug-info level");
500  if (A.getOption().matches(options::OPT_g0) ||
501  A.getOption().matches(options::OPT_ggdb0))
503  if (A.getOption().matches(options::OPT_gline_tables_only) ||
504  A.getOption().matches(options::OPT_ggdb1))
506  if (A.getOption().matches(options::OPT_gline_directives_only))
509 }
510 
511 static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple) {
512  switch (Triple.getArch()){
513  default:
514  return false;
515  case llvm::Triple::arm:
516  case llvm::Triple::thumb:
517  // ARM Darwin targets require a frame pointer to be always present to aid
518  // offline debugging via backtraces.
519  return Triple.isOSDarwin();
520  }
521 }
522 
523 static bool useFramePointerForTargetByDefault(const ArgList &Args,
524  const llvm::Triple &Triple) {
525  if (Args.hasArg(options::OPT_pg))
526  return true;
527 
528  switch (Triple.getArch()) {
529  case llvm::Triple::xcore:
530  case llvm::Triple::wasm32:
531  case llvm::Triple::wasm64:
532  case llvm::Triple::msp430:
533  // XCore never wants frame pointers, regardless of OS.
534  // WebAssembly never wants frame pointers.
535  return false;
536  case llvm::Triple::ppc:
537  case llvm::Triple::ppc64:
538  case llvm::Triple::ppc64le:
539  case llvm::Triple::riscv32:
540  case llvm::Triple::riscv64:
541  case llvm::Triple::amdgcn:
542  case llvm::Triple::r600:
543  return !areOptimizationsEnabled(Args);
544  default:
545  break;
546  }
547 
548  if (Triple.isOSNetBSD()) {
549  return !areOptimizationsEnabled(Args);
550  }
551 
552  if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI ||
553  Triple.isOSHurd()) {
554  switch (Triple.getArch()) {
555  // Don't use a frame pointer on linux if optimizing for certain targets.
556  case llvm::Triple::mips64:
557  case llvm::Triple::mips64el:
558  case llvm::Triple::mips:
559  case llvm::Triple::mipsel:
560  case llvm::Triple::systemz:
561  case llvm::Triple::x86:
562  case llvm::Triple::x86_64:
563  return !areOptimizationsEnabled(Args);
564  default:
565  return true;
566  }
567  }
568 
569  if (Triple.isOSWindows()) {
570  switch (Triple.getArch()) {
571  case llvm::Triple::x86:
572  return !areOptimizationsEnabled(Args);
573  case llvm::Triple::x86_64:
574  return Triple.isOSBinFormatMachO();
575  case llvm::Triple::arm:
576  case llvm::Triple::thumb:
577  // Windows on ARM builds with FPO disabled to aid fast stack walking
578  return true;
579  default:
580  // All other supported Windows ISAs use xdata unwind information, so frame
581  // pointers are not generally useful.
582  return false;
583  }
584  }
585 
586  return true;
587 }
588 
590 getFramePointerKind(const ArgList &Args, const llvm::Triple &Triple) {
591  // We have 4 states:
592  //
593  // 00) leaf retained, non-leaf retained
594  // 01) leaf retained, non-leaf omitted (this is invalid)
595  // 10) leaf omitted, non-leaf retained
596  // (what -momit-leaf-frame-pointer was designed for)
597  // 11) leaf omitted, non-leaf omitted
598  //
599  // "omit" options taking precedence over "no-omit" options is the only way
600  // to make 3 valid states representable
601  Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
602  options::OPT_fno_omit_frame_pointer);
603  bool OmitFP = A && A->getOption().matches(options::OPT_fomit_frame_pointer);
604  bool NoOmitFP =
605  A && A->getOption().matches(options::OPT_fno_omit_frame_pointer);
606  bool KeepLeaf = Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
607  options::OPT_mno_omit_leaf_frame_pointer,
608  Triple.isAArch64() || Triple.isPS4CPU());
609  if (NoOmitFP || mustUseNonLeafFramePointerForTarget(Triple) ||
610  (!OmitFP && useFramePointerForTargetByDefault(Args, Triple))) {
611  if (KeepLeaf)
614  }
616 }
617 
618 /// Add a CC1 option to specify the debug compilation directory.
619 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs,
620  const llvm::vfs::FileSystem &VFS) {
621  if (Arg *A = Args.getLastArg(options::OPT_fdebug_compilation_dir)) {
622  CmdArgs.push_back("-fdebug-compilation-dir");
623  CmdArgs.push_back(A->getValue());
624  } else if (llvm::ErrorOr<std::string> CWD =
625  VFS.getCurrentWorkingDirectory()) {
626  CmdArgs.push_back("-fdebug-compilation-dir");
627  CmdArgs.push_back(Args.MakeArgString(*CWD));
628  }
629 }
630 
631 /// Add a CC1 and CC1AS option to specify the debug file path prefix map.
632 static void addDebugPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs) {
633  for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
634  options::OPT_fdebug_prefix_map_EQ)) {
635  StringRef Map = A->getValue();
636  if (Map.find('=') == StringRef::npos)
637  D.Diag(diag::err_drv_invalid_argument_to_option)
638  << Map << A->getOption().getName();
639  else
640  CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map));
641  A->claim();
642  }
643 }
644 
645 /// Add a CC1 and CC1AS option to specify the macro file path prefix map.
646 static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args,
647  ArgStringList &CmdArgs) {
648  for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
649  options::OPT_fmacro_prefix_map_EQ)) {
650  StringRef Map = A->getValue();
651  if (Map.find('=') == StringRef::npos)
652  D.Diag(diag::err_drv_invalid_argument_to_option)
653  << Map << A->getOption().getName();
654  else
655  CmdArgs.push_back(Args.MakeArgString("-fmacro-prefix-map=" + Map));
656  A->claim();
657  }
658 }
659 
660 /// Vectorize at all optimization levels greater than 1 except for -Oz.
661 /// For -Oz the loop vectorizer is disabled, while the slp vectorizer is
662 /// enabled.
663 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
664  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
665  if (A->getOption().matches(options::OPT_O4) ||
666  A->getOption().matches(options::OPT_Ofast))
667  return true;
668 
669  if (A->getOption().matches(options::OPT_O0))
670  return false;
671 
672  assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
673 
674  // Vectorize -Os.
675  StringRef S(A->getValue());
676  if (S == "s")
677  return true;
678 
679  // Don't vectorize -Oz, unless it's the slp vectorizer.
680  if (S == "z")
681  return isSlpVec;
682 
683  unsigned OptLevel = 0;
684  if (S.getAsInteger(10, OptLevel))
685  return false;
686 
687  return OptLevel > 1;
688  }
689 
690  return false;
691 }
692 
693 /// Add -x lang to \p CmdArgs for \p Input.
694 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
695  ArgStringList &CmdArgs) {
696  // When using -verify-pch, we don't want to provide the type
697  // 'precompiled-header' if it was inferred from the file extension
698  if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
699  return;
700 
701  CmdArgs.push_back("-x");
702  if (Args.hasArg(options::OPT_rewrite_objc))
703  CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
704  else {
705  // Map the driver type to the frontend type. This is mostly an identity
706  // mapping, except that the distinction between module interface units
707  // and other source files does not exist at the frontend layer.
708  const char *ClangType;
709  switch (Input.getType()) {
710  case types::TY_CXXModule:
711  ClangType = "c++";
712  break;
713  case types::TY_PP_CXXModule:
714  ClangType = "c++-cpp-output";
715  break;
716  default:
717  ClangType = types::getTypeName(Input.getType());
718  break;
719  }
720  CmdArgs.push_back(ClangType);
721  }
722 }
723 
725 #ifdef LLVM_ON_UNIX
726  const char *Username = getenv("LOGNAME");
727 #else
728  const char *Username = getenv("USERNAME");
729 #endif
730  if (Username) {
731  // Validate that LoginName can be used in a path, and get its length.
732  size_t Len = 0;
733  for (const char *P = Username; *P; ++P, ++Len) {
734  if (!clang::isAlphanumeric(*P) && *P != '_') {
735  Username = nullptr;
736  break;
737  }
738  }
739 
740  if (Username && Len > 0) {
741  Result.append(Username, Username + Len);
742  return;
743  }
744  }
745 
746 // Fallback to user id.
747 #ifdef LLVM_ON_UNIX
748  std::string UID = llvm::utostr(getuid());
749 #else
750  // FIXME: Windows seems to have an 'SID' that might work.
751  std::string UID = "9999";
752 #endif
753  Result.append(UID.begin(), UID.end());
754 }
755 
756 static void addPGOAndCoverageFlags(const ToolChain &TC, Compilation &C,
757  const Driver &D, const InputInfo &Output,
758  const ArgList &Args,
759  ArgStringList &CmdArgs) {
760 
761  auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
762  options::OPT_fprofile_generate_EQ,
763  options::OPT_fno_profile_generate);
764  if (PGOGenerateArg &&
765  PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
766  PGOGenerateArg = nullptr;
767 
768  auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
769  options::OPT_fcs_profile_generate_EQ,
770  options::OPT_fno_profile_generate);
771  if (CSPGOGenerateArg &&
772  CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
773  CSPGOGenerateArg = nullptr;
774 
775  auto *ProfileGenerateArg = Args.getLastArg(
776  options::OPT_fprofile_instr_generate,
777  options::OPT_fprofile_instr_generate_EQ,
778  options::OPT_fno_profile_instr_generate);
779  if (ProfileGenerateArg &&
780  ProfileGenerateArg->getOption().matches(
781  options::OPT_fno_profile_instr_generate))
782  ProfileGenerateArg = nullptr;
783 
784  if (PGOGenerateArg && ProfileGenerateArg)
785  D.Diag(diag::err_drv_argument_not_allowed_with)
786  << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
787 
788  auto *ProfileUseArg = getLastProfileUseArg(Args);
789 
790  if (PGOGenerateArg && ProfileUseArg)
791  D.Diag(diag::err_drv_argument_not_allowed_with)
792  << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
793 
794  if (ProfileGenerateArg && ProfileUseArg)
795  D.Diag(diag::err_drv_argument_not_allowed_with)
796  << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
797 
798  if (CSPGOGenerateArg && PGOGenerateArg)
799  D.Diag(diag::err_drv_argument_not_allowed_with)
800  << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
801 
802  if (ProfileGenerateArg) {
803  if (ProfileGenerateArg->getOption().matches(
804  options::OPT_fprofile_instr_generate_EQ))
805  CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") +
806  ProfileGenerateArg->getValue()));
807  // The default is to use Clang Instrumentation.
808  CmdArgs.push_back("-fprofile-instrument=clang");
809  if (TC.getTriple().isWindowsMSVCEnvironment()) {
810  // Add dependent lib for clang_rt.profile
811  CmdArgs.push_back(Args.MakeArgString("--dependent-lib=" +
812  TC.getCompilerRT(Args, "profile")));
813  }
814  }
815 
816  Arg *PGOGenArg = nullptr;
817  if (PGOGenerateArg) {
818  assert(!CSPGOGenerateArg);
819  PGOGenArg = PGOGenerateArg;
820  CmdArgs.push_back("-fprofile-instrument=llvm");
821  }
822  if (CSPGOGenerateArg) {
823  assert(!PGOGenerateArg);
824  PGOGenArg = CSPGOGenerateArg;
825  CmdArgs.push_back("-fprofile-instrument=csllvm");
826  }
827  if (PGOGenArg) {
828  if (TC.getTriple().isWindowsMSVCEnvironment()) {
829  CmdArgs.push_back(Args.MakeArgString("--dependent-lib=" +
830  TC.getCompilerRT(Args, "profile")));
831  }
832  if (PGOGenArg->getOption().matches(
833  PGOGenerateArg ? options::OPT_fprofile_generate_EQ
834  : options::OPT_fcs_profile_generate_EQ)) {
835  SmallString<128> Path(PGOGenArg->getValue());
836  llvm::sys::path::append(Path, "default_%m.profraw");
837  CmdArgs.push_back(
838  Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path));
839  }
840  }
841 
842  if (ProfileUseArg) {
843  if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
844  CmdArgs.push_back(Args.MakeArgString(
845  Twine("-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
846  else if ((ProfileUseArg->getOption().matches(
847  options::OPT_fprofile_use_EQ) ||
848  ProfileUseArg->getOption().matches(
849  options::OPT_fprofile_instr_use))) {
850  SmallString<128> Path(
851  ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
852  if (Path.empty() || llvm::sys::fs::is_directory(Path))
853  llvm::sys::path::append(Path, "default.profdata");
854  CmdArgs.push_back(
855  Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path));
856  }
857  }
858 
859  bool EmitCovNotes = Args.hasArg(options::OPT_ftest_coverage) ||
860  Args.hasArg(options::OPT_coverage);
861  bool EmitCovData = Args.hasFlag(options::OPT_fprofile_arcs,
862  options::OPT_fno_profile_arcs, false) ||
863  Args.hasArg(options::OPT_coverage);
864  if (EmitCovNotes)
865  CmdArgs.push_back("-femit-coverage-notes");
866  if (EmitCovData)
867  CmdArgs.push_back("-femit-coverage-data");
868 
869  if (Args.hasFlag(options::OPT_fcoverage_mapping,
870  options::OPT_fno_coverage_mapping, false)) {
871  if (!ProfileGenerateArg)
872  D.Diag(clang::diag::err_drv_argument_only_allowed_with)
873  << "-fcoverage-mapping"
874  << "-fprofile-instr-generate";
875 
876  CmdArgs.push_back("-fcoverage-mapping");
877  }
878 
879  if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
880  auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
881  if (!Args.hasArg(options::OPT_coverage))
882  D.Diag(clang::diag::err_drv_argument_only_allowed_with)
883  << "-fprofile-exclude-files="
884  << "--coverage";
885 
886  StringRef v = Arg->getValue();
887  CmdArgs.push_back(
888  Args.MakeArgString(Twine("-fprofile-exclude-files=" + v)));
889  }
890 
891  if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
892  auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
893  if (!Args.hasArg(options::OPT_coverage))
894  D.Diag(clang::diag::err_drv_argument_only_allowed_with)
895  << "-fprofile-filter-files="
896  << "--coverage";
897 
898  StringRef v = Arg->getValue();
899  CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-filter-files=" + v)));
900  }
901 
902  // Leave -fprofile-dir= an unused argument unless .gcda emission is
903  // enabled. To be polite, with '-fprofile-arcs -fno-profile-arcs' consider
904  // the flag used. There is no -fno-profile-dir, so the user has no
905  // targeted way to suppress the warning.
906  Arg *FProfileDir = nullptr;
907  if (Args.hasArg(options::OPT_fprofile_arcs) ||
908  Args.hasArg(options::OPT_coverage))
909  FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
910 
911  // Put the .gcno and .gcda files (if needed) next to the object file or
912  // bitcode file in the case of LTO.
913  // FIXME: There should be a simpler way to find the object file for this
914  // input, and this code probably does the wrong thing for commands that
915  // compile and link all at once.
916  if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
917  (EmitCovNotes || EmitCovData) && Output.isFilename()) {
918  SmallString<128> OutputFilename;
919  if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT__SLASH_Fo))
920  OutputFilename = FinalOutput->getValue();
921  else if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
922  OutputFilename = FinalOutput->getValue();
923  else
924  OutputFilename = llvm::sys::path::filename(Output.getBaseInput());
925  SmallString<128> CoverageFilename = OutputFilename;
926  if (llvm::sys::path::is_relative(CoverageFilename))
927  (void)D.getVFS().makeAbsolute(CoverageFilename);
928  llvm::sys::path::replace_extension(CoverageFilename, "gcno");
929 
930  CmdArgs.push_back("-coverage-notes-file");
931  CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
932 
933  if (EmitCovData) {
934  if (FProfileDir) {
935  CoverageFilename = FProfileDir->getValue();
936  llvm::sys::path::append(CoverageFilename, OutputFilename);
937  }
938  llvm::sys::path::replace_extension(CoverageFilename, "gcda");
939  CmdArgs.push_back("-coverage-data-file");
940  CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
941  }
942  }
943 }
944 
945 /// Check whether the given input tree contains any compilation actions.
946 static bool ContainsCompileAction(const Action *A) {
947  if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
948  return true;
949 
950  for (const auto &AI : A->inputs())
951  if (ContainsCompileAction(AI))
952  return true;
953 
954  return false;
955 }
956 
957 /// Check if -relax-all should be passed to the internal assembler.
958 /// This is done by default when compiling non-assembler source with -O0.
959 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
960  bool RelaxDefault = true;
961 
962  if (Arg *A = Args.getLastArg(options::OPT_O_Group))
963  RelaxDefault = A->getOption().matches(options::OPT_O0);
964 
965  if (RelaxDefault) {
966  RelaxDefault = false;
967  for (const auto &Act : C.getActions()) {
968  if (ContainsCompileAction(Act)) {
969  RelaxDefault = true;
970  break;
971  }
972  }
973  }
974 
975  return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
976  RelaxDefault);
977 }
978 
979 // Extract the integer N from a string spelled "-dwarf-N", returning 0
980 // on mismatch. The StringRef input (rather than an Arg) allows
981 // for use by the "-Xassembler" option parser.
982 static unsigned DwarfVersionNum(StringRef ArgValue) {
983  return llvm::StringSwitch<unsigned>(ArgValue)
984  .Case("-gdwarf-2", 2)
985  .Case("-gdwarf-3", 3)
986  .Case("-gdwarf-4", 4)
987  .Case("-gdwarf-5", 5)
988  .Default(0);
989 }
990 
991 static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
993  unsigned DwarfVersion,
994  llvm::DebuggerKind DebuggerTuning) {
995  switch (DebugInfoKind) {
997  CmdArgs.push_back("-debug-info-kind=line-directives-only");
998  break;
1000  CmdArgs.push_back("-debug-info-kind=line-tables-only");
1001  break;
1003  CmdArgs.push_back("-debug-info-kind=constructor");
1004  break;
1006  CmdArgs.push_back("-debug-info-kind=limited");
1007  break;
1009  CmdArgs.push_back("-debug-info-kind=standalone");
1010  break;
1011  default:
1012  break;
1013  }
1014  if (DwarfVersion > 0)
1015  CmdArgs.push_back(
1016  Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion)));
1017  switch (DebuggerTuning) {
1018  case llvm::DebuggerKind::GDB:
1019  CmdArgs.push_back("-debugger-tuning=gdb");
1020  break;
1021  case llvm::DebuggerKind::LLDB:
1022  CmdArgs.push_back("-debugger-tuning=lldb");
1023  break;
1024  case llvm::DebuggerKind::SCE:
1025  CmdArgs.push_back("-debugger-tuning=sce");
1026  break;
1027  default:
1028  break;
1029  }
1030 }
1031 
1032 static bool checkDebugInfoOption(const Arg *A, const ArgList &Args,
1033  const Driver &D, const ToolChain &TC) {
1034  assert(A && "Expected non-nullptr argument.");
1035  if (TC.supportsDebugInfoOption(A))
1036  return true;
1037  D.Diag(diag::warn_drv_unsupported_debug_info_opt_for_target)
1038  << A->getAsString(Args) << TC.getTripleString();
1039  return false;
1040 }
1041 
1042 static void RenderDebugInfoCompressionArgs(const ArgList &Args,
1043  ArgStringList &CmdArgs,
1044  const Driver &D,
1045  const ToolChain &TC) {
1046  const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ);
1047  if (!A)
1048  return;
1049  if (checkDebugInfoOption(A, Args, D, TC)) {
1050  if (A->getOption().getID() == options::OPT_gz) {
1051  if (llvm::zlib::isAvailable())
1052  CmdArgs.push_back("--compress-debug-sections");
1053  else
1054  D.Diag(diag::warn_debug_compression_unavailable);
1055  return;
1056  }
1057 
1058  StringRef Value = A->getValue();
1059  if (Value == "none") {
1060  CmdArgs.push_back("--compress-debug-sections=none");
1061  } else if (Value == "zlib" || Value == "zlib-gnu") {
1062  if (llvm::zlib::isAvailable()) {
1063  CmdArgs.push_back(
1064  Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
1065  } else {
1066  D.Diag(diag::warn_debug_compression_unavailable);
1067  }
1068  } else {
1069  D.Diag(diag::err_drv_unsupported_option_argument)
1070  << A->getOption().getName() << Value;
1071  }
1072  }
1073 }
1074 
1075 static const char *RelocationModelName(llvm::Reloc::Model Model) {
1076  switch (Model) {
1077  case llvm::Reloc::Static:
1078  return "static";
1079  case llvm::Reloc::PIC_:
1080  return "pic";
1081  case llvm::Reloc::DynamicNoPIC:
1082  return "dynamic-no-pic";
1083  case llvm::Reloc::ROPI:
1084  return "ropi";
1085  case llvm::Reloc::RWPI:
1086  return "rwpi";
1087  case llvm::Reloc::ROPI_RWPI:
1088  return "ropi-rwpi";
1089  }
1090  llvm_unreachable("Unknown Reloc::Model kind");
1091 }
1092 
1093 void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
1094  const Driver &D, const ArgList &Args,
1095  ArgStringList &CmdArgs,
1096  const InputInfo &Output,
1097  const InputInfoList &Inputs) const {
1098  const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU();
1099 
1100  CheckPreprocessingOptions(D, Args);
1101 
1102  Args.AddLastArg(CmdArgs, options::OPT_C);
1103  Args.AddLastArg(CmdArgs, options::OPT_CC);
1104 
1105  // Handle dependency file generation.
1106  Arg *ArgM = Args.getLastArg(options::OPT_MM);
1107  if (!ArgM)
1108  ArgM = Args.getLastArg(options::OPT_M);
1109  Arg *ArgMD = Args.getLastArg(options::OPT_MMD);
1110  if (!ArgMD)
1111  ArgMD = Args.getLastArg(options::OPT_MD);
1112 
1113  // -M and -MM imply -w.
1114  if (ArgM)
1115  CmdArgs.push_back("-w");
1116  else
1117  ArgM = ArgMD;
1118 
1119  if (ArgM) {
1120  // Determine the output location.
1121  const char *DepFile;
1122  if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
1123  DepFile = MF->getValue();
1124  C.addFailureResultFile(DepFile, &JA);
1125  } else if (Output.getType() == types::TY_Dependencies) {
1126  DepFile = Output.getFilename();
1127  } else if (!ArgMD) {
1128  DepFile = "-";
1129  } else {
1130  DepFile = getDependencyFileName(Args, Inputs);
1131  C.addFailureResultFile(DepFile, &JA);
1132  }
1133  CmdArgs.push_back("-dependency-file");
1134  CmdArgs.push_back(DepFile);
1135 
1136  bool HasTarget = false;
1137  for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
1138  HasTarget = true;
1139  A->claim();
1140  if (A->getOption().matches(options::OPT_MT)) {
1141  A->render(Args, CmdArgs);
1142  } else {
1143  CmdArgs.push_back("-MT");
1144  SmallString<128> Quoted;
1145  QuoteTarget(A->getValue(), Quoted);
1146  CmdArgs.push_back(Args.MakeArgString(Quoted));
1147  }
1148  }
1149 
1150  // Add a default target if one wasn't specified.
1151  if (!HasTarget) {
1152  const char *DepTarget;
1153 
1154  // If user provided -o, that is the dependency target, except
1155  // when we are only generating a dependency file.
1156  Arg *OutputOpt = Args.getLastArg(options::OPT_o);
1157  if (OutputOpt && Output.getType() != types::TY_Dependencies) {
1158  DepTarget = OutputOpt->getValue();
1159  } else {
1160  // Otherwise derive from the base input.
1161  //
1162  // FIXME: This should use the computed output file location.
1163  SmallString<128> P(Inputs[0].getBaseInput());
1164  llvm::sys::path::replace_extension(P, "o");
1165  DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
1166  }
1167 
1168  CmdArgs.push_back("-MT");
1169  SmallString<128> Quoted;
1170  QuoteTarget(DepTarget, Quoted);
1171  CmdArgs.push_back(Args.MakeArgString(Quoted));
1172  }
1173 
1174  if (ArgM->getOption().matches(options::OPT_M) ||
1175  ArgM->getOption().matches(options::OPT_MD))
1176  CmdArgs.push_back("-sys-header-deps");
1177  if ((isa<PrecompileJobAction>(JA) &&
1178  !Args.hasArg(options::OPT_fno_module_file_deps)) ||
1179  Args.hasArg(options::OPT_fmodule_file_deps))
1180  CmdArgs.push_back("-module-file-deps");
1181  }
1182 
1183  if (Args.hasArg(options::OPT_MG)) {
1184  if (!ArgM || ArgM->getOption().matches(options::OPT_MD) ||
1185  ArgM->getOption().matches(options::OPT_MMD))
1186  D.Diag(diag::err_drv_mg_requires_m_or_mm);
1187  CmdArgs.push_back("-MG");
1188  }
1189 
1190  Args.AddLastArg(CmdArgs, options::OPT_MP);
1191  Args.AddLastArg(CmdArgs, options::OPT_MV);
1192 
1193  // Add offload include arguments specific for CUDA. This must happen before
1194  // we -I or -include anything else, because we must pick up the CUDA headers
1195  // from the particular CUDA installation, rather than from e.g.
1196  // /usr/local/include.
1198  getToolChain().AddCudaIncludeArgs(Args, CmdArgs);
1199 
1200  // If we are offloading to a target via OpenMP we need to include the
1201  // openmp_wrappers folder which contains alternative system headers.
1203  getToolChain().getTriple().isNVPTX()){
1204  if (!Args.hasArg(options::OPT_nobuiltininc)) {
1205  // Add openmp_wrappers/* to our system include path. This lets us wrap
1206  // standard library headers.
1208  llvm::sys::path::append(P, "include");
1209  llvm::sys::path::append(P, "openmp_wrappers");
1210  CmdArgs.push_back("-internal-isystem");
1211  CmdArgs.push_back(Args.MakeArgString(P));
1212  }
1213 
1214  CmdArgs.push_back("-include");
1215  CmdArgs.push_back("__clang_openmp_math_declares.h");
1216  }
1217 
1218  // Add -i* options, and automatically translate to
1219  // -include-pch/-include-pth for transparent PCH support. It's
1220  // wonky, but we include looking for .gch so we can support seamless
1221  // replacement into a build system already set up to be generating
1222  // .gch files.
1223 
1224  if (getToolChain().getDriver().IsCLMode()) {
1225  const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1226  const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1227  if (YcArg && JA.getKind() >= Action::PrecompileJobClass &&
1229  CmdArgs.push_back(Args.MakeArgString("-building-pch-with-obj"));
1230  }
1231  if (YcArg || YuArg) {
1232  StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue();
1233  if (!isa<PrecompileJobAction>(JA)) {
1234  CmdArgs.push_back("-include-pch");
1235  CmdArgs.push_back(Args.MakeArgString(D.GetClPchPath(
1236  C, !ThroughHeader.empty()
1237  ? ThroughHeader
1238  : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1239  }
1240 
1241  if (ThroughHeader.empty()) {
1242  CmdArgs.push_back(Args.MakeArgString(
1243  Twine("-pch-through-hdrstop-") + (YcArg ? "create" : "use")));
1244  } else {
1245  CmdArgs.push_back(
1246  Args.MakeArgString(Twine("-pch-through-header=") + ThroughHeader));
1247  }
1248  }
1249  }
1250 
1251  bool RenderedImplicitInclude = false;
1252  for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
1253  if (A->getOption().matches(options::OPT_include)) {
1254  // Handling of gcc-style gch precompiled headers.
1255  bool IsFirstImplicitInclude = !RenderedImplicitInclude;
1256  RenderedImplicitInclude = true;
1257 
1258  bool FoundPCH = false;
1259  SmallString<128> P(A->getValue());
1260  // We want the files to have a name like foo.h.pch. Add a dummy extension
1261  // so that replace_extension does the right thing.
1262  P += ".dummy";
1263  llvm::sys::path::replace_extension(P, "pch");
1264  if (llvm::sys::fs::exists(P))
1265  FoundPCH = true;
1266 
1267  if (!FoundPCH) {
1268  llvm::sys::path::replace_extension(P, "gch");
1269  if (llvm::sys::fs::exists(P)) {
1270  FoundPCH = true;
1271  }
1272  }
1273 
1274  if (FoundPCH) {
1275  if (IsFirstImplicitInclude) {
1276  A->claim();
1277  CmdArgs.push_back("-include-pch");
1278  CmdArgs.push_back(Args.MakeArgString(P));
1279  continue;
1280  } else {
1281  // Ignore the PCH if not first on command line and emit warning.
1282  D.Diag(diag::warn_drv_pch_not_first_include) << P
1283  << A->getAsString(Args);
1284  }
1285  }
1286  } else if (A->getOption().matches(options::OPT_isystem_after)) {
1287  // Handling of paths which must come late. These entries are handled by
1288  // the toolchain itself after the resource dir is inserted in the right
1289  // search order.
1290  // Do not claim the argument so that the use of the argument does not
1291  // silently go unnoticed on toolchains which do not honour the option.
1292  continue;
1293  } else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) {
1294  // Translated to -internal-isystem by the driver, no need to pass to cc1.
1295  continue;
1296  }
1297 
1298  // Not translated, render as usual.
1299  A->claim();
1300  A->render(Args, CmdArgs);
1301  }
1302 
1303  Args.AddAllArgs(CmdArgs,
1304  {options::OPT_D, options::OPT_U, options::OPT_I_Group,
1305  options::OPT_F, options::OPT_index_header_map});
1306 
1307  // Add -Wp, and -Xpreprocessor if using the preprocessor.
1308 
1309  // FIXME: There is a very unfortunate problem here, some troubled
1310  // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
1311  // really support that we would have to parse and then translate
1312  // those options. :(
1313  Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
1314  options::OPT_Xpreprocessor);
1315 
1316  // -I- is a deprecated GCC feature, reject it.
1317  if (Arg *A = Args.getLastArg(options::OPT_I_))
1318  D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
1319 
1320  // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
1321  // -isysroot to the CC1 invocation.
1322  StringRef sysroot = C.getSysRoot();
1323  if (sysroot != "") {
1324  if (!Args.hasArg(options::OPT_isysroot)) {
1325  CmdArgs.push_back("-isysroot");
1326  CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
1327  }
1328  }
1329 
1330  // Parse additional include paths from environment variables.
1331  // FIXME: We should probably sink the logic for handling these from the
1332  // frontend into the driver. It will allow deleting 4 otherwise unused flags.
1333  // CPATH - included following the user specified includes (but prior to
1334  // builtin and standard includes).
1335  addDirectoryList(Args, CmdArgs, "-I", "CPATH");
1336  // C_INCLUDE_PATH - system includes enabled when compiling C.
1337  addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
1338  // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
1339  addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
1340  // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
1341  addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
1342  // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
1343  addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
1344 
1345  // While adding the include arguments, we also attempt to retrieve the
1346  // arguments of related offloading toolchains or arguments that are specific
1347  // of an offloading programming model.
1348 
1349  // Add C++ include arguments, if needed.
1350  if (types::isCXX(Inputs[0].getType())) {
1351  bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem);
1353  C, JA, getToolChain(),
1354  [&Args, &CmdArgs, HasStdlibxxIsystem](const ToolChain &TC) {
1355  HasStdlibxxIsystem ? TC.AddClangCXXStdlibIsystemArgs(Args, CmdArgs)
1356  : TC.AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
1357  });
1358  }
1359 
1360  // Add system include arguments for all targets but IAMCU.
1361  if (!IsIAMCU)
1362  forAllAssociatedToolChains(C, JA, getToolChain(),
1363  [&Args, &CmdArgs](const ToolChain &TC) {
1364  TC.AddClangSystemIncludeArgs(Args, CmdArgs);
1365  });
1366  else {
1367  // For IAMCU add special include arguments.
1368  getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs);
1369  }
1370 
1371  addMacroPrefixMapArg(D, Args, CmdArgs);
1372 }
1373 
1374 // FIXME: Move to target hook.
1375 static bool isSignedCharDefault(const llvm::Triple &Triple) {
1376  switch (Triple.getArch()) {
1377  default:
1378  return true;
1379 
1380  case llvm::Triple::aarch64:
1381  case llvm::Triple::aarch64_32:
1382  case llvm::Triple::aarch64_be:
1383  case llvm::Triple::arm:
1384  case llvm::Triple::armeb:
1385  case llvm::Triple::thumb:
1386  case llvm::Triple::thumbeb:
1387  if (Triple.isOSDarwin() || Triple.isOSWindows())
1388  return true;
1389  return false;
1390 
1391  case llvm::Triple::ppc:
1392  case llvm::Triple::ppc64:
1393  if (Triple.isOSDarwin())
1394  return true;
1395  return false;
1396 
1397  case llvm::Triple::hexagon:
1398  case llvm::Triple::ppc64le:
1399  case llvm::Triple::riscv32:
1400  case llvm::Triple::riscv64:
1401  case llvm::Triple::systemz:
1402  case llvm::Triple::xcore:
1403  return false;
1404  }
1405 }
1406 
1407 static bool isNoCommonDefault(const llvm::Triple &Triple) {
1408  switch (Triple.getArch()) {
1409  default:
1410  if (Triple.isOSFuchsia())
1411  return true;
1412  return false;
1413 
1414  case llvm::Triple::xcore:
1415  case llvm::Triple::wasm32:
1416  case llvm::Triple::wasm64:
1417  return true;
1418  }
1419 }
1420 
1421 static bool hasMultipleInvocations(const llvm::Triple &Triple,
1422  const ArgList &Args) {
1423  // Supported only on Darwin where we invoke the compiler multiple times
1424  // followed by an invocation to lipo.
1425  if (!Triple.isOSDarwin())
1426  return false;
1427  // If more than one "-arch <arch>" is specified, we're targeting multiple
1428  // architectures resulting in a fat binary.
1429  return Args.getAllArgValues(options::OPT_arch).size() > 1;
1430 }
1431 
1432 static bool checkRemarksOptions(const Driver &D, const ArgList &Args,
1433  const llvm::Triple &Triple) {
1434  // When enabling remarks, we need to error if:
1435  // * The remark file is specified but we're targeting multiple architectures,
1436  // which means more than one remark file is being generated.
1437  bool hasMultipleInvocations = ::hasMultipleInvocations(Triple, Args);
1438  bool hasExplicitOutputFile =
1439  Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1440  if (hasMultipleInvocations && hasExplicitOutputFile) {
1441  D.Diag(diag::err_drv_invalid_output_with_multiple_archs)
1442  << "-foptimization-record-file";
1443  return false;
1444  }
1445  return true;
1446 }
1447 
1448 static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs,
1449  const llvm::Triple &Triple,
1450  const InputInfo &Input,
1451  const InputInfo &Output, const JobAction &JA) {
1452  StringRef Format = "yaml";
1453  if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
1454  Format = A->getValue();
1455 
1456  CmdArgs.push_back("-opt-record-file");
1457 
1458  const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
1459  if (A) {
1460  CmdArgs.push_back(A->getValue());
1461  } else {
1462  bool hasMultipleArchs =
1463  Triple.isOSDarwin() && // Only supported on Darwin platforms.
1464  Args.getAllArgValues(options::OPT_arch).size() > 1;
1465 
1466  SmallString<128> F;
1467 
1468  if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) {
1469  if (Arg *FinalOutput = Args.getLastArg(options::OPT_o))
1470  F = FinalOutput->getValue();
1471  } else {
1472  if (Format != "yaml" && // For YAML, keep the original behavior.
1473  Triple.isOSDarwin() && // Enable this only on darwin, since it's the only platform supporting .dSYM bundles.
1474  Output.isFilename())
1475  F = Output.getFilename();
1476  }
1477 
1478  if (F.empty()) {
1479  // Use the input filename.
1480  F = llvm::sys::path::stem(Input.getBaseInput());
1481 
1482  // If we're compiling for an offload architecture (i.e. a CUDA device),
1483  // we need to make the file name for the device compilation different
1484  // from the host compilation.
1487  llvm::sys::path::replace_extension(F, "");
1489  Triple.normalize());
1490  F += "-";
1491  F += JA.getOffloadingArch();
1492  }
1493  }
1494 
1495  // If we're having more than one "-arch", we should name the files
1496  // differently so that every cc1 invocation writes to a different file.
1497  // We're doing that by appending "-<arch>" with "<arch>" being the arch
1498  // name from the triple.
1499  if (hasMultipleArchs) {
1500  // First, remember the extension.
1501  SmallString<64> OldExtension = llvm::sys::path::extension(F);
1502  // then, remove it.
1503  llvm::sys::path::replace_extension(F, "");
1504  // attach -<arch> to it.
1505  F += "-";
1506  F += Triple.getArchName();
1507  // put back the extension.
1508  llvm::sys::path::replace_extension(F, OldExtension);
1509  }
1510 
1511  SmallString<32> Extension;
1512  Extension += "opt.";
1513  Extension += Format;
1514 
1515  llvm::sys::path::replace_extension(F, Extension);
1516  CmdArgs.push_back(Args.MakeArgString(F));
1517  }
1518 
1519  if (const Arg *A =
1520  Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
1521  CmdArgs.push_back("-opt-record-passes");
1522  CmdArgs.push_back(A->getValue());
1523  }
1524 
1525  if (!Format.empty()) {
1526  CmdArgs.push_back("-opt-record-format");
1527  CmdArgs.push_back(Format.data());
1528  }
1529 }
1530 
1531 namespace {
1532 void RenderARMABI(const llvm::Triple &Triple, const ArgList &Args,
1533  ArgStringList &CmdArgs) {
1534  // Select the ABI to use.
1535  // FIXME: Support -meabi.
1536  // FIXME: Parts of this are duplicated in the backend, unify this somehow.
1537  const char *ABIName = nullptr;
1538  if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
1539  ABIName = A->getValue();
1540  } else {
1541  std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
1542  ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data();
1543  }
1544 
1545  CmdArgs.push_back("-target-abi");
1546  CmdArgs.push_back(ABIName);
1547 }
1548 }
1549 
1550 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
1551  ArgStringList &CmdArgs, bool KernelOrKext) const {
1552  RenderARMABI(Triple, Args, CmdArgs);
1553 
1554  // Determine floating point ABI from the options & target defaults.
1555  arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args);
1556  if (ABI == arm::FloatABI::Soft) {
1557  // Floating point operations and argument passing are soft.
1558  // FIXME: This changes CPP defines, we need -target-soft-float.
1559  CmdArgs.push_back("-msoft-float");
1560  CmdArgs.push_back("-mfloat-abi");
1561  CmdArgs.push_back("soft");
1562  } else if (ABI == arm::FloatABI::SoftFP) {
1563  // Floating point operations are hard, but argument passing is soft.
1564  CmdArgs.push_back("-mfloat-abi");
1565  CmdArgs.push_back("soft");
1566  } else {
1567  // Floating point operations and argument passing are hard.
1568  assert(ABI == arm::FloatABI::Hard && "Invalid float abi!");
1569  CmdArgs.push_back("-mfloat-abi");
1570  CmdArgs.push_back("hard");
1571  }
1572 
1573  // Forward the -mglobal-merge option for explicit control over the pass.
1574  if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1575  options::OPT_mno_global_merge)) {
1576  CmdArgs.push_back("-mllvm");
1577  if (A->getOption().matches(options::OPT_mno_global_merge))
1578  CmdArgs.push_back("-arm-global-merge=false");
1579  else
1580  CmdArgs.push_back("-arm-global-merge=true");
1581  }
1582 
1583  if (!Args.hasFlag(options::OPT_mimplicit_float,
1584  options::OPT_mno_implicit_float, true))
1585  CmdArgs.push_back("-no-implicit-float");
1586 
1587  if (Args.getLastArg(options::OPT_mcmse))
1588  CmdArgs.push_back("-mcmse");
1589 }
1590 
1591 void Clang::RenderTargetOptions(const llvm::Triple &EffectiveTriple,
1592  const ArgList &Args, bool KernelOrKext,
1593  ArgStringList &CmdArgs) const {
1594  const ToolChain &TC = getToolChain();
1595 
1596  // Add the target features
1597  getTargetFeatures(TC, EffectiveTriple, Args, CmdArgs, false);
1598 
1599  // Add target specific flags.
1600  switch (TC.getArch()) {
1601  default:
1602  break;
1603 
1604  case llvm::Triple::arm:
1605  case llvm::Triple::armeb:
1606  case llvm::Triple::thumb:
1607  case llvm::Triple::thumbeb:
1608  // Use the effective triple, which takes into account the deployment target.
1609  AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext);
1610  CmdArgs.push_back("-fallow-half-arguments-and-returns");
1611  break;
1612 
1613  case llvm::Triple::aarch64:
1614  case llvm::Triple::aarch64_32:
1615  case llvm::Triple::aarch64_be:
1616  AddAArch64TargetArgs(Args, CmdArgs);
1617  CmdArgs.push_back("-fallow-half-arguments-and-returns");
1618  break;
1619 
1620  case llvm::Triple::mips:
1621  case llvm::Triple::mipsel:
1622  case llvm::Triple::mips64:
1623  case llvm::Triple::mips64el:
1624  AddMIPSTargetArgs(Args, CmdArgs);
1625  break;
1626 
1627  case llvm::Triple::ppc:
1628  case llvm::Triple::ppc64:
1629  case llvm::Triple::ppc64le:
1630  AddPPCTargetArgs(Args, CmdArgs);
1631  break;
1632 
1633  case llvm::Triple::riscv32:
1634  case llvm::Triple::riscv64:
1635  AddRISCVTargetArgs(Args, CmdArgs);
1636  break;
1637 
1638  case llvm::Triple::sparc:
1639  case llvm::Triple::sparcel:
1640  case llvm::Triple::sparcv9:
1641  AddSparcTargetArgs(Args, CmdArgs);
1642  break;
1643 
1644  case llvm::Triple::systemz:
1645  AddSystemZTargetArgs(Args, CmdArgs);
1646  break;
1647 
1648  case llvm::Triple::x86:
1649  case llvm::Triple::x86_64:
1650  AddX86TargetArgs(Args, CmdArgs);
1651  break;
1652 
1653  case llvm::Triple::lanai:
1654  AddLanaiTargetArgs(Args, CmdArgs);
1655  break;
1656 
1657  case llvm::Triple::hexagon:
1658  AddHexagonTargetArgs(Args, CmdArgs);
1659  break;
1660 
1661  case llvm::Triple::wasm32:
1662  case llvm::Triple::wasm64:
1663  AddWebAssemblyTargetArgs(Args, CmdArgs);
1664  break;
1665  }
1666 }
1667 
1668 namespace {
1669 void RenderAArch64ABI(const llvm::Triple &Triple, const ArgList &Args,
1670  ArgStringList &CmdArgs) {
1671  const char *ABIName = nullptr;
1672  if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1673  ABIName = A->getValue();
1674  else if (Triple.isOSDarwin())
1675  ABIName = "darwinpcs";
1676  else
1677  ABIName = "aapcs";
1678 
1679  CmdArgs.push_back("-target-abi");
1680  CmdArgs.push_back(ABIName);
1681 }
1682 }
1683 
1684 void Clang::AddAArch64TargetArgs(const ArgList &Args,
1685  ArgStringList &CmdArgs) const {
1686  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
1687 
1688  if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
1689  Args.hasArg(options::OPT_mkernel) ||
1690  Args.hasArg(options::OPT_fapple_kext))
1691  CmdArgs.push_back("-disable-red-zone");
1692 
1693  if (!Args.hasFlag(options::OPT_mimplicit_float,
1694  options::OPT_mno_implicit_float, true))
1695  CmdArgs.push_back("-no-implicit-float");
1696 
1697  RenderAArch64ABI(Triple, Args, CmdArgs);
1698 
1699  if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
1700  options::OPT_mno_fix_cortex_a53_835769)) {
1701  CmdArgs.push_back("-mllvm");
1702  if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
1703  CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
1704  else
1705  CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
1706  } else if (Triple.isAndroid()) {
1707  // Enabled A53 errata (835769) workaround by default on android
1708  CmdArgs.push_back("-mllvm");
1709  CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
1710  }
1711 
1712  // Forward the -mglobal-merge option for explicit control over the pass.
1713  if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
1714  options::OPT_mno_global_merge)) {
1715  CmdArgs.push_back("-mllvm");
1716  if (A->getOption().matches(options::OPT_mno_global_merge))
1717  CmdArgs.push_back("-aarch64-enable-global-merge=false");
1718  else
1719  CmdArgs.push_back("-aarch64-enable-global-merge=true");
1720  }
1721 
1722  // Enable/disable return address signing and indirect branch targets.
1723  if (Arg *A = Args.getLastArg(options::OPT_msign_return_address_EQ,
1724  options::OPT_mbranch_protection_EQ)) {
1725 
1726  const Driver &D = getToolChain().getDriver();
1727 
1728  StringRef Scope, Key;
1729  bool IndirectBranches;
1730 
1731  if (A->getOption().matches(options::OPT_msign_return_address_EQ)) {
1732  Scope = A->getValue();
1733  if (!Scope.equals("none") && !Scope.equals("non-leaf") &&
1734  !Scope.equals("all"))
1735  D.Diag(diag::err_invalid_branch_protection)
1736  << Scope << A->getAsString(Args);
1737  Key = "a_key";
1738  IndirectBranches = false;
1739  } else {
1740  StringRef Err;
1741  llvm::AArch64::ParsedBranchProtection PBP;
1742  if (!llvm::AArch64::parseBranchProtection(A->getValue(), PBP, Err))
1743  D.Diag(diag::err_invalid_branch_protection)
1744  << Err << A->getAsString(Args);
1745  Scope = PBP.Scope;
1746  Key = PBP.Key;
1747  IndirectBranches = PBP.BranchTargetEnforcement;
1748  }
1749 
1750  CmdArgs.push_back(
1751  Args.MakeArgString(Twine("-msign-return-address=") + Scope));
1752  CmdArgs.push_back(
1753  Args.MakeArgString(Twine("-msign-return-address-key=") + Key));
1754  if (IndirectBranches)
1755  CmdArgs.push_back("-mbranch-target-enforce");
1756  }
1757 }
1758 
1759 void Clang::AddMIPSTargetArgs(const ArgList &Args,
1760  ArgStringList &CmdArgs) const {
1761  const Driver &D = getToolChain().getDriver();
1762  StringRef CPUName;
1763  StringRef ABIName;
1764  const llvm::Triple &Triple = getToolChain().getTriple();
1765  mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1766 
1767  CmdArgs.push_back("-target-abi");
1768  CmdArgs.push_back(ABIName.data());
1769 
1770  mips::FloatABI ABI = mips::getMipsFloatABI(D, Args, Triple);
1771  if (ABI == mips::FloatABI::Soft) {
1772  // Floating point operations and argument passing are soft.
1773  CmdArgs.push_back("-msoft-float");
1774  CmdArgs.push_back("-mfloat-abi");
1775  CmdArgs.push_back("soft");
1776  } else {
1777  // Floating point operations and argument passing are hard.
1778  assert(ABI == mips::FloatABI::Hard && "Invalid float abi!");
1779  CmdArgs.push_back("-mfloat-abi");
1780  CmdArgs.push_back("hard");
1781  }
1782 
1783  if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1784  options::OPT_mno_ldc1_sdc1)) {
1785  if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1786  CmdArgs.push_back("-mllvm");
1787  CmdArgs.push_back("-mno-ldc1-sdc1");
1788  }
1789  }
1790 
1791  if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1792  options::OPT_mno_check_zero_division)) {
1793  if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1794  CmdArgs.push_back("-mllvm");
1795  CmdArgs.push_back("-mno-check-zero-division");
1796  }
1797  }
1798 
1799  if (Arg *A = Args.getLastArg(options::OPT_G)) {
1800  StringRef v = A->getValue();
1801  CmdArgs.push_back("-mllvm");
1802  CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1803  A->claim();
1804  }
1805 
1806  Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt);
1807  Arg *ABICalls =
1808  Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls);
1809 
1810  // -mabicalls is the default for many MIPS environments, even with -fno-pic.
1811  // -mgpopt is the default for static, -fno-pic environments but these two
1812  // options conflict. We want to be certain that -mno-abicalls -mgpopt is
1813  // the only case where -mllvm -mgpopt is passed.
1814  // NOTE: We need a warning here or in the backend to warn when -mgpopt is
1815  // passed explicitly when compiling something with -mabicalls
1816  // (implictly) in affect. Currently the warning is in the backend.
1817  //
1818  // When the ABI in use is N64, we also need to determine the PIC mode that
1819  // is in use, as -fno-pic for N64 implies -mno-abicalls.
1820  bool NoABICalls =
1821  ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls);
1822 
1823  llvm::Reloc::Model RelocationModel;
1824  unsigned PICLevel;
1825  bool IsPIE;
1826  std::tie(RelocationModel, PICLevel, IsPIE) =
1827  ParsePICArgs(getToolChain(), Args);
1828 
1829  NoABICalls = NoABICalls ||
1830  (RelocationModel == llvm::Reloc::Static && ABIName == "n64");
1831 
1832  bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt);
1833  // We quietly ignore -mno-gpopt as the backend defaults to -mno-gpopt.
1834  if (NoABICalls && (!GPOpt || WantGPOpt)) {
1835  CmdArgs.push_back("-mllvm");
1836  CmdArgs.push_back("-mgpopt");
1837 
1838  Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata,
1839  options::OPT_mno_local_sdata);
1840  Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata,
1841  options::OPT_mno_extern_sdata);
1842  Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data,
1843  options::OPT_mno_embedded_data);
1844  if (LocalSData) {
1845  CmdArgs.push_back("-mllvm");
1846  if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) {
1847  CmdArgs.push_back("-mlocal-sdata=1");
1848  } else {
1849  CmdArgs.push_back("-mlocal-sdata=0");
1850  }
1851  LocalSData->claim();
1852  }
1853 
1854  if (ExternSData) {
1855  CmdArgs.push_back("-mllvm");
1856  if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) {
1857  CmdArgs.push_back("-mextern-sdata=1");
1858  } else {
1859  CmdArgs.push_back("-mextern-sdata=0");
1860  }
1861  ExternSData->claim();
1862  }
1863 
1864  if (EmbeddedData) {
1865  CmdArgs.push_back("-mllvm");
1866  if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) {
1867  CmdArgs.push_back("-membedded-data=1");
1868  } else {
1869  CmdArgs.push_back("-membedded-data=0");
1870  }
1871  EmbeddedData->claim();
1872  }
1873 
1874  } else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt)
1875  D.Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1);
1876 
1877  if (GPOpt)
1878  GPOpt->claim();
1879 
1880  if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) {
1881  StringRef Val = StringRef(A->getValue());
1882  if (mips::hasCompactBranches(CPUName)) {
1883  if (Val == "never" || Val == "always" || Val == "optimal") {
1884  CmdArgs.push_back("-mllvm");
1885  CmdArgs.push_back(Args.MakeArgString("-mips-compact-branches=" + Val));
1886  } else
1887  D.Diag(diag::err_drv_unsupported_option_argument)
1888  << A->getOption().getName() << Val;
1889  } else
1890  D.Diag(diag::warn_target_unsupported_compact_branches) << CPUName;
1891  }
1892 
1893  if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls,
1894  options::OPT_mno_relax_pic_calls)) {
1895  if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) {
1896  CmdArgs.push_back("-mllvm");
1897  CmdArgs.push_back("-mips-jalr-reloc=0");
1898  }
1899  }
1900 }
1901 
1902 void Clang::AddPPCTargetArgs(const ArgList &Args,
1903  ArgStringList &CmdArgs) const {
1904  // Select the ABI to use.
1905  const char *ABIName = nullptr;
1906  const llvm::Triple &T = getToolChain().getTriple();
1907  if (T.isOSBinFormatELF()) {
1908  switch (getToolChain().getArch()) {
1909  case llvm::Triple::ppc64: {
1910  // When targeting a processor that supports QPX, or if QPX is
1911  // specifically enabled, default to using the ABI that supports QPX (so
1912  // long as it is not specifically disabled).
1913  bool HasQPX = false;
1914  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1915  HasQPX = A->getValue() == StringRef("a2q");
1916  HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1917  if (HasQPX) {
1918  ABIName = "elfv1-qpx";
1919  break;
1920  }
1921 
1922  if (T.isMusl() || (T.isOSFreeBSD() && T.getOSMajorVersion() >= 13))
1923  ABIName = "elfv2";
1924  else
1925  ABIName = "elfv1";
1926  break;
1927  }
1928  case llvm::Triple::ppc64le:
1929  ABIName = "elfv2";
1930  break;
1931  default:
1932  break;
1933  }
1934  }
1935 
1936  bool IEEELongDouble = false;
1937  for (const Arg *A : Args.filtered(options::OPT_mabi_EQ)) {
1938  StringRef V = A->getValue();
1939  if (V == "ieeelongdouble")
1940  IEEELongDouble = true;
1941  else if (V == "ibmlongdouble")
1942  IEEELongDouble = false;
1943  else if (V != "altivec")
1944  // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore
1945  // the option if given as we don't have backend support for any targets
1946  // that don't use the altivec abi.
1947  ABIName = A->getValue();
1948  }
1949  if (IEEELongDouble)
1950  CmdArgs.push_back("-mabi=ieeelongdouble");
1951 
1953  ppc::getPPCFloatABI(getToolChain().getDriver(), Args);
1954 
1955  if (FloatABI == ppc::FloatABI::Soft) {
1956  // Floating point operations and argument passing are soft.
1957  CmdArgs.push_back("-msoft-float");
1958  CmdArgs.push_back("-mfloat-abi");
1959  CmdArgs.push_back("soft");
1960  } else {
1961  // Floating point operations and argument passing are hard.
1962  assert(FloatABI == ppc::FloatABI::Hard && "Invalid float abi!");
1963  CmdArgs.push_back("-mfloat-abi");
1964  CmdArgs.push_back("hard");
1965  }
1966 
1967  if (ABIName) {
1968  CmdArgs.push_back("-target-abi");
1969  CmdArgs.push_back(ABIName);
1970  }
1971 }
1972 
1973 void Clang::AddRISCVTargetArgs(const ArgList &Args,
1974  ArgStringList &CmdArgs) const {
1975  const llvm::Triple &Triple = getToolChain().getTriple();
1976  StringRef ABIName = riscv::getRISCVABI(Args, Triple);
1977 
1978  CmdArgs.push_back("-target-abi");
1979  CmdArgs.push_back(ABIName.data());
1980 }
1981 
1982 void Clang::AddSparcTargetArgs(const ArgList &Args,
1983  ArgStringList &CmdArgs) const {
1985  sparc::getSparcFloatABI(getToolChain().getDriver(), Args);
1986 
1987  if (FloatABI == sparc::FloatABI::Soft) {
1988  // Floating point operations and argument passing are soft.
1989  CmdArgs.push_back("-msoft-float");
1990  CmdArgs.push_back("-mfloat-abi");
1991  CmdArgs.push_back("soft");
1992  } else {
1993  // Floating point operations and argument passing are hard.
1994  assert(FloatABI == sparc::FloatABI::Hard && "Invalid float abi!");
1995  CmdArgs.push_back("-mfloat-abi");
1996  CmdArgs.push_back("hard");
1997  }
1998 }
1999 
2000 void Clang::AddSystemZTargetArgs(const ArgList &Args,
2001  ArgStringList &CmdArgs) const {
2002  bool HasBackchain = Args.hasFlag(options::OPT_mbackchain,
2003  options::OPT_mno_backchain, false);
2004  bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack,
2005  options::OPT_mno_packed_stack, false);
2006  if (HasBackchain && HasPackedStack) {
2007  const Driver &D = getToolChain().getDriver();
2008  D.Diag(diag::err_drv_unsupported_opt)
2009  << Args.getLastArg(options::OPT_mpacked_stack)->getAsString(Args) +
2010  " " + Args.getLastArg(options::OPT_mbackchain)->getAsString(Args);
2011  }
2012  if (HasBackchain)
2013  CmdArgs.push_back("-mbackchain");
2014  if (HasPackedStack)
2015  CmdArgs.push_back("-mpacked-stack");
2016 }
2017 
2018 static void addX86AlignBranchArgs(const Driver &D, const ArgList &Args,
2019  ArgStringList &CmdArgs) {
2020  if (Args.hasArg(options::OPT_mbranches_within_32B_boundaries)) {
2021  CmdArgs.push_back("-mllvm");
2022  CmdArgs.push_back("-x86-branches-within-32B-boundaries");
2023  }
2024  if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) {
2025  StringRef Value = A->getValue();
2026  unsigned Boundary;
2027  if (Value.getAsInteger(10, Boundary) || Boundary < 16 ||
2028  !llvm::isPowerOf2_64(Boundary)) {
2029  D.Diag(diag::err_drv_invalid_argument_to_option)
2030  << Value << A->getOption().getName();
2031  } else {
2032  CmdArgs.push_back("-mllvm");
2033  CmdArgs.push_back(
2034  Args.MakeArgString("-x86-align-branch-boundary=" + Twine(Boundary)));
2035  }
2036  }
2037  if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) {
2038  std::string AlignBranch;
2039  for (StringRef T : A->getValues()) {
2040  if (T != "fused" && T != "jcc" && T != "jmp" && T != "call" &&
2041  T != "ret" && T != "indirect")
2042  D.Diag(diag::err_drv_invalid_malign_branch_EQ)
2043  << T << "fused, jcc, jmp, call, ret, indirect";
2044  if (!AlignBranch.empty())
2045  AlignBranch += '+';
2046  AlignBranch += T;
2047  }
2048  CmdArgs.push_back("-mllvm");
2049  CmdArgs.push_back(Args.MakeArgString("-x86-align-branch=" + AlignBranch));
2050  }
2051  if (const Arg *A =
2052  Args.getLastArg(options::OPT_malign_branch_prefix_size_EQ)) {
2053  StringRef Value = A->getValue();
2054  unsigned PrefixSize;
2055  if (Value.getAsInteger(10, PrefixSize) || PrefixSize > 5) {
2056  D.Diag(diag::err_drv_invalid_argument_to_option)
2057  << Value << A->getOption().getName();
2058  } else {
2059  CmdArgs.push_back("-mllvm");
2060  CmdArgs.push_back(Args.MakeArgString("-x86-align-branch-prefix-size=" +
2061  Twine(PrefixSize)));
2062  }
2063  }
2064 }
2065 
2066 void Clang::AddX86TargetArgs(const ArgList &Args,
2067  ArgStringList &CmdArgs) const {
2068  const Driver &D = getToolChain().getDriver();
2069  addX86AlignBranchArgs(D, Args, CmdArgs);
2070 
2071  if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
2072  Args.hasArg(options::OPT_mkernel) ||
2073  Args.hasArg(options::OPT_fapple_kext))
2074  CmdArgs.push_back("-disable-red-zone");
2075 
2076  if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
2077  options::OPT_mno_tls_direct_seg_refs, true))
2078  CmdArgs.push_back("-mno-tls-direct-seg-refs");
2079 
2080  // Default to avoid implicit floating-point for kernel/kext code, but allow
2081  // that to be overridden with -mno-soft-float.
2082  bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
2083  Args.hasArg(options::OPT_fapple_kext));
2084  if (Arg *A = Args.getLastArg(
2085  options::OPT_msoft_float, options::OPT_mno_soft_float,
2086  options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
2087  const Option &O = A->getOption();
2088  NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
2089  O.matches(options::OPT_msoft_float));
2090  }
2091  if (NoImplicitFloat)
2092  CmdArgs.push_back("-no-implicit-float");
2093 
2094  if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
2095  StringRef Value = A->getValue();
2096  if (Value == "intel" || Value == "att") {
2097  CmdArgs.push_back("-mllvm");
2098  CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
2099  } else {
2100  D.Diag(diag::err_drv_unsupported_option_argument)
2101  << A->getOption().getName() << Value;
2102  }
2103  } else if (D.IsCLMode()) {
2104  CmdArgs.push_back("-mllvm");
2105  CmdArgs.push_back("-x86-asm-syntax=intel");
2106  }
2107 
2108  // Set flags to support MCU ABI.
2109  if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) {
2110  CmdArgs.push_back("-mfloat-abi");
2111  CmdArgs.push_back("soft");
2112  CmdArgs.push_back("-mstack-alignment=4");
2113  }
2114 }
2115 
2116 void Clang::AddHexagonTargetArgs(const ArgList &Args,
2117  ArgStringList &CmdArgs) const {
2118  CmdArgs.push_back("-mqdsp6-compat");
2119  CmdArgs.push_back("-Wreturn-type");
2120 
2122  CmdArgs.push_back("-mllvm");
2123  CmdArgs.push_back(Args.MakeArgString("-hexagon-small-data-threshold=" +
2124  Twine(G.getValue())));
2125  }
2126 
2127  if (!Args.hasArg(options::OPT_fno_short_enums))
2128  CmdArgs.push_back("-fshort-enums");
2129  if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
2130  CmdArgs.push_back("-mllvm");
2131  CmdArgs.push_back("-enable-hexagon-ieee-rnd-near");
2132  }
2133  CmdArgs.push_back("-mllvm");
2134  CmdArgs.push_back("-machine-sink-split=0");
2135 }
2136 
2137 void Clang::AddLanaiTargetArgs(const ArgList &Args,
2138  ArgStringList &CmdArgs) const {
2139  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
2140  StringRef CPUName = A->getValue();
2141 
2142  CmdArgs.push_back("-target-cpu");
2143  CmdArgs.push_back(Args.MakeArgString(CPUName));
2144  }
2145  if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2146  StringRef Value = A->getValue();
2147  // Only support mregparm=4 to support old usage. Report error for all other
2148  // cases.
2149  int Mregparm;
2150  if (Value.getAsInteger(10, Mregparm)) {
2151  if (Mregparm != 4) {
2152  getToolChain().getDriver().Diag(
2153  diag::err_drv_unsupported_option_argument)
2154  << A->getOption().getName() << Value;
2155  }
2156  }
2157  }
2158 }
2159 
2160 void Clang::AddWebAssemblyTargetArgs(const ArgList &Args,
2161  ArgStringList &CmdArgs) const {
2162  // Default to "hidden" visibility.
2163  if (!Args.hasArg(options::OPT_fvisibility_EQ,
2164  options::OPT_fvisibility_ms_compat)) {
2165  CmdArgs.push_back("-fvisibility");
2166  CmdArgs.push_back("hidden");
2167  }
2168 }
2169 
2170 void Clang::DumpCompilationDatabase(Compilation &C, StringRef Filename,
2171  StringRef Target, const InputInfo &Output,
2172  const InputInfo &Input, const ArgList &Args) const {
2173  // If this is a dry run, do not create the compilation database file.
2174  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2175  return;
2176 
2177  using llvm::yaml::escape;
2178  const Driver &D = getToolChain().getDriver();
2179 
2180  if (!CompilationDatabase) {
2181  std::error_code EC;
2182  auto File = std::make_unique<llvm::raw_fd_ostream>(Filename, EC,
2183  llvm::sys::fs::OF_Text);
2184  if (EC) {
2185  D.Diag(clang::diag::err_drv_compilationdatabase) << Filename
2186  << EC.message();
2187  return;
2188  }
2189  CompilationDatabase = std::move(File);
2190  }
2191  auto &CDB = *CompilationDatabase;
2192  auto CWD = D.getVFS().getCurrentWorkingDirectory();
2193  if (!CWD)
2194  CWD = ".";
2195  CDB << "{ \"directory\": \"" << escape(*CWD) << "\"";
2196  CDB << ", \"file\": \"" << escape(Input.getFilename()) << "\"";
2197  CDB << ", \"output\": \"" << escape(Output.getFilename()) << "\"";
2198  CDB << ", \"arguments\": [\"" << escape(D.ClangExecutable) << "\"";
2199  SmallString<128> Buf;
2200  Buf = "-x";
2201  Buf += types::getTypeName(Input.getType());
2202  CDB << ", \"" << escape(Buf) << "\"";
2203  if (!D.SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) {
2204  Buf = "--sysroot=";
2205  Buf += D.SysRoot;
2206  CDB << ", \"" << escape(Buf) << "\"";
2207  }
2208  CDB << ", \"" << escape(Input.getFilename()) << "\"";
2209  for (auto &A: Args) {
2210  auto &O = A->getOption();
2211  // Skip language selection, which is positional.
2212  if (O.getID() == options::OPT_x)
2213  continue;
2214  // Skip writing dependency output and the compilation database itself.
2215  if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group)
2216  continue;
2217  if (O.getID() == options::OPT_gen_cdb_fragment_path)
2218  continue;
2219  // Skip inputs.
2220  if (O.getKind() == Option::InputClass)
2221  continue;
2222  // All other arguments are quoted and appended.
2223  ArgStringList ASL;
2224  A->render(Args, ASL);
2225  for (auto &it: ASL)
2226  CDB << ", \"" << escape(it) << "\"";
2227  }
2228  Buf = "--target=";
2229  Buf += Target;
2230  CDB << ", \"" << escape(Buf) << "\"]},\n";
2231 }
2232 
2233 void Clang::DumpCompilationDatabaseFragmentToDir(
2234  StringRef Dir, Compilation &C, StringRef Target, const InputInfo &Output,
2235  const InputInfo &Input, const llvm::opt::ArgList &Args) const {
2236  // If this is a dry run, do not create the compilation database file.
2237  if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
2238  return;
2239 
2240  if (CompilationDatabase)
2241  DumpCompilationDatabase(C, "", Target, Output, Input, Args);
2242 
2243  SmallString<256> Path = Dir;
2244  const auto &Driver = C.getDriver();
2245  Driver.getVFS().makeAbsolute(Path);
2246  auto Err = llvm::sys::fs::create_directory(Path, /*IgnoreExisting=*/true);
2247  if (Err) {
2248  Driver.Diag(diag::err_drv_compilationdatabase) << Dir << Err.message();
2249  return;
2250  }
2251 
2252  llvm::sys::path::append(
2253  Path,
2254  Twine(llvm::sys::path::filename(Input.getFilename())) + ".%%%%.json");
2255  int FD;
2256  SmallString<256> TempPath;
2257  Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath);
2258  if (Err) {
2259  Driver.Diag(diag::err_drv_compilationdatabase) << Path << Err.message();
2260  return;
2261  }
2262  CompilationDatabase =
2263  std::make_unique<llvm::raw_fd_ostream>(FD, /*shouldClose=*/true);
2264  DumpCompilationDatabase(C, "", Target, Output, Input, Args);
2265 }
2266 
2268  const ArgList &Args,
2269  ArgStringList &CmdArgs,
2270  const Driver &D) {
2271  if (UseRelaxAll(C, Args))
2272  CmdArgs.push_back("-mrelax-all");
2273 
2274  // Only default to -mincremental-linker-compatible if we think we are
2275  // targeting the MSVC linker.
2276  bool DefaultIncrementalLinkerCompatible =
2277  C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
2278  if (Args.hasFlag(options::OPT_mincremental_linker_compatible,
2279  options::OPT_mno_incremental_linker_compatible,
2280  DefaultIncrementalLinkerCompatible))
2281  CmdArgs.push_back("-mincremental-linker-compatible");
2282 
2283  switch (C.getDefaultToolChain().getArch()) {
2284  case llvm::Triple::arm:
2285  case llvm::Triple::armeb:
2286  case llvm::Triple::thumb:
2287  case llvm::Triple::thumbeb:
2288  if (Arg *A = Args.getLastArg(options::OPT_mimplicit_it_EQ)) {
2289  StringRef Value = A->getValue();
2290  if (Value == "always" || Value == "never" || Value == "arm" ||
2291  Value == "thumb") {
2292  CmdArgs.push_back("-mllvm");
2293  CmdArgs.push_back(Args.MakeArgString("-arm-implicit-it=" + Value));
2294  } else {
2295  D.Diag(diag::err_drv_unsupported_option_argument)
2296  << A->getOption().getName() << Value;
2297  }
2298  }
2299  break;
2300  default:
2301  break;
2302  }
2303 
2304  // If you add more args here, also add them to the block below that
2305  // starts with "// If CollectArgsForIntegratedAssembler() isn't called below".
2306 
2307  // When passing -I arguments to the assembler we sometimes need to
2308  // unconditionally take the next argument. For example, when parsing
2309  // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2310  // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2311  // arg after parsing the '-I' arg.
2312  bool TakeNextArg = false;
2313 
2314  bool UseRelaxRelocations = C.getDefaultToolChain().useRelaxRelocations();
2315  bool UseNoExecStack = C.getDefaultToolChain().isNoExecStackDefault();
2316  const char *MipsTargetFeature = nullptr;
2317  for (const Arg *A :
2318  Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2319  A->claim();
2320 
2321  for (StringRef Value : A->getValues()) {
2322  if (TakeNextArg) {
2323  CmdArgs.push_back(Value.data());
2324  TakeNextArg = false;
2325  continue;
2326  }
2327 
2328  if (C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() &&
2329  Value == "-mbig-obj")
2330  continue; // LLVM handles bigobj automatically
2331 
2332  switch (C.getDefaultToolChain().getArch()) {
2333  default:
2334  break;
2335  case llvm::Triple::thumb:
2336  case llvm::Triple::thumbeb:
2337  case llvm::Triple::arm:
2338  case llvm::Triple::armeb:
2339  if (Value == "-mthumb")
2340  // -mthumb has already been processed in ComputeLLVMTriple()
2341  // recognize but skip over here.
2342  continue;
2343  break;
2344  case llvm::Triple::mips:
2345  case llvm::Triple::mipsel:
2346  case llvm::Triple::mips64:
2347  case llvm::Triple::mips64el:
2348  if (Value == "--trap") {
2349  CmdArgs.push_back("-target-feature");
2350  CmdArgs.push_back("+use-tcc-in-div");
2351  continue;
2352  }
2353  if (Value == "--break") {
2354  CmdArgs.push_back("-target-feature");
2355  CmdArgs.push_back("-use-tcc-in-div");
2356  continue;
2357  }
2358  if (Value.startswith("-msoft-float")) {
2359  CmdArgs.push_back("-target-feature");
2360  CmdArgs.push_back("+soft-float");
2361  continue;
2362  }
2363  if (Value.startswith("-mhard-float")) {
2364  CmdArgs.push_back("-target-feature");
2365  CmdArgs.push_back("-soft-float");
2366  continue;
2367  }
2368 
2369  MipsTargetFeature = llvm::StringSwitch<const char *>(Value)
2370  .Case("-mips1", "+mips1")
2371  .Case("-mips2", "+mips2")
2372  .Case("-mips3", "+mips3")
2373  .Case("-mips4", "+mips4")
2374  .Case("-mips5", "+mips5")
2375  .Case("-mips32", "+mips32")
2376  .Case("-mips32r2", "+mips32r2")
2377  .Case("-mips32r3", "+mips32r3")
2378  .Case("-mips32r5", "+mips32r5")
2379  .Case("-mips32r6", "+mips32r6")
2380  .Case("-mips64", "+mips64")
2381  .Case("-mips64r2", "+mips64r2")
2382  .Case("-mips64r3", "+mips64r3")
2383  .Case("-mips64r5", "+mips64r5")
2384  .Case("-mips64r6", "+mips64r6")
2385  .Default(nullptr);
2386  if (MipsTargetFeature)
2387  continue;
2388  }
2389 
2390  if (Value == "-force_cpusubtype_ALL") {
2391  // Do nothing, this is the default and we don't support anything else.
2392  } else if (Value == "-L") {
2393  CmdArgs.push_back("-msave-temp-labels");
2394  } else if (Value == "--fatal-warnings") {
2395  CmdArgs.push_back("-massembler-fatal-warnings");
2396  } else if (Value == "--no-warn" || Value == "-W") {
2397  CmdArgs.push_back("-massembler-no-warn");
2398  } else if (Value == "--noexecstack") {
2399  UseNoExecStack = true;
2400  } else if (Value.startswith("-compress-debug-sections") ||
2401  Value.startswith("--compress-debug-sections") ||
2402  Value == "-nocompress-debug-sections" ||
2403  Value == "--nocompress-debug-sections") {
2404  CmdArgs.push_back(Value.data());
2405  } else if (Value == "-mrelax-relocations=yes" ||
2406  Value == "--mrelax-relocations=yes") {
2407  UseRelaxRelocations = true;
2408  } else if (Value == "-mrelax-relocations=no" ||
2409  Value == "--mrelax-relocations=no") {
2410  UseRelaxRelocations = false;
2411  } else if (Value.startswith("-I")) {
2412  CmdArgs.push_back(Value.data());
2413  // We need to consume the next argument if the current arg is a plain
2414  // -I. The next arg will be the include directory.
2415  if (Value == "-I")
2416  TakeNextArg = true;
2417  } else if (Value.startswith("-gdwarf-")) {
2418  // "-gdwarf-N" options are not cc1as options.
2419  unsigned DwarfVersion = DwarfVersionNum(Value);
2420  if (DwarfVersion == 0) { // Send it onward, and let cc1as complain.
2421  CmdArgs.push_back(Value.data());
2422  } else {
2423  RenderDebugEnablingArgs(Args, CmdArgs,
2425  DwarfVersion, llvm::DebuggerKind::Default);
2426  }
2427  } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
2428  Value.startswith("-mhwdiv") || Value.startswith("-march")) {
2429  // Do nothing, we'll validate it later.
2430  } else if (Value == "-defsym") {
2431  if (A->getNumValues() != 2) {
2432  D.Diag(diag::err_drv_defsym_invalid_format) << Value;
2433  break;
2434  }
2435  const char *S = A->getValue(1);
2436  auto Pair = StringRef(S).split('=');
2437  auto Sym = Pair.first;
2438  auto SVal = Pair.second;
2439 
2440  if (Sym.empty() || SVal.empty()) {
2441  D.Diag(diag::err_drv_defsym_invalid_format) << S;
2442  break;
2443  }
2444  int64_t IVal;
2445  if (SVal.getAsInteger(0, IVal)) {
2446  D.Diag(diag::err_drv_defsym_invalid_symval) << SVal;
2447  break;
2448  }
2449  CmdArgs.push_back(Value.data());
2450  TakeNextArg = true;
2451  } else if (Value == "-fdebug-compilation-dir") {
2452  CmdArgs.push_back("-fdebug-compilation-dir");
2453  TakeNextArg = true;
2454  } else if (Value.consume_front("-fdebug-compilation-dir=")) {
2455  // The flag is a -Wa / -Xassembler argument and Options doesn't
2456  // parse the argument, so this isn't automatically aliased to
2457  // -fdebug-compilation-dir (without '=') here.
2458  CmdArgs.push_back("-fdebug-compilation-dir");
2459  CmdArgs.push_back(Value.data());
2460  } else {
2461  D.Diag(diag::err_drv_unsupported_option_argument)
2462  << A->getOption().getName() << Value;
2463  }
2464  }
2465  }
2466  if (UseRelaxRelocations)
2467  CmdArgs.push_back("--mrelax-relocations");
2468  if (UseNoExecStack)
2469  CmdArgs.push_back("-mnoexecstack");
2470  if (MipsTargetFeature != nullptr) {
2471  CmdArgs.push_back("-target-feature");
2472  CmdArgs.push_back(MipsTargetFeature);
2473  }
2474 
2475  // forward -fembed-bitcode to assmebler
2476  if (C.getDriver().embedBitcodeEnabled() ||
2478  Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
2479 }
2480 
2481 static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
2482  bool OFastEnabled, const ArgList &Args,
2483  ArgStringList &CmdArgs) {
2484  // Handle various floating point optimization flags, mapping them to the
2485  // appropriate LLVM code generation flags. This is complicated by several
2486  // "umbrella" flags, so we do this by stepping through the flags incrementally
2487  // adjusting what we think is enabled/disabled, then at the end setting the
2488  // LLVM flags based on the final state.
2489  bool HonorINFs = true;
2490  bool HonorNaNs = true;
2491  // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2492  bool MathErrno = TC.IsMathErrnoDefault();
2493  bool AssociativeMath = false;
2494  bool ReciprocalMath = false;
2495  bool SignedZeros = true;
2496  bool TrappingMath = false; // Implemented via -ffp-exception-behavior
2497  bool TrappingMathPresent = false; // Is trapping-math in args, and not
2498  // overriden by ffp-exception-behavior?
2499  bool RoundingFPMath = false;
2500  bool RoundingMathPresent = false; // Is rounding-math in args?
2501  // -ffp-model values: strict, fast, precise
2502  StringRef FPModel = "";
2503  // -ffp-exception-behavior options: strict, maytrap, ignore
2504  StringRef FPExceptionBehavior = "";
2505  StringRef DenormalFPMath = "";
2506  StringRef FPContract = "";
2507  bool StrictFPModel = false;
2508 
2509  if (const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2510  CmdArgs.push_back("-mlimit-float-precision");
2511  CmdArgs.push_back(A->getValue());
2512  }
2513 
2514  for (const Arg *A : Args) {
2515  auto optID = A->getOption().getID();
2516  bool PreciseFPModel = false;
2517  switch (optID) {
2518  default:
2519  break;
2520  case options::OPT_ffp_model_EQ: {
2521  // If -ffp-model= is seen, reset to fno-fast-math
2522  HonorINFs = true;
2523  HonorNaNs = true;
2524  // Turning *off* -ffast-math restores the toolchain default.
2525  MathErrno = TC.IsMathErrnoDefault();
2526  AssociativeMath = false;
2527  ReciprocalMath = false;
2528  SignedZeros = true;
2529  // -fno_fast_math restores default denormal and fpcontract handling
2530  DenormalFPMath = "";
2531  FPContract = "";
2532  StringRef Val = A->getValue();
2533  if (OFastEnabled && !Val.equals("fast")) {
2534  // Only -ffp-model=fast is compatible with OFast, ignore.
2535  D.Diag(clang::diag::warn_drv_overriding_flag_option)
2536  << Args.MakeArgString("-ffp-model=" + Val)
2537  << "-Ofast";
2538  break;
2539  }
2540  StrictFPModel = false;
2541  PreciseFPModel = true;
2542  // ffp-model= is a Driver option, it is entirely rewritten into more
2543  // granular options before being passed into cc1.
2544  // Use the gcc option in the switch below.
2545  if (!FPModel.empty() && !FPModel.equals(Val)) {
2546  D.Diag(clang::diag::warn_drv_overriding_flag_option)
2547  << Args.MakeArgString("-ffp-model=" + FPModel)
2548  << Args.MakeArgString("-ffp-model=" + Val);
2549  FPContract = "";
2550  }
2551  if (Val.equals("fast")) {
2552  optID = options::OPT_ffast_math;
2553  FPModel = Val;
2554  FPContract = "fast";
2555  } else if (Val.equals("precise")) {
2556  optID = options::OPT_ffp_contract;
2557  FPModel = Val;
2558  FPContract = "fast";
2559  PreciseFPModel = true;
2560  } else if (Val.equals("strict")) {
2561  StrictFPModel = true;
2562  optID = options::OPT_frounding_math;
2563  FPExceptionBehavior = "strict";
2564  FPModel = Val;
2565  TrappingMath = true;
2566  } else
2567  D.Diag(diag::err_drv_unsupported_option_argument)
2568  << A->getOption().getName() << Val;
2569  break;
2570  }
2571  }
2572 
2573  switch (optID) {
2574  // If this isn't an FP option skip the claim below
2575  default: continue;
2576 
2577  // Options controlling individual features
2578  case options::OPT_fhonor_infinities: HonorINFs = true; break;
2579  case options::OPT_fno_honor_infinities: HonorINFs = false; break;
2580  case options::OPT_fhonor_nans: HonorNaNs = true; break;
2581  case options::OPT_fno_honor_nans: HonorNaNs = false; break;
2582  case options::OPT_fmath_errno: MathErrno = true; break;
2583  case options::OPT_fno_math_errno: MathErrno = false; break;
2584  case options::OPT_fassociative_math: AssociativeMath = true; break;
2585  case options::OPT_fno_associative_math: AssociativeMath = false; break;
2586  case options::OPT_freciprocal_math: ReciprocalMath = true; break;
2587  case options::OPT_fno_reciprocal_math: ReciprocalMath = false; break;
2588  case options::OPT_fsigned_zeros: SignedZeros = true; break;
2589  case options::OPT_fno_signed_zeros: SignedZeros = false; break;
2590  case options::OPT_ftrapping_math:
2591  if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2592  !FPExceptionBehavior.equals("strict"))
2593  // Warn that previous value of option is overridden.
2594  D.Diag(clang::diag::warn_drv_overriding_flag_option)
2595  << Args.MakeArgString("-ffp-exception-behavior=" + FPExceptionBehavior)
2596  << "-ftrapping-math";
2597  TrappingMath = true;
2598  TrappingMathPresent = true;
2599  FPExceptionBehavior = "strict";
2600  break;
2601  case options::OPT_fno_trapping_math:
2602  if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2603  !FPExceptionBehavior.equals("ignore"))
2604  // Warn that previous value of option is overridden.
2605  D.Diag(clang::diag::warn_drv_overriding_flag_option)
2606  << Args.MakeArgString("-ffp-exception-behavior=" + FPExceptionBehavior)
2607  << "-fno-trapping-math";
2608  TrappingMath = false;
2609  TrappingMathPresent = true;
2610  FPExceptionBehavior = "ignore";
2611  break;
2612 
2613  case options::OPT_frounding_math:
2614  RoundingFPMath = true;
2615  RoundingMathPresent = true;
2616  break;
2617 
2618  case options::OPT_fno_rounding_math:
2619  RoundingFPMath = false;
2620  RoundingMathPresent = false;
2621  break;
2622 
2623  case options::OPT_fdenormal_fp_math_EQ:
2624  DenormalFPMath = A->getValue();
2625  break;
2626 
2627  // Validate and pass through -ffp-contract option.
2628  case options::OPT_ffp_contract: {
2629  StringRef Val = A->getValue();
2630  if (PreciseFPModel) {
2631  // -ffp-model=precise enables ffp-contract=fast as a side effect
2632  // the FPContract value has already been set to a string literal
2633  // and the Val string isn't a pertinent value.
2634  ;
2635  } else if (Val.equals("fast") || Val.equals("on") || Val.equals("off"))
2636  FPContract = Val;
2637  else
2638  D.Diag(diag::err_drv_unsupported_option_argument)
2639  << A->getOption().getName() << Val;
2640  break;
2641  }
2642 
2643  // Validate and pass through -ffp-model option.
2644  case options::OPT_ffp_model_EQ:
2645  // This should only occur in the error case
2646  // since the optID has been replaced by a more granular
2647  // floating point option.
2648  break;
2649 
2650  // Validate and pass through -ffp-exception-behavior option.
2651  case options::OPT_ffp_exception_behavior_EQ: {
2652  StringRef Val = A->getValue();
2653  if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
2654  !FPExceptionBehavior.equals(Val))
2655  // Warn that previous value of option is overridden.
2656  D.Diag(clang::diag::warn_drv_overriding_flag_option)
2657  << Args.MakeArgString("-ffp-exception-behavior=" + FPExceptionBehavior)
2658  << Args.MakeArgString("-ffp-exception-behavior=" + Val);
2659  TrappingMath = TrappingMathPresent = false;
2660  if (Val.equals("ignore") || Val.equals("maytrap"))
2661  FPExceptionBehavior = Val;
2662  else if (Val.equals("strict")) {
2663  FPExceptionBehavior = Val;
2664  TrappingMath = TrappingMathPresent = true;
2665  } else
2666  D.Diag(diag::err_drv_unsupported_option_argument)
2667  << A->getOption().getName() << Val;
2668  break;
2669  }
2670 
2671  case options::OPT_ffinite_math_only:
2672  HonorINFs = false;
2673  HonorNaNs = false;
2674  break;
2675  case options::OPT_fno_finite_math_only:
2676  HonorINFs = true;
2677  HonorNaNs = true;
2678  break;
2679 
2680  case options::OPT_funsafe_math_optimizations:
2681  AssociativeMath = true;
2682  ReciprocalMath = true;
2683  SignedZeros = false;
2684  TrappingMath = false;
2685  FPExceptionBehavior = "";
2686  break;
2687  case options::OPT_fno_unsafe_math_optimizations:
2688  AssociativeMath = false;
2689  ReciprocalMath = false;
2690  SignedZeros = true;
2691  TrappingMath = true;
2692  FPExceptionBehavior = "strict";
2693  // -fno_unsafe_math_optimizations restores default denormal handling
2694  DenormalFPMath = "";
2695  break;
2696 
2697  case options::OPT_Ofast:
2698  // If -Ofast is the optimization level, then -ffast-math should be enabled
2699  if (!OFastEnabled)
2700  continue;
2701  LLVM_FALLTHROUGH;
2702  case options::OPT_ffast_math:
2703  HonorINFs = false;
2704  HonorNaNs = false;
2705  MathErrno = false;
2706  AssociativeMath = true;
2707  ReciprocalMath = true;
2708  SignedZeros = false;
2709  TrappingMath = false;
2710  RoundingFPMath = false;
2711  // If fast-math is set then set the fp-contract mode to fast.
2712  FPContract = "fast";
2713  break;
2714  case options::OPT_fno_fast_math:
2715  HonorINFs = true;
2716  HonorNaNs = true;
2717  // Turning on -ffast-math (with either flag) removes the need for
2718  // MathErrno. However, turning *off* -ffast-math merely restores the
2719  // toolchain default (which may be false).
2720  MathErrno = TC.IsMathErrnoDefault();
2721  AssociativeMath = false;
2722  ReciprocalMath = false;
2723  SignedZeros = true;
2724  TrappingMath = false;
2725  RoundingFPMath = false;
2726  // -fno_fast_math restores default denormal and fpcontract handling
2727  DenormalFPMath = "";
2728  FPContract = "";
2729  break;
2730  }
2731  if (StrictFPModel) {
2732  // If -ffp-model=strict has been specified on command line but
2733  // subsequent options conflict then emit warning diagnostic.
2734  if (HonorINFs && HonorNaNs &&
2735  !AssociativeMath && !ReciprocalMath &&
2736  SignedZeros && TrappingMath && RoundingFPMath &&
2737  DenormalFPMath.empty() && FPContract.empty())
2738  // OK: Current Arg doesn't conflict with -ffp-model=strict
2739  ;
2740  else {
2741  StrictFPModel = false;
2742  FPModel = "";
2743  D.Diag(clang::diag::warn_drv_overriding_flag_option)
2744  << "-ffp-model=strict" <<
2745  ((A->getNumValues() == 0) ? A->getSpelling()
2746  : Args.MakeArgString(A->getSpelling() + A->getValue()));
2747  }
2748  }
2749 
2750  // If we handled this option claim it
2751  A->claim();
2752  }
2753 
2754  if (!HonorINFs)
2755  CmdArgs.push_back("-menable-no-infs");
2756 
2757  if (!HonorNaNs)
2758  CmdArgs.push_back("-menable-no-nans");
2759 
2760  if (MathErrno)
2761  CmdArgs.push_back("-fmath-errno");
2762 
2763  if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2764  !TrappingMath)
2765  CmdArgs.push_back("-menable-unsafe-fp-math");
2766 
2767  if (!SignedZeros)
2768  CmdArgs.push_back("-fno-signed-zeros");
2769 
2770  if (AssociativeMath && !SignedZeros && !TrappingMath)
2771  CmdArgs.push_back("-mreassociate");
2772 
2773  if (ReciprocalMath)
2774  CmdArgs.push_back("-freciprocal-math");
2775 
2776  if (TrappingMath) {
2777  // FP Exception Behavior is also set to strict
2778  assert(FPExceptionBehavior.equals("strict"));
2779  CmdArgs.push_back("-ftrapping-math");
2780  } else if (TrappingMathPresent)
2781  CmdArgs.push_back("-fno-trapping-math");
2782 
2783  if (!DenormalFPMath.empty())
2784  CmdArgs.push_back(
2785  Args.MakeArgString("-fdenormal-fp-math=" + DenormalFPMath));
2786 
2787  if (!FPContract.empty())
2788  CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
2789 
2790  if (!RoundingFPMath)
2791  CmdArgs.push_back(Args.MakeArgString("-fno-rounding-math"));
2792 
2793  if (RoundingFPMath && RoundingMathPresent)
2794  CmdArgs.push_back(Args.MakeArgString("-frounding-math"));
2795 
2796  if (!FPExceptionBehavior.empty())
2797  CmdArgs.push_back(Args.MakeArgString("-ffp-exception-behavior=" +
2798  FPExceptionBehavior));
2799 
2800  ParseMRecip(D, Args, CmdArgs);
2801 
2802  // -ffast-math enables the __FAST_MATH__ preprocessor macro, but check for the
2803  // individual features enabled by -ffast-math instead of the option itself as
2804  // that's consistent with gcc's behaviour.
2805  if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath &&
2806  ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
2807  CmdArgs.push_back("-ffast-math");
2808  if (FPModel.equals("fast")) {
2809  if (FPContract.equals("fast"))
2810  // All set, do nothing.
2811  ;
2812  else if (FPContract.empty())
2813  // Enable -ffp-contract=fast
2814  CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2815  else
2816  D.Diag(clang::diag::warn_drv_overriding_flag_option)
2817  << "-ffp-model=fast"
2818  << Args.MakeArgString("-ffp-contract=" + FPContract);
2819  }
2820  }
2821 
2822  // Handle __FINITE_MATH_ONLY__ similarly.
2823  if (!HonorINFs && !HonorNaNs)
2824  CmdArgs.push_back("-ffinite-math-only");
2825 
2826  if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2827  CmdArgs.push_back("-mfpmath");
2828  CmdArgs.push_back(A->getValue());
2829  }
2830 
2831  // Disable a codegen optimization for floating-point casts.
2832  if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow,
2833  options::OPT_fstrict_float_cast_overflow, false))
2834  CmdArgs.push_back("-fno-strict-float-cast-overflow");
2835 }
2836 
2837 static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs,
2838  const llvm::Triple &Triple,
2839  const InputInfo &Input) {
2840  // Enable region store model by default.
2841  CmdArgs.push_back("-analyzer-store=region");
2842 
2843  // Treat blocks as analysis entry points.
2844  CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2845 
2846  // Add default argument set.
2847  if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2848  CmdArgs.push_back("-analyzer-checker=core");
2849  CmdArgs.push_back("-analyzer-checker=apiModeling");
2850 
2851  if (!Triple.isWindowsMSVCEnvironment()) {
2852  CmdArgs.push_back("-analyzer-checker=unix");
2853  } else {
2854  // Enable "unix" checkers that also work on Windows.
2855  CmdArgs.push_back("-analyzer-checker=unix.API");
2856  CmdArgs.push_back("-analyzer-checker=unix.Malloc");
2857  CmdArgs.push_back("-analyzer-checker=unix.MallocSizeof");
2858  CmdArgs.push_back("-analyzer-checker=unix.MismatchedDeallocator");
2859  CmdArgs.push_back("-analyzer-checker=unix.cstring.BadSizeArg");
2860  CmdArgs.push_back("-analyzer-checker=unix.cstring.NullArg");
2861  }
2862 
2863  // Disable some unix checkers for PS4.
2864  if (Triple.isPS4CPU()) {
2865  CmdArgs.push_back("-analyzer-disable-checker=unix.API");
2866  CmdArgs.push_back("-analyzer-disable-checker=unix.Vfork");
2867  }
2868 
2869  if (Triple.isOSDarwin()) {
2870  CmdArgs.push_back("-analyzer-checker=osx");
2871  CmdArgs.push_back(
2872  "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType");
2873  }
2874  else if (Triple.isOSFuchsia())
2875  CmdArgs.push_back("-analyzer-checker=fuchsia");
2876 
2877  CmdArgs.push_back("-analyzer-checker=deadcode");
2878 
2879  if (types::isCXX(Input.getType()))
2880  CmdArgs.push_back("-analyzer-checker=cplusplus");
2881 
2882  if (!Triple.isPS4CPU()) {
2883  CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2884  CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2885  CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2886  CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2887  CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2888  CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
2889  }
2890 
2891  // Default nullability checks.
2892  CmdArgs.push_back("-analyzer-checker=nullability.NullPassedToNonnull");
2893  CmdArgs.push_back("-analyzer-checker=nullability.NullReturnedFromNonnull");
2894  }
2895 
2896  // Set the output format. The default is plist, for (lame) historical reasons.
2897  CmdArgs.push_back("-analyzer-output");
2898  if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2899  CmdArgs.push_back(A->getValue());
2900  else
2901  CmdArgs.push_back("plist");
2902 
2903  // Disable the presentation of standard compiler warnings when using
2904  // --analyze. We only want to show static analyzer diagnostics or frontend
2905  // errors.
2906  CmdArgs.push_back("-w");
2907 
2908  // Add -Xanalyzer arguments when running as analyzer.
2909  Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2910 }
2911 
2912 static void RenderSSPOptions(const ToolChain &TC, const ArgList &Args,
2913  ArgStringList &CmdArgs, bool KernelOrKext) {
2914  const llvm::Triple &EffectiveTriple = TC.getEffectiveTriple();
2915 
2916  // NVPTX doesn't support stack protectors; from the compiler's perspective, it
2917  // doesn't even have a stack!
2918  if (EffectiveTriple.isNVPTX())
2919  return;
2920 
2921  // -stack-protector=0 is default.
2922  unsigned StackProtectorLevel = 0;
2923  unsigned DefaultStackProtectorLevel =
2924  TC.GetDefaultStackProtectorLevel(KernelOrKext);
2925 
2926  if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
2927  options::OPT_fstack_protector_all,
2928  options::OPT_fstack_protector_strong,
2929  options::OPT_fstack_protector)) {
2930  if (A->getOption().matches(options::OPT_fstack_protector))
2931  StackProtectorLevel =
2932  std::max<unsigned>(LangOptions::SSPOn, DefaultStackProtectorLevel);
2933  else if (A->getOption().matches(options::OPT_fstack_protector_strong))
2934  StackProtectorLevel = LangOptions::SSPStrong;
2935  else if (A->getOption().matches(options::OPT_fstack_protector_all))
2936  StackProtectorLevel = LangOptions::SSPReq;
2937  } else {
2938  StackProtectorLevel = DefaultStackProtectorLevel;
2939  }
2940 
2941  if (StackProtectorLevel) {
2942  CmdArgs.push_back("-stack-protector");
2943  CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
2944  }
2945 
2946  // --param ssp-buffer-size=
2947  for (const Arg *A : Args.filtered(options::OPT__param)) {
2948  StringRef Str(A->getValue());
2949  if (Str.startswith("ssp-buffer-size=")) {
2950  if (StackProtectorLevel) {
2951  CmdArgs.push_back("-stack-protector-buffer-size");
2952  // FIXME: Verify the argument is a valid integer.
2953  CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
2954  }
2955  A->claim();
2956  }
2957  }
2958 }
2959 
2961  const ToolChain &TC,
2962  const ArgList &Args,
2963  ArgStringList &CmdArgs) {
2964  auto DefaultTrivialAutoVarInit = TC.GetDefaultTrivialAutoVarInit();
2965  StringRef TrivialAutoVarInit = "";
2966 
2967  for (const Arg *A : Args) {
2968  switch (A->getOption().getID()) {
2969  default:
2970  continue;
2971  case options::OPT_ftrivial_auto_var_init: {
2972  A->claim();
2973  StringRef Val = A->getValue();
2974  if (Val == "uninitialized" || Val == "zero" || Val == "pattern")
2975  TrivialAutoVarInit = Val;
2976  else
2977  D.Diag(diag::err_drv_unsupported_option_argument)
2978  << A->getOption().getName() << Val;
2979  break;
2980  }
2981  }
2982  }
2983 
2984  if (TrivialAutoVarInit.empty())
2985  switch (DefaultTrivialAutoVarInit) {
2987  break;
2989  TrivialAutoVarInit = "pattern";
2990  break;
2992  TrivialAutoVarInit = "zero";
2993  break;
2994  }
2995 
2996  if (!TrivialAutoVarInit.empty()) {
2997  if (TrivialAutoVarInit == "zero" && !Args.hasArg(options::OPT_enable_trivial_var_init_zero))
2998  D.Diag(diag::err_drv_trivial_auto_var_init_zero_disabled);
2999  CmdArgs.push_back(
3000  Args.MakeArgString("-ftrivial-auto-var-init=" + TrivialAutoVarInit));
3001  }
3002 }
3003 
3004 static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs) {
3005  const unsigned ForwardedArguments[] = {
3006  options::OPT_cl_opt_disable,
3007  options::OPT_cl_strict_aliasing,
3008  options::OPT_cl_single_precision_constant,
3009  options::OPT_cl_finite_math_only,
3010  options::OPT_cl_kernel_arg_info,
3011  options::OPT_cl_unsafe_math_optimizations,
3012  options::OPT_cl_fast_relaxed_math,
3013  options::OPT_cl_mad_enable,
3014  options::OPT_cl_no_signed_zeros,
3015  options::OPT_cl_denorms_are_zero,
3016  options::OPT_cl_fp32_correctly_rounded_divide_sqrt,
3017  options::OPT_cl_uniform_work_group_size
3018  };
3019 
3020  if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) {
3021  std::string CLStdStr = std::string("-cl-std=") + A->getValue();
3022  CmdArgs.push_back(Args.MakeArgString(CLStdStr));
3023  }
3024 
3025  for (const auto &Arg : ForwardedArguments)
3026  if (const auto *A = Args.getLastArg(Arg))
3027  CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName()));
3028 }
3029 
3030 static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args,
3031  ArgStringList &CmdArgs) {
3032  bool ARCMTEnabled = false;
3033  if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3034  if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3035  options::OPT_ccc_arcmt_modify,
3036  options::OPT_ccc_arcmt_migrate)) {
3037  ARCMTEnabled = true;
3038  switch (A->getOption().getID()) {
3039  default: llvm_unreachable("missed a case");
3040  case options::OPT_ccc_arcmt_check:
3041  CmdArgs.push_back("-arcmt-check");
3042  break;
3043  case options::OPT_ccc_arcmt_modify:
3044  CmdArgs.push_back("-arcmt-modify");
3045  break;
3046  case options::OPT_ccc_arcmt_migrate:
3047  CmdArgs.push_back("-arcmt-migrate");
3048  CmdArgs.push_back("-mt-migrate-directory");
3049  CmdArgs.push_back(A->getValue());
3050 
3051  Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3052  Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3053  break;
3054  }
3055  }
3056  } else {
3057  Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3058  Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3059  Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3060  }
3061 
3062  if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3063  if (ARCMTEnabled)
3064  D.Diag(diag::err_drv_argument_not_allowed_with)
3065  << A->getAsString(Args) << "-ccc-arcmt-migrate";
3066 
3067  CmdArgs.push_back("-mt-migrate-directory");
3068  CmdArgs.push_back(A->getValue());
3069 
3070  if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3071  options::OPT_objcmt_migrate_subscripting,
3072  options::OPT_objcmt_migrate_property)) {
3073  // None specified, means enable them all.
3074  CmdArgs.push_back("-objcmt-migrate-literals");
3075  CmdArgs.push_back("-objcmt-migrate-subscripting");
3076  CmdArgs.push_back("-objcmt-migrate-property");
3077  } else {
3078  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3079  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3080  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3081  }
3082  } else {
3083  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3084  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3085  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3086  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3087  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3088  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3089  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3090  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3091  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3092  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3093  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3094  Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3095  Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3096  Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3097  Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3098  Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
3099  }
3100 }
3101 
3102 static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T,
3103  const ArgList &Args, ArgStringList &CmdArgs) {
3104  // -fbuiltin is default unless -mkernel is used.
3105  bool UseBuiltins =
3106  Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin,
3107  !Args.hasArg(options::OPT_mkernel));
3108  if (!UseBuiltins)
3109  CmdArgs.push_back("-fno-builtin");
3110 
3111  // -ffreestanding implies -fno-builtin.
3112  if (Args.hasArg(options::OPT_ffreestanding))
3113  UseBuiltins = false;
3114 
3115  // Process the -fno-builtin-* options.
3116  for (const auto &Arg : Args) {
3117  const Option &O = Arg->getOption();
3118  if (!O.matches(options::OPT_fno_builtin_))
3119  continue;
3120 
3121  Arg->claim();
3122 
3123  // If -fno-builtin is specified, then there's no need to pass the option to
3124  // the frontend.
3125  if (!UseBuiltins)
3126  continue;
3127 
3128  StringRef FuncName = Arg->getValue();
3129  CmdArgs.push_back(Args.MakeArgString("-fno-builtin-" + FuncName));
3130  }
3131 
3132  // le32-specific flags:
3133  // -fno-math-builtin: clang should not convert math builtins to intrinsics
3134  // by default.
3135  if (TC.getArch() == llvm::Triple::le32)
3136  CmdArgs.push_back("-fno-math-builtin");
3137 }
3138 
3140  llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, Result);
3141  llvm::sys::path::append(Result, "org.llvm.clang.");
3142  appendUserToPath(Result);
3143  llvm::sys::path::append(Result, "ModuleCache");
3144 }
3145 
3146 static void RenderModulesOptions(Compilation &C, const Driver &D,
3147  const ArgList &Args, const InputInfo &Input,
3148  const InputInfo &Output,
3149  ArgStringList &CmdArgs, bool &HaveModules) {
3150  // -fmodules enables the use of precompiled modules (off by default).
3151  // Users can pass -fno-cxx-modules to turn off modules support for
3152  // C++/Objective-C++ programs.
3153  bool HaveClangModules = false;
3154  if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3155  bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3156  options::OPT_fno_cxx_modules, true);
3157  if (AllowedInCXX || !types::isCXX(Input.getType())) {
3158  CmdArgs.push_back("-fmodules");
3159  HaveClangModules = true;
3160  }
3161  }
3162 
3163  HaveModules |= HaveClangModules;
3164  if (Args.hasArg(options::OPT_fmodules_ts)) {
3165  CmdArgs.push_back("-fmodules-ts");
3166  HaveModules = true;
3167  }
3168 
3169  // -fmodule-maps enables implicit reading of module map files. By default,
3170  // this is enabled if we are using Clang's flavor of precompiled modules.
3171  if (Args.hasFlag(options::OPT_fimplicit_module_maps,
3172  options::OPT_fno_implicit_module_maps, HaveClangModules))
3173  CmdArgs.push_back("-fimplicit-module-maps");
3174 
3175  // -fmodules-decluse checks that modules used are declared so (off by default)
3176  if (Args.hasFlag(options::OPT_fmodules_decluse,
3177  options::OPT_fno_modules_decluse, false))
3178  CmdArgs.push_back("-fmodules-decluse");
3179 
3180  // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
3181  // all #included headers are part of modules.
3182  if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
3183  options::OPT_fno_modules_strict_decluse, false))
3184  CmdArgs.push_back("-fmodules-strict-decluse");
3185 
3186  // -fno-implicit-modules turns off implicitly compiling modules on demand.
3187  bool ImplicitModules = false;
3188  if (!Args.hasFlag(options::OPT_fimplicit_modules,
3189  options::OPT_fno_implicit_modules, HaveClangModules)) {
3190  if (HaveModules)
3191  CmdArgs.push_back("-fno-implicit-modules");
3192  } else if (HaveModules) {
3193  ImplicitModules = true;
3194  // -fmodule-cache-path specifies where our implicitly-built module files
3195  // should be written.
3196  SmallString<128> Path;
3197  if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
3198  Path = A->getValue();
3199 
3200  if (C.isForDiagnostics()) {
3201  // When generating crash reports, we want to emit the modules along with
3202  // the reproduction sources, so we ignore any provided module path.
3203  Path = Output.getFilename();
3204  llvm::sys::path::replace_extension(Path, ".cache");
3205  llvm::sys::path::append(Path, "modules");
3206  } else if (Path.empty()) {
3207  // No module path was provided: use the default.
3209  }
3210 
3211  const char Arg[] = "-fmodules-cache-path=";
3212  Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
3213  CmdArgs.push_back(Args.MakeArgString(Path));
3214  }
3215 
3216  if (HaveModules) {
3217  // -fprebuilt-module-path specifies where to load the prebuilt module files.
3218  for (const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) {
3219  CmdArgs.push_back(Args.MakeArgString(
3220  std::string("-fprebuilt-module-path=") + A->getValue()));
3221  A->claim();
3222  }
3223  if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
3224  options::OPT_fno_modules_validate_input_files_content,
3225  false))
3226  CmdArgs.push_back("-fvalidate-ast-input-files-content");
3227  }
3228 
3229  // -fmodule-name specifies the module that is currently being built (or
3230  // used for header checking by -fmodule-maps).
3231  Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
3232 
3233  // -fmodule-map-file can be used to specify files containing module
3234  // definitions.
3235  Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
3236 
3237  // -fbuiltin-module-map can be used to load the clang
3238  // builtin headers modulemap file.
3239  if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
3240  SmallString<128> BuiltinModuleMap(D.ResourceDir);
3241  llvm::sys::path::append(BuiltinModuleMap, "include");
3242  llvm::sys::path::append(BuiltinModuleMap, "module.modulemap");
3243  if (llvm::sys::fs::exists(BuiltinModuleMap))
3244  CmdArgs.push_back(
3245  Args.MakeArgString("-fmodule-map-file=" + BuiltinModuleMap));
3246  }
3247 
3248  // The -fmodule-file=<name>=<file> form specifies the mapping of module
3249  // names to precompiled module files (the module is loaded only if used).
3250  // The -fmodule-file=<file> form can be used to unconditionally load
3251  // precompiled module files (whether used or not).
3252  if (HaveModules)
3253  Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
3254  else
3255  Args.ClaimAllArgs(options::OPT_fmodule_file);
3256 
3257  // When building modules and generating crashdumps, we need to dump a module
3258  // dependency VFS alongside the output.
3259  if (HaveClangModules && C.isForDiagnostics()) {
3260  SmallString<128> VFSDir(Output.getFilename());
3261  llvm::sys::path::replace_extension(VFSDir, ".cache");
3262  // Add the cache directory as a temp so the crash diagnostics pick it up.
3263  C.addTempFile(Args.MakeArgString(VFSDir));
3264 
3265  llvm::sys::path::append(VFSDir, "vfs");
3266  CmdArgs.push_back("-module-dependency-dir");
3267  CmdArgs.push_back(Args.MakeArgString(VFSDir));
3268  }
3269 
3270  if (HaveClangModules)
3271  Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
3272 
3273  // Pass through all -fmodules-ignore-macro arguments.
3274  Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3275  Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3276  Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3277 
3278  Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
3279 
3280  if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
3281  if (Args.hasArg(options::OPT_fbuild_session_timestamp))
3282  D.Diag(diag::err_drv_argument_not_allowed_with)
3283  << A->getAsString(Args) << "-fbuild-session-timestamp";
3284 
3285  llvm::sys::fs::file_status Status;
3286  if (llvm::sys::fs::status(A->getValue(), Status))
3287  D.Diag(diag::err_drv_no_such_file) << A->getValue();
3288  CmdArgs.push_back(
3289  Args.MakeArgString("-fbuild-session-timestamp=" +
3290  Twine((uint64_t)Status.getLastModificationTime()
3291  .time_since_epoch()
3292  .count())));
3293  }
3294 
3295  if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
3296  if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
3297  options::OPT_fbuild_session_file))
3298  D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
3299 
3300  Args.AddLastArg(CmdArgs,
3301  options::OPT_fmodules_validate_once_per_build_session);
3302  }
3303 
3304  if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
3305  options::OPT_fno_modules_validate_system_headers,
3306  ImplicitModules))
3307  CmdArgs.push_back("-fmodules-validate-system-headers");
3308 
3309  Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
3310 }
3311 
3312 static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T,
3313  ArgStringList &CmdArgs) {
3314  // -fsigned-char is default.
3315  if (const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
3316  options::OPT_fno_signed_char,
3317  options::OPT_funsigned_char,
3318  options::OPT_fno_unsigned_char)) {
3319  if (A->getOption().matches(options::OPT_funsigned_char) ||
3320  A->getOption().matches(options::OPT_fno_signed_char)) {
3321  CmdArgs.push_back("-fno-signed-char");
3322  }
3323  } else if (!isSignedCharDefault(T)) {
3324  CmdArgs.push_back("-fno-signed-char");
3325  }
3326 
3327  // The default depends on the language standard.
3328  Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t);
3329 
3330  if (const Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
3331  options::OPT_fno_short_wchar)) {
3332  if (A->getOption().matches(options::OPT_fshort_wchar)) {
3333  CmdArgs.push_back("-fwchar-type=short");
3334  CmdArgs.push_back("-fno-signed-wchar");
3335  } else {
3336  bool IsARM = T.isARM() || T.isThumb() || T.isAArch64();
3337  CmdArgs.push_back("-fwchar-type=int");
3338  if (IsARM && !(T.isOSWindows() || T.isOSNetBSD() ||
3339  T.isOSOpenBSD()))
3340  CmdArgs.push_back("-fno-signed-wchar");
3341  else
3342  CmdArgs.push_back("-fsigned-wchar");
3343  }
3344  }
3345 }
3346 
3347 static void RenderObjCOptions(const ToolChain &TC, const Driver &D,
3348  const llvm::Triple &T, const ArgList &Args,
3349  ObjCRuntime &Runtime, bool InferCovariantReturns,
3350  const InputInfo &Input, ArgStringList &CmdArgs) {
3351  const llvm::Triple::ArchType Arch = TC.getArch();
3352 
3353  // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and legacy
3354  // is the default. Except for deployment target of 10.5, next runtime is
3355  // always legacy dispatch and -fno-objc-legacy-dispatch gets ignored silently.
3356  if (Runtime.isNonFragile()) {
3357  if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3358  options::OPT_fno_objc_legacy_dispatch,
3359  Runtime.isLegacyDispatchDefaultForArch(Arch))) {
3360  if (TC.UseObjCMixedDispatch())
3361  CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3362  else
3363  CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3364  }
3365  }
3366 
3367  // When ObjectiveC legacy runtime is in effect on MacOSX, turn on the option
3368  // to do Array/Dictionary subscripting by default.
3369  if (Arch == llvm::Triple::x86 && T.isMacOSX() &&
3370  Runtime.getKind() == ObjCRuntime::FragileMacOSX && Runtime.isNeXTFamily())
3371  CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3372 
3373  // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3374  // NOTE: This logic is duplicated in ToolChains.cpp.
3375  if (isObjCAutoRefCount(Args)) {
3376  TC.CheckObjCARC();
3377 
3378  CmdArgs.push_back("-fobjc-arc");
3379 
3380  // FIXME: It seems like this entire block, and several around it should be
3381  // wrapped in isObjC, but for now we just use it here as this is where it
3382  // was being used previously.
3383  if (types::isCXX(Input.getType()) && types::isObjC(Input.getType())) {
3384  if (TC.GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3385  CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3386  else
3387  CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3388  }
3389 
3390  // Allow the user to enable full exceptions code emission.
3391  // We default off for Objective-C, on for Objective-C++.
3392  if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3393  options::OPT_fno_objc_arc_exceptions,
3394  /*Default=*/types::isCXX(Input.getType())))
3395  CmdArgs.push_back("-fobjc-arc-exceptions");
3396  }
3397 
3398  // Silence warning for full exception code emission options when explicitly
3399  // set to use no ARC.
3400  if (Args.hasArg(options::OPT_fno_objc_arc)) {
3401  Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions);
3402  Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions);
3403  }
3404 
3405  // Allow the user to control whether messages can be converted to runtime
3406  // functions.
3407  if (types::isObjC(Input.getType())) {
3408  auto *Arg = Args.getLastArg(
3409  options::OPT_fobjc_convert_messages_to_runtime_calls,
3410  options::OPT_fno_objc_convert_messages_to_runtime_calls);
3411  if (Arg &&
3412  Arg->getOption().matches(
3413  options::OPT_fno_objc_convert_messages_to_runtime_calls))
3414  CmdArgs.push_back("-fno-objc-convert-messages-to-runtime-calls");
3415  }
3416 
3417  // -fobjc-infer-related-result-type is the default, except in the Objective-C
3418  // rewriter.
3419  if (InferCovariantReturns)
3420  CmdArgs.push_back("-fno-objc-infer-related-result-type");
3421 
3422  // Pass down -fobjc-weak or -fno-objc-weak if present.
3423  if (types::isObjC(Input.getType())) {
3424  auto WeakArg =
3425  Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak);
3426  if (!WeakArg) {
3427  // nothing to do
3428  } else if (!Runtime.allowsWeak()) {
3429  if (WeakArg->getOption().matches(options::OPT_fobjc_weak))
3430  D.Diag(diag::err_objc_weak_unsupported);
3431  } else {
3432  WeakArg->render(Args, CmdArgs);
3433  }
3434  }
3435 }
3436 
3437 static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args,
3438  ArgStringList &CmdArgs) {
3439  bool CaretDefault = true;
3440  bool ColumnDefault = true;
3441 
3442  if (const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic,
3443  options::OPT__SLASH_diagnostics_column,
3444  options::OPT__SLASH_diagnostics_caret)) {
3445  switch (A->getOption().getID()) {
3446  case options::OPT__SLASH_diagnostics_caret:
3447  CaretDefault = true;
3448  ColumnDefault = true;
3449  break;
3450  case options::OPT__SLASH_diagnostics_column:
3451  CaretDefault = false;
3452  ColumnDefault = true;
3453  break;
3454  case options::OPT__SLASH_diagnostics_classic:
3455  CaretDefault = false;
3456  ColumnDefault = false;
3457  break;
3458  }
3459  }
3460 
3461  // -fcaret-diagnostics is default.
3462  if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3463  options::OPT_fno_caret_diagnostics, CaretDefault))
3464  CmdArgs.push_back("-fno-caret-diagnostics");
3465 
3466  // -fdiagnostics-fixit-info is default, only pass non-default.
3467  if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3468  options::OPT_fno_diagnostics_fixit_info))
3469  CmdArgs.push_back("-fno-diagnostics-fixit-info");
3470 
3471  // Enable -fdiagnostics-show-option by default.
3472  if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3473  options::OPT_fno_diagnostics_show_option))
3474  CmdArgs.push_back("-fdiagnostics-show-option");
3475 
3476  if (const Arg *A =
3477  Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3478  CmdArgs.push_back("-fdiagnostics-show-category");
3479  CmdArgs.push_back(A->getValue());
3480  }
3481 
3482  if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
3483  options::OPT_fno_diagnostics_show_hotness, false))
3484  CmdArgs.push_back("-fdiagnostics-show-hotness");
3485 
3486  if (const Arg *A =
3487  Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
3488  std::string Opt =
3489  std::string("-fdiagnostics-hotness-threshold=") + A->getValue();
3490  CmdArgs.push_back(Args.MakeArgString(Opt));
3491  }
3492 
3493  if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3494  CmdArgs.push_back("-fdiagnostics-format");
3495  CmdArgs.push_back(A->getValue());
3496  }
3497 
3498  if (const Arg *A = Args.getLastArg(
3499  options::OPT_fdiagnostics_show_note_include_stack,
3500  options::OPT_fno_diagnostics_show_note_include_stack)) {
3501  const Option &O = A->getOption();
3502  if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
3503  CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3504  else
3505  CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3506  }
3507 
3508  // Color diagnostics are parsed by the driver directly from argv and later
3509  // re-parsed to construct this job; claim any possible color diagnostic here
3510  // to avoid warn_drv_unused_argument and diagnose bad
3511  // OPT_fdiagnostics_color_EQ values.
3512  for (const Arg *A : Args) {
3513  const Option &O = A->getOption();
3514  if (!O.matches(options::OPT_fcolor_diagnostics) &&
3515  !O.matches(options::OPT_fdiagnostics_color) &&
3516  !O.matches(options::OPT_fno_color_diagnostics) &&
3517  !O.matches(options::OPT_fno_diagnostics_color) &&
3518  !O.matches(options::OPT_fdiagnostics_color_EQ))
3519  continue;
3520 
3521  if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
3522  StringRef Value(A->getValue());
3523  if (Value != "always" && Value != "never" && Value != "auto")
3524  D.Diag(diag::err_drv_clang_unsupported)
3525  << ("-fdiagnostics-color=" + Value).str();
3526  }
3527  A->claim();
3528  }
3529 
3530  if (D.getDiags().getDiagnosticOptions().ShowColors)
3531  CmdArgs.push_back("-fcolor-diagnostics");
3532 
3533  if (Args.hasArg(options::OPT_fansi_escape_codes))
3534  CmdArgs.push_back("-fansi-escape-codes");
3535 
3536  if (!Args.hasFlag(options::OPT_fshow_source_location,
3537  options::OPT_fno_show_source_location))
3538  CmdArgs.push_back("-fno-show-source-location");
3539 
3540  if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths))
3541  CmdArgs.push_back("-fdiagnostics-absolute-paths");
3542 
3543  if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
3544  ColumnDefault))
3545  CmdArgs.push_back("-fno-show-column");
3546 
3547  if (!Args.hasFlag(options::OPT_fspell_checking,
3548  options::OPT_fno_spell_checking))
3549  CmdArgs.push_back("-fno-spell-checking");
3550 }
3551 
3552 enum class DwarfFissionKind { None, Split, Single };
3553 
3555  const ArgList &Args, Arg *&Arg) {
3556  Arg =
3557  Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ);
3558  if (!Arg)
3559  return DwarfFissionKind::None;
3560 
3561  if (Arg->getOption().matches(options::OPT_gsplit_dwarf))
3562  return DwarfFissionKind::Split;
3563 
3564  StringRef Value = Arg->getValue();
3565  if (Value == "split")
3566  return DwarfFissionKind::Split;
3567  if (Value == "single")
3568  return DwarfFissionKind::Single;
3569 
3570  D.Diag(diag::err_drv_unsupported_option_argument)
3571  << Arg->getOption().getName() << Arg->getValue();
3572  return DwarfFissionKind::None;
3573 }
3574 
3575 static void RenderDebugOptions(const ToolChain &TC, const Driver &D,
3576  const llvm::Triple &T, const ArgList &Args,
3577  bool EmitCodeView, bool IsWindowsMSVC,
3578  ArgStringList &CmdArgs,
3580  DwarfFissionKind &DwarfFission) {
3581  if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
3582  options::OPT_fno_debug_info_for_profiling, false) &&
3584  Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC))
3585  CmdArgs.push_back("-fdebug-info-for-profiling");
3586 
3587  // The 'g' groups options involve a somewhat intricate sequence of decisions
3588  // about what to pass from the driver to the frontend, but by the time they
3589  // reach cc1 they've been factored into three well-defined orthogonal choices:
3590  // * what level of debug info to generate
3591  // * what dwarf version to write
3592  // * what debugger tuning to use
3593  // This avoids having to monkey around further in cc1 other than to disable
3594  // codeview if not running in a Windows environment. Perhaps even that
3595  // decision should be made in the driver as well though.
3596  llvm::DebuggerKind DebuggerTuning = TC.getDefaultDebuggerTuning();
3597 
3598  bool SplitDWARFInlining =
3599  Args.hasFlag(options::OPT_fsplit_dwarf_inlining,
3600  options::OPT_fno_split_dwarf_inlining, false);
3601 
3602  Args.ClaimAllArgs(options::OPT_g_Group);
3603 
3604  Arg* SplitDWARFArg;
3605  DwarfFission = getDebugFissionKind(D, Args, SplitDWARFArg);
3606 
3607  if (DwarfFission != DwarfFissionKind::None &&
3608  !checkDebugInfoOption(SplitDWARFArg, Args, D, TC)) {
3609  DwarfFission = DwarfFissionKind::None;
3610  SplitDWARFInlining = false;
3611  }
3612 
3613  if (const Arg *A =
3614  Args.getLastArg(options::OPT_g_Group, options::OPT_gsplit_dwarf,
3615  options::OPT_gsplit_dwarf_EQ)) {
3616  DebugInfoKind = codegenoptions::LimitedDebugInfo;
3617 
3618  // If the last option explicitly specified a debug-info level, use it.
3619  if (checkDebugInfoOption(A, Args, D, TC) &&
3620  A->getOption().matches(options::OPT_gN_Group)) {
3621  DebugInfoKind = DebugLevelToInfoKind(*A);
3622  // For -g0 or -gline-tables-only, drop -gsplit-dwarf. This gets a bit more
3623  // complicated if you've disabled inline info in the skeleton CUs
3624  // (SplitDWARFInlining) - then there's value in composing split-dwarf and
3625  // line-tables-only, so let those compose naturally in that case.
3626  if (DebugInfoKind == codegenoptions::NoDebugInfo ||
3627  DebugInfoKind == codegenoptions::DebugDirectivesOnly ||
3628  (DebugInfoKind == codegenoptions::DebugLineTablesOnly &&
3629  SplitDWARFInlining))
3630  DwarfFission = DwarfFissionKind::None;
3631  }
3632  }
3633 
3634  // If a debugger tuning argument appeared, remember it.
3635  if (const Arg *A =
3636  Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
3637  if (checkDebugInfoOption(A, Args, D, TC)) {
3638  if (A->getOption().matches(options::OPT_glldb))
3639  DebuggerTuning = llvm::DebuggerKind::LLDB;
3640  else if (A->getOption().matches(options::OPT_gsce))
3641  DebuggerTuning = llvm::DebuggerKind::SCE;
3642  else
3643  DebuggerTuning = llvm::DebuggerKind::GDB;
3644  }
3645  }
3646 
3647  // If a -gdwarf argument appeared, remember it.
3648  const Arg *GDwarfN = Args.getLastArg(
3649  options::OPT_gdwarf_2, options::OPT_gdwarf_3, options::OPT_gdwarf_4,
3650  options::OPT_gdwarf_5, options::OPT_gdwarf);
3651  bool EmitDwarf = false;
3652  if (GDwarfN) {
3653  if (checkDebugInfoOption(GDwarfN, Args, D, TC))
3654  EmitDwarf = true;
3655  else
3656  GDwarfN = nullptr;
3657  }
3658 
3659  if (const Arg *A = Args.getLastArg(options::OPT_gcodeview)) {
3660  if (checkDebugInfoOption(A, Args, D, TC))
3661  EmitCodeView = true;
3662  }
3663 
3664  // If the user asked for debug info but did not explicitly specify -gcodeview
3665  // or -gdwarf, ask the toolchain for the default format.
3666  if (!EmitCodeView && !EmitDwarf &&
3667  DebugInfoKind != codegenoptions::NoDebugInfo) {
3668  switch (TC.getDefaultDebugFormat()) {
3670  EmitCodeView = true;
3671  break;
3673  EmitDwarf = true;
3674  break;
3675  }
3676  }
3677 
3678  unsigned DWARFVersion = 0;
3679  unsigned DefaultDWARFVersion = ParseDebugDefaultVersion(TC, Args);
3680  if (EmitDwarf) {
3681  // Start with the platform default DWARF version
3682  DWARFVersion = TC.GetDefaultDwarfVersion();
3683  assert(DWARFVersion && "toolchain default DWARF version must be nonzero");
3684 
3685  // If the user specified a default DWARF version, that takes precedence
3686  // over the platform default.
3687  if (DefaultDWARFVersion)
3688  DWARFVersion = DefaultDWARFVersion;
3689 
3690  // Override with a user-specified DWARF version
3691  if (GDwarfN)
3692  if (auto ExplicitVersion = DwarfVersionNum(GDwarfN->getSpelling()))
3693  DWARFVersion = ExplicitVersion;
3694  }
3695 
3696  // -gline-directives-only supported only for the DWARF debug info.
3697  if (DWARFVersion == 0 && DebugInfoKind == codegenoptions::DebugDirectivesOnly)
3698  DebugInfoKind = codegenoptions::NoDebugInfo;
3699 
3700  // We ignore flag -gstrict-dwarf for now.
3701  // And we handle flag -grecord-gcc-switches later with DWARFDebugFlags.
3702  Args.ClaimAllArgs(options::OPT_g_flags_Group);
3703 
3704  // Column info is included by default for everything except SCE and
3705  // CodeView. Clang doesn't track end columns, just starting columns, which,
3706  // in theory, is fine for CodeView (and PDB). In practice, however, the
3707  // Microsoft debuggers don't handle missing end columns well, so it's better
3708  // not to include any column info.
3709  if (const Arg *A = Args.getLastArg(options::OPT_gcolumn_info))
3710  (void)checkDebugInfoOption(A, Args, D, TC);
3711  if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3712  /*Default=*/!EmitCodeView &&
3713  DebuggerTuning != llvm::DebuggerKind::SCE))
3714  CmdArgs.push_back("-dwarf-column-info");
3715 
3716  // FIXME: Move backend command line options to the module.
3717  // If -gline-tables-only or -gline-directives-only is the last option it wins.
3718  if (const Arg *A = Args.getLastArg(options::OPT_gmodules))
3719  if (checkDebugInfoOption(A, Args, D, TC)) {
3720  if (DebugInfoKind != codegenoptions::DebugLineTablesOnly &&
3721  DebugInfoKind != codegenoptions::DebugDirectivesOnly) {
3722  DebugInfoKind = codegenoptions::LimitedDebugInfo;
3723  CmdArgs.push_back("-dwarf-ext-refs");
3724  CmdArgs.push_back("-fmodule-format=obj");
3725  }
3726  }
3727 
3728  if (T.isOSBinFormatELF() && !SplitDWARFInlining)
3729  CmdArgs.push_back("-fno-split-dwarf-inlining");
3730 
3731  // After we've dealt with all combinations of things that could
3732  // make DebugInfoKind be other than None or DebugLineTablesOnly,
3733  // figure out if we need to "upgrade" it to standalone debug info.
3734  // We parse these two '-f' options whether or not they will be used,
3735  // to claim them even if you wrote "-fstandalone-debug -gline-tables-only"
3736  bool NeedFullDebug = Args.hasFlag(
3737  options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug,
3738  DebuggerTuning == llvm::DebuggerKind::LLDB ||
3740  if (const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
3741  (void)checkDebugInfoOption(A, Args, D, TC);
3742  if (DebugInfoKind == codegenoptions::LimitedDebugInfo && NeedFullDebug)
3743  DebugInfoKind = codegenoptions::FullDebugInfo;
3744 
3745  if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
3746  false)) {
3747  // Source embedding is a vendor extension to DWARF v5. By now we have
3748  // checked if a DWARF version was stated explicitly, and have otherwise
3749  // fallen back to the target default, so if this is still not at least 5
3750  // we emit an error.
3751  const Arg *A = Args.getLastArg(options::OPT_gembed_source);
3752  if (DWARFVersion < 5)
3753  D.Diag(diag::err_drv_argument_only_allowed_with)
3754  << A->getAsString(Args) << "-gdwarf-5";
3755  else if (checkDebugInfoOption(A, Args, D, TC))
3756  CmdArgs.push_back("-gembed-source");
3757  }
3758 
3759  if (EmitCodeView) {
3760  CmdArgs.push_back("-gcodeview");
3761 
3762  // Emit codeview type hashes if requested.
3763  if (Args.hasFlag(options::OPT_gcodeview_ghash,
3764  options::OPT_gno_codeview_ghash, false)) {
3765  CmdArgs.push_back("-gcodeview-ghash");
3766  }
3767  }
3768 
3769  // Omit inline line tables if requested.
3770  if (Args.hasFlag(options::OPT_gno_inline_line_tables,
3771  options::OPT_ginline_line_tables, false)) {
3772  CmdArgs.push_back("-gno-inline-line-tables");
3773  }
3774 
3775  // Adjust the debug info kind for the given toolchain.
3776  TC.adjustDebugInfoKind(DebugInfoKind, Args);
3777 
3778  // When emitting remarks, we need at least debug lines in the output.
3779  if (willEmitRemarks(Args) &&
3780  DebugInfoKind <= codegenoptions::DebugDirectivesOnly)
3781  DebugInfoKind = codegenoptions::DebugLineTablesOnly;
3782 
3783  RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DWARFVersion,
3784  DebuggerTuning);
3785 
3786  // -fdebug-macro turns on macro debug info generation.
3787  if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro,
3788  false))
3789  if (checkDebugInfoOption(Args.getLastArg(options::OPT_fdebug_macro), Args,
3790  D, TC))
3791  CmdArgs.push_back("-debug-info-macro");
3792 
3793  // -ggnu-pubnames turns on gnu style pubnames in the backend.
3794  const auto *PubnamesArg =
3795  Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames,
3796  options::OPT_gpubnames, options::OPT_gno_pubnames);
3797  if (DwarfFission != DwarfFissionKind::None ||
3798  (PubnamesArg && checkDebugInfoOption(PubnamesArg, Args, D, TC)))
3799  if (!PubnamesArg ||
3800  (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) &&
3801  !PubnamesArg->getOption().matches(options::OPT_gno_pubnames)))
3802  CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches(
3803  options::OPT_gpubnames)
3804  ? "-gpubnames"
3805  : "-ggnu-pubnames");
3806 
3807  if (Args.hasFlag(options::OPT_fdebug_ranges_base_address,
3808  options::OPT_fno_debug_ranges_base_address, false)) {
3809  CmdArgs.push_back("-fdebug-ranges-base-address");
3810  }
3811 
3812  // -gdwarf-aranges turns on the emission of the aranges section in the
3813  // backend.
3814  // Always enabled for SCE tuning.
3815  bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE;
3816  if (const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges))
3817  NeedAranges = checkDebugInfoOption(A, Args, D, TC) || NeedAranges;
3818  if (NeedAranges) {
3819  CmdArgs.push_back("-mllvm");
3820  CmdArgs.push_back("-generate-arange-section");
3821  }
3822 
3823  if (Args.hasFlag(options::OPT_fforce_dwarf_frame,
3824  options::OPT_fno_force_dwarf_frame, false))
3825  CmdArgs.push_back("-fforce-dwarf-frame");
3826 
3827  if (Args.hasFlag(options::OPT_fdebug_types_section,
3828  options::OPT_fno_debug_types_section, false)) {
3829  if (!T.isOSBinFormatELF()) {
3830  D.Diag(diag::err_drv_unsupported_opt_for_target)
3831  << Args.getLastArg(options::OPT_fdebug_types_section)
3832  ->getAsString(Args)
3833  << T.getTriple();
3834  } else if (checkDebugInfoOption(
3835  Args.getLastArg(options::OPT_fdebug_types_section), Args, D,
3836  TC)) {
3837  CmdArgs.push_back("-mllvm");
3838  CmdArgs.push_back("-generate-type-units");
3839  }
3840  }
3841 
3842  // Decide how to render forward declarations of template instantiations.
3843  // SCE wants full descriptions, others just get them in the name.
3844  if (DebuggerTuning == llvm::DebuggerKind::SCE)
3845  CmdArgs.push_back("-debug-forward-template-params");
3846 
3847  // Do we need to explicitly import anonymous namespaces into the parent
3848  // scope?
3849  if (DebuggerTuning == llvm::DebuggerKind::SCE)
3850  CmdArgs.push_back("-dwarf-explicit-import");
3851 
3852  RenderDebugInfoCompressionArgs(Args, CmdArgs, D, TC);
3853 }
3854 
3856  const InputInfo &Output, const InputInfoList &Inputs,
3857  const ArgList &Args, const char *LinkingOutput) const {
3858  const auto &TC = getToolChain();
3859  const llvm::Triple &RawTriple = TC.getTriple();
3860  const llvm::Triple &Triple = TC.getEffectiveTriple();
3861  const std::string &TripleStr = Triple.getTriple();
3862 
3863  bool KernelOrKext =
3864  Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
3865  const Driver &D = TC.getDriver();
3866  ArgStringList CmdArgs;
3867 
3868  // Check number of inputs for sanity. We need at least one input.
3869  assert(Inputs.size() >= 1 && "Must have at least one input.");
3870  // CUDA/HIP compilation may have multiple inputs (source file + results of
3871  // device-side compilations). OpenMP device jobs also take the host IR as a
3872  // second input. Module precompilation accepts a list of header files to
3873  // include as part of the module. All other jobs are expected to have exactly
3874  // one input.
3875  bool IsCuda = JA.isOffloading(Action::OFK_Cuda);
3876  bool IsHIP = JA.isOffloading(Action::OFK_HIP);
3877  bool IsOpenMPDevice = JA.isDeviceOffloading(Action::OFK_OpenMP);
3878  bool IsHeaderModulePrecompile = isa<HeaderModulePrecompileJobAction>(JA);
3879 
3880  // A header module compilation doesn't have a main input file, so invent a
3881  // fake one as a placeholder.
3882  const char *ModuleName = [&]{
3883  auto *ModuleNameArg = Args.getLastArg(options::OPT_fmodule_name_EQ);
3884  return ModuleNameArg ? ModuleNameArg->getValue() : "";
3885  }();
3886  InputInfo HeaderModuleInput(Inputs[0].getType(), ModuleName, ModuleName);
3887 
3888  const InputInfo &Input =
3889  IsHeaderModulePrecompile ? HeaderModuleInput : Inputs[0];
3890 
3891  InputInfoList ModuleHeaderInputs;
3892  const InputInfo *CudaDeviceInput = nullptr;
3893  const InputInfo *OpenMPDeviceInput = nullptr;
3894  for (const InputInfo &I : Inputs) {
3895  if (&I == &Input) {
3896  // This is the primary input.
3897  } else if (IsHeaderModulePrecompile &&
3898  types::getPrecompiledType(I.getType()) == types::TY_PCH) {
3899  types::ID Expected = HeaderModuleInput.getType();
3900  if (I.getType() != Expected) {
3901  D.Diag(diag::err_drv_module_header_wrong_kind)
3902  << I.getFilename() << types::getTypeName(I.getType())
3903  << types::getTypeName(Expected);
3904  }
3905  ModuleHeaderInputs.push_back(I);
3906  } else if ((IsCuda || IsHIP) && !CudaDeviceInput) {
3907  CudaDeviceInput = &I;
3908  } else if (IsOpenMPDevice && !OpenMPDeviceInput) {
3909  OpenMPDeviceInput = &I;
3910  } else {
3911  llvm_unreachable("unexpectedly given multiple inputs");
3912  }
3913  }
3914 
3915  const llvm::Triple *AuxTriple = IsCuda ? TC.getAuxTriple() : nullptr;
3916  bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
3917  bool IsIAMCU = RawTriple.isOSIAMCU();
3918 
3919  // Adjust IsWindowsXYZ for CUDA/HIP compilations. Even when compiling in
3920  // device mode (i.e., getToolchain().getTriple() is NVPTX/AMDGCN, not
3921  // Windows), we need to pass Windows-specific flags to cc1.
3922  if (IsCuda || IsHIP)
3923  IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
3924 
3925  // C++ is not supported for IAMCU.
3926  if (IsIAMCU && types::isCXX(Input.getType()))
3927  D.Diag(diag::err_drv_clang_unsupported) << "C++ for IAMCU";
3928 
3929  // Invoke ourselves in -cc1 mode.
3930  //
3931  // FIXME: Implement custom jobs for internal actions.
3932  CmdArgs.push_back("-cc1");
3933 
3934  // Add the "effective" target triple.
3935  CmdArgs.push_back("-triple");
3936  CmdArgs.push_back(Args.MakeArgString(TripleStr));
3937 
3938  if (const Arg *MJ = Args.getLastArg(options::OPT_MJ)) {
3939  DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args);
3940  Args.ClaimAllArgs(options::OPT_MJ);
3941  } else if (const Arg *GenCDBFragment =
3942  Args.getLastArg(options::OPT_gen_cdb_fragment_path)) {
3943  DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(), C,
3944  TripleStr, Output, Input, Args);
3945  Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path);
3946  }
3947 
3948  if (IsCuda || IsHIP) {
3949  // We have to pass the triple of the host if compiling for a CUDA/HIP device
3950  // and vice-versa.
3951  std::string NormalizedTriple;
3954  NormalizedTriple = C.getSingleOffloadToolChain<Action::OFK_Host>()
3955  ->getTriple()
3956  .normalize();
3957  else {
3958  // Host-side compilation.
3959  NormalizedTriple =
3962  ->getTriple()
3963  .normalize();
3964  if (IsCuda) {
3965  // We need to figure out which CUDA version we're compiling for, as that
3966  // determines how we load and launch GPU kernels.
3967  auto *CTC = static_cast<const toolchains::CudaToolChain *>(
3969  assert(CTC && "Expected valid CUDA Toolchain.");
3970  if (CTC && CTC->CudaInstallation.version() != CudaVersion::UNKNOWN)
3971  CmdArgs.push_back(Args.MakeArgString(
3972  Twine("-target-sdk-version=") +
3973  CudaVersionToString(CTC->CudaInstallation.version())));
3974  }
3975  }
3976  CmdArgs.push_back("-aux-triple");
3977  CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3978  }
3979 
3980  if (IsOpenMPDevice) {
3981  // We have to pass the triple of the host if compiling for an OpenMP device.
3982  std::string NormalizedTriple =
3984  ->getTriple()
3985  .normalize();
3986  CmdArgs.push_back("-aux-triple");
3987  CmdArgs.push_back(Args.MakeArgString(NormalizedTriple));
3988  }
3989 
3990  if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm ||
3991  Triple.getArch() == llvm::Triple::thumb)) {
3992  unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
3993  unsigned Version;
3994  Triple.getArchName().substr(Offset).getAsInteger(10, Version);
3995  if (Version < 7)
3996  D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
3997  << TripleStr;
3998  }
3999 
4000  // Push all default warning arguments that are specific to
4001  // the given target. These come before user provided warning options
4002  // are provided.
4003  TC.addClangWarningOptions(CmdArgs);
4004 
4005  // Select the appropriate action.
4006  RewriteKind rewriteKind = RK_None;
4007 
4008  // If CollectArgsForIntegratedAssembler() isn't called below, claim the args
4009  // it claims when not running an assembler. Otherwise, clang would emit
4010  // "argument unused" warnings for assembler flags when e.g. adding "-E" to
4011  // flags while debugging something. That'd be somewhat inconvenient, and it's
4012  // also inconsistent with most other flags -- we don't warn on
4013  // -ffunction-sections not being used in -E mode either for example, even
4014  // though it's not really used either.
4015  if (!isa<AssembleJobAction>(JA)) {
4016  // The args claimed here should match the args used in
4017  // CollectArgsForIntegratedAssembler().
4018  if (TC.useIntegratedAs()) {
4019  Args.ClaimAllArgs(options::OPT_mrelax_all);
4020  Args.ClaimAllArgs(options::OPT_mno_relax_all);
4021  Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible);
4022  Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible);
4023  switch (C.getDefaultToolChain().getArch()) {
4024  case llvm::Triple::arm:
4025  case llvm::Triple::armeb:
4026  case llvm::Triple::thumb:
4027  case llvm::Triple::thumbeb:
4028  Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ);
4029  break;
4030  default:
4031  break;
4032  }
4033  }
4034  Args.ClaimAllArgs(options::OPT_Wa_COMMA);
4035  Args.ClaimAllArgs(options::OPT_Xassembler);
4036  }
4037 
4038  if (isa<AnalyzeJobAction>(JA)) {
4039  assert(JA.getType() == types::TY_Plist && "Invalid output type.");
4040  CmdArgs.push_back("-analyze");
4041  } else if (isa<MigrateJobAction>(JA)) {
4042  CmdArgs.push_back("-migrate");
4043  } else if (isa<PreprocessJobAction>(JA)) {
4044  if (Output.getType() == types::TY_Dependencies)
4045  CmdArgs.push_back("-Eonly");
4046  else {
4047  CmdArgs.push_back("-E");
4048  if (Args.hasArg(options::OPT_rewrite_objc) &&
4049  !Args.hasArg(options::OPT_g_Group))
4050  CmdArgs.push_back("-P");
4051  }
4052  } else if (isa<AssembleJobAction>(JA)) {
4053  CmdArgs.push_back("-emit-obj");
4054 
4055  CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
4056 
4057  // Also ignore explicit -force_cpusubtype_ALL option.
4058  (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
4059  } else if (isa<PrecompileJobAction>(JA)) {
4060  if (JA.getType() == types::TY_Nothing)
4061  CmdArgs.push_back("-fsyntax-only");
4062  else if (JA.getType() == types::TY_ModuleFile)
4063  CmdArgs.push_back(IsHeaderModulePrecompile
4064  ? "-emit-header-module"
4065  : "-emit-module-interface");
4066  else
4067  CmdArgs.push_back("-emit-pch");
4068  } else if (isa<VerifyPCHJobAction>(JA)) {
4069  CmdArgs.push_back("-verify-pch");
4070  } else {
4071  assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
4072  "Invalid action for clang tool.");
4073  if (JA.getType() == types::TY_Nothing) {
4074  CmdArgs.push_back("-fsyntax-only");
4075  } else if (JA.getType() == types::TY_LLVM_IR ||
4076  JA.getType() == types::TY_LTO_IR) {
4077  CmdArgs.push_back("-emit-llvm");
4078  } else if (JA.getType() == types::TY_LLVM_BC ||
4079  JA.getType() == types::TY_LTO_BC) {
4080  CmdArgs.push_back("-emit-llvm-bc");
4081  } else if (JA.getType() == types::TY_IFS ||
4082  JA.getType() == types::TY_IFS_CPP) {
4083  StringRef ArgStr =
4084  Args.hasArg(options::OPT_interface_stub_version_EQ)
4085  ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
4086  : "experimental-ifs-v1";
4087  CmdArgs.push_back("-emit-interface-stubs");
4088  CmdArgs.push_back(
4089  Args.MakeArgString(Twine("-interface-stub-version=") + ArgStr.str()));
4090  } else if (JA.getType() == types::TY_PP_Asm) {
4091  CmdArgs.push_back("-S");
4092  } else if (JA.getType() == types::TY_AST) {
4093  CmdArgs.push_back("-emit-pch");
4094  } else if (JA.getType() == types::TY_ModuleFile) {
4095  CmdArgs.push_back("-module-file-info");
4096  } else if (JA.getType() == types::TY_RewrittenObjC) {
4097  CmdArgs.push_back("-rewrite-objc");
4098  rewriteKind = RK_NonFragile;
4099  } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
4100  CmdArgs.push_back("-rewrite-objc");
4101  rewriteKind = RK_Fragile;
4102  } else {
4103  assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!");
4104  }
4105 
4106  // Preserve use-list order by default when emitting bitcode, so that
4107  // loading the bitcode up in 'opt' or 'llc' and running passes gives the
4108  // same result as running passes here. For LTO, we don't need to preserve
4109  // the use-list order, since serialization to bitcode is part of the flow.
4110  if (JA.getType() == types::TY_LLVM_BC)
4111  CmdArgs.push_back("-emit-llvm-uselists");
4112 
4113  // Device-side jobs do not support LTO.
4114  bool isDeviceOffloadAction = !(JA.isDeviceOffloading(Action::OFK_None) ||
4116 
4117  if (D.isUsingLTO() && !isDeviceOffloadAction) {
4118  Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ);
4119  CmdArgs.push_back("-flto-unit");
4120  }
4121  }
4122 
4123  if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) {
4124  if (!types::isLLVMIR(Input.getType()))
4125  D.Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args);
4126  Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ);
4127  }
4128 
4129  if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ))
4130  Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ);
4131 
4132  if (Args.getLastArg(options::OPT_save_temps_EQ))
4133  Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ);
4134 
4135  // Embed-bitcode option.
4136  // Only white-listed flags below are allowed to be embedded.
4137  if (C.getDriver().embedBitcodeInObject() && !C.getDriver().isUsingLTO() &&
4138  (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {
4139  // Add flags implied by -fembed-bitcode.
4140  Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ);
4141  // Disable all llvm IR level optimizations.
4142  CmdArgs.push_back("-disable-llvm-passes");
4143 
4144  // Render target options.
4145  TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind());
4146 
4147  // reject options that shouldn't be supported in bitcode
4148  // also reject kernel/kext
4149  static const constexpr unsigned kBitcodeOptionBlacklist[] = {
4150  options::OPT_mkernel,
4151  options::OPT_fapple_kext,
4152  options::OPT_ffunction_sections,
4153  options::OPT_fno_function_sections,
4154  options::OPT_fdata_sections,
4155  options::OPT_fno_data_sections,
4156  options::OPT_funique_section_names,
4157  options::OPT_fno_unique_section_names,
4158  options::OPT_mrestrict_it,
4159  options::OPT_mno_restrict_it,
4160  options::OPT_mstackrealign,
4161  options::OPT_mno_stackrealign,
4162  options::OPT_mstack_alignment,
4163  options::OPT_mcmodel_EQ,
4164  options::OPT_mlong_calls,
4165  options::OPT_mno_long_calls,
4166  options::OPT_ggnu_pubnames,
4167  options::OPT_gdwarf_aranges,
4168  options::OPT_fdebug_types_section,
4169  options::OPT_fno_debug_types_section,
4170  options::OPT_fdwarf_directory_asm,
4171  options::OPT_fno_dwarf_directory_asm,
4172  options::OPT_mrelax_all,
4173  options::OPT_mno_relax_all,
4174  options::OPT_ftrap_function_EQ,
4175  options::OPT_ffixed_r9,
4176  options::OPT_mfix_cortex_a53_835769,
4177  options::OPT_mno_fix_cortex_a53_835769,
4178  options::OPT_ffixed_x18,
4179  options::OPT_mglobal_merge,
4180  options::OPT_mno_global_merge,
4181  options::OPT_mred_zone,
4182  options::OPT_mno_red_zone,
4183  options::OPT_Wa_COMMA,
4184  options::OPT_Xassembler,
4185  options::OPT_mllvm,
4186  };
4187  for (const auto &A : Args)
4188  if (llvm::find(kBitcodeOptionBlacklist, A->getOption().getID()) !=
4189  std::end(kBitcodeOptionBlacklist))
4190  D.Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling();
4191 
4192  // Render the CodeGen options that need to be passed.
4193  if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
4194  options::OPT_fno_optimize_sibling_calls))
4195  CmdArgs.push_back("-mdisable-tail-calls");
4196 
4198  CmdArgs);
4199 
4200  // Render ABI arguments
4201  switch (TC.getArch()) {
4202  default: break;
4203  case llvm::Triple::arm:
4204  case llvm::Triple::armeb:
4205  case llvm::Triple::thumbeb:
4206  RenderARMABI(Triple, Args, CmdArgs);
4207  break;
4208  case llvm::Triple::aarch64:
4209  case llvm::Triple::aarch64_32:
4210  case llvm::Triple::aarch64_be:
4211  RenderAArch64ABI(Triple, Args, CmdArgs);
4212  break;
4213  }
4214 
4215  // Optimization level for CodeGen.
4216  if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4217  if (A->getOption().matches(options::OPT_O4)) {
4218  CmdArgs.push_back("-O3");
4219  D.Diag(diag::warn_O4_is_O3);
4220  } else {
4221  A->render(Args, CmdArgs);
4222  }
4223  }
4224 
4225  // Input/Output file.
4226  if (Output.getType() == types::TY_Dependencies) {
4227  // Handled with other dependency code.
4228  } else if (Output.isFilename()) {
4229  CmdArgs.push_back("-o");
4230  CmdArgs.push_back(Output.getFilename());
4231  } else {
4232  assert(Output.isNothing() && "Input output.");
4233  }
4234 
4235  for (const auto &II : Inputs) {
4236  addDashXForInput(Args, II, CmdArgs);
4237  if (II.isFilename())
4238  CmdArgs.push_back(II.getFilename());
4239  else
4240  II.getInputArg().renderAsInput(Args, CmdArgs);
4241  }
4242 
4243  C.addCommand(std::make_unique<Command>(JA, *this, D.getClangProgramPath(),
4244  CmdArgs, Inputs));
4245  return;
4246  }
4247 
4249  CmdArgs.push_back("-fembed-bitcode=marker");
4250 
4251  // We normally speed up the clang process a bit by skipping destructors at
4252  // exit, but when we're generating diagnostics we can rely on some of the
4253  // cleanup.
4254  if (!C.isForDiagnostics())
4255  CmdArgs.push_back("-disable-free");
4256 
4257 #ifdef NDEBUG
4258  const bool IsAssertBuild = false;
4259 #else
4260  const bool IsAssertBuild = true;
4261 #endif
4262 
4263  // Disable the verification pass in -asserts builds.
4264  if (!IsAssertBuild)
4265  CmdArgs.push_back("-disable-llvm-verifier");
4266 
4267  // Discard value names in assert builds unless otherwise specified.
4268  if (Args.hasFlag(options::OPT_fdiscard_value_names,
4269  options::OPT_fno_discard_value_names, !IsAssertBuild))
4270  CmdArgs.push_back("-discard-value-names");
4271 
4272  // Set the main file name, so that debug info works even with
4273  // -save-temps.
4274  CmdArgs.push_back("-main-file-name");
4275  CmdArgs.push_back(getBaseInputName(Args, Input));
4276 
4277  // Some flags which affect the language (via preprocessor
4278  // defines).
4279  if (Args.hasArg(options::OPT_static))
4280  CmdArgs.push_back("-static-define");
4281 
4282  if (Args.hasArg(options::OPT_municode))
4283  CmdArgs.push_back("-DUNICODE");
4284 
4285  if (isa<AnalyzeJobAction>(JA))
4286  RenderAnalyzerOptions(Args, CmdArgs, Triple, Input);
4287 
4288  if (isa<AnalyzeJobAction>(JA) ||
4289  (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze)))
4290  CmdArgs.push_back("-setup-static-analyzer");
4291 
4292  // Enable compatilibily mode to avoid analyzer-config related errors.
4293  // Since we can't access frontend flags through hasArg, let's manually iterate
4294  // through them.
4295  bool FoundAnalyzerConfig = false;
4296  for (auto Arg : Args.filtered(options::OPT_Xclang))
4297  if (StringRef(Arg->getValue()) == "-analyzer-config") {
4298  FoundAnalyzerConfig = true;
4299  break;
4300  }
4301  if (!FoundAnalyzerConfig)
4302  for (auto Arg : Args.filtered(options::OPT_Xanalyzer))
4303  if (StringRef(Arg->getValue()) == "-analyzer-config") {
4304  FoundAnalyzerConfig = true;
4305  break;
4306  }
4307  if (FoundAnalyzerConfig)
4308  CmdArgs.push_back("-analyzer-config-compatibility-mode=true");
4309 
4310  CheckCodeGenerationOptions(D, Args);
4311 
4312  unsigned FunctionAlignment = ParseFunctionAlignment(TC, Args);
4313  assert(FunctionAlignment <= 31 && "function alignment will be truncated!");
4314  if (FunctionAlignment) {
4315  CmdArgs.push_back("-function-alignment");
4316  CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment)));
4317  }
4318 
4319  llvm::Reloc::Model RelocationModel;
4320  unsigned PICLevel;
4321  bool IsPIE;
4322  std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(TC, Args);
4323 
4324  const char *RMName = RelocationModelName(RelocationModel);
4325 
4326  if ((RelocationModel == llvm::Reloc::ROPI ||
4327  RelocationModel == llvm::Reloc::ROPI_RWPI) &&
4328  types::isCXX(Input.getType()) &&
4329  !Args.hasArg(options::OPT_fallow_unsupported))
4330  D.Diag(diag::err_drv_ropi_incompatible_with_cxx);
4331 
4332  if (RMName) {
4333  CmdArgs.push_back("-mrelocation-model");
4334  CmdArgs.push_back(RMName);
4335  }
4336  if (PICLevel > 0) {
4337  CmdArgs.push_back("-pic-level");
4338  CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
4339  if (IsPIE)
4340  CmdArgs.push_back("-pic-is-pie");
4341  }
4342 
4343  if (RelocationModel == llvm::Reloc::ROPI ||
4344  RelocationModel == llvm::Reloc::ROPI_RWPI)
4345  CmdArgs.push_back("-fropi");
4346  if (RelocationModel == llvm::Reloc::RWPI ||
4347  RelocationModel == llvm::Reloc::ROPI_RWPI)
4348  CmdArgs.push_back("-frwpi");
4349 
4350  if (Arg *A = Args.getLastArg(options::OPT_meabi)) {
4351  CmdArgs.push_back("-meabi");
4352  CmdArgs.push_back(A->getValue());
4353  }
4354 
4355  CmdArgs.push_back("-mthread-model");
4356  if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) {
4357  if (!TC.isThreadModelSupported(A->getValue()))
4358  D.Diag(diag::err_drv_invalid_thread_model_for_target)
4359  << A->getValue() << A->getAsString(Args);
4360  CmdArgs.push_back(A->getValue());
4361  }
4362  else
4363  CmdArgs.push_back(Args.MakeArgString(TC.getThreadModel()));
4364 
4365  Args.AddLastArg(CmdArgs, options::OPT_fveclib);
4366 
4367  if (Args.hasFlag(options::OPT_fmerge_all_constants,
4368  options::OPT_fno_merge_all_constants, false))
4369  CmdArgs.push_back("-fmerge-all-constants");
4370 
4371  if (Args.hasFlag(options::OPT_fno_delete_null_pointer_checks,
4372  options::OPT_fdelete_null_pointer_checks, false))
4373  CmdArgs.push_back("-fno-delete-null-pointer-checks");
4374 
4375  // LLVM Code Generator Options.
4376 
4377  if (Args.hasArg(options::OPT_frewrite_map_file) ||
4378  Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
4379  for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
4380  options::OPT_frewrite_map_file_EQ)) {
4381  StringRef Map = A->getValue();
4382  if (!llvm::sys::fs::exists(Map)) {
4383  D.Diag(diag::err_drv_no_such_file) << Map;
4384  } else {
4385  CmdArgs.push_back("-frewrite-map-file");
4386  CmdArgs.push_back(A->getValue());
4387  A->claim();
4388  }
4389  }
4390  }
4391 
4392  if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
4393  StringRef v = A->getValue();
4394  CmdArgs.push_back("-mllvm");
4395  CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
4396  A->claim();
4397  }
4398 
4399  if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
4400  true))
4401  CmdArgs.push_back("-fno-jump-tables");
4402 
4403  if (Args.hasFlag(options::OPT_fprofile_sample_accurate,
4404  options::OPT_fno_profile_sample_accurate, false))
4405  CmdArgs.push_back("-fprofile-sample-accurate");
4406 
4407  if (!Args.hasFlag(options::OPT_fpreserve_as_comments,
4408  options::OPT_fno_preserve_as_comments, true))
4409  CmdArgs.push_back("-fno-preserve-as-comments");
4410 
4411  if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
4412  CmdArgs.push_back("-mregparm");
4413  CmdArgs.push_back(A->getValue());
4414  }
4415 
4416  if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
4417  options::OPT_freg_struct_return)) {
4418  if (TC.getArch() != llvm::Triple::x86) {
4419  D.Diag(diag::err_drv_unsupported_opt_for_target)
4420  << A->getSpelling() << RawTriple.str();
4421  } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
4422  CmdArgs.push_back("-fpcc-struct-return");
4423  } else {
4424  assert(A->getOption().matches(options::OPT_freg_struct_return));
4425  CmdArgs.push_back("-freg-struct-return");
4426  }
4427  }
4428 
4429  if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
4430  CmdArgs.push_back("-fdefault-calling-conv=stdcall");
4431 
4433  getFramePointerKind(Args, RawTriple);
4434  const char *FPKeepKindStr = nullptr;
4435  switch (FPKeepKind) {
4437  FPKeepKindStr = "-mframe-pointer=none";
4438  break;
4440  FPKeepKindStr = "-mframe-pointer=non-leaf";
4441  break;
4443  FPKeepKindStr = "-mframe-pointer=all";
4444  break;
4445  }
4446  assert(FPKeepKindStr && "unknown FramePointerKind");
4447  CmdArgs.push_back(FPKeepKindStr);
4448 
4449  if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
4450  options::OPT_fno_zero_initialized_in_bss))
4451  CmdArgs.push_back("-mno-zero-initialized-in-bss");
4452 
4453  bool OFastEnabled = isOptimizationLevelFast(Args);
4454  // If -Ofast is the optimization level, then -fstrict-aliasing should be
4455  // enabled. This alias option is being used to simplify the hasFlag logic.
4456  OptSpecifier StrictAliasingAliasOption =
4457  OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
4458  // We turn strict aliasing off by default if we're in CL mode, since MSVC
4459  // doesn't do any TBAA.
4460  bool TBAAOnByDefault = !D.IsCLMode();
4461  if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
4462  options::OPT_fno_strict_aliasing, TBAAOnByDefault))
4463  CmdArgs.push_back("-relaxed-aliasing");
4464  if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
4465  options::OPT_fno_struct_path_tbaa))
4466  CmdArgs.push_back("-no-struct-path-tbaa");
4467  if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
4468  false))
4469  CmdArgs.push_back("-fstrict-enums");
4470  if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
4471  true))
4472  CmdArgs.push_back("-fno-strict-return");
4473  if (Args.hasFlag(options::OPT_fallow_editor_placeholders,
4474  options::OPT_fno_allow_editor_placeholders, false))
4475  CmdArgs.push_back("-fallow-editor-placeholders");
4476  if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
4477  options::OPT_fno_strict_vtable_pointers,
4478  false))
4479  CmdArgs.push_back("-fstrict-vtable-pointers");
4480  if (Args.hasFlag(options::OPT_fforce_emit_vtables,
4481  options::OPT_fno_force_emit_vtables,
4482  false))
4483  CmdArgs.push_back("-fforce-emit-vtables");
4484  if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
4485  options::OPT_fno_optimize_sibling_calls))
4486  CmdArgs.push_back("-mdisable-tail-calls");
4487  if (Args.hasFlag(options::OPT_fno_escaping_block_tail_calls,
4488  options::OPT_fescaping_block_tail_calls, false))
4489  CmdArgs.push_back("-fno-escaping-block-tail-calls");
4490 
4491  Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses,
4492  options::OPT_fno_fine_grained_bitfield_accesses);
4493 
4494  // Handle segmented stacks.
4495  if (Args.hasArg(options::OPT_fsplit_stack))
4496  CmdArgs.push_back("-split-stacks");
4497 
4498  RenderFloatingPointOptions(TC, D, OFastEnabled, Args, CmdArgs);
4499 
4500  if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
4501  if (TC.getTriple().isX86())
4502  A->render(Args, CmdArgs);
4503  else if ((TC.getArch() == llvm::Triple::ppc || TC.getTriple().isPPC64()) &&
4504  (A->getOption().getID() != options::OPT_mlong_double_80))
4505  A->render(Args, CmdArgs);
4506  else
4507  D.Diag(diag::err_drv_unsupported_opt_for_target)
4508  << A->getAsString(Args) << TripleStr;
4509  }
4510 
4511  // Decide whether to use verbose asm. Verbose assembly is the default on
4512  // toolchains which have the integrated assembler on by default.
4513  bool IsIntegratedAssemblerDefault = TC.IsIntegratedAssemblerDefault();
4514  if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
4515  IsIntegratedAssemblerDefault))
4516  CmdArgs.push_back("-masm-verbose");
4517 
4518  if (!TC.useIntegratedAs())
4519  CmdArgs.push_back("-no-integrated-as");
4520 
4521  if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
4522  CmdArgs.push_back("-mdebug-pass");
4523  CmdArgs.push_back("Structure");
4524  }
4525  if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
4526  CmdArgs.push_back("-mdebug-pass");
4527  CmdArgs.push_back("Arguments");
4528  }
4529 
4530  // Enable -mconstructor-aliases except on darwin, where we have to work around
4531  // a linker bug (see <rdar://problem/7651567>), and CUDA device code, where
4532  // aliases aren't supported.
4533  if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX())
4534  CmdArgs.push_back("-mconstructor-aliases");
4535 
4536  // Darwin's kernel doesn't support guard variables; just die if we
4537  // try to use them.
4538  if (KernelOrKext && RawTriple.isOSDarwin())
4539  CmdArgs.push_back("-fforbid-guard-variables");
4540 
4541  if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields,
4542  false)) {
4543  CmdArgs.push_back("-mms-bitfields");
4544  }
4545 
4546  if (Args.hasFlag(options::OPT_mpie_copy_relocations,
4547  options::OPT_mno_pie_copy_relocations,
4548  false)) {
4549  CmdArgs.push_back("-mpie-copy-relocations");
4550  }
4551 
4552  if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt, false)) {
4553  CmdArgs.push_back("-fno-plt");
4554  }
4555 
4556  // -fhosted is default.
4557  // TODO: Audit uses of KernelOrKext and see where it'd be more appropriate to
4558  // use Freestanding.
4559  bool Freestanding =
4560  Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
4561  KernelOrKext;
4562  if (Freestanding)
4563  CmdArgs.push_back("-ffreestanding");
4564 
4565  // This is a coarse approximation of what llvm-gcc actually does, both
4566  // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
4567  // complicated ways.
4568  bool AsynchronousUnwindTables =
4569  Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
4570  options::OPT_fno_asynchronous_unwind_tables,
4571  (TC.IsUnwindTablesDefault(Args) ||
4572  TC.getSanitizerArgs().needsUnwindTables()) &&
4573  !Freestanding);
4574  if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
4575  AsynchronousUnwindTables))
4576  CmdArgs.push_back("-munwind-tables");
4577 
4578  TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind());
4579 
4580  // FIXME: Handle -mtune=.
4581  (void)Args.hasArg(options::OPT_mtune_EQ);
4582 
4583  if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
4584  CmdArgs.push_back("-mcode-model");
4585  CmdArgs.push_back(A->getValue());
4586  }
4587 
4588  if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) {
4589  StringRef Value = A->getValue();
4590  unsigned TLSSize = 0;
4591  Value.getAsInteger(10, TLSSize);
4592  if (!Triple.isAArch64() || !Triple.isOSBinFormatELF())
4593  D.Diag(diag::err_drv_unsupported_opt_for_target)
4594  << A->getOption().getName() << TripleStr;
4595  if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48)
4596  D.Diag(diag::err_drv_invalid_int_value)
4597  << A->getOption().getName() << Value;
4598  Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ);
4599  }
4600 
4601  // Add the target cpu
4602  std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false);
4603  if (!CPU.empty()) {
4604  CmdArgs.push_back("-target-cpu");
4605  CmdArgs.push_back(Args.MakeArgString(CPU));
4606  }
4607 
4608  RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
4609 
4610  // These two are potentially updated by AddClangCLArgs.
4612  bool EmitCodeView = false;
4613 
4614  // Add clang-cl arguments.
4615  types::ID InputType = Input.getType();
4616  if (D.IsCLMode())
4617  AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView);
4618 
4619  DwarfFissionKind DwarfFission;
4620  RenderDebugOptions(TC, D, RawTriple, Args, EmitCodeView, IsWindowsMSVC,
4621  CmdArgs, DebugInfoKind, DwarfFission);
4622 
4623  // Add the split debug info name to the command lines here so we
4624  // can propagate it to the backend.
4625  bool SplitDWARF = (DwarfFission != DwarfFissionKind::None) &&
4626  TC.getTriple().isOSBinFormatELF() &&
4627  (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4628  isa<BackendJobAction>(JA));
4629  if (SplitDWARF) {
4630  const char *SplitDWARFOut = SplitDebugName(Args, Input, Output);
4631  CmdArgs.push_back("-split-dwarf-file");
4632  CmdArgs.push_back(SplitDWARFOut);
4633  if (DwarfFission == DwarfFissionKind::Split) {
4634  CmdArgs.push_back("-split-dwarf-output");
4635  CmdArgs.push_back(SplitDWARFOut);
4636  }
4637  }
4638 
4639  // Pass the linker version in use.
4640  if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4641  CmdArgs.push_back("-target-linker-version");
4642  CmdArgs.push_back(A->getValue());
4643  }
4644 
4645  // Explicitly error on some things we know we don't support and can't just
4646  // ignore.
4647  if (!Args.hasArg(options::OPT_fallow_unsupported)) {
4648  Arg *Unsupported;
4649  if (types::isCXX(InputType) && RawTriple.isOSDarwin() &&
4650  TC.getArch() == llvm::Triple::x86) {
4651  if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
4652  (Unsupported = Args.getLastArg(options::OPT_mkernel)))
4653  D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
4654  << Unsupported->getOption().getName();
4655  }
4656  // The faltivec option has been superseded by the maltivec option.
4657  if ((Unsupported = Args.getLastArg(options::OPT_faltivec)))
4658  D.Diag(diag::err_drv_clang_unsupported_opt_faltivec)
4659  << Unsupported->getOption().getName()
4660  << "please use -maltivec and include altivec.h explicitly";
4661  if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec)))
4662  D.Diag(diag::err_drv_clang_unsupported_opt_faltivec)
4663  << Unsupported->getOption().getName() << "please use -mno-altivec";
4664  }
4665 
4666  Args.AddAllArgs(CmdArgs, options::OPT_v);
4667  Args.AddLastArg(CmdArgs, options::OPT_H);
4668  if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
4669  CmdArgs.push_back("-header-include-file");
4670  CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename
4671  : "-");
4672  }
4673  Args.AddLastArg(CmdArgs, options::OPT_P);
4674  Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
4675 
4676  if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
4677  CmdArgs.push_back("-diagnostic-log-file");
4678  CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename
4679  : "-");
4680  }
4681 
4682  // Give the gen diagnostics more chances to succeed, by avoiding intentional
4683  // crashes.
4684  if (D.CCGenDiagnostics)
4685  CmdArgs.push_back("-disable-pragma-debug-crash");
4686 
4687  bool UseSeparateSections = isUseSeparateSections(Triple);
4688 
4689  if (Args.hasFlag(options::OPT_ffunction_sections,
4690  options::OPT_fno_function_sections, UseSeparateSections)) {
4691  CmdArgs.push_back("-ffunction-sections");
4692  }
4693 
4694  if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
4695  UseSeparateSections)) {
4696  CmdArgs.push_back("-fdata-sections");
4697  }
4698 
4699  if (!Args.hasFlag(options::OPT_funique_section_names,
4700  options::OPT_fno_unique_section_names, true))
4701  CmdArgs.push_back("-fno-unique-section-names");
4702 
4703  Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions,
4704  options::OPT_finstrument_functions_after_inlining,
4705  options::OPT_finstrument_function_entry_bare);
4706 
4707  // NVPTX doesn't support PGO or coverage. There's no runtime support for
4708  // sampling, overhead of call arc collection is way too high and there's no
4709  // way to collect the output.
4710  if (!Triple.isNVPTX())
4711  addPGOAndCoverageFlags(TC, C, D, Output, Args, CmdArgs);
4712 
4713  Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
4714 
4715  // Add runtime flag for PS4 when PGO, coverage, or sanitizers are enabled.
4716  if (RawTriple.isPS4CPU() &&
4717  !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
4718  PS4cpu::addProfileRTArgs(TC, Args, CmdArgs);
4719  PS4cpu::addSanitizerArgs(TC, CmdArgs);
4720  }
4721 
4722  // Pass options for controlling the default header search paths.
4723  if (Args.hasArg(options::OPT_nostdinc)) {
4724  CmdArgs.push_back("-nostdsysteminc");
4725  CmdArgs.push_back("-nobuiltininc");
4726  } else {
4727  if (Args.hasArg(options::OPT_nostdlibinc))
4728  CmdArgs.push_back("-nostdsysteminc");
4729  Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
4730  Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
4731  }
4732 
4733  // Pass the path to compiler resource files.
4734  CmdArgs.push_back("-resource-dir");
4735  CmdArgs.push_back(D.ResourceDir.c_str());
4736 
4737  Args.AddLastArg(CmdArgs, options::OPT_working_directory);
4738 
4739  RenderARCMigrateToolOptions(D, Args, CmdArgs);
4740 
4741  // Add preprocessing options like -I, -D, etc. if we are using the
4742  // preprocessor.
4743  //
4744  // FIXME: Support -fpreprocessed
4746  AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
4747 
4748  // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
4749  // that "The compiler can only warn and ignore the option if not recognized".
4750  // When building with ccache, it will pass -D options to clang even on
4751  // preprocessed inputs and configure concludes that -fPIC is not supported.
4752  Args.ClaimAllArgs(options::OPT_D);
4753 
4754  // Manually translate -O4 to -O3; let clang reject others.
4755  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
4756  if (A->getOption().matches(options::OPT_O4)) {
4757  CmdArgs.push_back("-O3");
4758  D.Diag(diag::warn_O4_is_O3);
4759  } else {
4760  A->render(Args, CmdArgs);
4761  }
4762  }
4763 
4764  // Warn about ignored options to clang.
4765  for (const Arg *A :
4766  Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
4767  D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
4768  A->claim();
4769  }
4770 
4771  for (const Arg *A :
4772  Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) {
4773  D.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args);
4774  A->claim();
4775  }
4776 
4777  claimNoWarnArgs(Args);
4778 
4779  Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
4780 
4781  Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
4782  if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
4783  CmdArgs.push_back("-pedantic");
4784  Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
4785  Args.AddLastArg(CmdArgs, options::OPT_w);
4786 
4787  // Fixed point flags
4788  if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
4789  /*Default=*/false))
4790  Args.AddLastArg(CmdArgs, options::OPT_ffixed_point);
4791 
4792  // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
4793  // (-ansi is equivalent to -std=c89 or -std=c++98).
4794  //
4795  // If a std is supplied, only add -trigraphs if it follows the
4796  // option.
4797  bool ImplyVCPPCXXVer = false;
4798  const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi);
4799  if (Std) {
4800  if (Std->getOption().matches(options::OPT_ansi))
4801  if (types::isCXX(InputType))
4802  CmdArgs.push_back("-std=c++98");
4803  else
4804  CmdArgs.push_back("-std=c89");
4805  else
4806  Std->render(Args, CmdArgs);
4807 
4808  // If -f(no-)trigraphs appears after the language standard flag, honor it.
4809  if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
4810  options::OPT_ftrigraphs,
4811  options::OPT_fno_trigraphs))
4812  if (A != Std)
4813  A->render(Args, CmdArgs);
4814  } else {
4815  // Honor -std-default.
4816  //
4817  // FIXME: Clang doesn't correctly handle -std= when the input language
4818  // doesn't match. For the time being just ignore this for C++ inputs;
4819  // eventually we want to do all the standard defaulting here instead of
4820  // splitting it between the driver and clang -cc1.
4821  if (!types::isCXX(InputType))
4822  Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
4823  /*Joined=*/true);
4824  else if (IsWindowsMSVC)
4825  ImplyVCPPCXXVer = true;
4826 
4827  Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
4828  options::OPT_fno_trigraphs);
4829  }
4830 
4831  // GCC's behavior for -Wwrite-strings is a bit strange:
4832  // * In C, this "warning flag" changes the types of string literals from
4833  // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning
4834  // for the discarded qualifier.
4835  // * In C++, this is just a normal warning flag.
4836  //
4837  // Implementing this warning correctly in C is hard, so we follow GCC's
4838  // behavior for now. FIXME: Directly diagnose uses of a string literal as
4839  // a non-const char* in C, rather than using this crude hack.
4840  if (!types::isCXX(InputType)) {
4841  // FIXME: This should behave just like a warning flag, and thus should also
4842  // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
4843  Arg *WriteStrings =
4844  Args.getLastArg(options::OPT_Wwrite_strings,
4845  options::OPT_Wno_write_strings, options::OPT_w);
4846  if (WriteStrings &&
4847  WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
4848  CmdArgs.push_back("-fconst-strings");
4849  }
4850 
4851  // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
4852  // during C++ compilation, which it is by default. GCC keeps this define even
4853  // in the presence of '-w', match this behavior bug-for-bug.
4854  if (types::isCXX(InputType) &&
4855  Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
4856  true)) {
4857  CmdArgs.push_back("-fdeprecated-macro");
4858  }
4859 
4860  // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
4861  if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
4862  if (Asm->getOption().matches(options::OPT_fasm))
4863  CmdArgs.push_back("-fgnu-keywords");
4864  else
4865  CmdArgs.push_back("-fno-gnu-keywords");
4866  }
4867 
4868  if (ShouldDisableDwarfDirectory(Args, TC))
4869  CmdArgs.push_back("-fno-dwarf-directory-asm");
4870 
4871  if (!ShouldEnableAutolink(Args, TC, JA))
4872  CmdArgs.push_back("-fno-autolink");
4873 
4874  // Add in -fdebug-compilation-dir if necessary.
4875  addDebugCompDirArg(Args, CmdArgs, D.getVFS());
4876 
4877  addDebugPrefixMapArg(D, Args, CmdArgs);
4878 
4879  if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
4880  options::OPT_ftemplate_depth_EQ)) {
4881  CmdArgs.push_back("-ftemplate-depth");
4882  CmdArgs.push_back(A->getValue());
4883  }
4884 
4885  if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
4886  CmdArgs.push_back("-foperator-arrow-depth");
4887  CmdArgs.push_back(A->getValue());
4888  }
4889 
4890  if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
4891  CmdArgs.push_back("-fconstexpr-depth");
4892  CmdArgs.push_back(A->getValue());
4893  }
4894 
4895  if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
4896  CmdArgs.push_back("-fconstexpr-steps");
4897  CmdArgs.push_back(A->getValue());
4898  }
4899 
4900  if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter))
4901  CmdArgs.push_back("-fexperimental-new-constant-interpreter");
4902 
4903  if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
4904  CmdArgs.push_back("-fbracket-depth");
4905  CmdArgs.push_back(A->getValue());
4906  }
4907 
4908  if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
4909  options::OPT_Wlarge_by_value_copy_def)) {
4910  if (A->getNumValues()) {
4911  StringRef bytes = A->getValue();
4912  CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
4913  } else
4914  CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
4915  }
4916 
4917  if (Args.hasArg(options::OPT_relocatable_pch))
4918  CmdArgs.push_back("-relocatable-pch");
4919 
4920  if (const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) {
4921  static const char *kCFABIs[] = {
4922  "standalone", "objc", "swift", "swift-5.0", "swift-4.2", "swift-4.1",
4923  };
4924 
4925  if (find(kCFABIs, StringRef(A->getValue())) == std::end(kCFABIs))
4926  D.Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue();
4927  else
4928  A->render(Args, CmdArgs);
4929  }
4930 
4931  if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
4932  CmdArgs.push_back("-fconstant-string-class");
4933  CmdArgs.push_back(A->getValue());
4934  }
4935 
4936  if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
4937  CmdArgs.push_back("-ftabstop");
4938  CmdArgs.push_back(A->getValue());
4939  }
4940 
4941  if (Args.hasFlag(options::OPT_fstack_size_section,
4942  options::OPT_fno_stack_size_section, RawTriple.isPS4()))
4943  CmdArgs.push_back("-fstack-size-section");
4944 
4945  CmdArgs.push_back("-ferror-limit");
4946  if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
4947  CmdArgs.push_back(A->getValue());
4948  else
4949  CmdArgs.push_back("19");
4950 
4951  if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
4952  CmdArgs.push_back("-fmacro-backtrace-limit");
4953  CmdArgs.push_back(A->getValue());
4954  }
4955 
4956  if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
4957  CmdArgs.push_back("-ftemplate-backtrace-limit");
4958  CmdArgs.push_back(A->getValue());
4959  }
4960 
4961  if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
4962  CmdArgs.push_back("-fconstexpr-backtrace-limit");
4963  CmdArgs.push_back(A->getValue());
4964  }
4965 
4966  if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
4967  CmdArgs.push_back("-fspell-checking-limit");
4968  CmdArgs.push_back(A->getValue());
4969  }
4970 
4971  // Pass -fmessage-length=.
4972  CmdArgs.push_back("-fmessage-length");
4973  if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
4974  CmdArgs.push_back(A->getValue());
4975  } else {
4976  // If -fmessage-length=N was not specified, determine whether this is a
4977  // terminal and, if so, implicitly define -fmessage-length appropriately.
4978  unsigned N = llvm::sys::Process::StandardErrColumns();
4979  CmdArgs.push_back(Args.MakeArgString(Twine(N)));
4980  }
4981 
4982  // -fvisibility= and -fvisibility-ms-compat are of a piece.
4983  if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
4984  options::OPT_fvisibility_ms_compat)) {
4985  if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
4986  CmdArgs.push_back("-fvisibility");
4987  CmdArgs.push_back(A->getValue());
4988  } else {
4989  assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
4990  CmdArgs.push_back("-fvisibility");
4991  CmdArgs.push_back("hidden");
4992  CmdArgs.push_back("-ftype-visibility");
4993  CmdArgs.push_back("default");
4994  }
4995  }
4996 
4997  Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
4998  Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden);
4999 
5000  Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
5001 
5002  // Forward -f (flag) options which we can pass directly.
5003  Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
5004  Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
5005  Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs);
5006  Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
5007  Args.AddLastArg(CmdArgs, options::OPT_femulated_tls,
5008  options::OPT_fno_emulated_tls);
5009  Args.AddLastArg(CmdArgs, options::OPT_fkeep_static_consts);
5010 
5011  // AltiVec-like language extensions aren't relevant for assembling.
5012  if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm)
5013  Args.AddLastArg(CmdArgs, options::OPT_fzvector);
5014 
5015  Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
5016  Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
5017 
5018  // Forward flags for OpenMP. We don't do this if the current action is an
5019  // device offloading action other than OpenMP.
5020  if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
5021  options::OPT_fno_openmp, false) &&
5024  switch (D.getOpenMPRuntime(Args)) {
5025  case Driver::OMPRT_OMP:
5026  case Driver::OMPRT_IOMP5:
5027  // Clang can generate useful OpenMP code for these two runtime libraries.
5028  CmdArgs.push_back("-fopenmp");
5029 
5030  // If no option regarding the use of TLS in OpenMP codegeneration is
5031  // given, decide a default based on the target. Otherwise rely on the
5032  // options and pass the right information to the frontend.
5033  if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
5034  options::OPT_fnoopenmp_use_tls, /*Default=*/true))
5035  CmdArgs.push_back("-fnoopenmp-use-tls");
5036  Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
5037  options::OPT_fno_openmp_simd);
5038  Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder);
5039  Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
5040  Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ);
5041  Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ);
5042  Args.AddAllArgs(CmdArgs,
5043  options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ);
5044  if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse,
5045  options::OPT_fno_openmp_optimistic_collapse,
5046  /*Default=*/false))
5047  CmdArgs.push_back("-fopenmp-optimistic-collapse");
5048 
5049  // When in OpenMP offloading mode with NVPTX target, forward
5050  // cuda-mode flag
5051  if (Args.hasFlag(options::OPT_fopenmp_cuda_mode,
5052  options::OPT_fno_openmp_cuda_mode, /*Default=*/false))
5053  CmdArgs.push_back("-fopenmp-cuda-mode");
5054 
5055  // When in OpenMP offloading mode with NVPTX target, check if full runtime
5056  // is required.
5057  if (Args.hasFlag(options::OPT_fopenmp_cuda_force_full_runtime,
5058  options::OPT_fno_openmp_cuda_force_full_runtime,
5059  /*Default=*/false))
5060  CmdArgs.push_back("-fopenmp-cuda-force-full-runtime");
5061  break;
5062  default:
5063  // By default, if Clang doesn't know how to generate useful OpenMP code
5064  // for a specific runtime library, we just don't pass the '-fopenmp' flag
5065  // down to the actual compilation.
5066  // FIXME: It would be better to have a mode which *only* omits IR
5067  // generation based on the OpenMP support so that we get consistent
5068  // semantic analysis, etc.
5069  break;
5070  }
5071  } else {
5072  Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd,
5073  options::OPT_fno_openmp_simd);
5074  Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ);
5075  }
5076 
5077  const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
5078  Sanitize.addArgs(TC, Args, CmdArgs, InputType);
5079 
5080  const XRayArgs &XRay = TC.getXRayArgs();
5081  XRay.addArgs(TC, Args, CmdArgs, InputType);
5082 
5083  if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) {
5084  StringRef S0 = A->getValue(), S = S0;
5085  unsigned Size, Offset = 0;
5086  if (!Triple.isAArch64() && Triple.getArch() != llvm::Triple::x86 &&
5087  Triple.getArch() != llvm::Triple::x86_64)
5088  D.Diag(diag::err_drv_unsupported_opt_for_target)
5089  << A->getAsString(Args) << TripleStr;
5090  else if (S.consumeInteger(10, Size) ||
5091  (!S.empty() && (!S.consume_front(",") ||
5092  S.consumeInteger(10, Offset) || !S.empty())))
5093  D.Diag(diag::err_drv_invalid_argument_to_option)
5094  << S0 << A->getOption().getName();
5095  else if (Size < Offset)
5096  D.Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument);
5097  else {
5098  CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size)));
5099  CmdArgs.push_back(Args.MakeArgString(
5100  "-fpatchable-function-entry-offset=" + Twine(Offset)));
5101  }
5102  }
5103 
5104  if (TC.SupportsProfiling()) {
5105  Args.AddLastArg(CmdArgs, options::OPT_pg);
5106 
5107  llvm::Triple::ArchType Arch = TC.getArch();
5108  if (Arg *A = Args.getLastArg(options::OPT_mfentry)) {
5109  if (Arch == llvm::Triple::systemz || TC.getTriple().isX86())
5110  A->render(Args, CmdArgs);
5111  else
5112  D.Diag(diag::err_drv_unsupported_opt_for_target)
5113  << A->getAsString(Args) << TripleStr;
5114  }
5115  if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) {
5116  if (Arch == llvm::Triple::systemz)
5117  A->render(Args, CmdArgs);
5118  else
5119  D.Diag(diag::err_drv_unsupported_opt_for_target)
5120  << A->getAsString(Args) << TripleStr;
5121  }
5122  if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) {
5123  if (Arch == llvm::Triple::systemz)
5124  A->render(Args, CmdArgs);
5125  else
5126  D.Diag(diag::err_drv_unsupported_opt_for_target)
5127  << A->getAsString(Args) << TripleStr;
5128  }
5129  }
5130 
5131  if (Args.getLastArg(options::OPT_fapple_kext) ||
5132  (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType)))
5133  CmdArgs.push_back("-fapple-kext");
5134 
5135  Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
5136  Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
5137  Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
5138  Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
5139  Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
5140  Args.AddLastArg(CmdArgs, options::OPT_ftime_trace);
5141  Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
5142  Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
5143  Args.AddLastArg(CmdArgs, options::OPT_malign_double);
5144  Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
5145 
5146  if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
5147  CmdArgs.push_back("-ftrapv-handler");
5148  CmdArgs.push_back(A->getValue());
5149  }
5150 
5151  Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
5152 
5153  // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
5154  // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
5155  if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
5156  if (A->getOption().matches(options::OPT_fwrapv))
5157  CmdArgs.push_back("-fwrapv");
5158  } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
5159  options::OPT_fno_strict_overflow)) {
5160  if (A->getOption().matches(options::OPT_fno_strict_overflow))
5161  CmdArgs.push_back("-fwrapv");
5162  }
5163 
5164  if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
5165  options::OPT_fno_reroll_loops))
5166  if (A->getOption().matches(options::OPT_freroll_loops))
5167  CmdArgs.push_back("-freroll-loops");
5168 
5169  Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
5170  Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
5171  options::OPT_fno_unroll_loops);
5172 
5173  Args.AddLastArg(CmdArgs, options::OPT_pthread);
5174 
5175  if (Args.hasFlag(options::OPT_mspeculative_load_hardening, options::OPT_mno_speculative_load_hardening,
5176  false))
5177  CmdArgs.push_back(Args.MakeArgString("-mspeculative-load-hardening"));
5178 
5179  RenderSSPOptions(TC, Args, CmdArgs, KernelOrKext);
5180  RenderTrivialAutoVarInitOptions(D, TC, Args, CmdArgs);
5181 
5182  // Translate -mstackrealign
5183  if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
5184  false))
5185  CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
5186 
5187  if (Args.hasArg(options::OPT_mstack_alignment)) {
5188  StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
5189  CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
5190  }
5191 
5192  if (Args.hasArg(options::OPT_mstack_probe_size)) {
5193  StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
5194 
5195  if (!Size.empty())
5196  CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
5197  else
5198  CmdArgs.push_back("-mstack-probe-size=0");
5199  }
5200 
5201  if (!Args.hasFlag(options::OPT_mstack_arg_probe,
5202  options::OPT_mno_stack_arg_probe, true))
5203  CmdArgs.push_back(Args.MakeArgString("-mno-stack-arg-probe"));
5204 
5205  if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
5206  options::OPT_mno_restrict_it)) {
5207  if (A->getOption().matches(options::OPT_mrestrict_it)) {
5208  CmdArgs.push_back("-mllvm");
5209  CmdArgs.push_back("-arm-restrict-it");
5210  } else {
5211  CmdArgs.push_back("-mllvm");
5212  CmdArgs.push_back("-arm-no-restrict-it");
5213  }
5214  } else if (Triple.isOSWindows() &&
5215  (Triple.getArch() == llvm::Triple::arm ||
5216  Triple.getArch() == llvm::Triple::thumb)) {
5217  // Windows on ARM expects restricted IT blocks
5218  CmdArgs.push_back("-mllvm");
5219  CmdArgs.push_back("-arm-restrict-it");
5220  }
5221 
5222  // Forward -cl options to -cc1
5223  RenderOpenCLOptions(Args, CmdArgs);
5224 
5225  if (Args.hasFlag(options::OPT_fhip_new_launch_api,
5226  options::OPT_fno_hip_new_launch_api, false))
5227  CmdArgs.push_back("-fhip-new-launch-api");
5228 
5229  if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) {
5230  CmdArgs.push_back(
5231  Args.MakeArgString(Twine("-fcf-protection=") + A->getValue()));
5232  }
5233 
5234  // Forward -f options with positive and negative forms; we translate
5235  // these by hand.
5236  if (Arg *A = getLastProfileSampleUseArg(Args)) {
5237  auto *PGOArg = Args.getLastArg(
5238  options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ,
5239  options::OPT_fcs_profile_generate, options::OPT_fcs_profile_generate_EQ,
5240  options::OPT_fprofile_use, options::OPT_fprofile_use_EQ);
5241  if (PGOArg)
5242  D.Diag(diag::err_drv_argument_not_allowed_with)
5243  << "SampleUse with PGO options";
5244 
5245  StringRef fname = A->getValue();
5246  if (!llvm::sys::fs::exists(fname))
5247  D.Diag(diag::err_drv_no_such_file) << fname;
5248  else
5249  A->render(Args, CmdArgs);
5250  }
5251  Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ);
5252 
5253  RenderBuiltinOptions(TC, RawTriple, Args, CmdArgs);
5254 
5255  if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5256  options::OPT_fno_assume_sane_operator_new))
5257  CmdArgs.push_back("-fno-assume-sane-operator-new");
5258 
5259  // -fblocks=0 is default.
5260  if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
5261  TC.IsBlocksDefault()) ||
5262  (Args.hasArg(options::OPT_fgnu_runtime) &&
5263  Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
5264  !Args.hasArg(options::OPT_fno_blocks))) {
5265  CmdArgs.push_back("-fblocks");
5266 
5267  if (!Args.hasArg(options::OPT_fgnu_runtime) && !TC.hasBlocksRuntime())
5268  CmdArgs.push_back("-fblocks-runtime-optional");
5269  }
5270 
5271  // -fencode-extended-block-signature=1 is default.
5272  if (TC.IsEncodeExtendedBlockSignatureDefault())
5273  CmdArgs.push_back("-fencode-extended-block-signature");
5274 
5275  if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
5276  false) &&
5277  types::isCXX(InputType)) {
5278  CmdArgs.push_back("-fcoroutines-ts");
5279  }
5280 
5281  Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
5282  options::OPT_fno_double_square_bracket_attributes);
5283 
5284  // -faccess-control is default.
5285  if (Args.hasFlag(options::OPT_fno_access_control,
5286  options::OPT_faccess_control, false))
5287  CmdArgs.push_back("-fno-access-control");
5288 
5289  // -felide-constructors is the default.
5290  if (Args.hasFlag(options::OPT_fno_elide_constructors,
5291  options::OPT_felide_constructors, false))
5292  CmdArgs.push_back("-fno-elide-constructors");
5293 
5294  ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
5295 
5296  if (KernelOrKext || (types::isCXX(InputType) &&
5297  (RTTIMode == ToolChain::RM_Disabled)))
5298  CmdArgs.push_back("-fno-rtti");
5299 
5300  // -fshort-enums=0 is default for all architectures except Hexagon.
5301  if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
5302  TC.getArch() == llvm::Triple::hexagon))
5303  CmdArgs.push_back("-fshort-enums");
5304 
5305  RenderCharacterOptions(Args, AuxTriple ? *AuxTriple : RawTriple, CmdArgs);
5306 
5307  // -fuse-cxa-atexit is default.
5308  if (!Args.hasFlag(
5309  options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
5310  !RawTriple.isOSWindows() &&
5311  TC.getArch() != llvm::Triple::xcore &&
5312  ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
5313  RawTriple.hasEnvironment())) ||
5314  KernelOrKext)
5315  CmdArgs.push_back("-fno-use-cxa-atexit");
5316 
5317  if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
5318  options::OPT_fno_register_global_dtors_with_atexit,
5319  RawTriple.isOSDarwin() && !KernelOrKext))
5320  CmdArgs.push_back("-fregister-global-dtors-with-atexit");
5321 
5322  // -fms-extensions=0 is default.
5323  if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
5324  IsWindowsMSVC))
5325  CmdArgs.push_back("-fms-extensions");
5326 
5327  // -fno-use-line-directives is default.
5328  if (Args.hasFlag(options::OPT_fuse_line_directives,
5329  options::OPT_fno_use_line_directives, false))
5330  CmdArgs.push_back("-fuse-line-directives");
5331 
5332  // -fms-compatibility=0 is default.
5333  bool IsMSVCCompat = Args.hasFlag(
5334  options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
5335  (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
5336  options::OPT_fno_ms_extensions, true)));
5337  if (IsMSVCCompat)
5338  CmdArgs.push_back("-fms-compatibility");
5339 
5340  // Handle -fgcc-version, if present.
5341  VersionTuple GNUCVer;
5342  if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
5343  // Check that the version has 1 to 3 components and the minor and patch
5344  // versions fit in two decimal digits.
5345  StringRef Val = A->getValue();
5346  Val = Val.empty() ? "0" : Val; // Treat "" as 0 or disable.
5347  bool Invalid = GNUCVer.tryParse(Val);
5348  unsigned Minor = GNUCVer.getMinor().getValueOr(0);
5349  unsigned Patch = GNUCVer.getSubminor().getValueOr(0);
5350  if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
5351  D.Diag(diag::err_drv_invalid_value)
5352  << A->getAsString(Args) << A->getValue();
5353  }
5354  } else if (!IsMSVCCompat) {
5355  // Imitate GCC 4.2.1 by default if -fms-compatibility is not in effect.
5356  GNUCVer = VersionTuple(4, 2, 1);
5357  }
5358  if (!GNUCVer.empty()) {
5359  CmdArgs.push_back(
5360  Args.MakeArgString("-fgnuc-version=" + GNUCVer.getAsString()));
5361  }
5362 
5363  VersionTuple MSVT = TC.computeMSVCVersion(&D, Args);
5364  if (!MSVT.empty())
5365  CmdArgs.push_back(
5366  Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
5367 
5368  bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
5369  if (ImplyVCPPCXXVer) {
5370  StringRef LanguageStandard;
5371  if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
5372  Std = StdArg;
5373  LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
5374  .Case("c++14", "-std=c++14")
5375  .Case("c++17", "-std=c++17")
5376  .Case("c++latest", "-std=c++2a")
5377  .Default("");
5378  if (LanguageStandard.empty())
5379  D.Diag(clang::diag::warn_drv_unused_argument)
5380  << StdArg->getAsString(Args);
5381  }
5382 
5383  if (LanguageStandard.empty()) {
5384  if (IsMSVC2015Compatible)
5385  LanguageStandard = "-std=c++14";
5386  else
5387  LanguageStandard = "-std=c++11";
5388  }
5389 
5390  CmdArgs.push_back(LanguageStandard.data());
5391  }
5392 
5393  // -fno-borland-extensions is default.
5394  if (Args.hasFlag(options::OPT_fborland_extensions,
5395  options::OPT_fno_borland_extensions, false))
5396  CmdArgs.push_back("-fborland-extensions");
5397 
5398  // -fno-declspec is default, except for PS4.
5399  if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec,
5400  RawTriple.isPS4()))
5401  CmdArgs.push_back("-fdeclspec");
5402  else if (Args.hasArg(options::OPT_fno_declspec))
5403  CmdArgs.push_back("-fno-declspec"); // Explicitly disabling __declspec.
5404 
5405  // -fthreadsafe-static is default, except for MSVC compatibility versions less
5406  // than 19.
5407  if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
5408  options::OPT_fno_threadsafe_statics,
5409  !IsWindowsMSVC || IsMSVC2015Compatible))
5410  CmdArgs.push_back("-fno-threadsafe-statics");
5411 
5412  // -fno-delayed-template-parsing is default, except when targeting MSVC.
5413  // Many old Windows SDK versions require this to parse.
5414  // FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their
5415  // compiler. We should be able to disable this by default at some point.
5416  if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
5417  options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
5418  CmdArgs.push_back("-fdelayed-template-parsing");
5419 
5420  // -fgnu-keywords default varies depending on language; only pass if
5421  // specified.
5422  Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords,
5423  options::OPT_fno_gnu_keywords);
5424 
5425  if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
5426  false))
5427  CmdArgs.push_back("-fgnu89-inline");
5428 
5429  if (Args.hasArg(options::OPT_fno_inline))
5430  CmdArgs.push_back("-fno-inline");
5431 
5432  Args.AddLastArg(CmdArgs, options::OPT_finline_functions,
5433  options::OPT_finline_hint_functions,
5434  options::OPT_fno_inline_functions);
5435 
5436  // FIXME: Find a better way to determine whether the language has modules
5437  // support by default, or just assume that all languages do.
5438  bool HaveModules =
5439  Std && (Std->containsValue("c++2a") || Std->containsValue("c++latest"));
5440  RenderModulesOptions(C, D, Args, Input, Output, CmdArgs, HaveModules);
5441 
5442  if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
5443  options::OPT_fno_pch_validate_input_files_content, false))
5444  CmdArgs.push_back("-fvalidate-ast-input-files-content");
5445 
5446  Args.AddLastArg(CmdArgs, options::OPT_fexperimental_new_pass_manager,
5447  options::OPT_fno_experimental_new_pass_manager);
5448 
5449  ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
5450  RenderObjCOptions(TC, D, RawTriple, Args, Runtime, rewriteKind != RK_None,
5451  Input, CmdArgs);
5452 
5453  if (Args.hasFlag(options::OPT_fapplication_extension,
5454  options::OPT_fno_application_extension, false))
5455  CmdArgs.push_back("-fapplication-extension");
5456 
5457  // Handle GCC-style exception args.
5458  if (!C.getDriver().IsCLMode())
5459  addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs);
5460 
5461  // Handle exception personalities
5462  Arg *A = Args.getLastArg(
5463  options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
5464  options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
5465  if (A) {
5466  const Option &Opt = A->getOption();
5467  if (Opt.matches(options::OPT_fsjlj_exceptions))
5468  CmdArgs.push_back("-fsjlj-exceptions");
5469  if (Opt.matches(options::OPT_fseh_exceptions))
5470  CmdArgs.push_back("-fseh-exceptions");
5471  if (Opt.matches(options::OPT_fdwarf_exceptions))
5472  CmdArgs.push_back("-fdwarf-exceptions");
5473  if (Opt.matches(options::OPT_fwasm_exceptions))
5474  CmdArgs.push_back("-fwasm-exceptions");
5475  } else {
5476  switch (TC.GetExceptionModel(Args)) {
5477  default:
5478  break;
5479  case llvm::ExceptionHandling::DwarfCFI:
5480  CmdArgs.push_back("-fdwarf-exceptions");
5481  break;
5482  case llvm::ExceptionHandling::SjLj:
5483  CmdArgs.push_back("-fsjlj-exceptions");
5484  break;
5485  case llvm::ExceptionHandling::WinEH:
5486  CmdArgs.push_back("-fseh-exceptions");
5487  break;
5488  }
5489  }
5490 
5491  // C++ "sane" operator new.
5492  if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
5493  options::OPT_fno_assume_sane_operator_new))
5494  CmdArgs.push_back("-fno-assume-sane-operator-new");
5495 
5496  // -frelaxed-template-template-args is off by default, as it is a severe
5497  // breaking change until a corresponding change to template partial ordering
5498  // is provided.
5499  if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
5500  options::OPT_fno_relaxed_template_template_args, false))
5501  CmdArgs.push_back("-frelaxed-template-template-args");
5502 
5503  // -fsized-deallocation is off by default, as it is an ABI-breaking change for
5504  // most platforms.
5505  if (Args.hasFlag(options::OPT_fsized_deallocation,
5506  options::OPT_fno_sized_deallocation, false))
5507  CmdArgs.push_back("-fsized-deallocation");
5508 
5509  // -faligned-allocation is on by default in C++17 onwards and otherwise off
5510  // by default.
5511  if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation,
5512  options::OPT_fno_aligned_allocation,
5513  options::OPT_faligned_new_EQ)) {
5514  if (A->getOption().matches(options::OPT_fno_aligned_allocation))
5515  CmdArgs.push_back("-fno-aligned-allocation");
5516  else
5517  CmdArgs.push_back("-faligned-allocation");
5518  }
5519 
5520  // The default new alignment can be specified using a dedicated option or via
5521  // a GCC-compatible option that also turns on aligned allocation.
5522  if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ,
5523  options::OPT_faligned_new_EQ))
5524  CmdArgs.push_back(
5525  Args.MakeArgString(Twine("-fnew-alignment=") + A->getValue()));
5526 
5527  // -fconstant-cfstrings is default, and may be subject to argument translation
5528  // on Darwin.
5529  if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
5530  options::OPT_fno_constant_cfstrings) ||
5531  !Args.hasFlag(options::OPT_mconstant_cfstrings,
5532  options::OPT_mno_constant_cfstrings))
5533  CmdArgs.push_back("-fno-constant-cfstrings");
5534 
5535  // -fno-pascal-strings is default, only pass non-default.
5536  if (Args.hasFlag(options::OPT_fpascal_strings,
5537  options::OPT_fno_pascal_strings, false))
5538  CmdArgs.push_back("-fpascal-strings");
5539 
5540  // Honor -fpack-struct= and -fpack-struct, if given. Note that
5541  // -fno-pack-struct doesn't apply to -fpack-struct=.
5542  if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
5543  std::string PackStructStr = "-fpack-struct=";
5544  PackStructStr += A->getValue();
5545  CmdArgs.push_back(Args.MakeArgString(PackStructStr));
5546  } else if (Args.hasFlag(options::OPT_fpack_struct,
5547  options::OPT_fno_pack_struct, false)) {
5548  CmdArgs.push_back("-fpack-struct=1");
5549  }
5550 
5551  // Handle -fmax-type-align=N and -fno-type-align
5552  bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
5553  if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
5554  if (!SkipMaxTypeAlign) {
5555  std::string MaxTypeAlignStr = "-fmax-type-align=";
5556  MaxTypeAlignStr += A->getValue();
5557  CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5558  }
5559  } else if (RawTriple.isOSDarwin()) {
5560  if (!SkipMaxTypeAlign) {
5561  std::string MaxTypeAlignStr = "-fmax-type-align=16";
5562  CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
5563  }
5564  }
5565 
5566  if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn, true))
5567  CmdArgs.push_back("-Qn");
5568 
5569  // -fcommon is the default unless compiling kernel code or the target says so
5570  bool NoCommonDefault = KernelOrKext || isNoCommonDefault(RawTriple);
5571  if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common,
5572  !NoCommonDefault))
5573  CmdArgs.push_back("-fno-common");
5574 
5575  // -fsigned-bitfields is default, and clang doesn't yet support
5576  // -funsigned-bitfields.
5577  if (!Args.hasFlag(options::OPT_fsigned_bitfields,
5578  options::OPT_funsigned_bitfields))
5579  D.Diag(diag::warn_drv_clang_unsupported)
5580  << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
5581 
5582  // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
5583  if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
5584  D.Diag(diag::err_drv_clang_unsupported)
5585  << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
5586 
5587  // -finput_charset=UTF-8 is default. Reject others
5588  if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
5589  StringRef value = inputCharset->getValue();
5590  if (!value.equals_lower("utf-8"))
5591  D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
5592  << value;
5593  }
5594 
5595  // -fexec_charset=UTF-8 is default. Reject others
5596  if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
5597  StringRef value = execCharset->getValue();
5598  if (!value.equals_lower("utf-8"))
5599  D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
5600  << value;
5601  }
5602 
5603  RenderDiagnosticsOptions(D, Args, CmdArgs);
5604 
5605  // -fno-asm-blocks is default.
5606  if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
5607  false))
5608  CmdArgs.push_back("-fasm-blocks");
5609 
5610  // -fgnu-inline-asm is default.
5611  if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
5612  options::OPT_fno_gnu_inline_asm, true))
5613  CmdArgs.push_back("-fno-gnu-inline-asm");
5614 
5615  // Enable vectorization per default according to the optimization level
5616  // selected. For optimization levels that want vectorization we use the alias
5617  // option to simplify the hasFlag logic.
5618  bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
5619  OptSpecifier VectorizeAliasOption =
5620  EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
5621  if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
5622  options::OPT_fno_vectorize, EnableVec))
5623  CmdArgs.push_back("-vectorize-loops");
5624 
5625  // -fslp-vectorize is enabled based on the optimization level selected.
5626  bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
5627  OptSpecifier SLPVectAliasOption =
5628  EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
5629  if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
5630  options::OPT_fno_slp_vectorize, EnableSLPVec))
5631  CmdArgs.push_back("-vectorize-slp");
5632 
5633  ParseMPreferVectorWidth(D, Args, CmdArgs);
5634 
5635  Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ);
5636  Args.AddLastArg(CmdArgs,
5637  options::OPT_fsanitize_undefined_strip_path_components_EQ);
5638 
5639  // -fdollars-in-identifiers default varies depending on platform and
5640  // language; only pass if specified.
5641  if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
5642  options::OPT_fno_dollars_in_identifiers)) {
5643  if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
5644  CmdArgs.push_back("-fdollars-in-identifiers");
5645  else
5646  CmdArgs.push_back("-fno-dollars-in-identifiers");
5647  }
5648 
5649  // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
5650  // practical purposes.
5651  if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
5652  options::OPT_fno_unit_at_a_time)) {
5653  if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
5654  D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
5655  }
5656 
5657  if (Args.hasFlag(options::OPT_fapple_pragma_pack,
5658  options::OPT_fno_apple_pragma_pack, false))
5659  CmdArgs.push_back("-fapple-pragma-pack");
5660 
5661  // Remarks can be enabled with any of the `-f.*optimization-record.*` flags.
5662  if (willEmitRemarks(Args) && checkRemarksOptions(D, Args, Triple))
5663  renderRemarksOptions(Args, CmdArgs, Triple, Input, Output, JA);
5664 
5665  bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports,
5666  options::OPT_fno_rewrite_imports, false);
5667  if (RewriteImports)
5668  CmdArgs.push_back("-frewrite-imports");
5669 
5670  // Enable rewrite includes if the user's asked for it or if we're generating
5671  // diagnostics.
5672  // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
5673  // nice to enable this when doing a crashdump for modules as well.
5674  if (Args.hasFlag(options::OPT_frewrite_includes,
5675  options::OPT_fno_rewrite_includes, false) ||
5676  (C.isForDiagnostics() && !HaveModules))
5677  CmdArgs.push_back("-frewrite-includes");
5678 
5679  // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
5680  if (Arg *A = Args.getLastArg(options::OPT_traditional,
5681  options::OPT_traditional_cpp)) {
5682  if (isa<PreprocessJobAction>(JA))
5683  CmdArgs.push_back("-traditional-cpp");
5684  else
5685  D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
5686  }
5687 
5688  Args.AddLastArg(CmdArgs, options::OPT_dM);
5689  Args.AddLastArg(CmdArgs, options::OPT_dD);
5690 
5691  // Handle serialized diagnostics.
5692  if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
5693  CmdArgs.push_back("-serialize-diagnostic-file");
5694  CmdArgs.push_back(Args.MakeArgString(A->getValue()));
5695  }
5696 
5697  if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
5698  CmdArgs.push_back("-fretain-comments-from-system-headers");
5699 
5700  // Forward -fcomment-block-commands to -cc1.
5701  Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
5702  // Forward -fparse-all-comments to -cc1.
5703  Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
5704 
5705  // Turn -fplugin=name.so into -load name.so
5706  for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) {
5707  CmdArgs.push_back("-load");
5708  CmdArgs.push_back(A->getValue());
5709  A->claim();
5710  }
5711 
5712  // Forward -fpass-plugin=name.so to -cc1.
5713  for (const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) {
5714  CmdArgs.push_back(
5715  Args.MakeArgString(Twine("-fpass-plugin=") + A->getValue()));
5716  A->claim();
5717  }
5718 
5719  // Setup statistics file output.
5720  SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D);
5721  if (!StatsFile.empty())
5722  CmdArgs.push_back(Args.MakeArgString(Twine("-stats-file=") + StatsFile));
5723 
5724  // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
5725  // parser.
5726  // -finclude-default-header flag is for preprocessor,
5727  // do not pass it to other cc1 commands when save-temps is enabled
5728  if (C.getDriver().isSaveTempsEnabled() &&
5729  !isa<PreprocessJobAction>(JA)) {
5730  for (auto Arg : Args.filtered(options::OPT_Xclang)) {
5731  Arg->claim();
5732  if (StringRef(Arg->getValue()) != "-finclude-default-header")
5733  CmdArgs.push_back(Arg->getValue());
5734  }
5735  }
5736  else {
5737  Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
5738  }
5739  for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
5740  A->claim();
5741 
5742  // We translate this by hand to the -cc1 argument, since nightly test uses
5743  // it and developers have been trained to spell it with -mllvm. Both
5744  // spellings are now deprecated and should be removed.
5745  if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
5746  CmdArgs.push_back("-disable-llvm-optzns");
5747  } else {
5748  A->render(Args, CmdArgs);
5749  }
5750  }
5751 
5752  // With -save-temps, we want to save the unoptimized bitcode output from the
5753  // CompileJobAction, use -disable-llvm-passes to get pristine IR generated
5754  // by the frontend.
5755  // When -fembed-bitcode is enabled, optimized bitcode is emitted because it
5756  // has slightly different breakdown between stages.
5757  // FIXME: -fembed-bitcode -save-temps will save optimized bitcode instead of
5758  // pristine IR generated by the frontend. Ideally, a new compile action should
5759  // be added so both IR can be captured.
5760  if (C.getDriver().isSaveTempsEnabled() &&
5761  !(C.getDriver().embedBitcodeInObject() && !C.getDriver().isUsingLTO()) &&
5762  isa<CompileJobAction>(JA))
5763  CmdArgs.push_back("-disable-llvm-passes");
5764 
5765  Args.AddAllArgs(CmdArgs, options::OPT_undef);
5766 
5767  const char *Exec = D.getClangProgramPath();
5768 
5769  // Optionally embed the -cc1 level arguments into the debug info or a
5770  // section, for build analysis.
5771  // Also record command line arguments into the debug info if
5772  // -grecord-gcc-switches options is set on.
5773  // By default, -gno-record-gcc-switches is set on and no recording.
5774  auto GRecordSwitches =
5775  Args.hasFlag(options::OPT_grecord_command_line,
5776  options::OPT_gno_record_command_line, false);
5777  auto FRecordSwitches =
5778  Args.hasFlag(options::OPT_frecord_command_line,
5779  options::OPT_fno_record_command_line, false);
5780  if (FRecordSwitches && !Triple.isOSBinFormatELF())
5781  D.Diag(diag::err_drv_unsupported_opt_for_target)
5782  << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
5783  << TripleStr;
5784  if (TC.UseDwarfDebugFlags() || GRecordSwitches || FRecordSwitches) {
5785  ArgStringList OriginalArgs;
5786  for (const auto &Arg : Args)
5787  Arg->render(Args, OriginalArgs);
5788 
5789  SmallString<256> Flags;
5790  Flags += Exec;
5791  for (const char *OriginalArg : OriginalArgs) {
5792  SmallString<128> EscapedArg;
5793  EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
5794  Flags += " ";
5795  Flags += EscapedArg;
5796  }
5797  auto FlagsArgString = Args.MakeArgString(Flags);
5798  if (TC.UseDwarfDebugFlags() || GRecordSwitches) {
5799  CmdArgs.push_back("-dwarf-debug-flags");
5800  CmdArgs.push_back(FlagsArgString);
5801  }
5802  if (FRecordSwitches) {
5803  CmdArgs.push_back("-record-command-line");
5804  CmdArgs.push_back(FlagsArgString);
5805  }
5806  }
5807 
5808  // Host-side cuda compilation receives all device-side outputs in a single
5809  // fatbin as Inputs[1]. Include the binary with -fcuda-include-gpubinary.
5810  if ((IsCuda || IsHIP) && CudaDeviceInput) {
5811  CmdArgs.push_back("-fcuda-include-gpubinary");
5812  CmdArgs.push_back(CudaDeviceInput->getFilename());
5813  if (Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc, false))
5814  CmdArgs.push_back("-fgpu-rdc");
5815  }
5816 
5817  if (IsCuda) {
5818  if (Args.hasFlag(options::OPT_fcuda_short_ptr,
5819  options::OPT_fno_cuda_short_ptr, false))
5820  CmdArgs.push_back("-fcuda-short-ptr");
5821  }
5822 
5823  if (IsHIP)
5824  CmdArgs.push_back("-fcuda-allow-variadic-functions");
5825 
5826  // OpenMP offloading device jobs take the argument -fopenmp-host-ir-file-path
5827  // to specify the result of the compile phase on the host, so the meaningful
5828  // device declarations can be identified. Also, -fopenmp-is-device is passed
5829  // along to tell the frontend that it is generating code for a device, so that
5830  // only the relevant declarations are emitted.
5831  if (IsOpenMPDevice) {
5832  CmdArgs.push_back("-fopenmp-is-device");
5833  if (OpenMPDeviceInput) {
5834  CmdArgs.push_back("-fopenmp-host-ir-file-path");
5835  CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->getFilename()));
5836  }
5837  }
5838 
5839  // For all the host OpenMP offloading compile jobs we need to pass the targets
5840  // information using -fopenmp-targets= option.
5842  SmallString<128> TargetInfo("-fopenmp-targets=");
5843 
5844  Arg *Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ);
5845  assert(Tgts && Tgts->getNumValues() &&
5846  "OpenMP offloading has to have targets specified.");
5847  for (unsigned i = 0; i < Tgts->getNumValues(); ++i) {
5848  if (i)
5849  TargetInfo += ',';
5850  // We need to get the string from the triple because it may be not exactly
5851  // the same as the one we get directly from the arguments.
5852  llvm::Triple T(Tgts->getValue(i));
5853  TargetInfo += T.getTriple();
5854  }
5855  CmdArgs.push_back(Args.MakeArgString(TargetInfo.str()));
5856  }
5857 
5858  bool VirtualFunctionElimination =
5859  Args.hasFlag(options::OPT_fvirtual_function_elimination,
5860  options::OPT_fno_virtual_function_elimination, false);
5861  if (VirtualFunctionElimination) {
5862  // VFE requires full LTO (currently, this might be relaxed to allow ThinLTO
5863  // in the future).
5864  if (D.getLTOMode() != LTOK_Full)
5865  D.Diag(diag::err_drv_argument_only_allowed_with)
5866  << "-fvirtual-function-elimination"
5867  << "-flto=full";
5868 
5869  CmdArgs.push_back("-fvirtual-function-elimination");
5870  }
5871 
5872  // VFE requires whole-program-vtables, and enables it by default.
5873  bool WholeProgramVTables = Args.hasFlag(
5874  options::OPT_fwhole_program_vtables,
5875  options::OPT_fno_whole_program_vtables, VirtualFunctionElimination);
5876  if (VirtualFunctionElimination && !WholeProgramVTables) {
5877  D.Diag(diag::err_drv_argument_not_allowed_with)
5878  << "-fno-whole-program-vtables"
5879  << "-fvirtual-function-elimination";
5880  }
5881 
5882  if (WholeProgramVTables) {
5883  if (!D.isUsingLTO())
5884  D.Diag(diag::err_drv_argument_only_allowed_with)
5885  << "-fwhole-program-vtables"
5886  << "-flto";
5887  CmdArgs.push_back("-fwhole-program-vtables");
5888  }
5889 
5890  bool DefaultsSplitLTOUnit =
5891  (WholeProgramVTables || Sanitize.needsLTO()) &&
5892  (D.getLTOMode() == LTOK_Full || TC.canSplitThinLTOUnit());
5893  bool SplitLTOUnit =
5894  Args.hasFlag(options::OPT_fsplit_lto_unit,
5895  options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit);
5896  if (Sanitize.needsLTO() && !SplitLTOUnit)
5897  D.Diag(diag::err_drv_argument_not_allowed_with) << "-fno-split-lto-unit"
5898  << "-fsanitize=cfi";
5899  if (SplitLTOUnit)
5900  CmdArgs.push_back("-fsplit-lto-unit");
5901 
5902  if (Arg *A = Args.getLastArg(options::OPT_fexperimental_isel,
5903  options::OPT_fno_experimental_isel)) {
5904  CmdArgs.push_back("-mllvm");
5905  if (A->getOption().matches(options::OPT_fexperimental_isel)) {
5906  CmdArgs.push_back("-global-isel=1");
5907 
5908  // GISel is on by default on AArch64 -O0, so don't bother adding
5909  // the fallback remarks for it. Other combinations will add a warning of
5910  // some kind.
5911  bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64;
5912  bool IsOptLevelSupported = false;
5913 
5914  Arg *A = Args.getLastArg(options::OPT_O_Group);
5915  if (Triple.getArch() == llvm::Triple::aarch64) {
5916  if (!A || A->getOption().matches(options::OPT_O0))
5917  IsOptLevelSupported = true;
5918  }
5919  if (!IsArchSupported || !IsOptLevelSupported) {
5920  CmdArgs.push_back("-mllvm");
5921  CmdArgs.push_back("-global-isel-abort=2");
5922 
5923  if (!IsArchSupported)
5924  D.Diag(diag::warn_drv_experimental_isel_incomplete) << Triple.getArchName();
5925  else
5926  D.Diag(diag::warn_drv_experimental_isel_incomplete_opt);
5927  }
5928  } else {
5929  CmdArgs.push_back("-global-isel=0");
5930  }
5931  }
5932 
5933  if (Args.hasArg(options::OPT_forder_file_instrumentation)) {
5934  CmdArgs.push_back("-forder-file-instrumentation");
5935  // Enable order file instrumentation when ThinLTO is not on. When ThinLTO is
5936  // on, we need to pass these flags as linker flags and that will be handled
5937  // outside of the compiler.
5938  if (!D.isUsingLTO()) {
5939  CmdArgs.push_back("-mllvm");
5940  CmdArgs.push_back("-enable-order-file-instrumentation");
5941  }
5942  }
5943 
5944  if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128,
5945  options::OPT_fno_force_enable_int128)) {
5946  if (A->getOption().matches(options::OPT_fforce_enable_int128))
5947  CmdArgs.push_back("-fforce-enable-int128");
5948  }
5949 
5950  if (Args.hasFlag(options::OPT_fcomplete_member_pointers,
5951  options::OPT_fno_complete_member_pointers, false))
5952  CmdArgs.push_back("-fcomplete-member-pointers");
5953 
5954  if (!Args.hasFlag(options::OPT_fcxx_static_destructors,
5955  options::OPT_fno_cxx_static_destructors, true))
5956  CmdArgs.push_back("-fno-c++-static-destructors");
5957 
5958  if (Arg *A = Args.getLastArg(options::OPT_moutline,
5959  options::OPT_mno_outline)) {
5960  if (A->getOption().matches(options::OPT_moutline)) {
5961  // We only support -moutline in AArch64 right now. If we're not compiling
5962  // for AArch64, emit a warning and ignore the flag. Otherwise, add the
5963  // proper mllvm flags.
5964  if (Triple.getArch() != llvm::Triple::aarch64 &&
5965  Triple.getArch() != llvm::Triple::aarch64_32) {
5966  D.Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();
5967  } else {
5968  CmdArgs.push_back("-mllvm");
5969  CmdArgs.push_back("-enable-machine-outliner");
5970  }
5971  } else {
5972  // Disable all outlining behaviour.
5973  CmdArgs.push_back("-mllvm");
5974  CmdArgs.push_back("-enable-machine-outliner=never");
5975  }
5976  }
5977 
5978  if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
5979  (TC.getTriple().isOSBinFormatELF() ||
5980  TC.getTriple().isOSBinFormatCOFF()) &&
5981  !TC.getTriple().isPS4() &&
5982  !TC.getTriple().isOSNetBSD() &&
5983  !Distro(D.getVFS(), TC.getTriple()).IsGentoo() &&
5984  !TC.getTriple().isAndroid() &&
5985  TC.useIntegratedAs()))
5986  CmdArgs.push_back("-faddrsig");
5987 
5988  if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
5989  std::string Str = A->getAsString(Args);
5990  if (!TC.getTriple().isOSBinFormatELF())
5991  D.Diag(diag::err_drv_unsupported_opt_for_target)
5992  << Str << TC.getTripleString();
5993  CmdArgs.push_back(Args.MakeArgString(Str));
5994  }
5995 
5996  // Add the "-o out -x type src.c" flags last. This is done primarily to make
5997  // the -cc1 command easier to edit when reproducing compiler crashes.
5998  if (Output.getType() == types::TY_Dependencies) {
5999  // Handled with other dependency code.
6000  } else if (Output.isFilename()) {
6001  if (Output.getType() == clang::driver::types::TY_IFS_CPP ||
6002  Output.getType() == clang::driver::types::TY_IFS) {
6003  SmallString<128> OutputFilename(Output.getFilename());
6004  llvm::sys::path::replace_extension(OutputFilename, "ifs");
6005  CmdArgs.push_back("-o");
6006  CmdArgs.push_back(Args.MakeArgString(OutputFilename));
6007  } else {
6008  CmdArgs.push_back("-o");
6009  CmdArgs.push_back(Output.getFilename());
6010  }
6011  } else {
6012  assert(Output.isNothing() && "Invalid output.");
6013  }
6014 
6015  addDashXForInput(Args, Input, CmdArgs);
6016 
6017  ArrayRef<InputInfo> FrontendInputs = Input;
6018  if (IsHeaderModulePrecompile)
6019  FrontendInputs = ModuleHeaderInputs;
6020  else if (Input.isNothing())
6021  FrontendInputs = {};
6022 
6023  for (const InputInfo &Input : FrontendInputs) {
6024  if (Input.isFilename())
6025  CmdArgs.push_back(Input.getFilename());
6026  else
6027  Input.getInputArg().renderAsInput(Args, CmdArgs);
6028  }
6029 
6030  // Finally add the compile command to the compilation.
6031  if (Args.hasArg(options::OPT__SLASH_fallback) &&
6032  Output.getType() == types::TY_Object &&
6033  (InputType == types::TY_C || InputType == types::TY_CXX)) {
6034  auto CLCommand =
6035  getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
6036  C.addCommand(std::make_unique<FallbackCommand>(
6037  JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand)));
6038  } else if (Args.hasArg(options::OPT__SLASH_fallback) &&
6039  isa<PrecompileJobAction>(JA)) {
6040  // In /fallback builds, run the main compilation even if the pch generation
6041  // fails, so that the main compilation's fallback to cl.exe runs.
6042  C.addCommand(std::make_unique<ForceSuccessCommand>(JA, *this, Exec,
6043  CmdArgs, Inputs));
6044  } else if (D.CC1Main && !D.CCGenDiagnostics) {
6045  // Invoke the CC1 directly in this process
6046  C.addCommand(
6047  std::make_unique<CC1Command>(JA, *this, Exec, CmdArgs, Inputs));
6048  } else {
6049  C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
6050  }
6051 
6052  // Make the compile command echo its inputs for /showFilenames.
6053  if (Output.getType() == types::TY_Object &&
6054  Args.hasFlag(options::OPT__SLASH_showFilenames,
6055  options::OPT__SLASH_showFilenames_, false)) {
6056  C.getJobs().getJobs().back()->PrintInputFilenames = true;
6057  }
6058 
6059  if (Arg *A = Args.getLastArg(options::OPT_pg))
6060  if (FPKeepKind == CodeGenOptions::FramePointerKind::None)
6061  D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer"
6062  << A->getAsString(Args);
6063 
6064  // Claim some arguments which clang supports automatically.
6065 
6066  // -fpch-preprocess is used with gcc to add a special marker in the output to
6067  // include the PCH file.
6068  Args.ClaimAllArgs(options::OPT_fpch_preprocess);
6069 
6070  // Claim some arguments which clang doesn't support, but we don't
6071  // care to warn the user about.
6072  Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
6073  Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
6074 
6075  // Disable warnings for clang -E -emit-llvm foo.c
6076  Args.ClaimAllArgs(options::OPT_emit_llvm);
6077 }
6078 
6080  // CAUTION! The first constructor argument ("clang") is not arbitrary,
6081  // as it is for other tools. Some operations on a Tool actually test
6082  // whether that tool is Clang based on the Tool's Name as a string.
6083  : Tool("clang", "clang frontend", TC, RF_Full) {}
6084 
6086 
6087 /// Add options related to the Objective-C runtime/ABI.
6088 ///
6089 /// Returns true if the runtime is non-fragile.
6090 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
6091  ArgStringList &cmdArgs,
6092  RewriteKind rewriteKind) const {
6093  // Look for the controlling runtime option.
6094  Arg *runtimeArg =
6095  args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
6096  options::OPT_fobjc_runtime_EQ);
6097 
6098  // Just forward -fobjc-runtime= to the frontend. This supercedes
6099  // options about fragility.
6100  if (runtimeArg &&
6101  runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
6102  ObjCRuntime runtime;
6103  StringRef value = runtimeArg->getValue();
6104  if (runtime.tryParse(value)) {
6105  getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
6106  << value;
6107  }
6108  if ((runtime.getKind() == ObjCRuntime::GNUstep) &&
6109  (runtime.getVersion() >= VersionTuple(2, 0)))
6110  if (!getToolChain().getTriple().isOSBinFormatELF() &&
6111  !getToolChain().getTriple().isOSBinFormatCOFF()) {
6113  diag::err_drv_gnustep_objc_runtime_incompatible_binary)
6114  << runtime.getVersion().getMajor();
6115  }
6116 
6117  runtimeArg->render(args, cmdArgs);
6118  return runtime;
6119  }
6120 
6121  // Otherwise, we'll need the ABI "version". Version numbers are
6122  // slightly confusing for historical reasons:
6123  // 1 - Traditional "fragile" ABI
6124  // 2 - Non-fragile ABI, version 1
6125  // 3 - Non-fragile ABI, version 2
6126  unsigned objcABIVersion = 1;
6127  // If -fobjc-abi-version= is present, use that to set the version.
6128  if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
6129  StringRef value = abiArg->getValue();
6130  if (value == "1")
6131  objcABIVersion = 1;
6132  else if (value == "2")
6133  objcABIVersion = 2;
6134  else if (value == "3")
6135  objcABIVersion = 3;
6136  else
6137  getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
6138  } else {
6139  // Otherwise, determine if we are using the non-fragile ABI.
6140  bool nonFragileABIIsDefault =
6141  (rewriteKind == RK_NonFragile ||
6142  (rewriteKind == RK_None &&
6144  if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
6145  options::OPT_fno_objc_nonfragile_abi,
6146  nonFragileABIIsDefault)) {
6147 // Determine the non-fragile ABI version to use.
6148 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
6149  unsigned nonFragileABIVersion = 1;
6150 #else
6151  unsigned nonFragileABIVersion = 2;
6152 #endif
6153 
6154  if (Arg *abiArg =
6155  args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
6156  StringRef value = abiArg->getValue();
6157  if (value == "1")
6158  nonFragileABIVersion = 1;
6159  else if (value == "2")
6160  nonFragileABIVersion = 2;
6161  else
6162  getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
6163  << value;
6164  }
6165 
6166  objcABIVersion = 1 + nonFragileABIVersion;
6167  } else {
6168  objcABIVersion = 1;
6169  }
6170  }
6171 
6172  // We don't actually care about the ABI version other than whether
6173  // it's non-fragile.
6174  bool isNonFragile = objcABIVersion != 1;
6175 
6176  // If we have no runtime argument, ask the toolchain for its default runtime.
6177  // However, the rewriter only really supports the Mac runtime, so assume that.
6178  ObjCRuntime runtime;
6179  if (!runtimeArg) {
6180  switch (rewriteKind) {
6181  case RK_None:
6182  runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
6183  break;
6184  case RK_Fragile:
6185  runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
6186  break;
6187  case RK_NonFragile:
6188  runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
6189  break;
6190  }
6191 
6192  // -fnext-runtime
6193  } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
6194  // On Darwin, make this use the default behavior for the toolchain.
6195  if (getToolChain().getTriple().isOSDarwin()) {
6196  runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
6197 
6198  // Otherwise, build for a generic macosx port.
6199  } else {
6200  runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
6201  }
6202 
6203  // -fgnu-runtime
6204  } else {
6205  assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
6206  // Legacy behaviour is to target the gnustep runtime if we are in
6207  // non-fragile mode or the GCC runtime in fragile mode.
6208  if (isNonFragile)
6209  runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(2, 0));
6210  else
6211  runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
6212  }
6213 
6214  cmdArgs.push_back(
6215  args.MakeArgString("-fobjc-runtime=" + runtime.getAsString()));
6216  return runtime;
6217 }
6218 
6219 static bool maybeConsumeDash(const std::string &EH, size_t &I) {
6220  bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
6221  I += HaveDash;
6222  return !HaveDash;
6223 }
6224 
6225 namespace {
6226 struct EHFlags {
6227  bool Synch = false;
6228  bool Asynch = false;
6229  bool NoUnwindC = false;
6230 };
6231 } // end anonymous namespace
6232 
6233 /// /EH controls whether to run destructor cleanups when exceptions are
6234 /// thrown. There are three modifiers:
6235 /// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
6236 /// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
6237 /// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
6238 /// - c: Assume that extern "C" functions are implicitly nounwind.
6239 /// The default is /EHs-c-, meaning cleanups are disabled.
6240 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
6241  EHFlags EH;
6242 
6243  std::vector<std::string> EHArgs =
6244  Args.getAllArgValues(options::OPT__SLASH_EH);
6245  for (auto EHVal : EHArgs) {
6246  for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
6247  switch (EHVal[I]) {
6248  case 'a':
6249  EH.Asynch = maybeConsumeDash(EHVal, I);
6250  if (EH.Asynch)
6251  EH.Synch = false;
6252  continue;
6253  case 'c':
6254  EH.NoUnwindC = maybeConsumeDash(EHVal, I);
6255  continue;
6256  case 's':
6257  EH.Synch = maybeConsumeDash(EHVal, I);
6258  if (EH.Synch)
6259  EH.Asynch = false;
6260  continue;
6261  default:
6262  break;
6263  }
6264  D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
6265  break;
6266  }
6267  }
6268  // The /GX, /GX- flags are only processed if there are not /EH flags.
6269  // The default is that /GX is not specified.
6270  if (EHArgs.empty() &&
6271  Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
6272  /*Default=*/false)) {
6273  EH.Synch = true;
6274  EH.NoUnwindC = true;
6275  }
6276 
6277  return EH;
6278 }
6279 
6280 void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType,
6281  ArgStringList &CmdArgs,
6283  bool *EmitCodeView) const {
6284  unsigned RTOptionID = options::OPT__SLASH_MT;
6285 
6286  if (Args.hasArg(options::OPT__SLASH_LDd))
6287  // The /LDd option implies /MTd. The dependent lib part can be overridden,
6288  // but defining _DEBUG is sticky.
6289  RTOptionID = options::OPT__SLASH_MTd;
6290 
6291  if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
6292  RTOptionID = A->getOption().getID();
6293 
6294  StringRef FlagForCRT;
6295  switch (RTOptionID) {
6296  case options::OPT__SLASH_MD:
6297  if (Args.hasArg(options::OPT__SLASH_LDd))
6298  CmdArgs.push_back("-D_DEBUG");
6299  CmdArgs.push_back("-D_MT");
6300  CmdArgs.push_back("-D_DLL");
6301  FlagForCRT = "--dependent-lib=msvcrt";
6302  break;
6303  case options::OPT__SLASH_MDd:
6304  CmdArgs.push_back("-D_DEBUG");
6305  CmdArgs.push_back("-D_MT");
6306  CmdArgs.push_back("-D_DLL");
6307  FlagForCRT = "--dependent-lib=msvcrtd";
6308  break;
6309  case options::OPT__SLASH_MT:
6310  if (Args.hasArg(options::OPT__SLASH_LDd))
6311  CmdArgs.push_back("-D_DEBUG");
6312  CmdArgs.push_back("-D_MT");
6313  CmdArgs.push_back("-flto-visibility-public-std");
6314  FlagForCRT = "--dependent-lib=libcmt";
6315  break;
6316  case options::OPT__SLASH_MTd:
6317  CmdArgs.push_back("-D_DEBUG");
6318  CmdArgs.push_back("-D_MT");
6319  CmdArgs.push_back("-flto-visibility-public-std");
6320  FlagForCRT = "--dependent-lib=libcmtd";
6321  break;
6322  default:
6323  llvm_unreachable("Unexpected option ID.");
6324  }
6325 
6326  if (Args.hasArg(options::OPT__SLASH_Zl)) {
6327  CmdArgs.push_back("-D_VC_NODEFAULTLIB");
6328  } else {
6329  CmdArgs.push_back(FlagForCRT.data());
6330 
6331  // This provides POSIX compatibility (maps 'open' to '_open'), which most
6332  // users want. The /Za flag to cl.exe turns this off, but it's not
6333  // implemented in clang.
6334  CmdArgs.push_back("--dependent-lib=oldnames");
6335  }
6336 
6337  Args.AddLastArg(CmdArgs, options::OPT_show_includes);
6338 
6339  // This controls whether or not we emit RTTI data for polymorphic types.
6340  if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
6341  /*Default=*/false))
6342  CmdArgs.push_back("-fno-rtti-data");
6343 
6344  // This controls whether or not we emit stack-protector instrumentation.
6345  // In MSVC, Buffer Security Check (/GS) is on by default.
6346  if (Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_,
6347  /*Default=*/true)) {
6348  CmdArgs.push_back("-stack-protector");
6349  CmdArgs.push_back(Args.MakeArgString(Twine(LangOptions::SSPStrong)));
6350  }
6351 
6352  // Emit CodeView if -Z7, -Zd, or -gline-tables-only are present.
6353  if (Arg *DebugInfoArg =
6354  Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd,
6355  options::OPT_gline_tables_only)) {
6356  *EmitCodeView = true;
6357  if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7))
6358  *DebugInfoKind = codegenoptions::LimitedDebugInfo;
6359  else
6360  *DebugInfoKind = codegenoptions::DebugLineTablesOnly;
6361  } else {
6362  *EmitCodeView = false;
6363  }
6364 
6365  const Driver &D = getToolChain().getDriver();
6366  EHFlags EH = parseClangCLEHFlags(D, Args);
6367  if (EH.Synch || EH.Asynch) {
6368  if (types::isCXX(InputType))
6369  CmdArgs.push_back("-fcxx-exceptions");
6370  CmdArgs.push_back("-fexceptions");
6371  }
6372  if (types::isCXX(InputType) && EH.Synch && EH.NoUnwindC)
6373  CmdArgs.push_back("-fexternc-nounwind");
6374 
6375  // /EP should expand to -E -P.
6376  if (Args.hasArg(options::OPT__SLASH_EP)) {
6377  CmdArgs.push_back("-E");
6378  CmdArgs.push_back("-P");
6379  }
6380 
6381  unsigned VolatileOptionID;
6382  if (getToolChain().getTriple().isX86())
6383  VolatileOptionID = options::OPT__SLASH_volatile_ms;
6384  else
6385  VolatileOptionID = options::OPT__SLASH_volatile_iso;
6386 
6387  if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
6388  VolatileOptionID = A->getOption().getID();
6389 
6390  if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
6391  CmdArgs.push_back("-fms-volatile");
6392 
6393  if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_,
6394  options::OPT__SLASH_Zc_dllexportInlines,
6395  false)) {
6396  if (Args.hasArg(options::OPT__SLASH_fallback)) {
6397  D.Diag(clang::diag::err_drv_dllexport_inlines_and_fallback);
6398  } else {
6399  CmdArgs.push_back("-fno-dllexport-inlines");
6400  }
6401  }
6402 
6403  Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
6404  Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
6405  if (MostGeneralArg && BestCaseArg)
6406  D.Diag(clang::diag::err_drv_argument_not_allowed_with)
6407  << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
6408 
6409  if (MostGeneralArg) {
6410  Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
6411  Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
6412  Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
6413 
6414  Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
6415  Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
6416  if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
6417  D.Diag(clang::diag::err_drv_argument_not_allowed_with)
6418  << FirstConflict->getAsString(Args)
6419  << SecondConflict->getAsString(Args);
6420 
6421  if (SingleArg)
6422  CmdArgs.push_back("-fms-memptr-rep=single");
6423  else if (MultipleArg)
6424  CmdArgs.push_back("-fms-memptr-rep=multiple");
6425  else
6426  CmdArgs.push_back("-fms-memptr-rep=virtual");
6427  }
6428 
6429  // Parse the default calling convention options.
6430  if (Arg *CCArg =
6431  Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr,
6432  options::OPT__SLASH_Gz, options::OPT__SLASH_Gv,
6433  options::OPT__SLASH_Gregcall)) {
6434  unsigned DCCOptId = CCArg->getOption().getID();
6435  const char *DCCFlag = nullptr;
6436  bool ArchSupported = true;
6437  llvm::Triple::ArchType Arch = getToolChain().getArch();
6438  switch (DCCOptId) {
6439  case options::OPT__SLASH_Gd:
6440  DCCFlag = "-fdefault-calling-conv=cdecl";
6441  break;
6442  case options::OPT__SLASH_Gr:
6443  ArchSupported = Arch == llvm::Triple::x86;
6444  DCCFlag = "-fdefault-calling-conv=fastcall";
6445  break;
6446  case options::OPT__SLASH_Gz:
6447  ArchSupported = Arch == llvm::Triple::x86;
6448  DCCFlag = "-fdefault-calling-conv=stdcall";
6449  break;
6450  case options::OPT__SLASH_Gv:
6451  ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
6452  DCCFlag = "-fdefault-calling-conv=vectorcall";
6453  break;
6454  case options::OPT__SLASH_Gregcall:
6455  ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64;
6456  DCCFlag = "-fdefault-calling-conv=regcall";
6457  break;
6458  }
6459 
6460  // MSVC doesn't warn if /Gr or /Gz is used on x64, so we don't either.
6461  if (ArchSupported && DCCFlag)
6462  CmdArgs.push_back(DCCFlag);
6463  }
6464 
6465  Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ);
6466 
6467  if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
6468  CmdArgs.push_back("-fdiagnostics-format");
6469  if (Args.hasArg(options::OPT__SLASH_fallback))
6470  CmdArgs.push_back("msvc-fallback");
6471  else
6472  CmdArgs.push_back("msvc");
6473  }
6474 
6475  if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
6476  StringRef GuardArgs = A->getValue();
6477  // The only valid options are "cf", "cf,nochecks", and "cf-".
6478  if (GuardArgs.equals_lower("cf")) {
6479  // Emit CFG instrumentation and the table of address-taken functions.
6480  CmdArgs.push_back("-cfguard");
6481  } else if (GuardArgs.equals_lower("cf,nochecks")) {
6482  // Emit only the table of address-taken functions.
6483  CmdArgs.push_back("-cfguard-no-checks");
6484  } else if (GuardArgs.equals_lower("cf-")) {
6485  // Do nothing, but we might want to emit a security warning in future.
6486  } else {
6487  D.Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs;
6488  }
6489  }
6490 }
6491 
6492 visualstudio::Compiler *Clang::getCLFallback() const {
6493  if (!CLFallback)
6494  CLFallback.reset(new visualstudio::Compiler(getToolChain()));
6495  return CLFallback.get();
6496 }
6497 
6498 
6499 const char *Clang::getBaseInputName(const ArgList &Args,
6500  const InputInfo &Input) {
6501  return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
6502 }
6503 
6504 const char *Clang::getBaseInputStem(const ArgList &Args,
6505  const InputInfoList &Inputs) {
6506  const char *Str = getBaseInputName(Args, Inputs[0]);
6507 
6508  if (const char *End = strrchr(Str, '.'))
6509  return Args.MakeArgString(std::string(Str, End));
6510 
6511  return Str;
6512 }
6513 
6514 const char *Clang::getDependencyFileName(const ArgList &Args,
6515  const InputInfoList &Inputs) {
6516  // FIXME: Think about this more.
6517 
6518  if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6519  SmallString<128> OutputFilename(OutputOpt->getValue());
6520  llvm::sys::path::replace_extension(OutputFilename, llvm::Twine('d'));
6521  return Args.MakeArgString(OutputFilename);
6522  }
6523 
6524  return Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) + ".d");
6525 }
6526 
6527 // Begin ClangAs
6528 
6529 void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
6530  ArgStringList &CmdArgs) const {
6531  StringRef CPUName;
6532  StringRef ABIName;
6533  const llvm::Triple &Triple = getToolChain().getTriple();
6534  mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
6535 
6536  CmdArgs.push_back("-target-abi");
6537  CmdArgs.push_back(ABIName.data());
6538 }
6539 
6540 void ClangAs::AddX86TargetArgs(const ArgList &Args,
6541  ArgStringList &CmdArgs) const {
6542  addX86AlignBranchArgs(getToolChain().getDriver(), Args, CmdArgs);
6543 
6544  if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
6545  StringRef Value = A->getValue();
6546  if (Value == "intel" || Value == "att") {
6547  CmdArgs.push_back("-mllvm");
6548  CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
6549  } else {
6550  getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
6551  << A->getOption().getName() << Value;
6552  }
6553  }
6554 }
6555 
6556 void ClangAs::AddRISCVTargetArgs(const ArgList &Args,
6557  ArgStringList &CmdArgs) const {
6558  const llvm::Triple &Triple = getToolChain().getTriple();
6559  StringRef ABIName = riscv::getRISCVABI(Args, Triple);
6560 
6561  CmdArgs.push_back("-target-abi");
6562  CmdArgs.push_back(ABIName.data());
6563 }
6564 
6566  const InputInfo &Output, const InputInfoList &Inputs,
6567  const ArgList &Args,
6568  const char *LinkingOutput) const {
6569  ArgStringList CmdArgs;
6570 
6571  assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6572  const InputInfo &Input = Inputs[0];
6573 
6574  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
6575  const std::string &TripleStr = Triple.getTriple();
6576  const auto &D = getToolChain().getDriver();
6577 
6578  // Don't warn about "clang -w -c foo.s"
6579  Args.ClaimAllArgs(options::OPT_w);
6580  // and "clang -emit-llvm -c foo.s"
6581  Args.ClaimAllArgs(options::OPT_emit_llvm);
6582 
6583  claimNoWarnArgs(Args);
6584 
6585  // Invoke ourselves in -cc1as mode.
6586  //
6587  // FIXME: Implement custom jobs for internal actions.
6588  CmdArgs.push_back("-cc1as");
6589 
6590  // Add the "effective" target triple.
6591  CmdArgs.push_back("-triple");
6592  CmdArgs.push_back(Args.MakeArgString(TripleStr));
6593 
6594  // Set the output mode, we currently only expect to be used as a real
6595  // assembler.
6596  CmdArgs.push_back("-filetype");
6597  CmdArgs.push_back("obj");
6598 
6599  // Set the main file name, so that debug info works even with
6600  // -save-temps or preprocessed assembly.
6601  CmdArgs.push_back("-main-file-name");
6602  CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
6603 
6604  // Add the target cpu
6605  std::string CPU = getCPUName(Args, Triple, /*FromAs*/ true);
6606  if (!CPU.empty()) {
6607  CmdArgs.push_back("-target-cpu");
6608  CmdArgs.push_back(Args.MakeArgString(CPU));
6609  }
6610 
6611  // Add the target features
6612  getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, true);
6613 
6614  // Ignore explicit -force_cpusubtype_ALL option.
6615  (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
6616 
6617  // Pass along any -I options so we get proper .include search paths.
6618  Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
6619 
6620  // Determine the original source input.
6621  const Action *SourceAction = &JA;
6622  while (SourceAction->getKind() != Action::InputClass) {
6623  assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6624  SourceAction = SourceAction->getInputs()[0];
6625  }
6626 
6627  // Forward -g and handle debug info related flags, assuming we are dealing
6628  // with an actual assembly file.
6629  bool WantDebug = false;
6630  unsigned DwarfVersion = 0;
6631  Args.ClaimAllArgs(options::OPT_g_Group);
6632  if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
6633  WantDebug = !A->getOption().matches(options::OPT_g0) &&
6634  !A->getOption().matches(options::OPT_ggdb0);
6635  if (WantDebug)
6636  DwarfVersion = DwarfVersionNum(A->getSpelling());
6637  }
6638 
6639  unsigned DefaultDwarfVersion = ParseDebugDefaultVersion(getToolChain(), Args);
6640  if (DwarfVersion == 0)
6641  DwarfVersion = DefaultDwarfVersion;
6642 
6643  if (DwarfVersion == 0)
6644  DwarfVersion = getToolChain().GetDefaultDwarfVersion();
6645 
6647 
6648  if (SourceAction->getType() == types::TY_Asm ||
6649  SourceAction->getType() == types::TY_PP_Asm) {
6650  // You might think that it would be ok to set DebugInfoKind outside of
6651  // the guard for source type, however there is a test which asserts
6652  // that some assembler invocation receives no -debug-info-kind,
6653  // and it's not clear whether that test is just overly restrictive.
6654  DebugInfoKind = (WantDebug ? codegenoptions::LimitedDebugInfo
6656  // Add the -fdebug-compilation-dir flag if needed.
6657  addDebugCompDirArg(Args, CmdArgs, C.getDriver().getVFS());
6658 
6659  addDebugPrefixMapArg(getToolChain().getDriver(), Args, CmdArgs);
6660 
6661  // Set the AT_producer to the clang version when using the integrated
6662  // assembler on assembly source files.
6663  CmdArgs.push_back("-dwarf-debug-producer");
6664  CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
6665 
6666  // And pass along -I options
6667  Args.AddAllArgs(CmdArgs, options::OPT_I);
6668  }
6669  RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion,
6670  llvm::DebuggerKind::Default);
6671  RenderDebugInfoCompressionArgs(Args, CmdArgs, D, getToolChain());
6672 
6673 
6674  // Handle -fPIC et al -- the relocation-model affects the assembler
6675  // for some targets.
6676  llvm::Reloc::Model RelocationModel;
6677  unsigned PICLevel;
6678  bool IsPIE;
6679  std::tie(RelocationModel, PICLevel, IsPIE) =
6680  ParsePICArgs(getToolChain(), Args);
6681 
6682  const char *RMName = RelocationModelName(RelocationModel);
6683  if (RMName) {
6684  CmdArgs.push_back("-mrelocation-model");
6685  CmdArgs.push_back(RMName);
6686  }
6687 
6688  // Optionally embed the -cc1as level arguments into the debug info, for build
6689  // analysis.
6690  if (getToolChain().UseDwarfDebugFlags()) {
6691  ArgStringList OriginalArgs;
6692  for (const auto &Arg : Args)
6693  Arg->render(Args, OriginalArgs);
6694 
6695  SmallString<256> Flags;
6696  const char *Exec = getToolChain().getDriver().getClangProgramPath();
6697  Flags += Exec;
6698  for (const char *OriginalArg : OriginalArgs) {
6699  SmallString<128> EscapedArg;
6700  EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
6701  Flags += " ";
6702  Flags += EscapedArg;
6703  }
6704  CmdArgs.push_back("-dwarf-debug-flags");
6705  CmdArgs.push_back(Args.MakeArgString(Flags));
6706  }
6707 
6708  // FIXME: Add -static support, once we have it.
6709 
6710  // Add target specific flags.
6711  switch (getToolChain().getArch()) {
6712  default:
6713  break;
6714 
6715  case llvm::Triple::mips:
6716  case llvm::Triple::mipsel:
6717  case llvm::Triple::mips64:
6718  case llvm::Triple::mips64el:
6719  AddMIPSTargetArgs(Args, CmdArgs);
6720  break;
6721 
6722  case llvm::Triple::x86:
6723  case llvm::Triple::x86_64:
6724  AddX86TargetArgs(Args, CmdArgs);
6725  break;
6726 
6727  case llvm::Triple::arm:
6728  case llvm::Triple::armeb:
6729  case llvm::Triple::thumb:
6730  case llvm::Triple::thumbeb:
6731  // This isn't in AddARMTargetArgs because we want to do this for assembly
6732  // only, not C/C++.
6733  if (Args.hasFlag(options::OPT_mdefault_build_attributes,
6734  options::OPT_mno_default_build_attributes, true)) {
6735  CmdArgs.push_back("-mllvm");
6736  CmdArgs.push_back("-arm-add-build-attributes");
6737  }
6738  break;
6739 
6740  case llvm::Triple::riscv32:
6741  case llvm::Triple::riscv64:
6742  AddRISCVTargetArgs(Args, CmdArgs);
6743  break;
6744  }
6745 
6746  // Consume all the warning flags. Usually this would be handled more
6747  // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
6748  // doesn't handle that so rather than warning about unused flags that are
6749  // actually used, we'll lie by omission instead.
6750  // FIXME: Stop lying and consume only the appropriate driver flags
6751  Args.ClaimAllArgs(options::OPT_W_Group);
6752 
6753  CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
6754  getToolChain().getDriver());
6755 
6756  Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
6757 
6758  assert(Output.isFilename() && "Unexpected lipo output.");
6759  CmdArgs.push_back("-o");
6760  CmdArgs.push_back(Output.getFilename());
6761 
6762  const llvm::Triple &T = getToolChain().getTriple();
6763  Arg *A;
6764  if (getDebugFissionKind(D, Args, A) == DwarfFissionKind::Split &&
6765  T.isOSBinFormatELF()) {
6766  CmdArgs.push_back("-split-dwarf-output");
6767  CmdArgs.push_back(SplitDebugName(Args, Input, Output));
6768  }
6769 
6770  assert(Input.isFilename() && "Invalid input.");
6771  CmdArgs.push_back(Input.getFilename());
6772 
6773  const char *Exec = getToolChain().getDriver().getClangProgramPath();
6774  C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
6775 }
6776 
6777 // Begin OffloadBundler
6778 
6780  const InputInfo &Output,
6781  const InputInfoList &Inputs,
6782  const llvm::opt::ArgList &TCArgs,
6783  const char *LinkingOutput) const {
6784  // The version with only one output is expected to refer to a bundling job.
6785  assert(isa<OffloadBundlingJobAction>(JA) && "Expecting bundling job!");
6786 
6787  // The bundling command looks like this:
6788  // clang-offload-bundler -type=bc
6789  // -targets=host-triple,openmp-triple1,openmp-triple2
6790  // -outputs=input_file
6791  // -inputs=unbundle_file_host,unbundle_file_tgt1,unbundle_file_tgt2"
6792 
6793  ArgStringList CmdArgs;
6794 
6795  // Get the type.
6796  CmdArgs.push_back(TCArgs.MakeArgString(
6797  Twine("-type=") + types::getTypeTempSuffix(Output.getType())));
6798 
6799  assert(JA.getInputs().size() == Inputs.size() &&
6800  "Not have inputs for all dependence actions??");
6801 
6802  // Get the targets.
6803  SmallString<128> Triples;
6804  Triples += "-targets=";
6805  for (unsigned I = 0; I < Inputs.size(); ++I) {
6806  if (I)
6807  Triples += ',';
6808 
6809  // Find ToolChain for this input.
6811  const ToolChain *CurTC = &getToolChain();
6812  const Action *CurDep = JA.getInputs()[I];
6813 
6814  if (const auto *OA = dyn_cast<OffloadAction>(CurDep)) {
6815  CurTC = nullptr;
6816  OA->doOnEachDependence([&](Action *A, const ToolChain *TC, const char *) {
6817  assert(CurTC == nullptr && "Expected one dependence!");
6818  CurKind = A->getOffloadingDeviceKind();
6819  CurTC = TC;
6820  });
6821  }
6822  Triples += Action::GetOffloadKindName(CurKind);
6823  Triples += '-';
6824  Triples += CurTC->getTriple().normalize();
6825  if (CurKind == Action::OFK_HIP && CurDep->getOffloadingArch()) {
6826  Triples += '-';
6827  Triples += CurDep->getOffloadingArch();
6828  }
6829  }
6830  CmdArgs.push_back(TCArgs.MakeArgString(Triples));
6831 
6832  // Get bundled file command.
6833  CmdArgs.push_back(
6834  TCArgs.MakeArgString(Twine("-outputs=") + Output.getFilename()));
6835 
6836  // Get unbundled files command.
6837  SmallString<128> UB;
6838  UB += "-inputs=";
6839  for (unsigned I = 0; I < Inputs.size(); ++I) {
6840  if (I)
6841  UB += ',';
6842 
6843  // Find ToolChain for this input.
6844  const ToolChain *CurTC = &getToolChain();
6845  if (const auto *OA = dyn_cast<OffloadAction>(JA.getInputs()[I])) {
6846  CurTC = nullptr;
6847  OA->doOnEachDependence([&](Action *, const ToolChain *TC, const char *) {
6848  assert(CurTC == nullptr && "Expected one dependence!");
6849  CurTC = TC;
6850  });
6851  }
6852  UB += CurTC->getInputFilename(Inputs[I]);
6853  }
6854  CmdArgs.push_back(TCArgs.MakeArgString(UB));
6855 
6856  // All the inputs are encoded as commands.
6857  C.addCommand(std::make_unique<Command>(
6858  JA, *this,
6859  TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())),
6860  CmdArgs, None));
6861 }
6862 
6864  Compilation &C, const JobAction &JA, const InputInfoList &Outputs,
6865  const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs,
6866  const char *LinkingOutput) const {
6867  // The version with multiple outputs is expected to refer to a unbundling job.
6868  auto &UA = cast<OffloadUnbundlingJobAction>(JA);
6869 
6870  // The unbundling command looks like this:
6871  // clang-offload-bundler -type=bc
6872  // -targets=host-triple,openmp-triple1,openmp-triple2
6873  // -inputs=input_file
6874  // -outputs=unbundle_file_host,unbundle_file_tgt1,unbundle_file_tgt2"
6875  // -unbundle
6876 
6877  ArgStringList CmdArgs;
6878 
6879  assert(Inputs.size() == 1 && "Expecting to unbundle a single file!");
6880  InputInfo Input = Inputs.front();
6881 
6882  // Get the type.
6883  CmdArgs.push_back(TCArgs.MakeArgString(
6884  Twine("-type=") + types::getTypeTempSuffix(Input.getType())));
6885 
6886  // Get the targets.
6887  SmallString<128> Triples;
6888  Triples += "-targets=";
6889  auto DepInfo = UA.getDependentActionsInfo();
6890  for (unsigned I = 0; I < DepInfo.size(); ++I) {
6891  if (I)
6892  Triples += ',';
6893 
6894  auto &Dep = DepInfo[I];
6895  Triples += Action::GetOffloadKindName(Dep.DependentOffloadKind);
6896  Triples += '-';
6897  Triples += Dep.DependentToolChain->getTriple().normalize();
6898  if (Dep.DependentOffloadKind == Action::OFK_HIP &&
6899  !Dep.DependentBoundArch.empty()) {
6900  Triples += '-';
6901  Triples += Dep.DependentBoundArch;
6902  }
6903  }
6904 
6905  CmdArgs.push_back(TCArgs.MakeArgString(Triples));
6906 
6907  // Get bundled file command.
6908  CmdArgs.push_back(
6909  TCArgs.MakeArgString(Twine("-inputs=") + Input.getFilename()));
6910 
6911  // Get unbundled files command.
6912  SmallString<128> UB;
6913  UB += "-outputs=";
6914  for (unsigned I = 0; I < Outputs.size(); ++I) {
6915  if (I)
6916  UB += ',';
6917  UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
6918  }
6919  CmdArgs.push_back(TCArgs.MakeArgString(UB));
6920  CmdArgs.push_back("-unbundle");
6921 
6922  // All the inputs are encoded as commands.
6923  C.addCommand(std::make_unique<Command>(
6924  JA, *this,
6925  TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())),
6926  CmdArgs, None));
6927 }
6928 
6930  const InputInfo &Output,
6931  const InputInfoList &Inputs,
6932  const ArgList &Args,
6933  const char *LinkingOutput) const {
6934  ArgStringList CmdArgs;
6935 
6936  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
6937 
6938  // Add the "effective" target triple.
6939  CmdArgs.push_back("-target");
6940  CmdArgs.push_back(Args.MakeArgString(Triple.getTriple()));
6941 
6942  // Add the output file name.
6943  assert(Output.isFilename() && "Invalid output.");
6944  CmdArgs.push_back("-o");
6945  CmdArgs.push_back(Output.getFilename());
6946 
6947  // Add inputs.
6948  for (const InputInfo &I : Inputs) {
6949  assert(I.isFilename() && "Invalid input.");
6950  CmdArgs.push_back(I.getFilename());
6951  }
6952 
6953  C.addCommand(std::make_unique<Command>(
6954  JA, *this,
6955  Args.MakeArgString(getToolChain().GetProgramPath(getShortName())),
6956  CmdArgs, Inputs));
6957 }
StringRef getSysRoot() const
Returns the sysroot path.
static bool checkRemarksOptions(const Driver &D, const ArgList &Args, const llvm::Triple &Triple)
Definition: Clang.cpp:1432
static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T, ArgStringList &CmdArgs)
Definition: Clang.cpp:3312
void getAArch64TargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
static const char * getBaseInputName(const llvm::opt::ArgList &Args, const InputInfo &Input)
Definition: Clang.cpp:6499
static bool hasMultipleInvocations(const llvm::Triple &Triple, const ArgList &Args)
Definition: Clang.cpp:1421
void handleTargetFeaturesGroup(const llvm::opt::ArgList &Args, std::vector< StringRef > &Features, llvm::opt::OptSpecifier Group)
static void getTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple, const ArgList &Args, ArgStringList &CmdArgs, bool ForAS)
Definition: Clang.cpp:310
void ConstructJobMultipleOutputs(Compilation &C, const JobAction &JA, const InputInfoList &Outputs, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
Construct jobs to perform the action JA, writing to the Outputs and with Inputs, and add the jobs to ...
Definition: Clang.cpp:6863
static bool useFramePointerForTargetByDefault(const ArgList &Args, const llvm::Triple &Triple)
Definition: Clang.cpp:523
void AddClangCXXStdlibIsystemArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
AddClangCXXStdlibIsystemArgs - Add the clang -cc1 level arguments to set the specified include paths ...
Definition: ToolChain.cpp:873
static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC, const JobAction &JA)
Definition: Clang.cpp:471
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
Definition: Driver.cpp:581
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
Definition: Version.cpp:117
virtual ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const
getDefaultObjCRuntime - Return the default Objective-C runtime for this platform. ...
Definition: ToolChain.cpp:584
unsigned CCPrintHeaders
Set CC_PRINT_HEADERS mode, which causes the frontend to log header include information to CCPrintHead...
Definition: Driver.h:197
void addProfileRTArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
llvm::Expected< T > Expected
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:67
static void addExceptionArgs(const ArgList &Args, types::ID InputType, const ToolChain &TC, bool KernelOrKext, const ObjCRuntime &objcRuntime, ArgStringList &CmdArgs)
Adds exception related arguments to the driver command arguments.
Definition: Clang.cpp:416
bool isUseSeparateSections(const llvm::Triple &Triple)
Definition: CommonArgs.cpp:352
StringRef P
FloatABI getSparcFloatABI(const Driver &D, const llvm::opt::ArgList &Args)
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
Definition: Driver.h:554
Defines types useful for describing an Objective-C runtime.
virtual void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
Definition: ToolChain.cpp:859
input_range inputs()
Definition: Action.h:151
bool embedBitcodeEnabled() const
Definition: Driver.h:350
static void addDebugPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the debug file path prefix map.
Definition: Clang.cpp:632
static void forAllAssociatedToolChains(Compilation &C, const JobAction &JA, const ToolChain &RegularToolChain, llvm::function_ref< void(const ToolChain &)> Work)
Apply Work on the current tool chain RegularToolChain and any other offloading tool chain that is ass...
Definition: Clang.cpp:124
void getSystemZTargetFeatures(const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
bool isHostOffloading(OffloadKind OKind) const
Check if this action have any offload kinds.
Definition: Action.h:203
static void CollectArgsForIntegratedAssembler(Compilation &C, const ArgList &Args, ArgStringList &CmdArgs, const Driver &D)
Definition: Clang.cpp:2267
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
Definition: Driver.h:557
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
static void QuoteTarget(StringRef Target, SmallVectorImpl< char > &Res)
Definition: Clang.cpp:95
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args)
Definition: Clang.cpp:54
&#39;gcc&#39; is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
Definition: ObjCRuntime.h:52
static bool UseRelaxAll(Compilation &C, const ArgList &Args)
Check if -relax-all should be passed to the internal assembler.
Definition: Clang.cpp:959
FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args)
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs...
Definition: Clang.cpp:6929
static StringRef bytes(const std::vector< T, Allocator > &v)
Definition: ASTWriter.cpp:121
Don&#39;t generate debug info.
std::string getCPUName(const llvm::opt::ArgList &Args, const llvm::Triple &T, bool FromAs=false)
&#39;macosx-fragile&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:39
const char * getFilename() const
Definition: InputInfo.h:83
virtual void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Add the clang cc1 arguments for system include paths.
Definition: ToolChain.cpp:737
Distro - Helper class for detecting and classifying Linux distributions.
Definition: Distro.h:23
bool embedBitcodeMarkerOnly() const
Definition: Driver.h:352
ActionList & getInputs()
Definition: Action.h:144
unsigned CCLogDiagnostics
Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics to CCLogDiagnosticsFilename...
Definition: Driver.h:202
virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const
GetDefaultStackProtectorLevel - Get the default stack protector level for this tool chain (0=off...
Definition: ToolChain.h:362
static void addPGOAndCoverageFlags(const ToolChain &TC, Compilation &C, const Driver &D, const InputInfo &Output, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:756
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, bool OFastEnabled, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:2481
bool isOffloading(OffloadKind OKind) const
Definition: Action.h:209
std::string GetClPchPath(Compilation &C, StringRef BaseName) const
Return the pathname of the pch file in clang-cl mode.
Definition: Driver.cpp:4771
Action - Represent an abstract compilation step to perform.
Definition: Action.h:47
static const char * RelocationModelName(llvm::Reloc::Model Model)
Definition: Clang.cpp:1075
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:81
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:134
std::string getTripleString() const
Definition: ToolChain.h:224
Emit only debug directives with the line numbers data.
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
static void addDashXForInput(const ArgList &Args, const InputInfo &Input, ArgStringList &CmdArgs)
Add -x lang to CmdArgs for Input.
Definition: Clang.cpp:694
types::ID getType() const
Definition: Action.h:142
bool isDeviceOffloading(OffloadKind OKind) const
Definition: Action.h:206
bool isOptimizationLevelFast(const llvm::opt::ArgList &Args)
The LLVM OpenMP runtime.
Definition: Driver.h:95
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
OffloadKind getOffloadingDeviceKind() const
Definition: Action.h:198
static void RenderSSPOptions(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, bool KernelOrKext)
Definition: Clang.cpp:2912
FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
types::ID getType() const
Definition: InputInfo.h:77
void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const
Definition: XRayArgs.cpp:188
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs...
Definition: Clang.cpp:6779
void getAMDGPUTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
Definition: AMDGPU.cpp:38
const char * SplitDebugName(const llvm::opt::ArgList &Args, const InputInfo &Input, const InputInfo &Output)
static void RenderDebugInfoCompressionArgs(const ArgList &Args, ArgStringList &CmdArgs, const Driver &D, const ToolChain &TC)
Definition: Clang.cpp:1042
void AddX86TargetArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Clang.cpp:6540
virtual void adjustDebugInfoKind(codegenoptions::DebugInfoKind &DebugInfoKind, const llvm::opt::ArgList &Args) const
Adjust debug information kind considering all passed options.
Definition: ToolChain.h:472
llvm::vfs::FileSystem & getVFS() const
Definition: Driver.h:319
void addDirectoryList(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const char *ArgName, const char *EnvVar)
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:47
const char * CudaVersionToString(CudaVersion V)
Definition: Cuda.cpp:11
static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:3030
StringRef getRISCVABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
StringRef Filename
Definition: Format.cpp:1825
const ToolChain & getDefaultToolChain() const
Definition: Compilation.h:135
virtual bool useRelaxRelocations() const
Check whether to enable x86 relax relocations by default.
Definition: ToolChain.cpp:109
static void getDefaultModuleCachePath(SmallVectorImpl< char > &Result)
Compute the default -fmodule-cache-path.
Definition: Clang.cpp:3139
unsigned Offset
Definition: Format.cpp:1827
Exposes information about the current target.
Definition: TargetInfo.h:164
virtual bool useIntegratedAs() const
Check if the toolchain should use the integrated assembler.
Definition: ToolChain.cpp:103
static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:3102
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:43
const DiagnosticsEngine & getDiags() const
Definition: Driver.h:317
bool isForDiagnostics() const
Return true if we&#39;re compiling for diagnostics.
Definition: Compilation.h:295
static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind DebugInfoKind, unsigned DwarfVersion, llvm::DebuggerKind DebuggerTuning)
Definition: Clang.cpp:991
Defines the clang::LangOptions interface.
ActionClass getKind() const
Definition: Action.h:141
SourceLocation End
Limit generated debug info to reduce size (-fno-standalone-debug).
static void getWebAssemblyTargetFeatures(const ArgList &Args, std::vector< StringRef > &Features)
Definition: Clang.cpp:305
&#39;macosx&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition: ObjCRuntime.h:34
std::string getAsString() const
Definition: ObjCRuntime.cpp:23
static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
The -mprefer-vector-width option accepts either a positive integer or the string "none".
Definition: Clang.cpp:286
CC1ToolFunc CC1Main
Definition: Driver.h:212
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)
Definition: Clang.cpp:1448
const llvm::Triple & getEffectiveTriple() const
Get the toolchain&#39;s effective clang triple.
Definition: ToolChain.h:229
#define V(N, I)
Definition: ASTContext.h:2941
static unsigned DwarfVersionNum(StringRef ArgValue)
Definition: Clang.cpp:982
Defines version macros and version-related utility functions for Clang.
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
Definition: ObjCRuntime.cpp:48
static void addX86AlignBranchArgs(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:2018
virtual bool IsObjCNonFragileABIDefault() const
IsObjCNonFragileABIDefault - Does this tool chain set -fobjc-nonfragile-abi by default.
Definition: ToolChain.h:351
SmallString< 128 > getStatsFileName(const llvm::opt::ArgList &Args, const InputInfo &Output, const InputInfo &Input, const Driver &D)
Handles the -save-stats option and returns the filename to save statistics to.
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
Definition: Driver.h:182
void AddRISCVTargetArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Clang.cpp:6556
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
Definition: CharInfo.h:117
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:205
static const char * getDependencyFileName(const llvm::opt::ArgList &Args, const InputInfoList &Inputs)
Definition: Clang.cpp:6514
virtual bool isNoExecStackDefault() const
Test whether this toolchaind defaults to non-executable stacks.
Definition: ToolChain.cpp:113
std::tuple< llvm::Reloc::Model, unsigned, bool > ParsePICArgs(const ToolChain &ToolChain, const llvm::opt::ArgList &Args)
void getSparcTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
bool isObjCAutoRefCount(const llvm::opt::ArgList &Args)
&#39;gnustep&#39; is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:55
virtual bool supportsDebugInfoOption(const llvm::opt::Arg *) const
Does this toolchain supports given debug info option or not.
Definition: ToolChain.h:467
do v
Definition: arm_acle.h:64
static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args)
Definition: Clang.cpp:66
const_offload_toolchains_range getOffloadToolChains() const
Definition: Compilation.h:150
static bool isSignedCharDefault(const llvm::Triple &Triple)
Definition: Clang.cpp:1375
virtual bool IsMathErrnoDefault() const
IsMathErrnoDefault - Does this tool chain use -fmath-errno by default.
Definition: ToolChain.h:343
unsigned ParseFunctionAlignment(const ToolChain &TC, const llvm::opt::ArgList &Args)
static CodeGenOptions::FramePointerKind getFramePointerKind(const ArgList &Args, const llvm::Triple &Triple)
Definition: Clang.cpp:590
void addSanitizerArgs(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:215
virtual bool UseObjCMixedDispatch() const
UseObjCMixedDispatchDefault - When using non-legacy dispatch, should the mixed dispatch method be use...
Definition: ToolChain.h:355
static void RenderModulesOptions(Compilation &C, const Driver &D, const ArgList &Args, const InputInfo &Input, const InputInfo &Output, ArgStringList &CmdArgs, bool &HaveModules)
Definition: Clang.cpp:3146
virtual std::string getInputFilename(const InputInfo &Input) const
Some toolchains need to modify the file name, for example to replace the extension for object files w...
Definition: ToolChain.cpp:245
virtual std::string getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component, FileType Type=ToolChain::FT_Static) const
Definition: ToolChain.cpp:391
bool embedBitcodeInObject() const
Definition: Driver.h:351
static bool isNoCommonDefault(const llvm::Triple &Triple)
Definition: Clang.cpp:1407
static void EscapeSpacesAndBackslashes(const char *Arg, SmallVectorImpl< char > &Res)
Definition: Clang.cpp:78
const llvm::opt::DerivedArgList & getArgs() const
Definition: Compilation.h:186
static bool getRefinementStep(StringRef In, const Driver &D, const Arg &A, size_t &Position)
This is a helper function for validating the optional refinement step parameter in reciprocal argumen...
Definition: Clang.cpp:157
Generate complete debug info.
const Driver & getDriver() const
Definition: ToolChain.h:199
Kind getKind() const
Definition: ObjCRuntime.h:76
static bool checkDebugInfoOption(const Arg *A, const ArgList &Args, const Driver &D, const ToolChain &TC)
Definition: Clang.cpp:1032
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
Definition: Driver.h:105
void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
static DwarfFissionKind getDebugFissionKind(const Driver &D, const ArgList &Args, Arg *&Arg)
Definition: Clang.cpp:3554
bool isSaveTempsEnabled() const
Definition: Driver.h:347
llvm::opt::Arg * getLastProfileSampleUseArg(const llvm::opt::ArgList &Args)
Limit generated debug info for classes to reduce size.
bool isLegacyDispatchDefaultForArch(llvm::Triple::ArchType Arch)
The default dispatch mechanism to use for the specified architecture.
Definition: ObjCRuntime.h:99
llvm::opt::Arg * getLastProfileUseArg(const llvm::opt::ArgList &Args)
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:77
static void appendUserToPath(SmallVectorImpl< char > &Result)
Definition: Clang.cpp:724
const llvm::opt::Arg & getInputArg() const
Definition: InputInfo.h:87
const char * getShortName() const
Definition: Tool.h:81
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs...
Definition: Clang.cpp:3855
Dataflow Directional Tag Classes.
const char * CCPrintHeadersFilename
The file to log CC_PRINT_HEADERS output to, if enabled.
Definition: Driver.h:163
static void RenderObjCOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, ObjCRuntime &Runtime, bool InferCovariantReturns, const InputInfo &Input, ArgStringList &CmdArgs)
Definition: Clang.cpp:3347
void AddMIPSTargetArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Clang.cpp:6529
void getPPCTargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
virtual void CheckObjCARC() const
Complain if this tool chain doesn&#39;t support Objective-C ARC.
Definition: ToolChain.h:440
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:27
virtual llvm::DebuggerKind getDefaultDebuggerTuning() const
Definition: ToolChain.h:462
Emit only debug info necessary for generating line number tables (-gline-tables-only).
std::string SysRoot
sysroot, if present
Definition: Driver.h:148
void getHexagonTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
Tool - Information on a specific compilation tool.
Definition: Tool.h:33
DiagnosticOptions & getDiagnosticOptions() const
Retrieve the diagnostic options.
Definition: Diagnostic.h:506
bool areOptimizationsEnabled(const llvm::opt::ArgList &Args)
void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
ActionList & getActions()
Definition: Compilation.h:190
static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:3437
virtual unsigned GetDefaultDwarfVersion() const
Definition: ToolChain.h:453
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args)
/EH controls whether to run destructor cleanups when exceptions are thrown.
Definition: Clang.cpp:6240
static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs, const llvm::vfs::FileSystem &VFS)
Add a CC1 option to specify the debug compilation directory.
Definition: Clang.cpp:619
void getMSP430TargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
std::string ClangExecutable
The original path to the clang executable.
Definition: Driver.h:123
Assembly: we accept this only so that we can preprocess it.
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:59
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Definition: Types.cpp:160
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
DwarfFissionKind
Definition: Clang.cpp:3552
virtual codegenoptions::DebugInfoFormat getDefaultDebugFormat() const
Get the default debug info format. Typically, this is DWARF.
Definition: ToolChain.h:443
const Driver & getDriver() const
Definition: Compilation.h:133
const llvm::Triple & getTriple() const
Definition: ToolChain.h:201
static Optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:401
static bool shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, const llvm::Triple &Triple)
Definition: Clang.cpp:396
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
Definition: Action.cpp:146
bool hasCompactBranches(StringRef &CPU)
Definition: Mips.cpp:426
const ToolChain & getToolChain() const
Definition: Tool.h:83
const char * CCLogDiagnosticsFilename
The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
Definition: Driver.h:166
const char * addFailureResultFile(const char *Name, const JobAction *JA)
addFailureResultFile - Add a file to remove if we crash, and returns its argument.
Definition: Compilation.h:246
virtual bool GetDefaultStandaloneDebug() const
Definition: ToolChain.h:459
bool willEmitRemarks(const llvm::opt::ArgList &Args)
bool isNothing() const
Definition: InputInfo.h:74
static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args, ArgStringList &CmdArgs)
Add a CC1 and CC1AS option to specify the macro file path prefix map.
Definition: Clang.cpp:646
void getARMTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, std::vector< llvm::StringRef > &Features, bool ForAS)
const char * getBaseInput() const
Definition: InputInfo.h:78
static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple)
Definition: Clang.cpp:511
static std::string GetOffloadingFileNamePrefix(OffloadKind Kind, 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:130
virtual LangOptions::TrivialAutoVarInitKind GetDefaultTrivialAutoVarInit() const
Get the default trivial automatic variable initialization.
Definition: ToolChain.h:368
unsigned ParseDebugDefaultVersion(const ToolChain &TC, const llvm::opt::ArgList &Args)
static void ParseMRecip(const Driver &D, const ArgList &Args, ArgStringList &OutStrings)
The -mrecip flag requires processing of many optional parameters.
Definition: Clang.cpp:185
bool isFilename() const
Definition: InputInfo.h:75
Clang(const ToolChain &TC)
Definition: Clang.cpp:6079
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:801
static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec)
Vectorize at all optimization levels greater than 1 except for -Oz.
Definition: Clang.cpp:663
static bool maybeConsumeDash(const std::string &EH, size_t &I)
Definition: Clang.cpp:6219
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
Definition: Compilation.h:232
static void RenderTrivialAutoVarInitOptions(const Driver &D, const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:2960
const char * getClangProgramPath() const
Get the path to the main clang executable.
Definition: Driver.h:333
const ToolChain * getSingleOffloadToolChain() const
Return an offload toolchain of the provided kind.
Definition: Compilation.h:163
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs...
Definition: Clang.cpp:6565
bool CCCIsCPP() const
Whether the driver is just the preprocessor.
Definition: Driver.h:176
void getMipsCPUAndABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef &CPUName, StringRef &ABIName)
static const char * getBaseInputStem(const llvm::opt::ArgList &Args, const InputInfoList &Inputs)
Definition: Clang.cpp:6504
static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input)
Definition: Clang.cpp:2837
static bool ContainsCompileAction(const Action *A)
Check whether the given input tree contains any compilation actions.
Definition: Clang.cpp:946
static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A)
Definition: Clang.cpp:497
void getRISCVTargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
static bool ShouldDisableDwarfDirectory(const ArgList &Args, const ToolChain &TC)
Definition: Clang.cpp:487
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:178
static void RenderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T, const ArgList &Args, bool EmitCodeView, bool IsWindowsMSVC, ArgStringList &CmdArgs, codegenoptions::DebugInfoKind &DebugInfoKind, DwarfFissionKind &DwarfFission)
Definition: Clang.cpp:3575
const char * getOffloadingArch() const
Definition: Action.h:199
unsigned CCGenDiagnostics
Whether the driver is generating diagnostics for debugging purposes.
Definition: Driver.h:205
const list_type & getJobs() const
Definition: Job.h:211
static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs)
Definition: Clang.cpp:3004
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
Definition: Types.cpp:147
bool allowsWeak() const
Does this runtime allow the use of __weak?
Definition: ObjCRuntime.h:282
LangStandard::Kind Std
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:88
std::string ResourceDir
The path to the compiler resource directory.
Definition: Driver.h:132
mips::FloatABI getMipsFloatABI(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple)