clang  8.0.0svn
CompilerInvocation.cpp
Go to the documentation of this file.
1 //===- CompilerInvocation.cpp ---------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
12 #include "clang/Basic/Builtins.h"
13 #include "clang/Basic/CharInfo.h"
17 #include "clang/Basic/Diagnostic.h"
20 #include "clang/Basic/LLVM.h"
23 #include "clang/Basic/Sanitizers.h"
26 #include "clang/Basic/Version.h"
27 #include "clang/Basic/Visibility.h"
28 #include "clang/Basic/XRayInstr.h"
29 #include "clang/Config/config.h"
31 #include "clang/Driver/Options.h"
40 #include "clang/Frontend/Utils.h"
46 #include "llvm/ADT/APInt.h"
47 #include "llvm/ADT/ArrayRef.h"
48 #include "llvm/ADT/CachedHashString.h"
49 #include "llvm/ADT/Hashing.h"
50 #include "llvm/ADT/None.h"
51 #include "llvm/ADT/Optional.h"
52 #include "llvm/ADT/SmallString.h"
53 #include "llvm/ADT/SmallVector.h"
54 #include "llvm/ADT/StringRef.h"
55 #include "llvm/ADT/StringSwitch.h"
56 #include "llvm/ADT/Triple.h"
57 #include "llvm/ADT/Twine.h"
58 #include "llvm/IR/DebugInfoMetadata.h"
59 #include "llvm/Linker/Linker.h"
60 #include "llvm/MC/MCTargetOptions.h"
61 #include "llvm/Option/Arg.h"
62 #include "llvm/Option/ArgList.h"
63 #include "llvm/Option/OptSpecifier.h"
64 #include "llvm/Option/OptTable.h"
65 #include "llvm/Option/Option.h"
66 #include "llvm/ProfileData/InstrProfReader.h"
67 #include "llvm/Support/CodeGen.h"
68 #include "llvm/Support/Compiler.h"
69 #include "llvm/Support/Error.h"
70 #include "llvm/Support/ErrorHandling.h"
71 #include "llvm/Support/ErrorOr.h"
72 #include "llvm/Support/FileSystem.h"
73 #include "llvm/Support/Host.h"
74 #include "llvm/Support/MathExtras.h"
75 #include "llvm/Support/MemoryBuffer.h"
76 #include "llvm/Support/Path.h"
77 #include "llvm/Support/Process.h"
78 #include "llvm/Support/Regex.h"
79 #include "llvm/Support/VersionTuple.h"
80 #include "llvm/Support/VirtualFileSystem.h"
81 #include "llvm/Support/raw_ostream.h"
82 #include "llvm/Target/TargetOptions.h"
83 #include <algorithm>
84 #include <atomic>
85 #include <cassert>
86 #include <cstddef>
87 #include <cstring>
88 #include <memory>
89 #include <string>
90 #include <tuple>
91 #include <utility>
92 #include <vector>
93 
94 using namespace clang;
95 using namespace driver;
96 using namespace options;
97 using namespace llvm::opt;
98 
99 //===----------------------------------------------------------------------===//
100 // Initialization.
101 //===----------------------------------------------------------------------===//
102 
104  : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
105  DiagnosticOpts(new DiagnosticOptions()),
106  HeaderSearchOpts(new HeaderSearchOptions()),
107  PreprocessorOpts(new PreprocessorOptions()) {}
108 
110  : LangOpts(new LangOptions(*X.getLangOpts())),
115 
117 
118 //===----------------------------------------------------------------------===//
119 // Deserialization (from args)
120 //===----------------------------------------------------------------------===//
121 
122 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
123  DiagnosticsEngine &Diags) {
124  unsigned DefaultOpt = llvm::CodeGenOpt::None;
125  if (IK.getLanguage() == InputKind::OpenCL && !Args.hasArg(OPT_cl_opt_disable))
126  DefaultOpt = llvm::CodeGenOpt::Default;
127 
128  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
129  if (A->getOption().matches(options::OPT_O0))
130  return llvm::CodeGenOpt::None;
131 
132  if (A->getOption().matches(options::OPT_Ofast))
133  return llvm::CodeGenOpt::Aggressive;
134 
135  assert(A->getOption().matches(options::OPT_O));
136 
137  StringRef S(A->getValue());
138  if (S == "s" || S == "z" || S.empty())
139  return llvm::CodeGenOpt::Default;
140 
141  if (S == "g")
142  return llvm::CodeGenOpt::Less;
143 
144  return getLastArgIntValue(Args, OPT_O, DefaultOpt, Diags);
145  }
146 
147  return DefaultOpt;
148 }
149 
150 static unsigned getOptimizationLevelSize(ArgList &Args) {
151  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
152  if (A->getOption().matches(options::OPT_O)) {
153  switch (A->getValue()[0]) {
154  default:
155  return 0;
156  case 's':
157  return 1;
158  case 'z':
159  return 2;
160  }
161  }
162  }
163  return 0;
164 }
165 
166 static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
167  OptSpecifier GroupWithValue,
168  std::vector<std::string> &Diagnostics) {
169  for (auto *A : Args.filtered(Group)) {
170  if (A->getOption().getKind() == Option::FlagClass) {
171  // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
172  // its name (minus the "W" or "R" at the beginning) to the warning list.
173  Diagnostics.push_back(A->getOption().getName().drop_front(1));
174  } else if (A->getOption().matches(GroupWithValue)) {
175  // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group.
176  Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
177  } else {
178  // Otherwise, add its value (for OPT_W_Joined and similar).
179  for (const auto *Arg : A->getValues())
180  Diagnostics.emplace_back(Arg);
181  }
182  }
183 }
184 
185 // Parse the Static Analyzer configuration. If \p Diags is set to nullptr,
186 // it won't verify the input.
187 static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,
188  DiagnosticsEngine *Diags);
189 
190 static void getAllNoBuiltinFuncValues(ArgList &Args,
191  std::vector<std::string> &Funcs) {
193  for (const auto &Arg : Args) {
194  const Option &O = Arg->getOption();
195  if (O.matches(options::OPT_fno_builtin_)) {
196  const char *FuncName = Arg->getValue();
197  if (Builtin::Context::isBuiltinFunc(FuncName))
198  Values.push_back(FuncName);
199  }
200  }
201  Funcs.insert(Funcs.end(), Values.begin(), Values.end());
202 }
203 
204 static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
205  DiagnosticsEngine &Diags) {
206  bool Success = true;
207  if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
208  StringRef Name = A->getValue();
209  AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
210 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
211  .Case(CMDFLAG, NAME##Model)
212 #include "clang/StaticAnalyzer/Core/Analyses.def"
213  .Default(NumStores);
214  if (Value == NumStores) {
215  Diags.Report(diag::err_drv_invalid_value)
216  << A->getAsString(Args) << Name;
217  Success = false;
218  } else {
219  Opts.AnalysisStoreOpt = Value;
220  }
221  }
222 
223  if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
224  StringRef Name = A->getValue();
225  AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
226 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
227  .Case(CMDFLAG, NAME##Model)
228 #include "clang/StaticAnalyzer/Core/Analyses.def"
229  .Default(NumConstraints);
230  if (Value == NumConstraints) {
231  Diags.Report(diag::err_drv_invalid_value)
232  << A->getAsString(Args) << Name;
233  Success = false;
234  } else {
236  }
237  }
238 
239  if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
240  StringRef Name = A->getValue();
241  AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
242 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
243  .Case(CMDFLAG, PD_##NAME)
244 #include "clang/StaticAnalyzer/Core/Analyses.def"
245  .Default(NUM_ANALYSIS_DIAG_CLIENTS);
246  if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
247  Diags.Report(diag::err_drv_invalid_value)
248  << A->getAsString(Args) << Name;
249  Success = false;
250  } else {
251  Opts.AnalysisDiagOpt = Value;
252  }
253  }
254 
255  if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
256  StringRef Name = A->getValue();
257  AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
258 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
259  .Case(CMDFLAG, NAME)
260 #include "clang/StaticAnalyzer/Core/Analyses.def"
261  .Default(NumPurgeModes);
262  if (Value == NumPurgeModes) {
263  Diags.Report(diag::err_drv_invalid_value)
264  << A->getAsString(Args) << Name;
265  Success = false;
266  } else {
267  Opts.AnalysisPurgeOpt = Value;
268  }
269  }
270 
271  if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
272  StringRef Name = A->getValue();
273  AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name)
274 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
275  .Case(CMDFLAG, NAME)
276 #include "clang/StaticAnalyzer/Core/Analyses.def"
277  .Default(NumInliningModes);
278  if (Value == NumInliningModes) {
279  Diags.Report(diag::err_drv_invalid_value)
280  << A->getAsString(Args) << Name;
281  Success = false;
282  } else {
283  Opts.InliningMode = Value;
284  }
285  }
286 
287  Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
288  Opts.ShowConfigOptionsList = Args.hasArg(OPT_analyzer_config_help);
289  Opts.ShowEnabledCheckerList = Args.hasArg(OPT_analyzer_list_enabled_checkers);
291  /* negated */!llvm::StringSwitch<bool>(
292  Args.getLastArgValue(OPT_analyzer_config_compatibility_mode))
293  .Case("true", true)
294  .Case("false", false)
295  .Default(false);
296  Opts.DisableAllChecks = Args.hasArg(OPT_analyzer_disable_all_checks);
297 
299  Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
300  Opts.DumpExplodedGraphTo = Args.getLastArgValue(OPT_analyzer_dump_egraph);
301  Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted);
302  Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
303  Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
304  Opts.AnalyzeNestedBlocks =
305  Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
306  Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
307  Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
308  Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
309  Opts.maxBlockVisitOnPath =
310  getLastArgIntValue(Args, OPT_analyzer_max_loop, 4, Diags);
311  Opts.PrintStats = Args.hasArg(OPT_analyzer_stats);
312  Opts.InlineMaxStackDepth =
313  getLastArgIntValue(Args, OPT_analyzer_inline_max_stack_depth,
314  Opts.InlineMaxStackDepth, Diags);
315 
316  Opts.CheckersControlList.clear();
317  for (const Arg *A :
318  Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
319  A->claim();
320  bool enable = (A->getOption().getID() == OPT_analyzer_checker);
321  // We can have a list of comma separated checker names, e.g:
322  // '-analyzer-checker=cocoa,unix'
323  StringRef checkerList = A->getValue();
324  SmallVector<StringRef, 4> checkers;
325  checkerList.split(checkers, ",");
326  for (auto checker : checkers)
327  Opts.CheckersControlList.emplace_back(checker, enable);
328  }
329 
330  // Go through the analyzer configuration options.
331  for (const auto *A : Args.filtered(OPT_analyzer_config)) {
332 
333  // We can have a list of comma separated config names, e.g:
334  // '-analyzer-config key1=val1,key2=val2'
335  StringRef configList = A->getValue();
336  SmallVector<StringRef, 4> configVals;
337  configList.split(configVals, ",");
338  for (const auto &configVal : configVals) {
339  StringRef key, val;
340  std::tie(key, val) = configVal.split("=");
341  if (val.empty()) {
342  Diags.Report(SourceLocation(),
343  diag::err_analyzer_config_no_value) << configVal;
344  Success = false;
345  break;
346  }
347  if (val.find('=') != StringRef::npos) {
348  Diags.Report(SourceLocation(),
349  diag::err_analyzer_config_multiple_values)
350  << configVal;
351  Success = false;
352  break;
353  }
354 
355  // TODO: Check checker options too, possibly in CheckerRegistry.
356  // Leave unknown non-checker configs unclaimed.
357  if (!key.contains(":") && Opts.isUnknownAnalyzerConfig(key)) {
359  Diags.Report(diag::err_analyzer_config_unknown) << key;
360  continue;
361  }
362 
363  A->claim();
364  Opts.Config[key] = val;
365  }
366  }
367 
369  parseAnalyzerConfigs(Opts, &Diags);
370  else
371  parseAnalyzerConfigs(Opts, nullptr);
372 
373  llvm::raw_string_ostream os(Opts.FullCompilerInvocation);
374  for (unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
375  if (i != 0)
376  os << " ";
377  os << Args.getArgString(i);
378  }
379  os.flush();
380 
381  return Success;
382 }
383 
385  StringRef OptionName, StringRef DefaultVal) {
386  return Config.insert({OptionName, DefaultVal}).first->second;
387 }
388 
390  DiagnosticsEngine *Diags,
391  StringRef &OptionField, StringRef Name,
392  StringRef DefaultVal) {
393  // String options may be known to invalid (e.g. if the expected string is a
394  // file name, but the file does not exist), those will have to be checked in
395  // parseConfigs.
396  OptionField = getStringOption(Config, Name, DefaultVal);
397 }
398 
400  DiagnosticsEngine *Diags,
401  bool &OptionField, StringRef Name, bool DefaultVal) {
402  auto PossiblyInvalidVal = llvm::StringSwitch<Optional<bool>>(
403  getStringOption(Config, Name, (DefaultVal ? "true" : "false")))
404  .Case("true", true)
405  .Case("false", false)
406  .Default(None);
407 
408  if (!PossiblyInvalidVal) {
409  if (Diags)
410  Diags->Report(diag::err_analyzer_config_invalid_input)
411  << Name << "a boolean";
412  else
413  OptionField = DefaultVal;
414  } else
415  OptionField = PossiblyInvalidVal.getValue();
416 }
417 
419  DiagnosticsEngine *Diags,
420  unsigned &OptionField, StringRef Name,
421  unsigned DefaultVal) {
422 
423  OptionField = DefaultVal;
424  bool HasFailed = getStringOption(Config, Name, std::to_string(DefaultVal))
425  .getAsInteger(10, OptionField);
426  if (Diags && HasFailed)
427  Diags->Report(diag::err_analyzer_config_invalid_input)
428  << Name << "an unsigned";
429 }
430 
432  DiagnosticsEngine *Diags) {
433  // TODO: There's no need to store the entire configtable, it'd be plenty
434  // enough tostore checker options.
435 
436 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
437  initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
438 
439 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
440  SHALLOW_VAL, DEEP_VAL) \
441  switch (AnOpts.getUserMode()) { \
442  case UMK_Shallow: \
443  initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, SHALLOW_VAL); \
444  break; \
445  case UMK_Deep: \
446  initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEEP_VAL); \
447  break; \
448  } \
449 
450 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
451 #undef ANALYZER_OPTION
452 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
453 
454  // At this point, AnalyzerOptions is configured. Let's validate some options.
455 
456  if (!Diags)
457  return;
458 
459  if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
460  Diags->Report(diag::err_analyzer_config_invalid_input) << "ctu-dir"
461  << "a filename";
462 
463  if (!AnOpts.ModelPath.empty() &&
464  !llvm::sys::fs::is_directory(AnOpts.ModelPath))
465  Diags->Report(diag::err_analyzer_config_invalid_input) << "model-path"
466  << "a filename";
467 }
468 
469 static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args) {
470  Opts.NoNSAllocReallocError = Args.hasArg(OPT_migrator_no_nsalloc_error);
471  Opts.NoFinalizeRemoval = Args.hasArg(OPT_migrator_no_finalize_removal);
472  return true;
473 }
474 
475 static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args) {
476  Opts.BlockCommandNames = Args.getAllArgValues(OPT_fcomment_block_commands);
477  Opts.ParseAllComments = Args.hasArg(OPT_fparse_all_comments);
478 }
479 
480 static StringRef getCodeModel(ArgList &Args, DiagnosticsEngine &Diags) {
481  if (Arg *A = Args.getLastArg(OPT_mcode_model)) {
482  StringRef Value = A->getValue();
483  if (Value == "small" || Value == "kernel" || Value == "medium" ||
484  Value == "large" || Value == "tiny")
485  return Value;
486  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
487  }
488  return "default";
489 }
490 
491 static llvm::Reloc::Model getRelocModel(ArgList &Args,
492  DiagnosticsEngine &Diags) {
493  if (Arg *A = Args.getLastArg(OPT_mrelocation_model)) {
494  StringRef Value = A->getValue();
495  auto RM = llvm::StringSwitch<llvm::Optional<llvm::Reloc::Model>>(Value)
496  .Case("static", llvm::Reloc::Static)
497  .Case("pic", llvm::Reloc::PIC_)
498  .Case("ropi", llvm::Reloc::ROPI)
499  .Case("rwpi", llvm::Reloc::RWPI)
500  .Case("ropi-rwpi", llvm::Reloc::ROPI_RWPI)
501  .Case("dynamic-no-pic", llvm::Reloc::DynamicNoPIC)
502  .Default(None);
503  if (RM.hasValue())
504  return *RM;
505  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
506  }
507  return llvm::Reloc::PIC_;
508 }
509 
510 /// Create a new Regex instance out of the string value in \p RpassArg.
511 /// It returns a pointer to the newly generated Regex instance.
512 static std::shared_ptr<llvm::Regex>
514  Arg *RpassArg) {
515  StringRef Val = RpassArg->getValue();
516  std::string RegexError;
517  std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val);
518  if (!Pattern->isValid(RegexError)) {
519  Diags.Report(diag::err_drv_optimization_remark_pattern)
520  << RegexError << RpassArg->getAsString(Args);
521  Pattern.reset();
522  }
523  return Pattern;
524 }
525 
526 static bool parseDiagnosticLevelMask(StringRef FlagName,
527  const std::vector<std::string> &Levels,
528  DiagnosticsEngine *Diags,
529  DiagnosticLevelMask &M) {
530  bool Success = true;
531  for (const auto &Level : Levels) {
532  DiagnosticLevelMask const PM =
533  llvm::StringSwitch<DiagnosticLevelMask>(Level)
534  .Case("note", DiagnosticLevelMask::Note)
535  .Case("remark", DiagnosticLevelMask::Remark)
536  .Case("warning", DiagnosticLevelMask::Warning)
537  .Case("error", DiagnosticLevelMask::Error)
538  .Default(DiagnosticLevelMask::None);
539  if (PM == DiagnosticLevelMask::None) {
540  Success = false;
541  if (Diags)
542  Diags->Report(diag::err_drv_invalid_value) << FlagName << Level;
543  }
544  M = M | PM;
545  }
546  return Success;
547 }
548 
549 static void parseSanitizerKinds(StringRef FlagName,
550  const std::vector<std::string> &Sanitizers,
551  DiagnosticsEngine &Diags, SanitizerSet &S) {
552  for (const auto &Sanitizer : Sanitizers) {
553  SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
554  if (K == 0)
555  Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
556  else
557  S.set(K, true);
558  }
559 }
560 
561 static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle,
562  ArgList &Args, DiagnosticsEngine &D,
563  XRayInstrSet &S) {
565  llvm::SplitString(Bundle, BundleParts, ",");
566  for (const auto B : BundleParts) {
567  auto Mask = parseXRayInstrValue(B);
568  if (Mask == XRayInstrKind::None)
569  if (B != "none")
570  D.Report(diag::err_drv_invalid_value) << FlagName << Bundle;
571  else
572  S.Mask = Mask;
573  else if (Mask == XRayInstrKind::All)
574  S.Mask = Mask;
575  else
576  S.set(Mask, true);
577  }
578 }
579 
580 // Set the profile kind for fprofile-instrument.
581 static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args,
582  DiagnosticsEngine &Diags) {
583  Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ);
584  if (A == nullptr)
585  return;
586  StringRef S = A->getValue();
587  unsigned I = llvm::StringSwitch<unsigned>(S)
588  .Case("none", CodeGenOptions::ProfileNone)
589  .Case("clang", CodeGenOptions::ProfileClangInstr)
590  .Case("llvm", CodeGenOptions::ProfileIRInstr)
591  .Default(~0U);
592  if (I == ~0U) {
593  Diags.Report(diag::err_drv_invalid_pgo_instrumentor) << A->getAsString(Args)
594  << S;
595  return;
596  }
597  auto Instrumentor = static_cast<CodeGenOptions::ProfileInstrKind>(I);
598  Opts.setProfileInstr(Instrumentor);
599 }
600 
601 // Set the profile kind using fprofile-instrument-use-path.
603  const Twine &ProfileName) {
604  auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName);
605  // In error, return silently and let Clang PGOUse report the error message.
606  if (auto E = ReaderOrErr.takeError()) {
607  llvm::consumeError(std::move(E));
608  Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
609  return;
610  }
611  std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
612  std::move(ReaderOrErr.get());
613  if (PGOReader->isIRLevelProfile())
614  Opts.setProfileUse(CodeGenOptions::ProfileIRInstr);
615  else
616  Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
617 }
618 
619 static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
620  DiagnosticsEngine &Diags,
621  const TargetOptions &TargetOpts,
622  const FrontendOptions &FrontendOpts) {
623  bool Success = true;
624  llvm::Triple Triple = llvm::Triple(TargetOpts.Triple);
625 
626  unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
627  // TODO: This could be done in Driver
628  unsigned MaxOptLevel = 3;
629  if (OptimizationLevel > MaxOptLevel) {
630  // If the optimization level is not supported, fall back on the default
631  // optimization
632  Diags.Report(diag::warn_drv_optimization_value)
633  << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel;
634  OptimizationLevel = MaxOptLevel;
635  }
636  Opts.OptimizationLevel = OptimizationLevel;
637 
638  // At O0 we want to fully disable inlining outside of cases marked with
639  // 'alwaysinline' that are required for correctness.
640  Opts.setInlining((Opts.OptimizationLevel == 0)
643  // Explicit inlining flags can disable some or all inlining even at
644  // optimization levels above zero.
645  if (Arg *InlineArg = Args.getLastArg(
646  options::OPT_finline_functions, options::OPT_finline_hint_functions,
647  options::OPT_fno_inline_functions, options::OPT_fno_inline)) {
648  if (Opts.OptimizationLevel > 0) {
649  const Option &InlineOpt = InlineArg->getOption();
650  if (InlineOpt.matches(options::OPT_finline_functions))
651  Opts.setInlining(CodeGenOptions::NormalInlining);
652  else if (InlineOpt.matches(options::OPT_finline_hint_functions))
653  Opts.setInlining(CodeGenOptions::OnlyHintInlining);
654  else
655  Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
656  }
657  }
658 
659  Opts.ExperimentalNewPassManager = Args.hasFlag(
660  OPT_fexperimental_new_pass_manager, OPT_fno_experimental_new_pass_manager,
661  /* Default */ ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER);
662 
663  Opts.DebugPassManager =
664  Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
665  /* Default */ false);
666 
667  if (Arg *A = Args.getLastArg(OPT_fveclib)) {
668  StringRef Name = A->getValue();
669  if (Name == "Accelerate")
670  Opts.setVecLib(CodeGenOptions::Accelerate);
671  else if (Name == "SVML")
672  Opts.setVecLib(CodeGenOptions::SVML);
673  else if (Name == "none")
674  Opts.setVecLib(CodeGenOptions::NoLibrary);
675  else
676  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
677  }
678 
679  if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
680  unsigned Val =
681  llvm::StringSwitch<unsigned>(A->getValue())
682  .Case("line-tables-only", codegenoptions::DebugLineTablesOnly)
683  .Case("line-directives-only", codegenoptions::DebugDirectivesOnly)
684  .Case("limited", codegenoptions::LimitedDebugInfo)
685  .Case("standalone", codegenoptions::FullDebugInfo)
686  .Default(~0U);
687  if (Val == ~0U)
688  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
689  << A->getValue();
690  else
691  Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val));
692  }
693  if (Arg *A = Args.getLastArg(OPT_debugger_tuning_EQ)) {
694  unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
695  .Case("gdb", unsigned(llvm::DebuggerKind::GDB))
696  .Case("lldb", unsigned(llvm::DebuggerKind::LLDB))
697  .Case("sce", unsigned(llvm::DebuggerKind::SCE))
698  .Default(~0U);
699  if (Val == ~0U)
700  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
701  << A->getValue();
702  else
703  Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val));
704  }
705  Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
706  Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
707  Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
708  Opts.CodeViewGHash = Args.hasArg(OPT_gcodeview_ghash);
709  Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro);
710  Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
711  Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std);
712  Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
713  Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining);
714 
715  if (Arg *A =
716  Args.getLastArg(OPT_enable_split_dwarf, OPT_enable_split_dwarf_EQ)) {
717  if (A->getOption().matches(options::OPT_enable_split_dwarf)) {
718  Opts.setSplitDwarfMode(CodeGenOptions::SplitFileFission);
719  } else {
720  StringRef Name = A->getValue();
721  if (Name == "single")
722  Opts.setSplitDwarfMode(CodeGenOptions::SingleFileFission);
723  else if (Name == "split")
724  Opts.setSplitDwarfMode(CodeGenOptions::SplitFileFission);
725  else
726  Diags.Report(diag::err_drv_invalid_value)
727  << A->getAsString(Args) << Name;
728  }
729  }
730 
731  Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
732  Opts.DebugExplicitImport = Args.hasArg(OPT_dwarf_explicit_import);
733  Opts.DebugFwdTemplateParams = Args.hasArg(OPT_debug_forward_template_params);
734  Opts.EmbedSource = Args.hasArg(OPT_gembed_source);
735 
736  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
737  Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
738 
739  if (const Arg *A =
740  Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
741  Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
742 
743  Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
744  Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
745  Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
746  Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
747  Opts.IndirectTlsSegRefs = Args.hasArg(OPT_mno_tls_direct_seg_refs);
748  Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
749  Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
750  OPT_fuse_register_sized_bitfield_access);
751  Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
752  Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
753  Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
754  Args.hasArg(OPT_new_struct_path_tbaa);
755  Opts.FineGrainedBitfieldAccesses =
756  Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
757  OPT_fno_fine_grained_bitfield_accesses, false);
758  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
759  Opts.RecordCommandLine = Args.getLastArgValue(OPT_record_command_line);
760  Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants);
761  Opts.NoCommon = Args.hasArg(OPT_fno_common);
762  Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
763  Opts.OptimizeSize = getOptimizationLevelSize(Args);
764  Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
765  Args.hasArg(OPT_ffreestanding));
766  if (Opts.SimplifyLibCalls)
768  Opts.UnrollLoops =
769  Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
770  (Opts.OptimizationLevel > 1));
771  Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
772 
773  Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
774  Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
775  Opts.SampleProfileFile = Args.getLastArgValue(OPT_fprofile_sample_use_EQ);
776  Opts.DebugInfoForProfiling = Args.hasFlag(
777  OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
778  Opts.DebugNameTable = static_cast<unsigned>(
779  Args.hasArg(OPT_ggnu_pubnames)
780  ? llvm::DICompileUnit::DebugNameTableKind::GNU
781  : Args.hasArg(OPT_gpubnames)
782  ? llvm::DICompileUnit::DebugNameTableKind::Default
784  Opts.DebugRangesBaseAddress = Args.hasArg(OPT_fdebug_ranges_base_address);
785 
786  setPGOInstrumentor(Opts, Args, Diags);
787  Opts.InstrProfileOutput =
788  Args.getLastArgValue(OPT_fprofile_instrument_path_EQ);
790  Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ);
791  if (!Opts.ProfileInstrumentUsePath.empty())
793  Opts.ProfileRemappingFile =
794  Args.getLastArgValue(OPT_fprofile_remapping_file_EQ);
795  if (!Opts.ProfileRemappingFile.empty() && !Opts.ExperimentalNewPassManager) {
796  Diags.Report(diag::err_drv_argument_only_allowed_with)
797  << Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args)
798  << "-fexperimental-new-pass-manager";
799  }
800 
801  Opts.CoverageMapping =
802  Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
803  Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
804  Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
805  Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
806  Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
807  Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
808  Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
809  Opts.RegisterGlobalDtorsWithAtExit =
810  Args.hasArg(OPT_fregister_global_dtors_with_atexit);
811  Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
812  Opts.CodeModel = TargetOpts.CodeModel;
813  Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
814  Opts.DisableFPElim =
815  (Args.hasArg(OPT_mdisable_fp_elim) || Args.hasArg(OPT_pg));
816  Opts.DisableFree = Args.hasArg(OPT_disable_free);
817  Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
818  Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
819  Opts.NoEscapingBlockTailCalls =
820  Args.hasArg(OPT_fno_escaping_block_tail_calls);
821  Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
822  Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable) ||
823  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
824  Args.hasArg(OPT_cl_fast_relaxed_math);
825  Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
826  Opts.NoInfsFPMath = (Args.hasArg(OPT_menable_no_infinities) ||
827  Args.hasArg(OPT_cl_finite_math_only) ||
828  Args.hasArg(OPT_cl_fast_relaxed_math));
829  Opts.NoNaNsFPMath = (Args.hasArg(OPT_menable_no_nans) ||
830  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
831  Args.hasArg(OPT_cl_finite_math_only) ||
832  Args.hasArg(OPT_cl_fast_relaxed_math));
833  Opts.NoSignedZeros = (Args.hasArg(OPT_fno_signed_zeros) ||
834  Args.hasArg(OPT_cl_no_signed_zeros) ||
835  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
836  Args.hasArg(OPT_cl_fast_relaxed_math));
837  Opts.Reassociate = Args.hasArg(OPT_mreassociate);
838  Opts.FlushDenorm = Args.hasArg(OPT_cl_denorms_are_zero) ||
839  (Args.hasArg(OPT_fcuda_is_device) &&
840  Args.hasArg(OPT_fcuda_flush_denormals_to_zero));
841  Opts.CorrectlyRoundedDivSqrt =
842  Args.hasArg(OPT_cl_fp32_correctly_rounded_divide_sqrt);
843  Opts.UniformWGSize =
844  Args.hasArg(OPT_cl_uniform_work_group_size);
845  Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
846  Opts.ReciprocalMath = Args.hasArg(OPT_freciprocal_math);
847  Opts.NoTrappingMath = Args.hasArg(OPT_fno_trapping_math);
848  Opts.StrictFloatCastOverflow =
849  !Args.hasArg(OPT_fno_strict_float_cast_overflow);
850 
851  Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
852  Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
853  Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
854  Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
855  Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
856  Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
857  Opts.IncrementalLinkerCompatible =
858  Args.hasArg(OPT_mincremental_linker_compatible);
859  Opts.PIECopyRelocations =
860  Args.hasArg(OPT_mpie_copy_relocations);
861  Opts.NoPLT = Args.hasArg(OPT_fno_plt);
862  Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
863  Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
864  Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
865  Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
866  Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
867  Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
868  Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
869  Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables);
870  Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
871  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
872  Args.hasArg(OPT_cl_fast_relaxed_math);
873  Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
874  Opts.RelocationModel = getRelocModel(Args, Diags);
875  Opts.ThreadModel = Args.getLastArgValue(OPT_mthread_model, "posix");
876  if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
877  Diags.Report(diag::err_drv_invalid_value)
878  << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
879  << Opts.ThreadModel;
880  Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
881  Opts.UseInitArray = Args.hasArg(OPT_fuse_init_array);
882 
883  Opts.FunctionSections = Args.hasFlag(OPT_ffunction_sections,
884  OPT_fno_function_sections, false);
885  Opts.DataSections = Args.hasFlag(OPT_fdata_sections,
886  OPT_fno_data_sections, false);
887  Opts.StackSizeSection =
888  Args.hasFlag(OPT_fstack_size_section, OPT_fno_stack_size_section, false);
889  Opts.UniqueSectionNames = Args.hasFlag(OPT_funique_section_names,
890  OPT_fno_unique_section_names, true);
891 
892  Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
893 
894  Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
895 
896  Opts.NullPointerIsValid = Args.hasArg(OPT_fno_delete_null_pointer_checks);
897 
898  Opts.ProfileSampleAccurate = Args.hasArg(OPT_fprofile_sample_accurate);
899 
900  Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
901  Opts.PrepareForThinLTO = false;
902  if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
903  StringRef S = A->getValue();
904  if (S == "thin")
905  Opts.PrepareForThinLTO = true;
906  else if (S != "full")
907  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
908  }
909  Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false);
910  Opts.EnableSplitLTOUnit = Args.hasArg(OPT_fsplit_lto_unit);
911  if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
912  if (IK.getLanguage() != InputKind::LLVM_IR)
913  Diags.Report(diag::err_drv_argument_only_allowed_with)
914  << A->getAsString(Args) << "-x ir";
915  Opts.ThinLTOIndexFile = Args.getLastArgValue(OPT_fthinlto_index_EQ);
916  }
917  if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
918  Opts.SaveTempsFilePrefix =
919  llvm::StringSwitch<std::string>(A->getValue())
920  .Case("obj", FrontendOpts.OutputFile)
921  .Default(llvm::sys::path::filename(FrontendOpts.OutputFile).str());
922 
923  Opts.ThinLinkBitcodeFile = Args.getLastArgValue(OPT_fthin_link_bitcode_EQ);
924 
925  Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
926 
927  Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
928  Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
929 
930  Opts.PreferVectorWidth = Args.getLastArgValue(OPT_mprefer_vector_width_EQ);
931 
932  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
933  Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
934 
935  Opts.ControlFlowGuard = Args.hasArg(OPT_cfguard);
936 
937  Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
938  Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
939  Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
940  if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
941  Opts.CoverageDataFile = Args.getLastArgValue(OPT_coverage_data_file);
942  Opts.CoverageNotesFile = Args.getLastArgValue(OPT_coverage_notes_file);
943  Opts.CoverageExtraChecksum = Args.hasArg(OPT_coverage_cfg_checksum);
944  Opts.CoverageNoFunctionNamesInData =
945  Args.hasArg(OPT_coverage_no_function_names_in_data);
946  Opts.ProfileFilterFiles =
947  Args.getLastArgValue(OPT_fprofile_filter_files_EQ);
948  Opts.ProfileExcludeFiles =
949  Args.getLastArgValue(OPT_fprofile_exclude_files_EQ);
950  Opts.CoverageExitBlockBeforeBody =
951  Args.hasArg(OPT_coverage_exit_block_before_body);
952  if (Args.hasArg(OPT_coverage_version_EQ)) {
953  StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
954  if (CoverageVersion.size() != 4) {
955  Diags.Report(diag::err_drv_invalid_value)
956  << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
957  << CoverageVersion;
958  } else {
959  memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
960  }
961  }
962  }
963  // Handle -fembed-bitcode option.
964  if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
965  StringRef Name = A->getValue();
966  unsigned Model = llvm::StringSwitch<unsigned>(Name)
967  .Case("off", CodeGenOptions::Embed_Off)
968  .Case("all", CodeGenOptions::Embed_All)
969  .Case("bitcode", CodeGenOptions::Embed_Bitcode)
970  .Case("marker", CodeGenOptions::Embed_Marker)
971  .Default(~0U);
972  if (Model == ~0U) {
973  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
974  Success = false;
975  } else
976  Opts.setEmbedBitcode(
977  static_cast<CodeGenOptions::EmbedBitcodeKind>(Model));
978  }
979  // FIXME: For backend options that are not yet recorded as function
980  // attributes in the IR, keep track of them so we can embed them in a
981  // separate data section and use them when building the bitcode.
982  if (Opts.getEmbedBitcode() == CodeGenOptions::Embed_All) {
983  for (const auto &A : Args) {
984  // Do not encode output and input.
985  if (A->getOption().getID() == options::OPT_o ||
986  A->getOption().getID() == options::OPT_INPUT ||
987  A->getOption().getID() == options::OPT_x ||
988  A->getOption().getID() == options::OPT_fembed_bitcode ||
989  (A->getOption().getGroup().isValid() &&
990  A->getOption().getGroup().getID() == options::OPT_W_Group))
991  continue;
992  ArgStringList ASL;
993  A->render(Args, ASL);
994  for (const auto &arg : ASL) {
995  StringRef ArgStr(arg);
996  Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
997  // using \00 to separate each commandline options.
998  Opts.CmdArgs.push_back('\0');
999  }
1000  }
1001  }
1002 
1003  Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
1004  Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
1005  Opts.InstrumentFunctionsAfterInlining =
1006  Args.hasArg(OPT_finstrument_functions_after_inlining);
1007  Opts.InstrumentFunctionEntryBare =
1008  Args.hasArg(OPT_finstrument_function_entry_bare);
1009 
1010  Opts.XRayInstrumentFunctions =
1011  Args.hasArg(OPT_fxray_instrument);
1012  Opts.XRayAlwaysEmitCustomEvents =
1013  Args.hasArg(OPT_fxray_always_emit_customevents);
1014  Opts.XRayAlwaysEmitTypedEvents =
1015  Args.hasArg(OPT_fxray_always_emit_typedevents);
1016  Opts.XRayInstructionThreshold =
1017  getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
1018 
1019  auto XRayInstrBundles =
1020  Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1021  if (XRayInstrBundles.empty())
1023  else
1024  for (const auto &A : XRayInstrBundles)
1025  parseXRayInstrumentationBundle("-fxray-instrumentation-bundle=", A, Args,
1026  Diags, Opts.XRayInstrumentationBundle);
1027 
1028  Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
1029  Opts.CallFEntry = Args.hasArg(OPT_mfentry);
1030  Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
1031 
1032  if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1033  StringRef Name = A->getValue();
1034  if (Name == "full") {
1035  Opts.CFProtectionReturn = 1;
1036  Opts.CFProtectionBranch = 1;
1037  } else if (Name == "return")
1038  Opts.CFProtectionReturn = 1;
1039  else if (Name == "branch")
1040  Opts.CFProtectionBranch = 1;
1041  else if (Name != "none") {
1042  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1043  Success = false;
1044  }
1045  }
1046 
1047  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
1048  OPT_compress_debug_sections_EQ)) {
1049  if (A->getOption().getID() == OPT_compress_debug_sections) {
1050  // TODO: be more clever about the compression type auto-detection
1051  Opts.setCompressDebugSections(llvm::DebugCompressionType::GNU);
1052  } else {
1053  auto DCT = llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
1054  .Case("none", llvm::DebugCompressionType::None)
1055  .Case("zlib", llvm::DebugCompressionType::Z)
1056  .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
1058  Opts.setCompressDebugSections(DCT);
1059  }
1060  }
1061 
1062  Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
1063  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
1064  for (auto *A :
1065  Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1067  F.Filename = A->getValue();
1068  if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1069  F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1070  // When linking CUDA bitcode, propagate function attributes so that
1071  // e.g. libdevice gets fast-math attrs if we're building with fast-math.
1072  F.PropagateAttrs = true;
1073  F.Internalize = true;
1074  }
1075  Opts.LinkBitcodeFiles.push_back(F);
1076  }
1077  Opts.SanitizeCoverageType =
1078  getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
1079  Opts.SanitizeCoverageIndirectCalls =
1080  Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
1081  Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
1082  Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
1083  Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
1084  Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
1085  Opts.SanitizeCoverage8bitCounters =
1086  Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
1087  Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
1088  Opts.SanitizeCoverageTracePCGuard =
1089  Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
1090  Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune);
1091  Opts.SanitizeCoverageInline8bitCounters =
1092  Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters);
1093  Opts.SanitizeCoveragePCTable = Args.hasArg(OPT_fsanitize_coverage_pc_table);
1094  Opts.SanitizeCoverageStackDepth =
1095  Args.hasArg(OPT_fsanitize_coverage_stack_depth);
1096  Opts.SanitizeMemoryTrackOrigins =
1097  getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
1098  Opts.SanitizeMemoryUseAfterDtor =
1099  Args.hasFlag(OPT_fsanitize_memory_use_after_dtor,
1100  OPT_fno_sanitize_memory_use_after_dtor,
1101  false);
1102  Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime);
1103  Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
1104  Opts.SanitizeCfiICallGeneralizePointers =
1105  Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers);
1106  Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
1107  if (Arg *A = Args.getLastArg(
1108  OPT_fsanitize_address_poison_custom_array_cookie,
1109  OPT_fno_sanitize_address_poison_custom_array_cookie)) {
1110  Opts.SanitizeAddressPoisonCustomArrayCookie =
1111  A->getOption().getID() ==
1112  OPT_fsanitize_address_poison_custom_array_cookie;
1113  }
1114  if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope,
1115  OPT_fno_sanitize_address_use_after_scope)) {
1116  Opts.SanitizeAddressUseAfterScope =
1117  A->getOption().getID() == OPT_fsanitize_address_use_after_scope;
1118  }
1119  Opts.SanitizeAddressGlobalsDeadStripping =
1120  Args.hasArg(OPT_fsanitize_address_globals_dead_stripping);
1121  if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_odr_indicator,
1122  OPT_fno_sanitize_address_use_odr_indicator)) {
1123  Opts.SanitizeAddressUseOdrIndicator =
1124  A->getOption().getID() == OPT_fsanitize_address_use_odr_indicator;
1125  }
1126  Opts.SSPBufferSize =
1127  getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
1128  Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
1129  if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
1130  StringRef Val = A->getValue();
1131  unsigned StackAlignment = Opts.StackAlignment;
1132  Val.getAsInteger(10, StackAlignment);
1133  Opts.StackAlignment = StackAlignment;
1134  }
1135 
1136  if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) {
1137  StringRef Val = A->getValue();
1138  unsigned StackProbeSize = Opts.StackProbeSize;
1139  Val.getAsInteger(0, StackProbeSize);
1140  Opts.StackProbeSize = StackProbeSize;
1141  }
1142 
1143  Opts.NoStackArgProbe = Args.hasArg(OPT_mno_stack_arg_probe);
1144 
1145  if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
1146  StringRef Name = A->getValue();
1147  unsigned Method = llvm::StringSwitch<unsigned>(Name)
1148  .Case("legacy", CodeGenOptions::Legacy)
1149  .Case("non-legacy", CodeGenOptions::NonLegacy)
1150  .Case("mixed", CodeGenOptions::Mixed)
1151  .Default(~0U);
1152  if (Method == ~0U) {
1153  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1154  Success = false;
1155  } else {
1156  Opts.setObjCDispatchMethod(
1157  static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
1158  }
1159  }
1160 
1161 
1162  if (Args.hasArg(OPT_fno_objc_convert_messages_to_runtime_calls))
1163  Opts.ObjCConvertMessagesToRuntimeCalls = 0;
1164 
1165  if (Args.getLastArg(OPT_femulated_tls) ||
1166  Args.getLastArg(OPT_fno_emulated_tls)) {
1167  Opts.ExplicitEmulatedTLS = true;
1168  Opts.EmulatedTLS =
1169  Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
1170  }
1171 
1172  if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
1173  StringRef Name = A->getValue();
1174  unsigned Model = llvm::StringSwitch<unsigned>(Name)
1175  .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
1176  .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
1177  .Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
1178  .Case("local-exec", CodeGenOptions::LocalExecTLSModel)
1179  .Default(~0U);
1180  if (Model == ~0U) {
1181  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1182  Success = false;
1183  } else {
1184  Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
1185  }
1186  }
1187 
1188  if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1189  StringRef Val = A->getValue();
1190  if (Val == "ieee")
1191  Opts.FPDenormalMode = "ieee";
1192  else if (Val == "preserve-sign")
1193  Opts.FPDenormalMode = "preserve-sign";
1194  else if (Val == "positive-zero")
1195  Opts.FPDenormalMode = "positive-zero";
1196  else
1197  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1198  }
1199 
1200  if (Arg *A = Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return)) {
1201  if (A->getOption().matches(OPT_fpcc_struct_return)) {
1202  Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
1203  } else {
1204  assert(A->getOption().matches(OPT_freg_struct_return));
1205  Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
1206  }
1207  }
1208 
1209  Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
1210  Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
1211  bool NeedLocTracking = false;
1212 
1213  Opts.OptRecordFile = Args.getLastArgValue(OPT_opt_record_file);
1214  if (!Opts.OptRecordFile.empty())
1215  NeedLocTracking = true;
1216 
1217  if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
1219  GenerateOptimizationRemarkRegex(Diags, Args, A);
1220  NeedLocTracking = true;
1221  }
1222 
1223  if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) {
1225  GenerateOptimizationRemarkRegex(Diags, Args, A);
1226  NeedLocTracking = true;
1227  }
1228 
1229  if (Arg *A = Args.getLastArg(OPT_Rpass_analysis_EQ)) {
1231  GenerateOptimizationRemarkRegex(Diags, Args, A);
1232  NeedLocTracking = true;
1233  }
1234 
1235  Opts.DiagnosticsWithHotness =
1236  Args.hasArg(options::OPT_fdiagnostics_show_hotness);
1237  bool UsingSampleProfile = !Opts.SampleProfileFile.empty();
1238  bool UsingProfile = UsingSampleProfile ||
1239  (Opts.getProfileUse() != CodeGenOptions::ProfileNone);
1240 
1241  if (Opts.DiagnosticsWithHotness && !UsingProfile &&
1242  // An IR file will contain PGO as metadata
1244  Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1245  << "-fdiagnostics-show-hotness";
1246 
1247  Opts.DiagnosticsHotnessThreshold = getLastArgUInt64Value(
1248  Args, options::OPT_fdiagnostics_hotness_threshold_EQ, 0);
1249  if (Opts.DiagnosticsHotnessThreshold > 0 && !UsingProfile)
1250  Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1251  << "-fdiagnostics-hotness-threshold=";
1252 
1253  // If the user requested to use a sample profile for PGO, then the
1254  // backend will need to track source location information so the profile
1255  // can be incorporated into the IR.
1256  if (UsingSampleProfile)
1257  NeedLocTracking = true;
1258 
1259  // If the user requested a flag that requires source locations available in
1260  // the backend, make sure that the backend tracks source location information.
1261  if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo)
1262  Opts.setDebugInfo(codegenoptions::LocTrackingOnly);
1263 
1264  Opts.RewriteMapFiles = Args.getAllArgValues(OPT_frewrite_map_file);
1265 
1266  // Parse -fsanitize-recover= arguments.
1267  // FIXME: Report unrecoverable sanitizers incorrectly specified here.
1268  parseSanitizerKinds("-fsanitize-recover=",
1269  Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
1270  Opts.SanitizeRecover);
1271  parseSanitizerKinds("-fsanitize-trap=",
1272  Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
1273  Opts.SanitizeTrap);
1274 
1275  Opts.CudaGpuBinaryFileName =
1276  Args.getLastArgValue(OPT_fcuda_include_gpubinary);
1277 
1278  Opts.Backchain = Args.hasArg(OPT_mbackchain);
1279 
1280  Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
1281  Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
1282 
1283  Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);
1284 
1285  Opts.Addrsig = Args.hasArg(OPT_faddrsig);
1286 
1287  if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
1288  StringRef SignScope = A->getValue();
1289 
1290  if (SignScope.equals_lower("none"))
1291  Opts.setSignReturnAddress(CodeGenOptions::SignReturnAddressScope::None);
1292  else if (SignScope.equals_lower("all"))
1293  Opts.setSignReturnAddress(CodeGenOptions::SignReturnAddressScope::All);
1294  else if (SignScope.equals_lower("non-leaf"))
1295  Opts.setSignReturnAddress(
1296  CodeGenOptions::SignReturnAddressScope::NonLeaf);
1297  else
1298  Diags.Report(diag::err_drv_invalid_value)
1299  << A->getAsString(Args) << SignScope;
1300 
1301  if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
1302  StringRef SignKey = A->getValue();
1303  if (!SignScope.empty() && !SignKey.empty()) {
1304  if (SignKey.equals_lower("a_key"))
1305  Opts.setSignReturnAddressKey(
1306  CodeGenOptions::SignReturnAddressKeyValue::AKey);
1307  else if (SignKey.equals_lower("b_key"))
1308  Opts.setSignReturnAddressKey(
1309  CodeGenOptions::SignReturnAddressKeyValue::BKey);
1310  else
1311  Diags.Report(diag::err_drv_invalid_value)
1312  << A->getAsString(Args) << SignKey;
1313  }
1314  }
1315  }
1316 
1317  Opts.BranchTargetEnforcement = Args.hasArg(OPT_mbranch_target_enforce);
1318 
1319  Opts.KeepStaticConsts = Args.hasArg(OPT_fkeep_static_consts);
1320 
1321  Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening);
1322 
1323  Opts.DefaultFunctionAttrs = Args.getAllArgValues(OPT_default_function_attr);
1324 
1325  return Success;
1326 }
1327 
1329  ArgList &Args) {
1330  Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
1331  Opts.Targets = Args.getAllArgValues(OPT_MT);
1332  Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
1333  Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
1334  Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
1335  Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
1336  Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
1337  Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
1338  if (Args.hasArg(OPT_show_includes)) {
1339  // Writing both /showIncludes and preprocessor output to stdout
1340  // would produce interleaved output, so use stderr for /showIncludes.
1341  // This behaves the same as cl.exe, when /E, /EP or /P are passed.
1342  if (Args.hasArg(options::OPT_E) || Args.hasArg(options::OPT_P))
1344  else
1346  } else {
1348  }
1349  Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
1351  Args.getLastArgValue(OPT_module_dependency_dir);
1352  if (Args.hasArg(OPT_MV))
1354  // Add sanitizer blacklists as extra dependencies.
1355  // They won't be discovered by the regular preprocessor, so
1356  // we let make / ninja to know about this implicit dependency.
1357  Opts.ExtraDeps = Args.getAllArgValues(OPT_fdepfile_entry);
1358  // Only the -fmodule-file=<file> form.
1359  for (const auto *A : Args.filtered(OPT_fmodule_file)) {
1360  StringRef Val = A->getValue();
1361  if (Val.find('=') == StringRef::npos)
1362  Opts.ExtraDeps.push_back(Val);
1363  }
1364 }
1365 
1366 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
1367  // Color diagnostics default to auto ("on" if terminal supports) in the driver
1368  // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
1369  // Support both clang's -f[no-]color-diagnostics and gcc's
1370  // -f[no-]diagnostics-colors[=never|always|auto].
1371  enum {
1372  Colors_On,
1373  Colors_Off,
1374  Colors_Auto
1375  } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
1376  for (auto *A : Args) {
1377  const Option &O = A->getOption();
1378  if (O.matches(options::OPT_fcolor_diagnostics) ||
1379  O.matches(options::OPT_fdiagnostics_color)) {
1380  ShowColors = Colors_On;
1381  } else if (O.matches(options::OPT_fno_color_diagnostics) ||
1382  O.matches(options::OPT_fno_diagnostics_color)) {
1383  ShowColors = Colors_Off;
1384  } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
1385  StringRef Value(A->getValue());
1386  if (Value == "always")
1387  ShowColors = Colors_On;
1388  else if (Value == "never")
1389  ShowColors = Colors_Off;
1390  else if (Value == "auto")
1391  ShowColors = Colors_Auto;
1392  }
1393  }
1394  return ShowColors == Colors_On ||
1395  (ShowColors == Colors_Auto &&
1396  llvm::sys::Process::StandardErrHasColors());
1397 }
1398 
1399 static bool checkVerifyPrefixes(const std::vector<std::string> &VerifyPrefixes,
1400  DiagnosticsEngine *Diags) {
1401  bool Success = true;
1402  for (const auto &Prefix : VerifyPrefixes) {
1403  // Every prefix must start with a letter and contain only alphanumeric
1404  // characters, hyphens, and underscores.
1405  auto BadChar = std::find_if(Prefix.begin(), Prefix.end(),
1406  [](char C){return !isAlphanumeric(C)
1407  && C != '-' && C != '_';});
1408  if (BadChar != Prefix.end() || !isLetter(Prefix[0])) {
1409  Success = false;
1410  if (Diags) {
1411  Diags->Report(diag::err_drv_invalid_value) << "-verify=" << Prefix;
1412  Diags->Report(diag::note_drv_verify_prefix_spelling);
1413  }
1414  }
1415  }
1416  return Success;
1417 }
1418 
1419 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
1420  DiagnosticsEngine *Diags,
1421  bool DefaultDiagColor, bool DefaultShowOpt) {
1422  bool Success = true;
1423 
1424  Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
1425  if (Arg *A =
1426  Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
1427  Opts.DiagnosticSerializationFile = A->getValue();
1428  Opts.IgnoreWarnings = Args.hasArg(OPT_w);
1429  Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
1430  Opts.Pedantic = Args.hasArg(OPT_pedantic);
1431  Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
1432  Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
1433  Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
1434  Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
1435  OPT_fno_show_column,
1436  /*Default=*/true);
1437  Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
1438  Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
1439  Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
1440  Opts.ShowOptionNames =
1441  Args.hasFlag(OPT_fdiagnostics_show_option,
1442  OPT_fno_diagnostics_show_option, DefaultShowOpt);
1443 
1444  llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
1445 
1446  // Default behavior is to not to show note include stacks.
1447  Opts.ShowNoteIncludeStack = false;
1448  if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
1449  OPT_fno_diagnostics_show_note_include_stack))
1450  if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
1451  Opts.ShowNoteIncludeStack = true;
1452 
1453  StringRef ShowOverloads =
1454  Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
1455  if (ShowOverloads == "best")
1456  Opts.setShowOverloads(Ovl_Best);
1457  else if (ShowOverloads == "all")
1458  Opts.setShowOverloads(Ovl_All);
1459  else {
1460  Success = false;
1461  if (Diags)
1462  Diags->Report(diag::err_drv_invalid_value)
1463  << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1464  << ShowOverloads;
1465  }
1466 
1467  StringRef ShowCategory =
1468  Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
1469  if (ShowCategory == "none")
1470  Opts.ShowCategories = 0;
1471  else if (ShowCategory == "id")
1472  Opts.ShowCategories = 1;
1473  else if (ShowCategory == "name")
1474  Opts.ShowCategories = 2;
1475  else {
1476  Success = false;
1477  if (Diags)
1478  Diags->Report(diag::err_drv_invalid_value)
1479  << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1480  << ShowCategory;
1481  }
1482 
1483  StringRef Format =
1484  Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
1485  if (Format == "clang")
1486  Opts.setFormat(DiagnosticOptions::Clang);
1487  else if (Format == "msvc")
1488  Opts.setFormat(DiagnosticOptions::MSVC);
1489  else if (Format == "msvc-fallback") {
1490  Opts.setFormat(DiagnosticOptions::MSVC);
1491  Opts.CLFallbackMode = true;
1492  } else if (Format == "vi")
1493  Opts.setFormat(DiagnosticOptions::Vi);
1494  else {
1495  Success = false;
1496  if (Diags)
1497  Diags->Report(diag::err_drv_invalid_value)
1498  << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
1499  << Format;
1500  }
1501 
1502  Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
1503  Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
1504  Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
1505  Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
1506  Opts.VerifyPrefixes = Args.getAllArgValues(OPT_verify_EQ);
1507  if (Args.hasArg(OPT_verify))
1508  Opts.VerifyPrefixes.push_back("expected");
1509  // Keep VerifyPrefixes in its original order for the sake of diagnostics, and
1510  // then sort it to prepare for fast lookup using std::binary_search.
1511  if (!checkVerifyPrefixes(Opts.VerifyPrefixes, Diags)) {
1512  Opts.VerifyDiagnostics = false;
1513  Success = false;
1514  }
1515  else
1516  llvm::sort(Opts.VerifyPrefixes);
1518  Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
1519  Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
1520  Diags, DiagMask);
1521  if (Args.hasArg(OPT_verify_ignore_unexpected))
1522  DiagMask = DiagnosticLevelMask::All;
1523  Opts.setVerifyIgnoreUnexpected(DiagMask);
1524  Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
1525  Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
1526  Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
1527  Opts.MacroBacktraceLimit =
1528  getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
1530  Opts.TemplateBacktraceLimit = getLastArgIntValue(
1531  Args, OPT_ftemplate_backtrace_limit,
1533  Opts.ConstexprBacktraceLimit = getLastArgIntValue(
1534  Args, OPT_fconstexpr_backtrace_limit,
1536  Opts.SpellCheckingLimit = getLastArgIntValue(
1537  Args, OPT_fspell_checking_limit,
1539  Opts.SnippetLineLimit = getLastArgIntValue(
1540  Args, OPT_fcaret_diagnostics_max_lines,
1542  Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
1544  if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
1545  Opts.TabStop = DiagnosticOptions::DefaultTabStop;
1546  if (Diags)
1547  Diags->Report(diag::warn_ignoring_ftabstop_value)
1548  << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
1549  }
1550  Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
1551  addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
1552  addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
1553 
1554  return Success;
1555 }
1556 
1557 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1558  Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
1559 }
1560 
1561 /// Parse the argument to the -ftest-module-file-extension
1562 /// command-line argument.
1563 ///
1564 /// \returns true on error, false on success.
1565 static bool parseTestModuleFileExtensionArg(StringRef Arg,
1566  std::string &BlockName,
1567  unsigned &MajorVersion,
1568  unsigned &MinorVersion,
1569  bool &Hashed,
1570  std::string &UserInfo) {
1572  Arg.split(Args, ':', 5);
1573  if (Args.size() < 5)
1574  return true;
1575 
1576  BlockName = Args[0];
1577  if (Args[1].getAsInteger(10, MajorVersion)) return true;
1578  if (Args[2].getAsInteger(10, MinorVersion)) return true;
1579  if (Args[3].getAsInteger(2, Hashed)) return true;
1580  if (Args.size() > 4)
1581  UserInfo = Args[4];
1582  return false;
1583 }
1584 
1585 static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
1586  DiagnosticsEngine &Diags,
1587  bool &IsHeaderFile) {
1589  if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1590  switch (A->getOption().getID()) {
1591  default:
1592  llvm_unreachable("Invalid option in group!");
1593  case OPT_ast_list:
1594  Opts.ProgramAction = frontend::ASTDeclList; break;
1595  case OPT_ast_dump:
1596  case OPT_ast_dump_all:
1597  case OPT_ast_dump_lookups:
1598  Opts.ProgramAction = frontend::ASTDump; break;
1599  case OPT_ast_print:
1600  Opts.ProgramAction = frontend::ASTPrint; break;
1601  case OPT_ast_view:
1602  Opts.ProgramAction = frontend::ASTView; break;
1603  case OPT_compiler_options_dump:
1605  case OPT_dump_raw_tokens:
1606  Opts.ProgramAction = frontend::DumpRawTokens; break;
1607  case OPT_dump_tokens:
1608  Opts.ProgramAction = frontend::DumpTokens; break;
1609  case OPT_S:
1610  Opts.ProgramAction = frontend::EmitAssembly; break;
1611  case OPT_emit_llvm_bc:
1612  Opts.ProgramAction = frontend::EmitBC; break;
1613  case OPT_emit_html:
1614  Opts.ProgramAction = frontend::EmitHTML; break;
1615  case OPT_emit_llvm:
1616  Opts.ProgramAction = frontend::EmitLLVM; break;
1617  case OPT_emit_llvm_only:
1618  Opts.ProgramAction = frontend::EmitLLVMOnly; break;
1619  case OPT_emit_codegen_only:
1621  case OPT_emit_obj:
1622  Opts.ProgramAction = frontend::EmitObj; break;
1623  case OPT_fixit_EQ:
1624  Opts.FixItSuffix = A->getValue();
1625  LLVM_FALLTHROUGH;
1626  case OPT_fixit:
1627  Opts.ProgramAction = frontend::FixIt; break;
1628  case OPT_emit_module:
1630  case OPT_emit_module_interface:
1632  case OPT_emit_header_module:
1634  case OPT_emit_pch:
1635  Opts.ProgramAction = frontend::GeneratePCH; break;
1636  case OPT_init_only:
1637  Opts.ProgramAction = frontend::InitOnly; break;
1638  case OPT_fsyntax_only:
1640  case OPT_module_file_info:
1642  case OPT_verify_pch:
1643  Opts.ProgramAction = frontend::VerifyPCH; break;
1644  case OPT_print_preamble:
1645  Opts.ProgramAction = frontend::PrintPreamble; break;
1646  case OPT_E:
1648  case OPT_templight_dump:
1649  Opts.ProgramAction = frontend::TemplightDump; break;
1650  case OPT_rewrite_macros:
1651  Opts.ProgramAction = frontend::RewriteMacros; break;
1652  case OPT_rewrite_objc:
1653  Opts.ProgramAction = frontend::RewriteObjC; break;
1654  case OPT_rewrite_test:
1655  Opts.ProgramAction = frontend::RewriteTest; break;
1656  case OPT_analyze:
1657  Opts.ProgramAction = frontend::RunAnalysis; break;
1658  case OPT_migrate:
1659  Opts.ProgramAction = frontend::MigrateSource; break;
1660  case OPT_Eonly:
1662  }
1663  }
1664 
1665  if (const Arg* A = Args.getLastArg(OPT_plugin)) {
1666  Opts.Plugins.emplace_back(A->getValue(0));
1668  Opts.ActionName = A->getValue();
1669  }
1670  Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
1671  for (const auto *AA : Args.filtered(OPT_plugin_arg))
1672  Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
1673 
1674  for (const std::string &Arg :
1675  Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
1676  std::string BlockName;
1677  unsigned MajorVersion;
1678  unsigned MinorVersion;
1679  bool Hashed;
1680  std::string UserInfo;
1681  if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion,
1682  MinorVersion, Hashed, UserInfo)) {
1683  Diags.Report(diag::err_test_module_file_extension_format) << Arg;
1684 
1685  continue;
1686  }
1687 
1688  // Add the testing module file extension.
1689  Opts.ModuleFileExtensions.push_back(
1690  std::make_shared<TestModuleFileExtension>(
1691  BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
1692  }
1693 
1694  if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1695  Opts.CodeCompletionAt =
1696  ParsedSourceLocation::FromString(A->getValue());
1697  if (Opts.CodeCompletionAt.FileName.empty())
1698  Diags.Report(diag::err_drv_invalid_value)
1699  << A->getAsString(Args) << A->getValue();
1700  }
1701  Opts.DisableFree = Args.hasArg(OPT_disable_free);
1702 
1703  Opts.OutputFile = Args.getLastArgValue(OPT_o);
1704  Opts.Plugins = Args.getAllArgValues(OPT_load);
1705  Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
1706  Opts.ShowHelp = Args.hasArg(OPT_help);
1707  Opts.ShowStats = Args.hasArg(OPT_print_stats);
1708  Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
1709  Opts.ShowVersion = Args.hasArg(OPT_version);
1710  Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1711  Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
1712  Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
1713  Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
1714  Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
1715  Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
1716  Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump);
1717  Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all);
1718  Opts.ASTDumpFilter = Args.getLastArgValue(OPT_ast_dump_filter);
1719  Opts.ASTDumpLookups = Args.hasArg(OPT_ast_dump_lookups);
1720  Opts.UseGlobalModuleIndex = !Args.hasArg(OPT_fno_modules_global_index);
1722  Opts.ModuleMapFiles = Args.getAllArgValues(OPT_fmodule_map_file);
1723  // Only the -fmodule-file=<file> form.
1724  for (const auto *A : Args.filtered(OPT_fmodule_file)) {
1725  StringRef Val = A->getValue();
1726  if (Val.find('=') == StringRef::npos)
1727  Opts.ModuleFiles.push_back(Val);
1728  }
1729  Opts.ModulesEmbedFiles = Args.getAllArgValues(OPT_fmodules_embed_file_EQ);
1730  Opts.ModulesEmbedAllFiles = Args.hasArg(OPT_fmodules_embed_all_files);
1731  Opts.IncludeTimestamps = !Args.hasArg(OPT_fno_pch_timestamp);
1732 
1734  = Args.hasArg(OPT_code_completion_macros);
1736  = Args.hasArg(OPT_code_completion_patterns);
1738  = !Args.hasArg(OPT_no_code_completion_globals);
1740  = !Args.hasArg(OPT_no_code_completion_ns_level_decls);
1742  = Args.hasArg(OPT_code_completion_brief_comments);
1744  = Args.hasArg(OPT_code_completion_with_fixits);
1745 
1747  = Args.getLastArgValue(OPT_foverride_record_layout_EQ);
1748  Opts.AuxTriple = Args.getLastArgValue(OPT_aux_triple);
1749  Opts.StatsFile = Args.getLastArgValue(OPT_stats_file);
1750 
1751  if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
1752  OPT_arcmt_modify,
1753  OPT_arcmt_migrate)) {
1754  switch (A->getOption().getID()) {
1755  default:
1756  llvm_unreachable("missed a case");
1757  case OPT_arcmt_check:
1759  break;
1760  case OPT_arcmt_modify:
1762  break;
1763  case OPT_arcmt_migrate:
1765  break;
1766  }
1767  }
1768  Opts.MTMigrateDir = Args.getLastArgValue(OPT_mt_migrate_directory);
1770  = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
1772  = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
1773 
1774  if (Args.hasArg(OPT_objcmt_migrate_literals))
1776  if (Args.hasArg(OPT_objcmt_migrate_subscripting))
1778  if (Args.hasArg(OPT_objcmt_migrate_property_dot_syntax))
1780  if (Args.hasArg(OPT_objcmt_migrate_property))
1782  if (Args.hasArg(OPT_objcmt_migrate_readonly_property))
1784  if (Args.hasArg(OPT_objcmt_migrate_readwrite_property))
1786  if (Args.hasArg(OPT_objcmt_migrate_annotation))
1788  if (Args.hasArg(OPT_objcmt_returns_innerpointer_property))
1790  if (Args.hasArg(OPT_objcmt_migrate_instancetype))
1792  if (Args.hasArg(OPT_objcmt_migrate_nsmacros))
1794  if (Args.hasArg(OPT_objcmt_migrate_protocol_conformance))
1796  if (Args.hasArg(OPT_objcmt_atomic_property))
1798  if (Args.hasArg(OPT_objcmt_ns_nonatomic_iosonly))
1800  if (Args.hasArg(OPT_objcmt_migrate_designated_init))
1802  if (Args.hasArg(OPT_objcmt_migrate_all))
1804 
1805  Opts.ObjCMTWhiteListPath = Args.getLastArgValue(OPT_objcmt_whitelist_dir_path);
1806 
1809  Diags.Report(diag::err_drv_argument_not_allowed_with)
1810  << "ARC migration" << "ObjC migration";
1811  }
1812 
1814  if (const Arg *A = Args.getLastArg(OPT_x)) {
1815  StringRef XValue = A->getValue();
1816 
1817  // Parse suffixes: '<lang>(-header|[-module-map][-cpp-output])'.
1818  // FIXME: Supporting '<lang>-header-cpp-output' would be useful.
1819  bool Preprocessed = XValue.consume_back("-cpp-output");
1820  bool ModuleMap = XValue.consume_back("-module-map");
1821  IsHeaderFile =
1822  !Preprocessed && !ModuleMap && XValue.consume_back("-header");
1823 
1824  // Principal languages.
1825  DashX = llvm::StringSwitch<InputKind>(XValue)
1826  .Case("c", InputKind::C)
1827  .Case("cl", InputKind::OpenCL)
1828  .Case("cuda", InputKind::CUDA)
1829  .Case("hip", InputKind::HIP)
1830  .Case("c++", InputKind::CXX)
1831  .Case("objective-c", InputKind::ObjC)
1832  .Case("objective-c++", InputKind::ObjCXX)
1833  .Case("renderscript", InputKind::RenderScript)
1834  .Default(InputKind::Unknown);
1835 
1836  // "objc[++]-cpp-output" is an acceptable synonym for
1837  // "objective-c[++]-cpp-output".
1838  if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap)
1839  DashX = llvm::StringSwitch<InputKind>(XValue)
1840  .Case("objc", InputKind::ObjC)
1841  .Case("objc++", InputKind::ObjCXX)
1842  .Default(InputKind::Unknown);
1843 
1844  // Some special cases cannot be combined with suffixes.
1845  if (DashX.isUnknown() && !Preprocessed && !ModuleMap && !IsHeaderFile)
1846  DashX = llvm::StringSwitch<InputKind>(XValue)
1847  .Case("cpp-output", InputKind(InputKind::C).getPreprocessed())
1848  .Case("assembler-with-cpp", InputKind::Asm)
1849  .Cases("ast", "pcm",
1851  .Case("ir", InputKind::LLVM_IR)
1852  .Default(InputKind::Unknown);
1853 
1854  if (DashX.isUnknown())
1855  Diags.Report(diag::err_drv_invalid_value)
1856  << A->getAsString(Args) << A->getValue();
1857 
1858  if (Preprocessed)
1859  DashX = DashX.getPreprocessed();
1860  if (ModuleMap)
1861  DashX = DashX.withFormat(InputKind::ModuleMap);
1862  }
1863 
1864  // '-' is the default input if none is given.
1865  std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
1866  Opts.Inputs.clear();
1867  if (Inputs.empty())
1868  Inputs.push_back("-");
1869  for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1870  InputKind IK = DashX;
1871  if (IK.isUnknown()) {
1873  StringRef(Inputs[i]).rsplit('.').second);
1874  // FIXME: Warn on this?
1875  if (IK.isUnknown())
1876  IK = InputKind::C;
1877  // FIXME: Remove this hack.
1878  if (i == 0)
1879  DashX = IK;
1880  }
1881 
1882  // The -emit-module action implicitly takes a module map.
1884  IK.getFormat() == InputKind::Source)
1886 
1887  Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
1888  }
1889 
1890  return DashX;
1891 }
1892 
1893 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
1894  void *MainAddr) {
1895  std::string ClangExecutable =
1896  llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
1897  StringRef Dir = llvm::sys::path::parent_path(ClangExecutable);
1898 
1899  // Compute the path to the resource directory.
1900  StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
1901  SmallString<128> P(Dir);
1902  if (ClangResourceDir != "")
1903  llvm::sys::path::append(P, ClangResourceDir);
1904  else
1905  llvm::sys::path::append(P, "..", Twine("lib") + CLANG_LIBDIR_SUFFIX,
1906  "clang", CLANG_VERSION_STRING);
1907 
1908  return P.str();
1909 }
1910 
1911 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
1912  const std::string &WorkingDir) {
1913  Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
1914  Opts.Verbose = Args.hasArg(OPT_v);
1915  Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
1916  Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
1917  Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
1918  if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
1919  Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
1920  Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
1921 
1922  // Canonicalize -fmodules-cache-path before storing it.
1923  SmallString<128> P(Args.getLastArgValue(OPT_fmodules_cache_path));
1924  if (!(P.empty() || llvm::sys::path::is_absolute(P))) {
1925  if (WorkingDir.empty())
1926  llvm::sys::fs::make_absolute(P);
1927  else
1928  llvm::sys::fs::make_absolute(WorkingDir, P);
1929  }
1930  llvm::sys::path::remove_dots(P);
1931  Opts.ModuleCachePath = P.str();
1932 
1933  Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path);
1934  // Only the -fmodule-file=<name>=<file> form.
1935  for (const auto *A : Args.filtered(OPT_fmodule_file)) {
1936  StringRef Val = A->getValue();
1937  if (Val.find('=') != StringRef::npos)
1938  Opts.PrebuiltModuleFiles.insert(Val.split('='));
1939  }
1940  for (const auto *A : Args.filtered(OPT_fprebuilt_module_path))
1941  Opts.AddPrebuiltModulePath(A->getValue());
1942  Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
1943  Opts.ModulesHashContent = Args.hasArg(OPT_fmodules_hash_content);
1945  !Args.hasArg(OPT_fmodules_disable_diagnostic_validation);
1946  Opts.ImplicitModuleMaps = Args.hasArg(OPT_fimplicit_module_maps);
1947  Opts.ModuleMapFileHomeIsCwd = Args.hasArg(OPT_fmodule_map_file_home_is_cwd);
1949  getLastArgIntValue(Args, OPT_fmodules_prune_interval, 7 * 24 * 60 * 60);
1950  Opts.ModuleCachePruneAfter =
1951  getLastArgIntValue(Args, OPT_fmodules_prune_after, 31 * 24 * 60 * 60);
1953  Args.hasArg(OPT_fmodules_validate_once_per_build_session);
1954  Opts.BuildSessionTimestamp =
1955  getLastArgUInt64Value(Args, OPT_fbuild_session_timestamp, 0);
1957  Args.hasArg(OPT_fmodules_validate_system_headers);
1958  if (const Arg *A = Args.getLastArg(OPT_fmodule_format_EQ))
1959  Opts.ModuleFormat = A->getValue();
1960 
1961  for (const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
1962  StringRef MacroDef = A->getValue();
1963  Opts.ModulesIgnoreMacros.insert(
1964  llvm::CachedHashString(MacroDef.split('=').first));
1965  }
1966 
1967  // Add -I..., -F..., and -index-header-map options in order.
1968  bool IsIndexHeaderMap = false;
1969  bool IsSysrootSpecified =
1970  Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
1971  for (const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
1972  if (A->getOption().matches(OPT_index_header_map)) {
1973  // -index-header-map applies to the next -I or -F.
1974  IsIndexHeaderMap = true;
1975  continue;
1976  }
1977 
1979  IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled;
1980 
1981  bool IsFramework = A->getOption().matches(OPT_F);
1982  std::string Path = A->getValue();
1983 
1984  if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {
1985  SmallString<32> Buffer;
1986  llvm::sys::path::append(Buffer, Opts.Sysroot,
1987  llvm::StringRef(A->getValue()).substr(1));
1988  Path = Buffer.str();
1989  }
1990 
1991  Opts.AddPath(Path, Group, IsFramework,
1992  /*IgnoreSysroot*/ true);
1993  IsIndexHeaderMap = false;
1994  }
1995 
1996  // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
1997  StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
1998  for (const auto *A :
1999  Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
2000  if (A->getOption().matches(OPT_iprefix))
2001  Prefix = A->getValue();
2002  else if (A->getOption().matches(OPT_iwithprefix))
2003  Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
2004  else
2005  Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
2006  }
2007 
2008  for (const auto *A : Args.filtered(OPT_idirafter))
2009  Opts.AddPath(A->getValue(), frontend::After, false, true);
2010  for (const auto *A : Args.filtered(OPT_iquote))
2011  Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
2012  for (const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
2013  Opts.AddPath(A->getValue(), frontend::System, false,
2014  !A->getOption().matches(OPT_iwithsysroot));
2015  for (const auto *A : Args.filtered(OPT_iframework))
2016  Opts.AddPath(A->getValue(), frontend::System, true, true);
2017  for (const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
2018  Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,
2019  /*IgnoreSysRoot=*/false);
2020 
2021  // Add the paths for the various language specific isystem flags.
2022  for (const auto *A : Args.filtered(OPT_c_isystem))
2023  Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
2024  for (const auto *A : Args.filtered(OPT_cxx_isystem))
2025  Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
2026  for (const auto *A : Args.filtered(OPT_objc_isystem))
2027  Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
2028  for (const auto *A : Args.filtered(OPT_objcxx_isystem))
2029  Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
2030 
2031  // Add the internal paths from a driver that detects standard include paths.
2032  for (const auto *A :
2033  Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
2035  if (A->getOption().matches(OPT_internal_externc_isystem))
2036  Group = frontend::ExternCSystem;
2037  Opts.AddPath(A->getValue(), Group, false, true);
2038  }
2039 
2040  // Add the path prefixes which are implicitly treated as being system headers.
2041  for (const auto *A :
2042  Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
2043  Opts.AddSystemHeaderPrefix(
2044  A->getValue(), A->getOption().matches(OPT_system_header_prefix));
2045 
2046  for (const auto *A : Args.filtered(OPT_ivfsoverlay))
2047  Opts.AddVFSOverlayFile(A->getValue());
2048 }
2049 
2051  const llvm::Triple &T,
2052  PreprocessorOptions &PPOpts,
2053  LangStandard::Kind LangStd) {
2054  // Set some properties which depend solely on the input kind; it would be nice
2055  // to move these to the language standard, and have the driver resolve the
2056  // input kind + language standard.
2057  //
2058  // FIXME: Perhaps a better model would be for a single source file to have
2059  // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
2060  // simultaneously active?
2061  if (IK.getLanguage() == InputKind::Asm) {
2062  Opts.AsmPreprocessor = 1;
2063  } else if (IK.isObjectiveC()) {
2064  Opts.ObjC = 1;
2065  }
2066 
2067  if (LangStd == LangStandard::lang_unspecified) {
2068  // Based on the base language, pick one.
2069  switch (IK.getLanguage()) {
2070  case InputKind::Unknown:
2071  case InputKind::LLVM_IR:
2072  llvm_unreachable("Invalid input kind!");
2073  case InputKind::OpenCL:
2074  LangStd = LangStandard::lang_opencl10;
2075  break;
2076  case InputKind::CUDA:
2077  LangStd = LangStandard::lang_cuda;
2078  break;
2079  case InputKind::Asm:
2080  case InputKind::C:
2081 #if defined(CLANG_DEFAULT_STD_C)
2082  LangStd = CLANG_DEFAULT_STD_C;
2083 #else
2084  // The PS4 uses C99 as the default C standard.
2085  if (T.isPS4())
2086  LangStd = LangStandard::lang_gnu99;
2087  else
2088  LangStd = LangStandard::lang_gnu11;
2089 #endif
2090  break;
2091  case InputKind::ObjC:
2092 #if defined(CLANG_DEFAULT_STD_C)
2093  LangStd = CLANG_DEFAULT_STD_C;
2094 #else
2095  LangStd = LangStandard::lang_gnu11;
2096 #endif
2097  break;
2098  case InputKind::CXX:
2099  case InputKind::ObjCXX:
2100 #if defined(CLANG_DEFAULT_STD_CXX)
2101  LangStd = CLANG_DEFAULT_STD_CXX;
2102 #else
2103  LangStd = LangStandard::lang_gnucxx14;
2104 #endif
2105  break;
2107  LangStd = LangStandard::lang_c99;
2108  break;
2109  case InputKind::HIP:
2110  LangStd = LangStandard::lang_hip;
2111  break;
2112  }
2113  }
2114 
2116  Opts.LineComment = Std.hasLineComments();
2117  Opts.C99 = Std.isC99();
2118  Opts.C11 = Std.isC11();
2119  Opts.C17 = Std.isC17();
2120  Opts.CPlusPlus = Std.isCPlusPlus();
2121  Opts.CPlusPlus11 = Std.isCPlusPlus11();
2122  Opts.CPlusPlus14 = Std.isCPlusPlus14();
2123  Opts.CPlusPlus17 = Std.isCPlusPlus17();
2124  Opts.CPlusPlus2a = Std.isCPlusPlus2a();
2125  Opts.Digraphs = Std.hasDigraphs();
2126  Opts.GNUMode = Std.isGNUMode();
2127  Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;
2128  Opts.HexFloats = Std.hasHexFloats();
2129  Opts.ImplicitInt = Std.hasImplicitInt();
2130 
2131  // Set OpenCL Version.
2132  Opts.OpenCL = Std.isOpenCL();
2133  if (LangStd == LangStandard::lang_opencl10)
2134  Opts.OpenCLVersion = 100;
2135  else if (LangStd == LangStandard::lang_opencl11)
2136  Opts.OpenCLVersion = 110;
2137  else if (LangStd == LangStandard::lang_opencl12)
2138  Opts.OpenCLVersion = 120;
2139  else if (LangStd == LangStandard::lang_opencl20)
2140  Opts.OpenCLVersion = 200;
2141  else if (LangStd == LangStandard::lang_openclcpp)
2142  Opts.OpenCLCPlusPlusVersion = 100;
2143 
2144  // OpenCL has some additional defaults.
2145  if (Opts.OpenCL) {
2146  Opts.AltiVec = 0;
2147  Opts.ZVector = 0;
2148  Opts.LaxVectorConversions = 0;
2149  Opts.setDefaultFPContractMode(LangOptions::FPC_On);
2150  Opts.NativeHalfType = 1;
2151  Opts.NativeHalfArgsAndReturns = 1;
2152  Opts.OpenCLCPlusPlus = Opts.CPlusPlus;
2153  // Include default header file for OpenCL.
2154  if (Opts.IncludeDefaultHeader) {
2155  PPOpts.Includes.push_back("opencl-c.h");
2156  }
2157  }
2158 
2159  Opts.HIP = IK.getLanguage() == InputKind::HIP;
2160  Opts.CUDA = IK.getLanguage() == InputKind::CUDA || Opts.HIP;
2161  if (Opts.CUDA)
2162  // Set default FP_CONTRACT to FAST.
2163  Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
2164 
2165  Opts.RenderScript = IK.getLanguage() == InputKind::RenderScript;
2166  if (Opts.RenderScript) {
2167  Opts.NativeHalfType = 1;
2168  Opts.NativeHalfArgsAndReturns = 1;
2169  }
2170 
2171  // OpenCL and C++ both have bool, true, false keywords.
2172  Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
2173 
2174  // OpenCL has half keyword
2175  Opts.Half = Opts.OpenCL;
2176 
2177  // C++ has wchar_t keyword.
2178  Opts.WChar = Opts.CPlusPlus;
2179 
2180  Opts.GNUKeywords = Opts.GNUMode;
2181  Opts.CXXOperatorNames = Opts.CPlusPlus;
2182 
2183  Opts.AlignedAllocation = Opts.CPlusPlus17;
2184 
2185  Opts.DollarIdents = !Opts.AsmPreprocessor;
2186 }
2187 
2188 /// Attempt to parse a visibility value out of the given argument.
2189 static Visibility parseVisibility(Arg *arg, ArgList &args,
2190  DiagnosticsEngine &diags) {
2191  StringRef value = arg->getValue();
2192  if (value == "default") {
2193  return DefaultVisibility;
2194  } else if (value == "hidden" || value == "internal") {
2195  return HiddenVisibility;
2196  } else if (value == "protected") {
2197  // FIXME: diagnose if target does not support protected visibility
2198  return ProtectedVisibility;
2199  }
2200 
2201  diags.Report(diag::err_drv_invalid_value)
2202  << arg->getAsString(args) << value;
2203  return DefaultVisibility;
2204 }
2205 
2206 /// Check if input file kind and language standard are compatible.
2208  const LangStandard &S) {
2209  switch (IK.getLanguage()) {
2210  case InputKind::Unknown:
2211  case InputKind::LLVM_IR:
2212  llvm_unreachable("should not parse language flags for this input");
2213 
2214  case InputKind::C:
2215  case InputKind::ObjC:
2217  return S.getLanguage() == InputKind::C;
2218 
2219  case InputKind::OpenCL:
2220  return S.getLanguage() == InputKind::OpenCL;
2221 
2222  case InputKind::CXX:
2223  case InputKind::ObjCXX:
2224  return S.getLanguage() == InputKind::CXX;
2225 
2226  case InputKind::CUDA:
2227  // FIXME: What -std= values should be permitted for CUDA compilations?
2228  return S.getLanguage() == InputKind::CUDA ||
2229  S.getLanguage() == InputKind::CXX;
2230 
2231  case InputKind::HIP:
2232  return S.getLanguage() == InputKind::CXX ||
2233  S.getLanguage() == InputKind::HIP;
2234 
2235  case InputKind::Asm:
2236  // Accept (and ignore) all -std= values.
2237  // FIXME: The -std= value is not ignored; it affects the tokenization
2238  // and preprocessing rules if we're preprocessing this asm input.
2239  return true;
2240  }
2241 
2242  llvm_unreachable("unexpected input language");
2243 }
2244 
2245 /// Get language name for given input kind.
2246 static const StringRef GetInputKindName(InputKind IK) {
2247  switch (IK.getLanguage()) {
2248  case InputKind::C:
2249  return "C";
2250  case InputKind::ObjC:
2251  return "Objective-C";
2252  case InputKind::CXX:
2253  return "C++";
2254  case InputKind::ObjCXX:
2255  return "Objective-C++";
2256  case InputKind::OpenCL:
2257  return "OpenCL";
2258  case InputKind::CUDA:
2259  return "CUDA";
2261  return "RenderScript";
2262  case InputKind::HIP:
2263  return "HIP";
2264 
2265  case InputKind::Asm:
2266  return "Asm";
2267  case InputKind::LLVM_IR:
2268  return "LLVM IR";
2269 
2270  case InputKind::Unknown:
2271  break;
2272  }
2273  llvm_unreachable("unknown input language");
2274 }
2275 
2276 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
2277  const TargetOptions &TargetOpts,
2278  PreprocessorOptions &PPOpts,
2279  DiagnosticsEngine &Diags) {
2280  // FIXME: Cleanup per-file based stuff.
2282  if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
2283  LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
2284 #define LANGSTANDARD(id, name, lang, desc, features) \
2285  .Case(name, LangStandard::lang_##id)
2286 #define LANGSTANDARD_ALIAS(id, alias) \
2287  .Case(alias, LangStandard::lang_##id)
2288 #include "clang/Frontend/LangStandards.def"
2290  if (LangStd == LangStandard::lang_unspecified) {
2291  Diags.Report(diag::err_drv_invalid_value)
2292  << A->getAsString(Args) << A->getValue();
2293  // Report supported standards with short description.
2294  for (unsigned KindValue = 0;
2295  KindValue != LangStandard::lang_unspecified;
2296  ++KindValue) {
2298  static_cast<LangStandard::Kind>(KindValue));
2299  if (IsInputCompatibleWithStandard(IK, Std)) {
2300  auto Diag = Diags.Report(diag::note_drv_use_standard);
2301  Diag << Std.getName() << Std.getDescription();
2302  unsigned NumAliases = 0;
2303 #define LANGSTANDARD(id, name, lang, desc, features)
2304 #define LANGSTANDARD_ALIAS(id, alias) \
2305  if (KindValue == LangStandard::lang_##id) ++NumAliases;
2306 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
2307 #include "clang/Frontend/LangStandards.def"
2308  Diag << NumAliases;
2309 #define LANGSTANDARD(id, name, lang, desc, features)
2310 #define LANGSTANDARD_ALIAS(id, alias) \
2311  if (KindValue == LangStandard::lang_##id) Diag << alias;
2312 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
2313 #include "clang/Frontend/LangStandards.def"
2314  }
2315  }
2316  } else {
2317  // Valid standard, check to make sure language and standard are
2318  // compatible.
2320  if (!IsInputCompatibleWithStandard(IK, Std)) {
2321  Diags.Report(diag::err_drv_argument_not_allowed_with)
2322  << A->getAsString(Args) << GetInputKindName(IK);
2323  }
2324  }
2325  }
2326 
2327  if (Args.hasArg(OPT_fno_dllexport_inlines))
2328  Opts.DllExportInlines = false;
2329 
2330  if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
2331  StringRef Name = A->getValue();
2332  if (Name == "full" || Name == "branch") {
2333  Opts.CFProtectionBranch = 1;
2334  }
2335  }
2336  // -cl-std only applies for OpenCL language standards.
2337  // Override the -std option in this case.
2338  if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
2339  LangStandard::Kind OpenCLLangStd
2340  = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
2341  .Cases("cl", "CL", LangStandard::lang_opencl10)
2342  .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
2343  .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
2344  .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
2345  .Case("c++", LangStandard::lang_openclcpp)
2347 
2348  if (OpenCLLangStd == LangStandard::lang_unspecified) {
2349  Diags.Report(diag::err_drv_invalid_value)
2350  << A->getAsString(Args) << A->getValue();
2351  }
2352  else
2353  LangStd = OpenCLLangStd;
2354  }
2355 
2356  Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
2357 
2358  llvm::Triple T(TargetOpts.Triple);
2359  CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
2360 
2361  // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
2362  // This option should be deprecated for CL > 1.0 because
2363  // this option was added for compatibility with OpenCL 1.0.
2364  if (Args.getLastArg(OPT_cl_strict_aliasing)
2365  && Opts.OpenCLVersion > 100) {
2366  Diags.Report(diag::warn_option_invalid_ocl_version)
2367  << Opts.getOpenCLVersionTuple().getAsString()
2368  << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
2369  }
2370 
2371  // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
2372  // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
2373  // while a subset (the non-C++ GNU keywords) is provided by GCC's
2374  // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
2375  // name, as it doesn't seem a useful distinction.
2376  Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
2377  Opts.GNUKeywords);
2378 
2379  Opts.Digraphs = Args.hasFlag(OPT_fdigraphs, OPT_fno_digraphs, Opts.Digraphs);
2380 
2381  if (Args.hasArg(OPT_fno_operator_names))
2382  Opts.CXXOperatorNames = 0;
2383 
2384  if (Args.hasArg(OPT_fcuda_is_device))
2385  Opts.CUDAIsDevice = 1;
2386 
2387  if (Args.hasArg(OPT_fcuda_allow_variadic_functions))
2388  Opts.CUDAAllowVariadicFunctions = 1;
2389 
2390  if (Args.hasArg(OPT_fno_cuda_host_device_constexpr))
2391  Opts.CUDAHostDeviceConstexpr = 0;
2392 
2393  if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals))
2394  Opts.CUDADeviceApproxTranscendentals = 1;
2395 
2396  Opts.GPURelocatableDeviceCode = Args.hasArg(OPT_fgpu_rdc);
2397 
2398  if (Opts.ObjC) {
2399  if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
2400  StringRef value = arg->getValue();
2401  if (Opts.ObjCRuntime.tryParse(value))
2402  Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
2403  }
2404 
2405  if (Args.hasArg(OPT_fobjc_gc_only))
2406  Opts.setGC(LangOptions::GCOnly);
2407  else if (Args.hasArg(OPT_fobjc_gc))
2408  Opts.setGC(LangOptions::HybridGC);
2409  else if (Args.hasArg(OPT_fobjc_arc)) {
2410  Opts.ObjCAutoRefCount = 1;
2411  if (!Opts.ObjCRuntime.allowsARC())
2412  Diags.Report(diag::err_arc_unsupported_on_runtime);
2413  }
2414 
2415  // ObjCWeakRuntime tracks whether the runtime supports __weak, not
2416  // whether the feature is actually enabled. This is predominantly
2417  // determined by -fobjc-runtime, but we allow it to be overridden
2418  // from the command line for testing purposes.
2419  if (Args.hasArg(OPT_fobjc_runtime_has_weak))
2420  Opts.ObjCWeakRuntime = 1;
2421  else
2422  Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak();
2423 
2424  // ObjCWeak determines whether __weak is actually enabled.
2425  // Note that we allow -fno-objc-weak to disable this even in ARC mode.
2426  if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
2427  if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
2428  assert(!Opts.ObjCWeak);
2429  } else if (Opts.getGC() != LangOptions::NonGC) {
2430  Diags.Report(diag::err_objc_weak_with_gc);
2431  } else if (!Opts.ObjCWeakRuntime) {
2432  Diags.Report(diag::err_objc_weak_unsupported);
2433  } else {
2434  Opts.ObjCWeak = 1;
2435  }
2436  } else if (Opts.ObjCAutoRefCount) {
2437  Opts.ObjCWeak = Opts.ObjCWeakRuntime;
2438  }
2439 
2440  if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
2441  Opts.ObjCInferRelatedResultType = 0;
2442 
2443  if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
2444  Opts.ObjCSubscriptingLegacyRuntime =
2446  }
2447 
2448  if (Args.hasArg(OPT_fgnu89_inline)) {
2449  if (Opts.CPlusPlus)
2450  Diags.Report(diag::err_drv_argument_not_allowed_with)
2451  << "-fgnu89-inline" << GetInputKindName(IK);
2452  else
2453  Opts.GNUInline = 1;
2454  }
2455 
2456  if (Args.hasArg(OPT_fapple_kext)) {
2457  if (!Opts.CPlusPlus)
2458  Diags.Report(diag::warn_c_kext);
2459  else
2460  Opts.AppleKext = 1;
2461  }
2462 
2463  if (Args.hasArg(OPT_print_ivar_layout))
2464  Opts.ObjCGCBitmapPrint = 1;
2465 
2466  if (Args.hasArg(OPT_fno_constant_cfstrings))
2467  Opts.NoConstantCFStrings = 1;
2468  if (const auto *A = Args.getLastArg(OPT_fcf_runtime_abi_EQ))
2469  Opts.CFRuntime =
2470  llvm::StringSwitch<LangOptions::CoreFoundationABI>(A->getValue())
2471  .Cases("unspecified", "standalone", "objc",
2473  .Cases("swift", "swift-5.0",
2475  .Case("swift-4.2", LangOptions::CoreFoundationABI::Swift4_2)
2476  .Case("swift-4.1", LangOptions::CoreFoundationABI::Swift4_1)
2478 
2479  if (Args.hasArg(OPT_fzvector))
2480  Opts.ZVector = 1;
2481 
2482  if (Args.hasArg(OPT_pthread))
2483  Opts.POSIXThreads = 1;
2484 
2485  // The value-visibility mode defaults to "default".
2486  if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
2487  Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
2488  } else {
2489  Opts.setValueVisibilityMode(DefaultVisibility);
2490  }
2491 
2492  // The type-visibility mode defaults to the value-visibility mode.
2493  if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) {
2494  Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags));
2495  } else {
2496  Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
2497  }
2498 
2499  if (Args.hasArg(OPT_fvisibility_inlines_hidden))
2500  Opts.InlineVisibilityHidden = 1;
2501 
2502  if (Args.hasArg(OPT_fvisibility_global_new_delete_hidden))
2503  Opts.GlobalAllocationFunctionVisibilityHidden = 1;
2504 
2505  if (Args.hasArg(OPT_ftrapv)) {
2506  Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
2507  // Set the handler, if one is specified.
2508  Opts.OverflowHandler =
2509  Args.getLastArgValue(OPT_ftrapv_handler);
2510  }
2511  else if (Args.hasArg(OPT_fwrapv))
2512  Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
2513 
2514  Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
2515  Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
2516  Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
2517  Opts.MSCompatibilityVersion = 0;
2518  if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
2519  VersionTuple VT;
2520  if (VT.tryParse(A->getValue()))
2521  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
2522  << A->getValue();
2523  Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
2524  VT.getMinor().getValueOr(0) * 100000 +
2525  VT.getSubminor().getValueOr(0);
2526  }
2527 
2528  // Mimicking gcc's behavior, trigraphs are only enabled if -trigraphs
2529  // is specified, or -std is set to a conforming mode.
2530  // Trigraphs are disabled by default in c++1z onwards.
2531  Opts.Trigraphs = !Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17;
2532  Opts.Trigraphs =
2533  Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
2534 
2535  Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
2536  OPT_fno_dollars_in_identifiers,
2537  Opts.DollarIdents);
2538  Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
2539  Opts.VtorDispMode = getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags);
2540  Opts.Borland = Args.hasArg(OPT_fborland_extensions);
2541  Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
2542  Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
2543  Opts.ConstStrings);
2544  if (Args.hasArg(OPT_fno_lax_vector_conversions))
2545  Opts.LaxVectorConversions = 0;
2546  if (Args.hasArg(OPT_fno_threadsafe_statics))
2547  Opts.ThreadsafeStatics = 0;
2548  Opts.Exceptions = Args.hasArg(OPT_fexceptions);
2549  Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
2550  Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
2551 
2552  // -ffixed-point
2553  Opts.FixedPoint =
2554  Args.hasFlag(OPT_ffixed_point, OPT_fno_fixed_point, /*Default=*/false) &&
2555  !Opts.CPlusPlus;
2556  Opts.PaddingOnUnsignedFixedPoint =
2557  Args.hasFlag(OPT_fpadding_on_unsigned_fixed_point,
2558  OPT_fno_padding_on_unsigned_fixed_point,
2559  /*Default=*/false) &&
2560  Opts.FixedPoint;
2561 
2562  // Handle exception personalities
2563  Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions,
2564  options::OPT_fseh_exceptions,
2565  options::OPT_fdwarf_exceptions);
2566  if (A) {
2567  const Option &Opt = A->getOption();
2568  llvm::Triple T(TargetOpts.Triple);
2569  if (T.isWindowsMSVCEnvironment())
2570  Diags.Report(diag::err_fe_invalid_exception_model)
2571  << Opt.getName() << T.str();
2572 
2573  Opts.SjLjExceptions = Opt.matches(options::OPT_fsjlj_exceptions);
2574  Opts.SEHExceptions = Opt.matches(options::OPT_fseh_exceptions);
2575  Opts.DWARFExceptions = Opt.matches(options::OPT_fdwarf_exceptions);
2576  }
2577 
2578  Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
2579  Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
2580 
2581  Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
2582  Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
2583  Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
2584  && Opts.OpenCLVersion == 200);
2585  Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
2586  Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
2587 
2588  // Enable [[]] attributes in C++11 by default.
2589  Opts.DoubleSquareBracketAttributes =
2590  Args.hasFlag(OPT_fdouble_square_bracket_attributes,
2591  OPT_fno_double_square_bracket_attributes, Opts.CPlusPlus11);
2592 
2593  Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
2594  Opts.Modules = Args.hasArg(OPT_fmodules) || Opts.ModulesTS;
2595  Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
2596  Opts.ModulesDeclUse =
2597  Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
2598  Opts.ModulesLocalVisibility =
2599  Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS;
2600  Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen);
2601  Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
2602  Opts.ModulesSearchAll = Opts.Modules &&
2603  !Args.hasArg(OPT_fno_modules_search_all) &&
2604  Args.hasArg(OPT_fmodules_search_all);
2605  Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
2606  Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
2607  Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
2608  Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
2609  Opts.Char8 = Args.hasFlag(OPT_fchar8__t, OPT_fno_char8__t, Opts.CPlusPlus2a);
2610  if (const Arg *A = Args.getLastArg(OPT_fwchar_type_EQ)) {
2611  Opts.WCharSize = llvm::StringSwitch<unsigned>(A->getValue())
2612  .Case("char", 1)
2613  .Case("short", 2)
2614  .Case("int", 4)
2615  .Default(0);
2616  if (Opts.WCharSize == 0)
2617  Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue();
2618  }
2619  Opts.WCharIsSigned = Args.hasFlag(OPT_fsigned_wchar, OPT_fno_signed_wchar, true);
2620  Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
2621  Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
2622  Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
2623  if (!Opts.NoBuiltin)
2625  Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
2626  Opts.RelaxedTemplateTemplateArgs =
2627  Args.hasArg(OPT_frelaxed_template_template_args);
2628  Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
2629  Opts.AlignedAllocation =
2630  Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
2631  Opts.AlignedAllocation);
2632  Opts.AlignedAllocationUnavailable =
2633  Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable);
2634  Opts.NewAlignOverride =
2635  getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
2636  if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
2637  Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
2638  Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
2639  << A->getValue();
2640  Opts.NewAlignOverride = 0;
2641  }
2642  Opts.ConceptsTS = Args.hasArg(OPT_fconcepts_ts);
2643  Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
2644  Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
2645  Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
2646  Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
2647  Opts.InstantiationDepth =
2648  getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
2649  Opts.ArrowDepth =
2650  getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
2651  Opts.ConstexprCallDepth =
2652  getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
2653  Opts.ConstexprStepLimit =
2654  getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
2655  Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
2656  Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
2657  Opts.NumLargeByValueCopy =
2658  getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
2659  Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
2661  Args.getLastArgValue(OPT_fconstant_string_class);
2662  Opts.ObjCDefaultSynthProperties =
2663  !Args.hasArg(OPT_disable_objc_default_synthesize_properties);
2664  Opts.EncodeExtendedBlockSig =
2665  Args.hasArg(OPT_fencode_extended_block_signature);
2666  Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
2667  Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
2668  Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
2669  Opts.AlignDouble = Args.hasArg(OPT_malign_double);
2670  Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
2671  Opts.PIE = Args.hasArg(OPT_pic_is_pie);
2672  Opts.Static = Args.hasArg(OPT_static_define);
2673  Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
2674  Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
2675  || Args.hasArg(OPT_fdump_record_layouts);
2676  Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
2677  Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
2678  Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
2679  Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
2680  Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
2681  Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
2682  Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
2683  Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
2684  Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
2685  Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
2686  Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
2687  Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
2688  Opts.ModuleName = Args.getLastArgValue(OPT_fmodule_name_EQ);
2689  Opts.CurrentModule = Opts.ModuleName;
2690  Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
2691  Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
2692  llvm::sort(Opts.ModuleFeatures);
2693  Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
2694  Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns);
2695  // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns
2696  // is enabled.
2697  Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
2698  | Opts.NativeHalfArgsAndReturns;
2699  Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
2700 
2701  // __declspec is enabled by default for the PS4 by the driver, and also
2702  // enabled for Microsoft Extensions or Borland Extensions, here.
2703  //
2704  // FIXME: __declspec is also currently enabled for CUDA, but isn't really a
2705  // CUDA extension. However, it is required for supporting
2706  // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
2707  // been rewritten in terms of something more generic, remove the Opts.CUDA
2708  // term here.
2709  Opts.DeclSpecKeyword =
2710  Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec,
2711  (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA));
2712 
2713  if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) {
2714  switch (llvm::StringSwitch<unsigned>(A->getValue())
2715  .Case("target", LangOptions::ASMM_Target)
2716  .Case("no", LangOptions::ASMM_Off)
2717  .Case("yes", LangOptions::ASMM_On)
2718  .Default(255)) {
2719  default:
2720  Diags.Report(diag::err_drv_invalid_value)
2721  << "-faddress-space-map-mangling=" << A->getValue();
2722  break;
2724  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Target);
2725  break;
2726  case LangOptions::ASMM_On:
2727  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On);
2728  break;
2729  case LangOptions::ASMM_Off:
2730  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off);
2731  break;
2732  }
2733  }
2734 
2735  if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
2737  llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
2738  A->getValue())
2739  .Case("single",
2741  .Case("multiple",
2743  .Case("virtual",
2745  .Default(LangOptions::PPTMK_BestCase);
2746  if (InheritanceModel == LangOptions::PPTMK_BestCase)
2747  Diags.Report(diag::err_drv_invalid_value)
2748  << "-fms-memptr-rep=" << A->getValue();
2749 
2750  Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
2751  }
2752 
2753  // Check for MS default calling conventions being specified.
2754  if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
2756  llvm::StringSwitch<LangOptions::DefaultCallingConvention>(A->getValue())
2757  .Case("cdecl", LangOptions::DCC_CDecl)
2758  .Case("fastcall", LangOptions::DCC_FastCall)
2759  .Case("stdcall", LangOptions::DCC_StdCall)
2760  .Case("vectorcall", LangOptions::DCC_VectorCall)
2761  .Case("regcall", LangOptions::DCC_RegCall)
2762  .Default(LangOptions::DCC_None);
2763  if (DefaultCC == LangOptions::DCC_None)
2764  Diags.Report(diag::err_drv_invalid_value)
2765  << "-fdefault-calling-conv=" << A->getValue();
2766 
2767  llvm::Triple T(TargetOpts.Triple);
2768  llvm::Triple::ArchType Arch = T.getArch();
2769  bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||
2770  DefaultCC == LangOptions::DCC_StdCall) &&
2771  Arch != llvm::Triple::x86;
2772  emitError |= (DefaultCC == LangOptions::DCC_VectorCall ||
2773  DefaultCC == LangOptions::DCC_RegCall) &&
2774  !(Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64);
2775  if (emitError)
2776  Diags.Report(diag::err_drv_argument_not_allowed_with)
2777  << A->getSpelling() << T.getTriple();
2778  else
2779  Opts.setDefaultCallingConv(DefaultCC);
2780  }
2781 
2782  // -mrtd option
2783  if (Arg *A = Args.getLastArg(OPT_mrtd)) {
2784  if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
2785  Diags.Report(diag::err_drv_argument_not_allowed_with)
2786  << A->getSpelling() << "-fdefault-calling-conv";
2787  else {
2788  llvm::Triple T(TargetOpts.Triple);
2789  if (T.getArch() != llvm::Triple::x86)
2790  Diags.Report(diag::err_drv_argument_not_allowed_with)
2791  << A->getSpelling() << T.getTriple();
2792  else
2793  Opts.setDefaultCallingConv(LangOptions::DCC_StdCall);
2794  }
2795  }
2796 
2797  // Check if -fopenmp is specified.
2798  Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 1 : 0;
2799  // Check if -fopenmp-simd is specified.
2800  bool IsSimdSpecified =
2801  Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
2802  /*Default=*/false);
2803  Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
2804  Opts.OpenMPUseTLS =
2805  Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
2806  Opts.OpenMPIsDevice =
2807  Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
2808  bool IsTargetSpecified =
2809  Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
2810 
2811  if (Opts.OpenMP || Opts.OpenMPSimd) {
2812  if (int Version = getLastArgIntValue(
2813  Args, OPT_fopenmp_version_EQ,
2814  (IsSimdSpecified || IsTargetSpecified) ? 45 : Opts.OpenMP, Diags))
2815  Opts.OpenMP = Version;
2816  else if (IsSimdSpecified || IsTargetSpecified)
2817  Opts.OpenMP = 45;
2818  // Provide diagnostic when a given target is not expected to be an OpenMP
2819  // device or host.
2820  if (!Opts.OpenMPIsDevice) {
2821  switch (T.getArch()) {
2822  default:
2823  break;
2824  // Add unsupported host targets here:
2825  case llvm::Triple::nvptx:
2826  case llvm::Triple::nvptx64:
2827  Diags.Report(diag::err_drv_omp_host_target_not_supported)
2828  << TargetOpts.Triple;
2829  break;
2830  }
2831  }
2832  }
2833 
2834  // Set the flag to prevent the implementation from emitting device exception
2835  // handling code for those requiring so.
2836  Opts.OpenMPHostCXXExceptions = Opts.Exceptions && Opts.CXXExceptions;
2837  if ((Opts.OpenMPIsDevice && T.isNVPTX()) || Opts.OpenCLCPlusPlus) {
2838  Opts.Exceptions = 0;
2839  Opts.CXXExceptions = 0;
2840  }
2841  if (Opts.OpenMPIsDevice && T.isNVPTX()) {
2842  Opts.OpenMPCUDANumSMs =
2843  getLastArgIntValue(Args, options::OPT_fopenmp_cuda_number_of_sm_EQ,
2844  Opts.OpenMPCUDANumSMs, Diags);
2845  Opts.OpenMPCUDABlocksPerSM =
2846  getLastArgIntValue(Args, options::OPT_fopenmp_cuda_blocks_per_sm_EQ,
2847  Opts.OpenMPCUDABlocksPerSM, Diags);
2848  }
2849 
2850  // Prevent auto-widening the representation of loop counters during an
2851  // OpenMP collapse clause.
2852  Opts.OpenMPOptimisticCollapse =
2853  Args.hasArg(options::OPT_fopenmp_optimistic_collapse) ? 1 : 0;
2854 
2855  // Get the OpenMP target triples if any.
2856  if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
2857 
2858  for (unsigned i = 0; i < A->getNumValues(); ++i) {
2859  llvm::Triple TT(A->getValue(i));
2860 
2861  if (TT.getArch() == llvm::Triple::UnknownArch ||
2862  !(TT.getArch() == llvm::Triple::ppc ||
2863  TT.getArch() == llvm::Triple::ppc64 ||
2864  TT.getArch() == llvm::Triple::ppc64le ||
2865  TT.getArch() == llvm::Triple::nvptx ||
2866  TT.getArch() == llvm::Triple::nvptx64 ||
2867  TT.getArch() == llvm::Triple::x86 ||
2868  TT.getArch() == llvm::Triple::x86_64))
2869  Diags.Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
2870  else
2871  Opts.OMPTargetTriples.push_back(TT);
2872  }
2873  }
2874 
2875  // Get OpenMP host file path if any and report if a non existent file is
2876  // found
2877  if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
2878  Opts.OMPHostIRFile = A->getValue();
2879  if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
2880  Diags.Report(diag::err_drv_omp_host_ir_file_not_found)
2881  << Opts.OMPHostIRFile;
2882  }
2883 
2884  // Set CUDA mode for OpenMP target NVPTX if specified in options
2885  Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && T.isNVPTX() &&
2886  Args.hasArg(options::OPT_fopenmp_cuda_mode);
2887 
2888  // Set CUDA mode for OpenMP target NVPTX if specified in options
2889  Opts.OpenMPCUDAForceFullRuntime =
2890  Opts.OpenMPIsDevice && T.isNVPTX() &&
2891  Args.hasArg(options::OPT_fopenmp_cuda_force_full_runtime);
2892 
2893  // Record whether the __DEPRECATED define was requested.
2894  Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
2895  OPT_fno_deprecated_macro,
2896  Opts.Deprecated);
2897 
2898  // FIXME: Eliminate this dependency.
2899  unsigned Opt = getOptimizationLevel(Args, IK, Diags),
2900  OptSize = getOptimizationLevelSize(Args);
2901  Opts.Optimize = Opt != 0;
2902  Opts.OptimizeSize = OptSize != 0;
2903 
2904  // This is the __NO_INLINE__ define, which just depends on things like the
2905  // optimization level and -fno-inline, not actually whether the backend has
2906  // inlining enabled.
2907  Opts.NoInlineDefine = !Opts.Optimize;
2908  if (Arg *InlineArg = Args.getLastArg(
2909  options::OPT_finline_functions, options::OPT_finline_hint_functions,
2910  options::OPT_fno_inline_functions, options::OPT_fno_inline))
2911  if (InlineArg->getOption().matches(options::OPT_fno_inline))
2912  Opts.NoInlineDefine = true;
2913 
2914  Opts.FastMath = Args.hasArg(OPT_ffast_math) ||
2915  Args.hasArg(OPT_cl_fast_relaxed_math);
2916  Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
2917  Args.hasArg(OPT_cl_finite_math_only) ||
2918  Args.hasArg(OPT_cl_fast_relaxed_math);
2919  Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
2920  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
2921  Args.hasArg(OPT_cl_fast_relaxed_math);
2922 
2923  if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
2924  StringRef Val = A->getValue();
2925  if (Val == "fast")
2926  Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
2927  else if (Val == "on")
2928  Opts.setDefaultFPContractMode(LangOptions::FPC_On);
2929  else if (Val == "off")
2930  Opts.setDefaultFPContractMode(LangOptions::FPC_Off);
2931  else
2932  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2933  }
2934 
2935  Opts.RetainCommentsFromSystemHeaders =
2936  Args.hasArg(OPT_fretain_comments_from_system_headers);
2937 
2938  unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
2939  switch (SSP) {
2940  default:
2941  Diags.Report(diag::err_drv_invalid_value)
2942  << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
2943  break;
2944  case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
2945  case 1: Opts.setStackProtector(LangOptions::SSPOn); break;
2946  case 2: Opts.setStackProtector(LangOptions::SSPStrong); break;
2947  case 3: Opts.setStackProtector(LangOptions::SSPReq); break;
2948  }
2949 
2950  if (Arg *A = Args.getLastArg(OPT_ftrivial_auto_var_init)) {
2951  StringRef Val = A->getValue();
2952  if (Val == "uninitialized")
2953  Opts.setTrivialAutoVarInit(
2955  else if (Val == "zero")
2956  Opts.setTrivialAutoVarInit(LangOptions::TrivialAutoVarInitKind::Zero);
2957  else if (Val == "pattern")
2958  Opts.setTrivialAutoVarInit(LangOptions::TrivialAutoVarInitKind::Pattern);
2959  else
2960  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2961  }
2962 
2963  // Parse -fsanitize= arguments.
2964  parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
2965  Diags, Opts.Sanitize);
2966  // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
2967  Opts.SanitizeAddressFieldPadding =
2968  getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
2969  Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
2970 
2971  // -fxray-instrument
2972  Opts.XRayInstrument =
2973  Args.hasFlag(OPT_fxray_instrument, OPT_fnoxray_instrument, false);
2974 
2975  // -fxray-always-emit-customevents
2976  Opts.XRayAlwaysEmitCustomEvents =
2977  Args.hasFlag(OPT_fxray_always_emit_customevents,
2978  OPT_fnoxray_always_emit_customevents, false);
2979 
2980  // -fxray-always-emit-typedevents
2981  Opts.XRayAlwaysEmitTypedEvents =
2982  Args.hasFlag(OPT_fxray_always_emit_typedevents,
2983  OPT_fnoxray_always_emit_customevents, false);
2984 
2985  // -fxray-{always,never}-instrument= filenames.
2987  Args.getAllArgValues(OPT_fxray_always_instrument);
2989  Args.getAllArgValues(OPT_fxray_never_instrument);
2990  Opts.XRayAttrListFiles = Args.getAllArgValues(OPT_fxray_attr_list);
2991 
2992  // -fforce-emit-vtables
2993  Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables);
2994 
2995  // -fallow-editor-placeholders
2996  Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders);
2997 
2998  Opts.RegisterStaticDestructors = !Args.hasArg(OPT_fno_cxx_static_destructors);
2999 
3000  if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
3001  Opts.setClangABICompat(LangOptions::ClangABI::Latest);
3002 
3003  StringRef Ver = A->getValue();
3004  std::pair<StringRef, StringRef> VerParts = Ver.split('.');
3005  unsigned Major, Minor = 0;
3006 
3007  // Check the version number is valid: either 3.x (0 <= x <= 9) or
3008  // y or y.0 (4 <= y <= current version).
3009  if (!VerParts.first.startswith("0") &&
3010  !VerParts.first.getAsInteger(10, Major) &&
3011  3 <= Major && Major <= CLANG_VERSION_MAJOR &&
3012  (Major == 3 ? VerParts.second.size() == 1 &&
3013  !VerParts.second.getAsInteger(10, Minor)
3014  : VerParts.first.size() == Ver.size() ||
3015  VerParts.second == "0")) {
3016  // Got a valid version number.
3017  if (Major == 3 && Minor <= 8)
3018  Opts.setClangABICompat(LangOptions::ClangABI::Ver3_8);
3019  else if (Major <= 4)
3020  Opts.setClangABICompat(LangOptions::ClangABI::Ver4);
3021  else if (Major <= 6)
3022  Opts.setClangABICompat(LangOptions::ClangABI::Ver6);
3023  else if (Major <= 7)
3024  Opts.setClangABICompat(LangOptions::ClangABI::Ver7);
3025  } else if (Ver != "latest") {
3026  Diags.Report(diag::err_drv_invalid_value)
3027  << A->getAsString(Args) << A->getValue();
3028  }
3029  }
3030 
3031  Opts.CompleteMemberPointers = Args.hasArg(OPT_fcomplete_member_pointers);
3032  Opts.BuildingPCHWithObjectFile = Args.hasArg(OPT_building_pch_with_obj);
3033 }
3034 
3036  switch (Action) {
3037  case frontend::ASTDeclList:
3038  case frontend::ASTDump:
3039  case frontend::ASTPrint:
3040  case frontend::ASTView:
3042  case frontend::EmitBC:
3043  case frontend::EmitHTML:
3044  case frontend::EmitLLVM:
3047  case frontend::EmitObj:
3048  case frontend::FixIt:
3052  case frontend::GeneratePCH:
3055  case frontend::VerifyPCH:
3057  case frontend::RewriteObjC:
3058  case frontend::RewriteTest:
3059  case frontend::RunAnalysis:
3062  return false;
3063 
3066  case frontend::DumpTokens:
3067  case frontend::InitOnly:
3072  return true;
3073  }
3074  llvm_unreachable("invalid frontend action");
3075 }
3076 
3077 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
3078  DiagnosticsEngine &Diags,
3080  Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
3081  Opts.PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
3082  Args.hasArg(OPT_pch_through_hdrstop_use);
3083  Opts.PCHWithHdrStopCreate = Args.hasArg(OPT_pch_through_hdrstop_create);
3084  Opts.PCHThroughHeader = Args.getLastArgValue(OPT_pch_through_header_EQ);
3085  Opts.UsePredefines = !Args.hasArg(OPT_undef);
3086  Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
3087  Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
3088  Opts.AllowPCHWithCompilerErrors = Args.hasArg(OPT_fallow_pch_with_errors);
3089 
3090  Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
3091  for (const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
3092  Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue());
3093 
3094  if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
3095  StringRef Value(A->getValue());
3096  size_t Comma = Value.find(',');
3097  unsigned Bytes = 0;
3098  unsigned EndOfLine = 0;
3099 
3100  if (Comma == StringRef::npos ||
3101  Value.substr(0, Comma).getAsInteger(10, Bytes) ||
3102  Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
3103  Diags.Report(diag::err_drv_preamble_format);
3104  else {
3105  Opts.PrecompiledPreambleBytes.first = Bytes;
3106  Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
3107  }
3108  }
3109 
3110  // Add the __CET__ macro if a CFProtection option is set.
3111  if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3112  StringRef Name = A->getValue();
3113  if (Name == "branch")
3114  Opts.addMacroDef("__CET__=1");
3115  else if (Name == "return")
3116  Opts.addMacroDef("__CET__=2");
3117  else if (Name == "full")
3118  Opts.addMacroDef("__CET__=3");
3119  }
3120 
3121  // Add macros from the command line.
3122  for (const auto *A : Args.filtered(OPT_D, OPT_U)) {
3123  if (A->getOption().matches(OPT_D))
3124  Opts.addMacroDef(A->getValue());
3125  else
3126  Opts.addMacroUndef(A->getValue());
3127  }
3128 
3129  Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
3130 
3131  // Add the ordered list of -includes.
3132  for (const auto *A : Args.filtered(OPT_include))
3133  Opts.Includes.emplace_back(A->getValue());
3134 
3135  for (const auto *A : Args.filtered(OPT_chain_include))
3136  Opts.ChainedIncludes.emplace_back(A->getValue());
3137 
3138  for (const auto *A : Args.filtered(OPT_remap_file)) {
3139  std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');
3140 
3141  if (Split.second.empty()) {
3142  Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
3143  continue;
3144  }
3145 
3146  Opts.addRemappedFile(Split.first, Split.second);
3147  }
3148 
3149  if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
3150  StringRef Name = A->getValue();
3151  unsigned Library = llvm::StringSwitch<unsigned>(Name)
3152  .Case("libc++", ARCXX_libcxx)
3153  .Case("libstdc++", ARCXX_libstdcxx)
3154  .Case("none", ARCXX_nolib)
3155  .Default(~0U);
3156  if (Library == ~0U)
3157  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
3158  else
3160  }
3161 
3162  // Always avoid lexing editor placeholders when we're just running the
3163  // preprocessor as we never want to emit the
3164  // "editor placeholder in source file" error in PP only mode.
3165  if (isStrictlyPreprocessorAction(Action))
3166  Opts.LexEditorPlaceholders = false;
3167 }
3168 
3170  ArgList &Args,
3172  if (isStrictlyPreprocessorAction(Action))
3173  Opts.ShowCPP = !Args.hasArg(OPT_dM);
3174  else
3175  Opts.ShowCPP = 0;
3176 
3177  Opts.ShowComments = Args.hasArg(OPT_C);
3178  Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
3179  Opts.ShowMacroComments = Args.hasArg(OPT_CC);
3180  Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
3181  Opts.ShowIncludeDirectives = Args.hasArg(OPT_dI);
3182  Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
3183  Opts.RewriteImports = Args.hasArg(OPT_frewrite_imports);
3184  Opts.UseLineDirectives = Args.hasArg(OPT_fuse_line_directives);
3185 }
3186 
3187 static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
3188  DiagnosticsEngine &Diags) {
3189  Opts.CodeModel = getCodeModel(Args, Diags);
3190  Opts.ABI = Args.getLastArgValue(OPT_target_abi);
3191  if (Arg *A = Args.getLastArg(OPT_meabi)) {
3192  StringRef Value = A->getValue();
3193  llvm::EABI EABIVersion = llvm::StringSwitch<llvm::EABI>(Value)
3194  .Case("default", llvm::EABI::Default)
3195  .Case("4", llvm::EABI::EABI4)
3196  .Case("5", llvm::EABI::EABI5)
3197  .Case("gnu", llvm::EABI::GNU)
3198  .Default(llvm::EABI::Unknown);
3199  if (EABIVersion == llvm::EABI::Unknown)
3200  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3201  << Value;
3202  else
3203  Opts.EABIVersion = EABIVersion;
3204  }
3205  Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
3206  Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
3207  Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
3208  Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
3209  Opts.Triple = Args.getLastArgValue(OPT_triple);
3210  // Use the default target triple if unspecified.
3211  if (Opts.Triple.empty())
3212  Opts.Triple = llvm::sys::getDefaultTargetTriple();
3213  Opts.Triple = llvm::Triple::normalize(Opts.Triple);
3214  Opts.OpenCLExtensionsAsWritten = Args.getAllArgValues(OPT_cl_ext_EQ);
3215  Opts.ForceEnableInt128 = Args.hasArg(OPT_fforce_enable_int128);
3216  Opts.NVPTXUseShortPointers = Args.hasFlag(
3217  options::OPT_fcuda_short_ptr, options::OPT_fno_cuda_short_ptr, false);
3218  if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
3219  llvm::VersionTuple Version;
3220  if (Version.tryParse(A->getValue()))
3221  Diags.Report(diag::err_drv_invalid_value)
3222  << A->getAsString(Args) << A->getValue();
3223  else
3224  Opts.SDKVersion = Version;
3225  }
3226 }
3227 
3229  const char *const *ArgBegin,
3230  const char *const *ArgEnd,
3231  DiagnosticsEngine &Diags) {
3232  bool Success = true;
3233 
3234  // Parse the arguments.
3235  std::unique_ptr<OptTable> Opts = createDriverOptTable();
3236  const unsigned IncludedFlagsBitmask = options::CC1Option;
3237  unsigned MissingArgIndex, MissingArgCount;
3238  InputArgList Args =
3239  Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex,
3240  MissingArgCount, IncludedFlagsBitmask);
3241  LangOptions &LangOpts = *Res.getLangOpts();
3242 
3243  // Check for missing argument error.
3244  if (MissingArgCount) {
3245  Diags.Report(diag::err_drv_missing_argument)
3246  << Args.getArgString(MissingArgIndex) << MissingArgCount;
3247  Success = false;
3248  }
3249 
3250  // Issue errors on unknown arguments.
3251  for (const auto *A : Args.filtered(OPT_UNKNOWN)) {
3252  auto ArgString = A->getAsString(Args);
3253  std::string Nearest;
3254  if (Opts->findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
3255  Diags.Report(diag::err_drv_unknown_argument) << ArgString;
3256  else
3257  Diags.Report(diag::err_drv_unknown_argument_with_suggestion)
3258  << ArgString << Nearest;
3259  Success = false;
3260  }
3261 
3262  Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
3263  Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args);
3265  Success &=
3266  ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
3267  false /*DefaultDiagColor*/, false /*DefaultShowOpt*/);
3268  ParseCommentArgs(LangOpts.CommentOpts, Args);
3270  // FIXME: We shouldn't have to pass the DashX option around here
3271  InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
3272  LangOpts.IsHeaderFile);
3273  ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
3274  Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags,
3275  Res.getTargetOpts(), Res.getFrontendOpts());
3278  llvm::Triple T(Res.getTargetOpts().Triple);
3279  if (DashX.getFormat() == InputKind::Precompiled ||
3280  DashX.getLanguage() == InputKind::LLVM_IR) {
3281  // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
3282  // PassManager in BackendUtil.cpp. They need to be initializd no matter
3283  // what the input type is.
3284  if (Args.hasArg(OPT_fobjc_arc))
3285  LangOpts.ObjCAutoRefCount = 1;
3286  // PIClevel and PIELevel are needed during code generation and this should be
3287  // set regardless of the input type.
3288  LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
3289  LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
3290  parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
3291  Diags, LangOpts.Sanitize);
3292  } else {
3293  // Other LangOpts are only initialized when the input is not AST or LLVM IR.
3294  // FIXME: Should we really be calling this for an InputKind::Asm input?
3295  ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
3296  Res.getPreprocessorOpts(), Diags);
3298  LangOpts.ObjCExceptions = 1;
3299  if (T.isOSDarwin() && DashX.isPreprocessed()) {
3300  // Supress the darwin-specific 'stdlibcxx-not-found' diagnostic for
3301  // preprocessed input as we don't expect it to be used with -std=libc++
3302  // anyway.
3303  Res.getDiagnosticOpts().Warnings.push_back("no-stdlibcxx-not-found");
3304  }
3305  }
3306 
3307  LangOpts.FunctionAlignment =
3308  getLastArgIntValue(Args, OPT_function_alignment, 0, Diags);
3309 
3310  if (LangOpts.CUDA) {
3311  // During CUDA device-side compilation, the aux triple is the
3312  // triple used for host compilation.
3313  if (LangOpts.CUDAIsDevice)
3315  }
3316 
3317  // Set the triple of the host for OpenMP device compile.
3318  if (LangOpts.OpenMPIsDevice)
3320 
3321  // FIXME: Override value name discarding when asan or msan is used because the
3322  // backend passes depend on the name of the alloca in order to print out
3323  // names.
3324  Res.getCodeGenOpts().DiscardValueNames &=
3325  !LangOpts.Sanitize.has(SanitizerKind::Address) &&
3326  !LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
3327  !LangOpts.Sanitize.has(SanitizerKind::Memory) &&
3328  !LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
3329 
3330  ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, Diags,
3334 
3335  // Turn on -Wspir-compat for SPIR target.
3336  auto Arch = T.getArch();
3337  if (Arch == llvm::Triple::spir || Arch == llvm::Triple::spir64) {
3338  Res.getDiagnosticOpts().Warnings.push_back("spir-compat");
3339  }
3340 
3341  // If sanitizer is enabled, disable OPT_ffine_grained_bitfield_accesses.
3342  if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&
3343  !Res.getLangOpts()->Sanitize.empty()) {
3344  Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;
3345  Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
3346  }
3347  return Success;
3348 }
3349 
3351  // Note: For QoI reasons, the things we use as a hash here should all be
3352  // dumped via the -module-info flag.
3353  using llvm::hash_code;
3354  using llvm::hash_value;
3355  using llvm::hash_combine;
3356 
3357  // Start the signature with the compiler version.
3358  // FIXME: We'd rather use something more cryptographically sound than
3359  // CityHash, but this will do for now.
3360  hash_code code = hash_value(getClangFullRepositoryVersion());
3361 
3362  // Extend the signature with the language options
3363 #define LANGOPT(Name, Bits, Default, Description) \
3364  code = hash_combine(code, LangOpts->Name);
3365 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
3366  code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
3367 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
3368 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
3369 #include "clang/Basic/LangOptions.def"
3370 
3371  for (StringRef Feature : LangOpts->ModuleFeatures)
3372  code = hash_combine(code, Feature);
3373 
3374  // Extend the signature with the target options.
3375  code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
3376  TargetOpts->ABI);
3377  for (const auto &FeatureAsWritten : TargetOpts->FeaturesAsWritten)
3378  code = hash_combine(code, FeatureAsWritten);
3379 
3380  // Extend the signature with preprocessor options.
3381  const PreprocessorOptions &ppOpts = getPreprocessorOpts();
3382  const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
3383  code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord);
3384 
3385  for (const auto &I : getPreprocessorOpts().Macros) {
3386  // If we're supposed to ignore this macro for the purposes of modules,
3387  // don't put it into the hash.
3388  if (!hsOpts.ModulesIgnoreMacros.empty()) {
3389  // Check whether we're ignoring this macro.
3390  StringRef MacroDef = I.first;
3391  if (hsOpts.ModulesIgnoreMacros.count(
3392  llvm::CachedHashString(MacroDef.split('=').first)))
3393  continue;
3394  }
3395 
3396  code = hash_combine(code, I.first, I.second);
3397  }
3398 
3399  // Extend the signature with the sysroot and other header search options.
3400  code = hash_combine(code, hsOpts.Sysroot,
3401  hsOpts.ModuleFormat,
3402  hsOpts.UseDebugInfo,
3403  hsOpts.UseBuiltinIncludes,
3405  hsOpts.UseStandardCXXIncludes,
3406  hsOpts.UseLibcxx,
3408  code = hash_combine(code, hsOpts.ResourceDir);
3409 
3410  // Extend the signature with the user build path.
3411  code = hash_combine(code, hsOpts.ModuleUserBuildPath);
3412 
3413  // Extend the signature with the module file extensions.
3414  const FrontendOptions &frontendOpts = getFrontendOpts();
3415  for (const auto &ext : frontendOpts.ModuleFileExtensions) {
3416  code = ext->hashExtension(code);
3417  }
3418 
3419  // When compiling with -gmodules, also hash -fdebug-prefix-map as it
3420  // affects the debug info in the PCM.
3421  if (getCodeGenOpts().DebugTypeExtRefs)
3422  for (const auto &KeyValue : getCodeGenOpts().DebugPrefixMap)
3423  code = hash_combine(code, KeyValue.first, KeyValue.second);
3424 
3425  // Extend the signature with the enabled sanitizers, if at least one is
3426  // enabled. Sanitizers which cannot affect AST generation aren't hashed.
3427  SanitizerSet SanHash = LangOpts->Sanitize;
3428  SanHash.clear(getPPTransparentSanitizers());
3429  if (!SanHash.empty())
3430  code = hash_combine(code, SanHash.Mask);
3431 
3432  return llvm::APInt(64, code).toString(36, /*Signed=*/false);
3433 }
3434 
3435 template<typename IntTy>
3436 static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id,
3437  IntTy Default,
3438  DiagnosticsEngine *Diags) {
3439  IntTy Res = Default;
3440  if (Arg *A = Args.getLastArg(Id)) {
3441  if (StringRef(A->getValue()).getAsInteger(10, Res)) {
3442  if (Diags)
3443  Diags->Report(diag::err_drv_invalid_int_value) << A->getAsString(Args)
3444  << A->getValue();
3445  }
3446  }
3447  return Res;
3448 }
3449 
3450 namespace clang {
3451 
3452 // Declared in clang/Frontend/Utils.h.
3453 int getLastArgIntValue(const ArgList &Args, OptSpecifier Id, int Default,
3454  DiagnosticsEngine *Diags) {
3455  return getLastArgIntValueImpl<int>(Args, Id, Default, Diags);
3456 }
3457 
3458 uint64_t getLastArgUInt64Value(const ArgList &Args, OptSpecifier Id,
3459  uint64_t Default,
3460  DiagnosticsEngine *Diags) {
3461  return getLastArgIntValueImpl<uint64_t>(Args, Id, Default, Diags);
3462 }
3463 
3466  DiagnosticsEngine &Diags) {
3467  return createVFSFromCompilerInvocation(CI, Diags,
3468  llvm::vfs::getRealFileSystem());
3469 }
3470 
3472  const CompilerInvocation &CI, DiagnosticsEngine &Diags,
3474  if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
3475  return BaseFS;
3476 
3478  // earlier vfs files are on the bottom
3479  for (const auto &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
3480  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
3481  Result->getBufferForFile(File);
3482  if (!Buffer) {
3483  Diags.Report(diag::err_missing_vfs_overlay_file) << File;
3484  continue;
3485  }
3486 
3487  IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = llvm::vfs::getVFSFromYAML(
3488  std::move(Buffer.get()), /*DiagHandler*/ nullptr, File,
3489  /*DiagContext*/ nullptr, Result);
3490  if (!FS) {
3491  Diags.Report(diag::err_invalid_vfs_overlay) << File;
3492  continue;
3493  }
3494 
3495  Result = FS;
3496  }
3497  return Result;
3498 }
3499 
3500 } // namespace clang
HeaderSearchOptions & getHeaderSearchOpts()
static Visibility parseVisibility(Arg *arg, ArgList &args, DiagnosticsEngine &diags)
Attempt to parse a visibility value out of the given argument.
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
Expand macros but not #includes.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string OutputFile
The output file, if any.
bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args, DiagnosticsEngine *Diags=nullptr, bool DefaultDiagColor=true, bool DefaultShowOpt=true)
Fill out Opts based on the options given in Args.
static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args)
Enable converting setter/getter expressions to property-dot syntx.
Enable migration to modern ObjC readonly property.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args)
Conform to the underlying platform&#39;s C and C++ ABIs as closely as we can.
unsigned InlineMaxStackDepth
The inlining stack depth limit.
Paths for &#39;#include <>&#39; added by &#39;-I&#39;.
std::string ModuleDependencyOutputDir
The directory to copy module dependencies to when collecting them.
std::string ObjCMTWhiteListPath
std::string DwarfDebugFlags
The string to embed in the debug information for the compile unit, if non-empty.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
std::string DOTOutputFile
The file to write GraphViz-formatted header dependencies to.
void addMacroUndef(StringRef Name)
Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, bool &IsHeaderFile)
Generate pre-compiled module from a module map.
Attempt to be ABI-compatible with code generated by Clang 6.0.x (SVN r321711).
unsigned UseLibcxx
Use libc++ instead of the default libstdc++.
unsigned IncludeBriefComments
Show brief documentation comments in code completion results.
unsigned ImplicitModuleMaps
Implicit module maps.
static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, const TargetOptions &TargetOpts, PreprocessorOptions &PPOpts, DiagnosticsEngine &Diags)
std::string SaveTempsFilePrefix
Prefix to use for -save-temps output.
Parse and perform semantic analysis.
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
XRayInstrMask Mask
Definition: XRayInstr.h:65
std::string ModuleUserBuildPath
The directory used for a user build.
static StringRef getCodeModel(ArgList &Args, DiagnosticsEngine &Diags)
unsigned IncludeGlobals
Show top-level decls in code completion results.
Emit a .bc file.
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:184
Format getFormat() const
Like System, but headers are implicitly wrapped in extern "C".
DependencyOutputOptions & getDependencyOutputOpts()
std::shared_ptr< HeaderSearchOptions > HeaderSearchOpts
Options controlling the #include directive.
std::shared_ptr< llvm::Regex > OptimizationRemarkMissedPattern
Regular expression to select optimizations for which we should enable missed optimization remarks...
static unsigned getOptimizationLevel(ArgList &Args, InputKind IK, DiagnosticsEngine &Diags)
static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config, StringRef OptionName, StringRef DefaultVal)
LangStandard - Information about the properties of a particular language standard.
Definition: LangStandard.h:42
static bool isBuiltinFunc(const char *Name)
Returns true if this is a libc/libm function without the &#39;__builtin_&#39; prefix.
Definition: Builtins.cpp:51
CoreFoundationABI CFRuntime
Definition: LangOptions.h:209
unsigned IncludeModuleFiles
Include module file dependencies.
void set(XRayInstrMask K, bool Value)
Definition: XRayInstr.h:54
Parse ASTs and print them.
Enable migration to add conforming protocols.
bool hasDigraphs() const
hasDigraphs - Language supports digraphs.
Definition: LangStandard.h:94
Like System, but only used for C++.
std::string HeaderIncludeOutputFile
The file to write header include output to.
StringRef P
std::vector< std::string > Includes
static bool parseDiagnosticLevelMask(StringRef FlagName, const std::vector< std::string > &Levels, DiagnosticsEngine *Diags, DiagnosticLevelMask &M)
std::string FPDenormalMode
The floating-point denormal mode to use.
Defines types useful for describing an Objective-C runtime.
bool isObjectiveC() const
Is the language of the input some dialect of Objective-C?
unsigned visualizeExplodedGraphWithGraphViz
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
Show all overloads.
Like System, but only used for ObjC++.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1295
static bool CreateFromArgs(CompilerInvocation &Res, const char *const *ArgBegin, const char *const *ArgEnd, DiagnosticsEngine &Diags)
Create a compiler invocation from a list of input options.
use NS_NONATOMIC_IOSONLY for property &#39;atomic&#39; attribute
#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN)
std::shared_ptr< LangOptions > LangOpts
Options controlling the language variant.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::string > Reciprocals
std::vector< std::string > RewriteMapFiles
Set of files defining the rules for the symbol rewriting.
Options for controlling comment parsing.
static const LangStandard & getLangStandardForKind(Kind K)
InputKind::Language getLanguage() const
Get the language that this standard describes.
Definition: LangStandard.h:63
std::string ASTDumpFilter
If given, filter dumped AST Decl nodes by this substring.
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition: Visibility.h:37
static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, const std::string &WorkingDir)
Options for controlling the target.
Definition: TargetOptions.h:27
llvm::SmallSetVector< llvm::CachedHashString, 16 > ModulesIgnoreMacros
The set of macro names that should be ignored for the purposes of computing the module hash...
void AddPath(StringRef Path, frontend::IncludeDirGroup Group, bool IsFramework, bool IgnoreSysRoot)
AddPath - Add the Path path to the specified Group list.
void addRemappedFile(StringRef From, StringRef To)
static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, DiagnosticsEngine *Diags)
std::string FixItSuffix
If given, the new suffix for fix-it rewritten files.
std::string HostTriple
When compiling for the device side, contains the triple used to compile for the host.
Definition: TargetOptions.h:34
std::string SplitDwarfFile
The name for the split debug info file that we&#39;ll break out.
Like System, but searched after the system directories.
BlockCommandNamesTy BlockCommandNames
Command names to treat as block commands in comments.
std::string ModuleCachePath
The directory used for the module cache.
std::string DebugPass
Enable additional debugging information.
float __ovld __cnfn normalize(float p)
Returns a vector in the same direction as p but with a length of 1.
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
Parse and apply any fixits to the source.
Defines the clang::SanitizerKind enum.
void AddSystemHeaderPrefix(StringRef Prefix, bool IsSystemHeader)
AddSystemHeaderPrefix - Override whether #include directives naming a path starting with Prefix shoul...
static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
&#39;macosx-fragile&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:40
std::map< std::string, std::string > DebugPrefixMap
std::vector< std::string > XRayAlwaysInstrumentFiles
Paths to the XRay "always instrument" files specifying which objects (files, functions, variables) should be imbued with the XRay "always instrument" attribute.
Definition: LangOptions.h:194
bool isCPlusPlus14() const
isCPlusPlus14 - Language is a C++14 variant (or later).
Definition: LangStandard.h:84
std::string FPMath
If given, the unit to use for floating point math.
Definition: TargetOptions.h:40
static std::shared_ptr< llvm::Regex > GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args, Arg *RpassArg)
Create a new Regex instance out of the string value in RpassArg.
LLVM_READONLY bool isLetter(unsigned char c)
Return true if this character is an ASCII letter: [a-zA-Z].
Definition: CharInfo.h:112
unsigned IncludeSystemHeaders
Include system header dependencies.
ShowIncludesDestination ShowIncludesDest
Destination of cl.exe style /showIncludes info.
Translate input source into HTML.
static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, DiagnosticsEngine &Diags, const TargetOptions &TargetOpts, const FrontendOptions &FrontendOpts)
Interoperability with the Swift 4.1 runtime.
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:73
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
std::string DumpExplodedGraphTo
File path to which the exploded graph should be dumped.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
InputKind withFormat(Format F) const
std::vector< std::string > ASTMergeFiles
The list of AST files to merge.
std::string CodeModel
The code model to use (-mcmodel).
std::vector< std::string > ModulesEmbedFiles
The list of files to embed into the compiled module file.
unsigned RelocatablePCH
When generating PCH files, instruct the AST writer to create relocatable PCH files.
Languages that the frontend can parse and compile.
Objects with "default" visibility are seen by the dynamic linker and act like normal objects...
Definition: Visibility.h:46
std::shared_ptr< PreprocessorOptions > PreprocessorOpts
Options controlling the preprocessor (aside from #include handling).
unsigned IncludeCodePatterns
Show code patterns in code completion results.
Action - Represent an abstract compilation step to perform.
Definition: Action.h:48
Generate LLVM IR, but do not emit anything.
static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
std::vector< std::string > XRayAttrListFiles
Paths to the XRay attribute list files, specifying which objects (files, functions, variables) should be imbued with the appropriate XRay attribute(s).
Definition: LangOptions.h:205
CodeGenOptions & getCodeGenOpts()
bool hasLineComments() const
Language supports &#39;//&#39; comments.
Definition: LangStandard.h:66
unsigned ShowStats
Show frontend performance metrics and statistics.
static void hash_combine(std::size_t &seed, const T &v)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts, ArgList &Args)
Emit location information but do not generate debug info in the output.
static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:34
std::vector< std::string > VFSOverlayFiles
The set of user-provided virtual filesystem overlay files.
bool isOpenCL() const
isOpenCL - Language is a OpenCL variant.
Definition: LangStandard.h:106
bool isCPlusPlus2a() const
isCPlusPlus2a - Language is a post-C++17 variant (or later).
Definition: LangStandard.h:90
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
unsigned FixWhatYouCan
Apply fixes even if there are unfixable errors.
Defines the Diagnostic-related interfaces.
std::unique_ptr< llvm::opt::OptTable > createDriverOptTable()
std::string FullCompilerInvocation
Store full compiler invocation for reproducible instructions in the generated report.
std::vector< std::string > Warnings
The list of -W...
std::vector< std::pair< std::string, bool > > CheckersControlList
Pair of checker name and enable/disable.
unsigned DisableModuleHash
Whether we should disable the use of the hash string within the module cache.
AnalysisStores
AnalysisStores - Set of available analysis store models.
constexpr XRayInstrMask All
Definition: XRayInstr.h:42
bool isCPlusPlus() const
isCPlusPlus - Language is a C++ variant.
Definition: LangStandard.h:78
bool DisablePCHValidation
When true, disables most of the normal validation performed on precompiled headers.
Interoperability with the Swift 5.0 runtime.
VersionTuple getOpenCLVersionTuple() const
Return the OpenCL C or C++ version as a VersionTuple.
Definition: LangOptions.cpp:47
static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName)
unsigned FixAndRecompile
Apply fixes and recompile.
Defines the clang::Visibility enumeration and various utility functions.
std::string FloatABI
The ABI to use for passing floating point arguments.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module &#39;requires&#39; decls in addition to the hard-coded list in ...
Definition: LangOptions.h:233
PreprocessorOutputOptions & getPreprocessorOutputOpts()
std::string ThreadModel
The thread model to use.
FrontendOptions & getFrontendOpts()
std::vector< std::string > DependentLibraries
A list of dependent libraries.
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
Dump the compiler configuration.
MigratorOptions & getMigratorOpts()
Dump template instantiations.
std::string ProfileFilterFiles
Regexes separated by a semi-colon to filter the files to instrument.
std::string ProfileRemappingFile
Name of the profile remapping file to apply to the profile data supplied by -fprofile-sample-use or -...
char CoverageVersion[4]
The version string to put into coverage files.
Dump out preprocessed tokens.
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:227
const char * getName() const
getName - Get the name of this standard.
Definition: LangStandard.h:57
AnalysisDiagClients AnalysisDiagOpt
Enable migration to modern ObjC readwrite property.
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
Interoperability with the ObjectiveC runtime.
void AddVFSOverlayFile(StringRef Name)
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g., -E).
static bool IsHeaderFile(const std::string &Filename)
std::string LimitFloatPrecision
The float precision limit to use, if non-empty.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
Generate pre-compiled module from a C++ module interface file.
for(unsigned I=0, E=TL.getNumArgs();I !=E;++I)
uint64_t getLastArgUInt64Value(const llvm::opt::ArgList &Args, llvm::opt::OptSpecifier Id, uint64_t Default, DiagnosticsEngine *Diags=nullptr)
#define LANGSTANDARD(id, name, lang, desc, features)
static void setLangDefaults(LangOptions &Opts, InputKind IK, const llvm::Triple &T, PreprocessorOptions &PPOpts, LangStandard::Kind LangStd=LangStandard::lang_unspecified)
Set language defaults for the given input language and language standard in the given LangOptions obj...
AnalysisInliningMode InliningMode
The mode of function selection used during inlining.
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:236
static std::string GetResourcesPath(const char *Argv0, void *MainAddr)
Get the directory where the compiler headers reside, relative to the compiler binary (found by the pa...
unsigned ModuleCachePruneInterval
The interval (in seconds) between pruning operations.
bool isCPlusPlus11() const
isCPlusPlus11 - Language is a C++11 variant (or later).
Definition: LangStandard.h:81
Defines the clang::LangOptions interface.
Enable migration to modern ObjC literals.
std::vector< std::string > Plugins
The list of plugins to load.
Show just the "best" overload candidates.
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
Emit only debug info necessary for generating line number tables (-gline-tables-only).
static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id, IntTy Default, DiagnosticsEngine *Diags)
int Id
Definition: ASTDiff.cpp:191
void AddPrebuiltModulePath(StringRef Name)
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
Definition: LangOptions.h:247
Defines the clang::CommentOptions interface.
std::set< std::string > DeserializedPCHDeclsToErrorOn
This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...
unsigned RewriteIncludes
Preprocess include directives only.
unsigned ShowTimers
Show timers for individual actions.
std::string LinkerVersion
If given, the version string of the linker in use.
Definition: TargetOptions.h:49
Only execute frontend initialization.
Defines version macros and version-related utility functions for Clang.
unsigned IncludeNamespaceLevelDecls
Show decls in namespace (including the global namespace) in code completion results.
Print the "preamble" of the input file.
static llvm::Reloc::Model getRelocModel(ArgList &Args, DiagnosticsEngine &Diags)
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
Definition: ObjCRuntime.cpp:49
bool PCHWithHdrStop
When true, we are creating or using a PCH where a #pragma hdrstop is expected to indicate the beginni...
unsigned ShowHeaderIncludes
Show header inclusions (-H).
std::shared_ptr< llvm::Regex > OptimizationRemarkPattern
Regular expression to select optimizations for which we should enable optimization remarks...
Rewriter playground.
unsigned UseBuiltinIncludes
Include the compiler builtin includes.
bool hasImplicitInt() const
hasImplicitInt - Language allows variables to be typed as int implicitly.
Definition: LangStandard.h:103
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:118
static bool IsInputCompatibleWithStandard(InputKind IK, const LangStandard &S)
Check if input file kind and language standard are compatible.
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
Definition: Sanitizers.h:67
unsigned ModulesEmbedAllFiles
Whether we should embed all used files into the PCM file.
AnalysisInliningMode
AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
Objects with "protected" visibility are seen by the dynamic linker but always dynamically resolve to ...
Definition: Visibility.h:42
unsigned ShowMacros
Print macro definitions.
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:207
static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, frontend::ActionKind Action)
static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action)
unsigned FixOnlyWarnings
Apply fixes only for warnings.
unsigned ModulesValidateOncePerBuildSession
If true, skip verifying input files used by modules if the module was already verified during this bu...
bool ForceEnableInt128
If given, enables support for __int128_t and __uint128_t types.
Definition: TargetOptions.h:66
The result type of a method or function.
Attempt to be ABI-compatible with code generated by Clang 3.8.x (SVN r257626).
static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, OptSpecifier GroupWithValue, std::vector< std::string > &Diagnostics)
std::string AuxTriple
Auxiliary triple for CUDA compilation.
bool isC11() const
isC11 - Language is a superset of C11.
Definition: LangStandard.h:72
Defines the clang::XRayInstrKind enum.
uint64_t BuildSessionTimestamp
The time in seconds when the build session started.
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:37
bool hasHexFloats() const
hasHexFloats - Language supports hexadecimal float constants.
Definition: LangStandard.h:100
unsigned ShowIncludeDirectives
Print includes, imports etc. within preprocessed output.
SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
Definition: Sanitizers.h:85
unsigned ARCMTMigrateEmitARCErrors
Emit ARC errors even if the migrator can fix them.
Enable migration of ObjC methods to &#39;instancetype&#39;.
enum clang::FrontendOptions::@192 ARCMTAction
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
Definition: Sanitizers.h:61
static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, StringRef &OptionField, StringRef Name, StringRef DefaultVal)
std::string ABI
If given, the name of the target ABI to use.
Definition: TargetOptions.h:43
AnalysisConstraints
AnalysisConstraints - Set of available constraint models.
llvm::StringMap< std::string > ConfigTable
AnalyzerOptionsRef getAnalyzerOpts() const
AnalysisStores AnalysisStoreOpt
InputKind getPreprocessed() const
Encodes a location in the source.
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
Generate machine code, but don&#39;t emit anything.
Assembly: we accept this only so that we can preprocess it.
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input. ...
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
Limit generated debug info to reduce size (-fno-standalone-debug).
Options for controlling the compiler diagnostics engine.
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
std::vector< FrontendInputFile > Inputs
The input files and their types.
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
Kind getKind() const
Definition: ObjCRuntime.h:77
unsigned ModulesValidateSystemHeaders
Whether to validate system input files when a module is loaded.
ConfigTable Config
A key-value table of use-specified configuration values.
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
The kind of a file that we&#39;ve been handed as an input.
#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN)
unsigned IncludeTimestamps
Whether timestamps should be written to the produced PCH file.
Parse ASTs and view them in Graphviz.
std::vector< std::string > Remarks
The list of -R...
std::vector< std::string > OpenCLExtensionsAsWritten
The list of OpenCL extensions to enable or disable, as written on the command line.
Definition: TargetOptions.h:63
std::vector< std::string > DefaultFunctionAttrs
Parse ASTs and list Decl nodes.
unsigned Verbose
Whether header search information should be output as for -v.
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:90
static void getAllNoBuiltinFuncValues(ArgList &Args, std::vector< std::string > &Funcs)
bool PCHWithHdrStopCreate
When true, we are creating a PCH or creating the PCH object while expecting a #pragma hdrstop to sepa...
Defines the clang::TargetOptions class.
Enable migration to modern ObjC subscripting.
std::unordered_map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
DiagnosticOptions & getDiagnosticOpts() const
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
unsigned ASTDumpLookups
Whether we include lookup table dumps in AST dumps.
std::vector< std::string > ExtraDeps
A list of filenames to be used as extra dependencies for every target.
Load and verify that a PCH file is usable.
std::shared_ptr< TargetOptions > TargetOpts
Options controlling the target.
std::string ModuleName
The module currently being compiled as speficied by -fmodule-name.
Definition: LangOptions.h:220
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
unsigned UseLineDirectives
Use #line instead of GCC-style # N.
Like System, but only used for ObjC.
unsigned ShowVersion
Show the -version text.
unsigned RewriteImports
Include contents of transitively-imported modules.
std::shared_ptr< llvm::Regex > OptimizationRemarkAnalysisPattern
Regular expression to select optimizations for which we should enable optimization analyses...
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line...
Definition: TargetOptions.h:52
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
Enable annotation of ObjCMethods of all kinds.
std::vector< BitcodeFileToLink > LinkBitcodeFiles
The files specified here are linked in to the module before optimizations.
constexpr XRayInstrMask None
Definition: XRayInstr.h:38
bool isUnknownAnalyzerConfig(StringRef Name) const
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
std::string PCHThroughHeader
If non-empty, the filename used in an #include directive in the primary source file (or command-line ...
static const StringRef GetInputKindName(InputKind IK)
Get language name for given input kind.
void addMacroDef(StringRef Name)
llvm::EABI EABIVersion
The EABI version to use.
Definition: TargetOptions.h:46
&#39;#include ""&#39; paths, added by &#39;gcc -iquote&#39;.
std::string ThinLTOIndexFile
Name of the function summary index file to use for ThinLTO function importing.
std::vector< std::string > MacroIncludes
unsigned ShowHelp
Show the -help text.
std::string OverrideRecordLayoutsFile
File name of the file that will provide record layouts (in the format produced by -fdump-record-layou...
unsigned FixToTemporaries
Apply fixes to temporary files.
Like Angled, but marks system directories.
static bool parseTestModuleFileExtensionArg(StringRef Arg, std::string &BlockName, unsigned &MajorVersion, unsigned &MinorVersion, bool &Hashed, std::string &UserInfo)
Parse the argument to the -ftest-module-file-extension command-line argument.
unsigned maxBlockVisitOnPath
The maximum number of times the analyzer visits a block.
unsigned DisableAllChecks
Disable all analyzer checks.
std::string OutputFile
The file to write dependency output to.
bool allowsARC() const
Does this runtime allow ARC at all?
Definition: ObjCRuntime.h:142
DependencyOutputFormat OutputFormat
The format for the dependency file.
std::string CudaGpuBinaryFileName
Name of file passed with -fcuda-include-gpubinary option to forward to CUDA runtime back-end for inco...
unsigned UseDebugInfo
Whether the module includes debug information (-gmodules).
Dataflow Directional Tag Classes.
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
Definition: LangOptions.h:217
static ParsedSourceLocation FromString(StringRef Str)
Construct a parsed source location from a string; the Filename is empty on error. ...
PreprocessorOptions & getPreprocessorOpts()
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
Language getLanguage() const
frontend::ActionKind ProgramAction
The frontend action to perform.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
Definition: LangOptions.h:243
std::vector< std::string > VerifyPrefixes
The prefixes for comment directives sought by -verify ("expected" by default).
std::string ARCMTMigrateReportOut
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
std::string PreferVectorWidth
The preferred width for auto-vectorization transforms.
Emit only debug directives with the line numbers data.
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Like System, but only used for C.
bool empty() const
Returns true if no sanitizers are enabled.
Definition: Sanitizers.h:70
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
AnalysisConstraints AnalysisConstraintsOpt
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action)
Helper class for holding the data necessary to invoke the compiler.
std::string DebugCompilationDir
The string to embed in debug information as the current working directory.
unsigned UsePhonyTargets
Include phony targets for each dependency, which can avoid some &#39;make&#39; problems.
std::string AnalyzeSpecificFunction
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i...
Definition: LangOptions.h:251
FrontendOptions - Options for controlling the behavior of the frontend.
bool isC17() const
isC17 - Language is a superset of C17.
Definition: LangStandard.h:75
static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args)
SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups)
Parse a single value from a -fsanitize= or -fno-sanitize= value list.
Definition: Sanitizers.cpp:19
Run a plugin action,.
bool isGNUMode() const
isGNUMode - Language includes GNU extensions.
Definition: LangStandard.h:97
Enable migration to modern ObjC property.
Enable migration to NS_ENUM/NS_OPTIONS macros.
uint64_t SanitizerMask
Definition: Sanitizers.h:26
std::string StatsFile
Filename to write statistics to.
Parse ASTs and dump them.
Don&#39;t generate debug info.
prefer &#39;atomic&#39; property over &#39;nonatomic&#39;.
std::string ProfileExcludeFiles
Regexes separated by a semi-colon to filter the files to not instrument.
std::string CoverageDataFile
The filename with path we use for coverage data files.
Defines the clang::FileSystemOptions interface.
std::vector< std::string > LinkerOptions
A list of linker options to embed in the object file.
std::string RecordCommandLine
The string containing the commandline for the llvm.commandline metadata, if non-empty.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
CodeCompleteOptions CodeCompleteOpts
static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor)
IntrusiveRefCntPtr< DiagnosticOptions > DiagnosticOpts
Options controlling the diagnostic engine.
std::vector< std::string > AddPluginActions
The list of plugin actions to run in addition to the normal action.
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
AnalysisPurgeMode
AnalysisPurgeModes - Set of available strategies for dead symbol removal.
Stores options for the analyzer from the command line.
Keeps track of options that affect how file operations are performed.
unsigned DisableFree
Disable memory freeing on exit.
Generate pre-compiled header.
Generate pre-compiled module from a set of header files.
int getLastArgIntValue(const llvm::opt::ArgList &Args, llvm::opt::OptSpecifier Id, int Default, DiagnosticsEngine *Diags=nullptr)
Return the value of the last argument as an integer, or a default.
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13953
unsigned ShowMacroComments
Show comments, even in macros.
bool isUnknown() const
Is the input kind fully-unknown?
Defines the clang::SourceLocation class and associated facilities.
unsigned NoRetryExhausted
Do not re-analyze paths leading to exhausted nodes with a different strategy.
Interoperability with the Swift 4.2 runtime.
std::vector< std::string > XRayNeverInstrumentFiles
Paths to the XRay "never instrument" files specifying which objects (files, functions, variables) should be imbued with the XRay "never instrument" attribute.
Definition: LangOptions.h:200
bool NVPTXUseShortPointers
If enabled, use 32-bit pointers for accessing const/local/shared address space.
Definition: TargetOptions.h:70
std::string MainFileName
The user provided name for the "main file", if non-empty.
unsigned ModuleCachePruneAfter
The time (in seconds) after which an unused module file will be considered unused and will...
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
Definition: LangOptions.h:239
static bool checkVerifyPrefixes(const std::vector< std::string > &VerifyPrefixes, DiagnosticsEngine *Diags)
XRayInstrMask parseXRayInstrValue(StringRef Value)
Definition: XRayInstr.cpp:19
bool isC99() const
isC99 - Language is a superset of C99.
Definition: LangStandard.h:69
annotate property with NS_RETURNS_INNER_POINTER
unsigned IncludeFixIts
Include results after corrections (small fix-its), e.g.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
std::string ActionName
The name of the action to run when using a plugin action.
unsigned ShowLineMarkers
Show #line markers.
bool isCPlusPlus17() const
isCPlusPlus17 - Language is a C++17 variant (or later).
Definition: LangStandard.h:87
FileSystemOptions & getFileSystemOpts()
static unsigned getOptimizationLevelSize(ArgList &Args)
Run one or more source code analyses.
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:52
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN)
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
std::vector< std::string > LLVMArgs
A list of arguments to forward to LLVM&#39;s option processing; this should only be used for debugging an...
std::vector< std::string > Targets
A list of names to use as the targets in the dependency file; this list must contain at least one ent...
std::string InstrProfileOutput
Name of the profile file to use as output for -fprofile-instr-generate and -fprofile-generate.
const char * getDescription() const
getDescription - Get the description of this standard.
Definition: LangStandard.h:60
std::string TrapFuncName
If not an empty string, trap intrinsics are lowered to calls to this function instead of to trap inst...
DiagnosticLevelMask
A bitmask representing the diagnostic levels used by VerifyDiagnosticConsumer.
Dump information about a module file.
unsigned ModuleMapFileHomeIsCwd
Set the &#39;home directory&#39; of a module map file to the current working directory (or the home directory...
std::string OptRecordFile
The name of the file to which the backend should save YAML optimization records.
std::string CodeModel
Definition: TargetOptions.h:76
unsigned AddMissingHeaderDeps
Add missing headers to dependency list.
std::string ThinLinkBitcodeFile
Name of a file that can optionally be written with minimized bitcode to be used as input for the Thin...
std::vector< std::string > SanitizerBlacklistFiles
Paths to blacklist files specifying which objects (files, functions, variables) should not be instrum...
Definition: LangOptions.h:188
unsigned ShowCPP
Print normal preprocessed output.
Like Angled, but marks header maps used when building frameworks.
unsigned ShouldEmitErrorsOnInvalidConfigValue
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
llvm::VersionTuple SDKVersion
The version of the SDK which was used during the compilation.
Definition: TargetOptions.h:79
static InputKind getInputKindForExtension(StringRef Extension)
getInputKindForExtension - Return the appropriate input kind for a file extension.
std::string ObjCConstantStringClass
Definition: LangOptions.h:211
#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC)
unsigned IncludeMacros
Show macros in code completion results.
AnalysisPurgeMode AnalysisPurgeOpt
static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, ArgList &Args, DiagnosticsEngine &D, XRayInstrSet &S)
bool DumpDeserializedPCHDecls
Dump declarations that are deserialized from PCH, for testing.
unsigned UseStandardCXXIncludes
Include the system standard C++ library include search directories.
std::map< std::string, std::string > PrebuiltModuleFiles
The mapping of module names to prebuilt module files.
AnalysisDiagClients
AnalysisDiagClients - Set of available diagnostic clients for rendering analysis results.
Attempt to be ABI-compatible with code generated by Clang 7.0.x (SVN r338536).
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:30
#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC)
Defines enum values for all the target-independent builtin functions.
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
std::string ModuleFormat
The module/pch container format.
static void parseSanitizerKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S)
bool allowsWeak() const
Does this runtime allow the use of __weak?
Definition: ObjCRuntime.h:267
LangStandard::Kind Std
std::string DiagnosticLogFile
The file to log diagnostic output to.
bool ParseAllComments
Treat ordinary comments as documentation comments.
bool LexEditorPlaceholders
When enabled, the preprocessor will construct editor placeholder tokens.
std::vector< std::string > ModuleMapFiles
The list of module map files to load before processing the input.