clang  6.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"
14 #include "clang/Basic/Version.h"
15 #include "clang/Config/config.h"
17 #include "clang/Driver/Options.h"
18 #include "clang/Driver/Util.h"
21 #include "clang/Frontend/Utils.h"
26 #include "llvm/ADT/Hashing.h"
27 #include "llvm/ADT/STLExtras.h"
28 #include "llvm/ADT/SmallVector.h"
29 #include "llvm/ADT/StringExtras.h"
30 #include "llvm/ADT/StringSwitch.h"
31 #include "llvm/ADT/Triple.h"
32 #include "llvm/Linker/Linker.h"
33 #include "llvm/Option/Arg.h"
34 #include "llvm/Option/ArgList.h"
35 #include "llvm/Option/OptTable.h"
36 #include "llvm/Option/Option.h"
37 #include "llvm/ProfileData/InstrProfReader.h"
38 #include "llvm/Support/CodeGen.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/FileSystem.h"
41 #include "llvm/Support/Host.h"
42 #include "llvm/Support/Path.h"
43 #include "llvm/Support/Process.h"
44 #include "llvm/Target/TargetOptions.h"
45 #include "llvm/Support/ScopedPrinter.h"
46 #include <atomic>
47 #include <memory>
48 #include <sys/stat.h>
49 #include <system_error>
50 using namespace clang;
51 
52 //===----------------------------------------------------------------------===//
53 // Initialization.
54 //===----------------------------------------------------------------------===//
55 
57  : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
58  DiagnosticOpts(new DiagnosticOptions()),
59  HeaderSearchOpts(new HeaderSearchOptions()),
60  PreprocessorOpts(new PreprocessorOptions()) {}
61 
63  : LangOpts(new LangOptions(*X.getLangOpts())),
68 
70 
71 //===----------------------------------------------------------------------===//
72 // Deserialization (from args)
73 //===----------------------------------------------------------------------===//
74 
75 using namespace clang::driver;
76 using namespace clang::driver::options;
77 using namespace llvm::opt;
78 
79 //
80 
81 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
82  DiagnosticsEngine &Diags) {
83  unsigned DefaultOpt = 0;
84  if (IK.getLanguage() == InputKind::OpenCL && !Args.hasArg(OPT_cl_opt_disable))
85  DefaultOpt = 2;
86 
87  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
88  if (A->getOption().matches(options::OPT_O0))
89  return 0;
90 
91  if (A->getOption().matches(options::OPT_Ofast))
92  return 3;
93 
94  assert (A->getOption().matches(options::OPT_O));
95 
96  StringRef S(A->getValue());
97  if (S == "s" || S == "z" || S.empty())
98  return 2;
99 
100  if (S == "g")
101  return 1;
102 
103  return getLastArgIntValue(Args, OPT_O, DefaultOpt, Diags);
104  }
105 
106  return DefaultOpt;
107 }
108 
109 static unsigned getOptimizationLevelSize(ArgList &Args) {
110  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
111  if (A->getOption().matches(options::OPT_O)) {
112  switch (A->getValue()[0]) {
113  default:
114  return 0;
115  case 's':
116  return 1;
117  case 'z':
118  return 2;
119  }
120  }
121  }
122  return 0;
123 }
124 
125 static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
126  OptSpecifier GroupWithValue,
127  std::vector<std::string> &Diagnostics) {
128  for (Arg *A : Args.filtered(Group)) {
129  if (A->getOption().getKind() == Option::FlagClass) {
130  // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
131  // its name (minus the "W" or "R" at the beginning) to the warning list.
132  Diagnostics.push_back(A->getOption().getName().drop_front(1));
133  } else if (A->getOption().matches(GroupWithValue)) {
134  // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group.
135  Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
136  } else {
137  // Otherwise, add its value (for OPT_W_Joined and similar).
138  for (const char *Arg : A->getValues())
139  Diagnostics.emplace_back(Arg);
140  }
141  }
142 }
143 
144 static void getAllNoBuiltinFuncValues(ArgList &Args,
145  std::vector<std::string> &Funcs) {
147  for (const auto &Arg : Args) {
148  const Option &O = Arg->getOption();
149  if (O.matches(options::OPT_fno_builtin_)) {
150  const char *FuncName = Arg->getValue();
151  if (Builtin::Context::isBuiltinFunc(FuncName))
152  Values.push_back(FuncName);
153  }
154  }
155  Funcs.insert(Funcs.end(), Values.begin(), Values.end());
156 }
157 
158 static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
159  DiagnosticsEngine &Diags) {
160  using namespace options;
161  bool Success = true;
162  if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
163  StringRef Name = A->getValue();
164  AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
165 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
166  .Case(CMDFLAG, NAME##Model)
167 #include "clang/StaticAnalyzer/Core/Analyses.def"
168  .Default(NumStores);
169  if (Value == NumStores) {
170  Diags.Report(diag::err_drv_invalid_value)
171  << A->getAsString(Args) << Name;
172  Success = false;
173  } else {
174  Opts.AnalysisStoreOpt = Value;
175  }
176  }
177 
178  if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
179  StringRef Name = A->getValue();
180  AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
181 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
182  .Case(CMDFLAG, NAME##Model)
183 #include "clang/StaticAnalyzer/Core/Analyses.def"
184  .Default(NumConstraints);
185  if (Value == NumConstraints) {
186  Diags.Report(diag::err_drv_invalid_value)
187  << A->getAsString(Args) << Name;
188  Success = false;
189  } else {
191  }
192  }
193 
194  if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
195  StringRef Name = A->getValue();
196  AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
197 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
198  .Case(CMDFLAG, PD_##NAME)
199 #include "clang/StaticAnalyzer/Core/Analyses.def"
200  .Default(NUM_ANALYSIS_DIAG_CLIENTS);
201  if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
202  Diags.Report(diag::err_drv_invalid_value)
203  << A->getAsString(Args) << Name;
204  Success = false;
205  } else {
206  Opts.AnalysisDiagOpt = Value;
207  }
208  }
209 
210  if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
211  StringRef Name = A->getValue();
212  AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
213 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
214  .Case(CMDFLAG, NAME)
215 #include "clang/StaticAnalyzer/Core/Analyses.def"
216  .Default(NumPurgeModes);
217  if (Value == NumPurgeModes) {
218  Diags.Report(diag::err_drv_invalid_value)
219  << A->getAsString(Args) << Name;
220  Success = false;
221  } else {
222  Opts.AnalysisPurgeOpt = Value;
223  }
224  }
225 
226  if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
227  StringRef Name = A->getValue();
228  AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name)
229 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
230  .Case(CMDFLAG, NAME)
231 #include "clang/StaticAnalyzer/Core/Analyses.def"
232  .Default(NumInliningModes);
233  if (Value == NumInliningModes) {
234  Diags.Report(diag::err_drv_invalid_value)
235  << A->getAsString(Args) << Name;
236  Success = false;
237  } else {
238  Opts.InliningMode = Value;
239  }
240  }
241 
242  Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
243  Opts.ShowEnabledCheckerList = Args.hasArg(OPT_analyzer_list_enabled_checkers);
244  Opts.DisableAllChecks = Args.hasArg(OPT_analyzer_disable_all_checks);
245 
247  Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
249  Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
250  Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted);
251  Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
252  Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
253  Opts.AnalyzeNestedBlocks =
254  Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
255  Opts.eagerlyAssumeBinOpBifurcation = Args.hasArg(OPT_analyzer_eagerly_assume);
256  Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
257  Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
258  Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
259  Opts.maxBlockVisitOnPath =
260  getLastArgIntValue(Args, OPT_analyzer_max_loop, 4, Diags);
261  Opts.PrintStats = Args.hasArg(OPT_analyzer_stats);
262  Opts.InlineMaxStackDepth =
263  getLastArgIntValue(Args, OPT_analyzer_inline_max_stack_depth,
264  Opts.InlineMaxStackDepth, Diags);
265 
266  Opts.CheckersControlList.clear();
267  for (const Arg *A :
268  Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
269  A->claim();
270  bool enable = (A->getOption().getID() == OPT_analyzer_checker);
271  // We can have a list of comma separated checker names, e.g:
272  // '-analyzer-checker=cocoa,unix'
273  StringRef checkerList = A->getValue();
274  SmallVector<StringRef, 4> checkers;
275  checkerList.split(checkers, ",");
276  for (StringRef checker : checkers)
277  Opts.CheckersControlList.emplace_back(checker, enable);
278  }
279 
280  // Go through the analyzer configuration options.
281  for (const Arg *A : Args.filtered(OPT_analyzer_config)) {
282  A->claim();
283  // We can have a list of comma separated config names, e.g:
284  // '-analyzer-config key1=val1,key2=val2'
285  StringRef configList = A->getValue();
286  SmallVector<StringRef, 4> configVals;
287  configList.split(configVals, ",");
288  for (unsigned i = 0, e = configVals.size(); i != e; ++i) {
289  StringRef key, val;
290  std::tie(key, val) = configVals[i].split("=");
291  if (val.empty()) {
292  Diags.Report(SourceLocation(),
293  diag::err_analyzer_config_no_value) << configVals[i];
294  Success = false;
295  break;
296  }
297  if (val.find('=') != StringRef::npos) {
298  Diags.Report(SourceLocation(),
299  diag::err_analyzer_config_multiple_values)
300  << configVals[i];
301  Success = false;
302  break;
303  }
304  Opts.Config[key] = val;
305  }
306  }
307 
308  return Success;
309 }
310 
311 static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args) {
312  Opts.NoNSAllocReallocError = Args.hasArg(OPT_migrator_no_nsalloc_error);
313  Opts.NoFinalizeRemoval = Args.hasArg(OPT_migrator_no_finalize_removal);
314  return true;
315 }
316 
317 static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args) {
318  Opts.BlockCommandNames = Args.getAllArgValues(OPT_fcomment_block_commands);
319  Opts.ParseAllComments = Args.hasArg(OPT_fparse_all_comments);
320 }
321 
322 static StringRef getCodeModel(ArgList &Args, DiagnosticsEngine &Diags) {
323  if (Arg *A = Args.getLastArg(OPT_mcode_model)) {
324  StringRef Value = A->getValue();
325  if (Value == "small" || Value == "kernel" || Value == "medium" ||
326  Value == "large")
327  return Value;
328  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
329  }
330  return "default";
331 }
332 
333 static StringRef getRelocModel(ArgList &Args, DiagnosticsEngine &Diags) {
334  if (Arg *A = Args.getLastArg(OPT_mrelocation_model)) {
335  StringRef Value = A->getValue();
336  if (Value == "static" || Value == "pic" || Value == "ropi" ||
337  Value == "rwpi" || Value == "ropi-rwpi" || Value == "dynamic-no-pic")
338  return Value;
339  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
340  }
341  return "pic";
342 }
343 
344 /// \brief Create a new Regex instance out of the string value in \p RpassArg.
345 /// It returns a pointer to the newly generated Regex instance.
346 static std::shared_ptr<llvm::Regex>
348  Arg *RpassArg) {
349  StringRef Val = RpassArg->getValue();
350  std::string RegexError;
351  std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val);
352  if (!Pattern->isValid(RegexError)) {
353  Diags.Report(diag::err_drv_optimization_remark_pattern)
354  << RegexError << RpassArg->getAsString(Args);
355  Pattern.reset();
356  }
357  return Pattern;
358 }
359 
360 static bool parseDiagnosticLevelMask(StringRef FlagName,
361  const std::vector<std::string> &Levels,
362  DiagnosticsEngine *Diags,
363  DiagnosticLevelMask &M) {
364  bool Success = true;
365  for (const auto &Level : Levels) {
366  DiagnosticLevelMask const PM =
367  llvm::StringSwitch<DiagnosticLevelMask>(Level)
368  .Case("note", DiagnosticLevelMask::Note)
369  .Case("remark", DiagnosticLevelMask::Remark)
370  .Case("warning", DiagnosticLevelMask::Warning)
371  .Case("error", DiagnosticLevelMask::Error)
372  .Default(DiagnosticLevelMask::None);
373  if (PM == DiagnosticLevelMask::None) {
374  Success = false;
375  if (Diags)
376  Diags->Report(diag::err_drv_invalid_value) << FlagName << Level;
377  }
378  M = M | PM;
379  }
380  return Success;
381 }
382 
383 static void parseSanitizerKinds(StringRef FlagName,
384  const std::vector<std::string> &Sanitizers,
385  DiagnosticsEngine &Diags, SanitizerSet &S) {
386  for (const auto &Sanitizer : Sanitizers) {
387  SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
388  if (K == 0)
389  Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
390  else
391  S.set(K, true);
392  }
393 }
394 
395 // Set the profile kind for fprofile-instrument.
396 static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args,
397  DiagnosticsEngine &Diags) {
398  Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ);
399  if (A == nullptr)
400  return;
401  StringRef S = A->getValue();
402  unsigned I = llvm::StringSwitch<unsigned>(S)
403  .Case("none", CodeGenOptions::ProfileNone)
404  .Case("clang", CodeGenOptions::ProfileClangInstr)
405  .Case("llvm", CodeGenOptions::ProfileIRInstr)
406  .Default(~0U);
407  if (I == ~0U) {
408  Diags.Report(diag::err_drv_invalid_pgo_instrumentor) << A->getAsString(Args)
409  << S;
410  return;
411  }
412  CodeGenOptions::ProfileInstrKind Instrumentor =
413  static_cast<CodeGenOptions::ProfileInstrKind>(I);
414  Opts.setProfileInstr(Instrumentor);
415 }
416 
417 // Set the profile kind using fprofile-instrument-use-path.
419  const Twine &ProfileName) {
420  auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName);
421  // In error, return silently and let Clang PGOUse report the error message.
422  if (auto E = ReaderOrErr.takeError()) {
423  llvm::consumeError(std::move(E));
424  Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
425  return;
426  }
427  std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
428  std::move(ReaderOrErr.get());
429  if (PGOReader->isIRLevelProfile())
430  Opts.setProfileUse(CodeGenOptions::ProfileIRInstr);
431  else
432  Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
433 }
434 
435 static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
436  DiagnosticsEngine &Diags,
437  const TargetOptions &TargetOpts) {
438  using namespace options;
439  bool Success = true;
440  llvm::Triple Triple = llvm::Triple(TargetOpts.Triple);
441 
442  unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
443  // TODO: This could be done in Driver
444  unsigned MaxOptLevel = 3;
445  if (OptimizationLevel > MaxOptLevel) {
446  // If the optimization level is not supported, fall back on the default
447  // optimization
448  Diags.Report(diag::warn_drv_optimization_value)
449  << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel;
450  OptimizationLevel = MaxOptLevel;
451  }
452  Opts.OptimizationLevel = OptimizationLevel;
453 
454  // At O0 we want to fully disable inlining outside of cases marked with
455  // 'alwaysinline' that are required for correctness.
456  Opts.setInlining((Opts.OptimizationLevel == 0)
459  // Explicit inlining flags can disable some or all inlining even at
460  // optimization levels above zero.
461  if (Arg *InlineArg = Args.getLastArg(
462  options::OPT_finline_functions, options::OPT_finline_hint_functions,
463  options::OPT_fno_inline_functions, options::OPT_fno_inline)) {
464  if (Opts.OptimizationLevel > 0) {
465  const Option &InlineOpt = InlineArg->getOption();
466  if (InlineOpt.matches(options::OPT_finline_functions))
467  Opts.setInlining(CodeGenOptions::NormalInlining);
468  else if (InlineOpt.matches(options::OPT_finline_hint_functions))
469  Opts.setInlining(CodeGenOptions::OnlyHintInlining);
470  else
471  Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
472  }
473  }
474 
475  Opts.ExperimentalNewPassManager = Args.hasFlag(
476  OPT_fexperimental_new_pass_manager, OPT_fno_experimental_new_pass_manager,
477  /* Default */ false);
478 
479  Opts.DebugPassManager =
480  Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
481  /* Default */ false);
482 
483  if (Arg *A = Args.getLastArg(OPT_fveclib)) {
484  StringRef Name = A->getValue();
485  if (Name == "Accelerate")
486  Opts.setVecLib(CodeGenOptions::Accelerate);
487  else if (Name == "SVML")
488  Opts.setVecLib(CodeGenOptions::SVML);
489  else if (Name == "none")
490  Opts.setVecLib(CodeGenOptions::NoLibrary);
491  else
492  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
493  }
494 
495  if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
496  unsigned Val =
497  llvm::StringSwitch<unsigned>(A->getValue())
498  .Case("line-tables-only", codegenoptions::DebugLineTablesOnly)
499  .Case("limited", codegenoptions::LimitedDebugInfo)
500  .Case("standalone", codegenoptions::FullDebugInfo)
501  .Default(~0U);
502  if (Val == ~0U)
503  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
504  << A->getValue();
505  else
506  Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val));
507  }
508  if (Arg *A = Args.getLastArg(OPT_debugger_tuning_EQ)) {
509  unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
510  .Case("gdb", unsigned(llvm::DebuggerKind::GDB))
511  .Case("lldb", unsigned(llvm::DebuggerKind::LLDB))
512  .Case("sce", unsigned(llvm::DebuggerKind::SCE))
513  .Default(~0U);
514  if (Val == ~0U)
515  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
516  << A->getValue();
517  else
518  Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val));
519  }
520  Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
521  Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
522  Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
523  Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro);
524  Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
525  Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std);
526  Opts.EnableSplitDwarf = Args.hasArg(OPT_enable_split_dwarf);
527  Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
528  Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining);
529  Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
530  Opts.DebugExplicitImport = Args.hasArg(OPT_dwarf_explicit_import);
531  Opts.DebugFwdTemplateParams = Args.hasArg(OPT_debug_forward_template_params);
532 
533  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
534  Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
535 
536  if (const Arg *A =
537  Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
538  Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
539 
540  Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
541  Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
542  Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
543  Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
544  Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
545  Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
546  OPT_fuse_register_sized_bitfield_access);
547  Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
548  Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
549  Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
550  Args.hasArg(OPT_new_struct_path_tbaa);
551  Opts.FineGrainedBitfieldAccesses =
552  Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
553  OPT_fno_fine_grained_bitfield_accesses, false);
554  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
555  Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
556  Opts.NoCommon = Args.hasArg(OPT_fno_common);
557  Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
558  Opts.OptimizeSize = getOptimizationLevelSize(Args);
559  Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
560  Args.hasArg(OPT_ffreestanding));
561  if (Opts.SimplifyLibCalls)
563  Opts.UnrollLoops =
564  Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
565  (Opts.OptimizationLevel > 1));
566  Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
567 
568  Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
569  Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
570  Opts.SampleProfileFile = Args.getLastArgValue(OPT_fprofile_sample_use_EQ);
571  Opts.DebugInfoForProfiling = Args.hasFlag(
572  OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
573  Opts.GnuPubnames = Args.hasArg(OPT_ggnu_pubnames);
574 
575  setPGOInstrumentor(Opts, Args, Diags);
576  Opts.InstrProfileOutput =
577  Args.getLastArgValue(OPT_fprofile_instrument_path_EQ);
579  Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ);
580  if (!Opts.ProfileInstrumentUsePath.empty())
582 
583  if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
584  Opts.setClangABICompat(CodeGenOptions::ClangABI::Latest);
585 
586  StringRef Ver = A->getValue();
587  std::pair<StringRef, StringRef> VerParts = Ver.split('.');
588  unsigned Major, Minor = 0;
589 
590  // Check the version number is valid: either 3.x (0 <= x <= 9) or
591  // y or y.0 (4 <= y <= current version).
592  if (!VerParts.first.startswith("0") &&
593  !VerParts.first.getAsInteger(10, Major) &&
594  3 <= Major && Major <= CLANG_VERSION_MAJOR &&
595  (Major == 3 ? VerParts.second.size() == 1 &&
596  !VerParts.second.getAsInteger(10, Minor)
597  : VerParts.first.size() == Ver.size() ||
598  VerParts.second == "0")) {
599  // Got a valid version number.
600  if (Major == 3 && Minor <= 8)
601  Opts.setClangABICompat(CodeGenOptions::ClangABI::Ver3_8);
602  else if (Major <= 4)
603  Opts.setClangABICompat(CodeGenOptions::ClangABI::Ver4);
604  } else if (Ver != "latest") {
605  Diags.Report(diag::err_drv_invalid_value)
606  << A->getAsString(Args) << A->getValue();
607  }
608  }
609 
610  Opts.CoverageMapping =
611  Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
612  Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
613  Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
614  Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
615  Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
616  Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
617  Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
618  Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
619  Opts.CodeModel = getCodeModel(Args, Diags);
620  Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
621  Opts.DisableFPElim =
622  (Args.hasArg(OPT_mdisable_fp_elim) || Args.hasArg(OPT_pg));
623  Opts.DisableFree = Args.hasArg(OPT_disable_free);
624  Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
625  Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
626  Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
627  Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable) ||
628  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
629  Args.hasArg(OPT_cl_fast_relaxed_math);
630  Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
631  Opts.NoInfsFPMath = (Args.hasArg(OPT_menable_no_infinities) ||
632  Args.hasArg(OPT_cl_finite_math_only) ||
633  Args.hasArg(OPT_cl_fast_relaxed_math));
634  Opts.NoNaNsFPMath = (Args.hasArg(OPT_menable_no_nans) ||
635  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
636  Args.hasArg(OPT_cl_finite_math_only) ||
637  Args.hasArg(OPT_cl_fast_relaxed_math));
638  Opts.NoSignedZeros = (Args.hasArg(OPT_fno_signed_zeros) ||
639  Args.hasArg(OPT_cl_no_signed_zeros) ||
640  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
641  Args.hasArg(OPT_cl_fast_relaxed_math));
642  Opts.FlushDenorm = Args.hasArg(OPT_cl_denorms_are_zero);
643  Opts.CorrectlyRoundedDivSqrt =
644  Args.hasArg(OPT_cl_fp32_correctly_rounded_divide_sqrt);
645  Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
646  Opts.ReciprocalMath = Args.hasArg(OPT_freciprocal_math);
647  Opts.NoTrappingMath = Args.hasArg(OPT_fno_trapping_math);
648  Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
649  Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
650  Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
651  Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
652  Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
653  Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
654  Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
655  Opts.IncrementalLinkerCompatible =
656  Args.hasArg(OPT_mincremental_linker_compatible);
657  Opts.PIECopyRelocations =
658  Args.hasArg(OPT_mpie_copy_relocations);
659  Opts.NoPLT = Args.hasArg(OPT_fno_plt);
660  Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
661  Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
662  Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
663  Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
664  Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
665  Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
666  Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
667  Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
668  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
669  Args.hasArg(OPT_cl_fast_relaxed_math);
670  Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
671  Opts.RelocationModel = getRelocModel(Args, Diags);
672  Opts.ThreadModel = Args.getLastArgValue(OPT_mthread_model, "posix");
673  if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
674  Diags.Report(diag::err_drv_invalid_value)
675  << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
676  << Opts.ThreadModel;
677  Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
678  Opts.UseInitArray = Args.hasArg(OPT_fuse_init_array);
679 
680  Opts.FunctionSections = Args.hasFlag(OPT_ffunction_sections,
681  OPT_fno_function_sections, false);
682  Opts.DataSections = Args.hasFlag(OPT_fdata_sections,
683  OPT_fno_data_sections, false);
684  Opts.UniqueSectionNames = Args.hasFlag(OPT_funique_section_names,
685  OPT_fno_unique_section_names, true);
686 
687  Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
688 
689  Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
690 
691  Opts.ProfileSampleAccurate = Args.hasArg(OPT_fprofile_sample_accurate);
692 
693  Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
694  Opts.EmitSummaryIndex = false;
695  if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
696  StringRef S = A->getValue();
697  if (S == "thin")
698  Opts.EmitSummaryIndex = true;
699  else if (S != "full")
700  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
701  }
702  Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false);
703  if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
704  if (IK.getLanguage() != InputKind::LLVM_IR)
705  Diags.Report(diag::err_drv_argument_only_allowed_with)
706  << A->getAsString(Args) << "-x ir";
707  Opts.ThinLTOIndexFile = Args.getLastArgValue(OPT_fthinlto_index_EQ);
708  }
709  Opts.ThinLinkBitcodeFile = Args.getLastArgValue(OPT_fthin_link_bitcode_EQ);
710 
711  Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
712 
713  Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
714  Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
715 
716  Opts.PreferVectorWidth = Args.getLastArgValue(OPT_mprefer_vector_width_EQ);
717 
718  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
719  Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
720 
721  Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
722  Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
723  Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
724  if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
725  Opts.CoverageDataFile = Args.getLastArgValue(OPT_coverage_data_file);
726  Opts.CoverageNotesFile = Args.getLastArgValue(OPT_coverage_notes_file);
727  Opts.CoverageExtraChecksum = Args.hasArg(OPT_coverage_cfg_checksum);
728  Opts.CoverageNoFunctionNamesInData =
729  Args.hasArg(OPT_coverage_no_function_names_in_data);
730  Opts.CoverageExitBlockBeforeBody =
731  Args.hasArg(OPT_coverage_exit_block_before_body);
732  if (Args.hasArg(OPT_coverage_version_EQ)) {
733  StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
734  if (CoverageVersion.size() != 4) {
735  Diags.Report(diag::err_drv_invalid_value)
736  << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
737  << CoverageVersion;
738  } else {
739  memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
740  }
741  }
742  }
743  // Handle -fembed-bitcode option.
744  if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
745  StringRef Name = A->getValue();
746  unsigned Model = llvm::StringSwitch<unsigned>(Name)
747  .Case("off", CodeGenOptions::Embed_Off)
748  .Case("all", CodeGenOptions::Embed_All)
749  .Case("bitcode", CodeGenOptions::Embed_Bitcode)
750  .Case("marker", CodeGenOptions::Embed_Marker)
751  .Default(~0U);
752  if (Model == ~0U) {
753  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
754  Success = false;
755  } else
756  Opts.setEmbedBitcode(
757  static_cast<CodeGenOptions::EmbedBitcodeKind>(Model));
758  }
759  // FIXME: For backend options that are not yet recorded as function
760  // attributes in the IR, keep track of them so we can embed them in a
761  // separate data section and use them when building the bitcode.
762  if (Opts.getEmbedBitcode() == CodeGenOptions::Embed_All) {
763  for (const auto &A : Args) {
764  // Do not encode output and input.
765  if (A->getOption().getID() == options::OPT_o ||
766  A->getOption().getID() == options::OPT_INPUT ||
767  A->getOption().getID() == options::OPT_x ||
768  A->getOption().getID() == options::OPT_fembed_bitcode ||
769  (A->getOption().getGroup().isValid() &&
770  A->getOption().getGroup().getID() == options::OPT_W_Group))
771  continue;
772  ArgStringList ASL;
773  A->render(Args, ASL);
774  for (const auto &arg : ASL) {
775  StringRef ArgStr(arg);
776  Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
777  // using \00 to seperate each commandline options.
778  Opts.CmdArgs.push_back('\0');
779  }
780  }
781  }
782 
783  Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
784  Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
785  Opts.InstrumentFunctionsAfterInlining =
786  Args.hasArg(OPT_finstrument_functions_after_inlining);
787  Opts.InstrumentFunctionEntryBare =
788  Args.hasArg(OPT_finstrument_function_entry_bare);
789  Opts.XRayInstrumentFunctions = Args.hasArg(OPT_fxray_instrument);
790  Opts.XRayAlwaysEmitCustomEvents =
791  Args.hasArg(OPT_fxray_always_emit_customevents);
792  Opts.XRayInstructionThreshold =
793  getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
794  Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
795  Opts.CallFEntry = Args.hasArg(OPT_mfentry);
796  Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
797 
798  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
799  OPT_compress_debug_sections_EQ)) {
800  if (A->getOption().getID() == OPT_compress_debug_sections) {
801  // TODO: be more clever about the compression type auto-detection
802  Opts.setCompressDebugSections(llvm::DebugCompressionType::GNU);
803  } else {
804  auto DCT = llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
805  .Case("none", llvm::DebugCompressionType::None)
806  .Case("zlib", llvm::DebugCompressionType::Z)
807  .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
809  Opts.setCompressDebugSections(DCT);
810  }
811  }
812 
813  Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
814  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
815  for (auto A : Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_cuda_bitcode)) {
817  F.Filename = A->getValue();
818  if (A->getOption().matches(OPT_mlink_cuda_bitcode)) {
819  F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
820  // When linking CUDA bitcode, propagate function attributes so that
821  // e.g. libdevice gets fast-math attrs if we're building with fast-math.
822  F.PropagateAttrs = true;
823  F.Internalize = true;
824  }
825  Opts.LinkBitcodeFiles.push_back(F);
826  }
827  Opts.SanitizeCoverageType =
828  getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
829  Opts.SanitizeCoverageIndirectCalls =
830  Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
831  Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
832  Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
833  Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
834  Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
835  Opts.SanitizeCoverage8bitCounters =
836  Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
837  Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
838  Opts.SanitizeCoverageTracePCGuard =
839  Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
840  Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune);
841  Opts.SanitizeCoverageInline8bitCounters =
842  Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters);
843  Opts.SanitizeCoveragePCTable = Args.hasArg(OPT_fsanitize_coverage_pc_table);
844  Opts.SanitizeCoverageStackDepth =
845  Args.hasArg(OPT_fsanitize_coverage_stack_depth);
846  Opts.SanitizeMemoryTrackOrigins =
847  getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
848  Opts.SanitizeMemoryUseAfterDtor =
849  Args.hasFlag(OPT_fsanitize_memory_use_after_dtor,
850  OPT_fno_sanitize_memory_use_after_dtor,
851  false);
852  Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime);
853  Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
854  Opts.SanitizeCfiICallGeneralizePointers =
855  Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers);
856  Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
857  if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope,
858  OPT_fno_sanitize_address_use_after_scope)) {
859  Opts.SanitizeAddressUseAfterScope =
860  A->getOption().getID() == OPT_fsanitize_address_use_after_scope;
861  }
862  Opts.SanitizeAddressGlobalsDeadStripping =
863  Args.hasArg(OPT_fsanitize_address_globals_dead_stripping);
864  Opts.SSPBufferSize =
865  getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
866  Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
867  if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
868  StringRef Val = A->getValue();
869  unsigned StackAlignment = Opts.StackAlignment;
870  Val.getAsInteger(10, StackAlignment);
871  Opts.StackAlignment = StackAlignment;
872  }
873 
874  if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) {
875  StringRef Val = A->getValue();
876  unsigned StackProbeSize = Opts.StackProbeSize;
877  Val.getAsInteger(0, StackProbeSize);
878  Opts.StackProbeSize = StackProbeSize;
879  }
880 
881  if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
882  StringRef Name = A->getValue();
883  unsigned Method = llvm::StringSwitch<unsigned>(Name)
884  .Case("legacy", CodeGenOptions::Legacy)
885  .Case("non-legacy", CodeGenOptions::NonLegacy)
886  .Case("mixed", CodeGenOptions::Mixed)
887  .Default(~0U);
888  if (Method == ~0U) {
889  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
890  Success = false;
891  } else {
892  Opts.setObjCDispatchMethod(
893  static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
894  }
895  }
896 
897  Opts.EmulatedTLS =
898  Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
899 
900  if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
901  StringRef Name = A->getValue();
902  unsigned Model = llvm::StringSwitch<unsigned>(Name)
903  .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
904  .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
905  .Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
906  .Case("local-exec", CodeGenOptions::LocalExecTLSModel)
907  .Default(~0U);
908  if (Model == ~0U) {
909  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
910  Success = false;
911  } else {
912  Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
913  }
914  }
915 
916  if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
917  StringRef Val = A->getValue();
918  if (Val == "ieee")
919  Opts.FPDenormalMode = "ieee";
920  else if (Val == "preserve-sign")
921  Opts.FPDenormalMode = "preserve-sign";
922  else if (Val == "positive-zero")
923  Opts.FPDenormalMode = "positive-zero";
924  else
925  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
926  }
927 
928  if (Arg *A = Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return)) {
929  if (A->getOption().matches(OPT_fpcc_struct_return)) {
930  Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
931  } else {
932  assert(A->getOption().matches(OPT_freg_struct_return));
933  Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
934  }
935  }
936 
937  Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
938  Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
939  bool NeedLocTracking = false;
940 
941  Opts.OptRecordFile = Args.getLastArgValue(OPT_opt_record_file);
942  if (!Opts.OptRecordFile.empty())
943  NeedLocTracking = true;
944 
945  if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
947  GenerateOptimizationRemarkRegex(Diags, Args, A);
948  NeedLocTracking = true;
949  }
950 
951  if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) {
953  GenerateOptimizationRemarkRegex(Diags, Args, A);
954  NeedLocTracking = true;
955  }
956 
957  if (Arg *A = Args.getLastArg(OPT_Rpass_analysis_EQ)) {
959  GenerateOptimizationRemarkRegex(Diags, Args, A);
960  NeedLocTracking = true;
961  }
962 
963  Opts.DiagnosticsWithHotness =
964  Args.hasArg(options::OPT_fdiagnostics_show_hotness);
965  bool UsingSampleProfile = !Opts.SampleProfileFile.empty();
966  bool UsingProfile = UsingSampleProfile ||
967  (Opts.getProfileUse() != CodeGenOptions::ProfileNone);
968 
969  if (Opts.DiagnosticsWithHotness && !UsingProfile)
970  Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
971  << "-fdiagnostics-show-hotness";
972 
973  Opts.DiagnosticsHotnessThreshold = getLastArgUInt64Value(
974  Args, options::OPT_fdiagnostics_hotness_threshold_EQ, 0);
975  if (Opts.DiagnosticsHotnessThreshold > 0 && !UsingProfile)
976  Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
977  << "-fdiagnostics-hotness-threshold=";
978 
979  // If the user requested to use a sample profile for PGO, then the
980  // backend will need to track source location information so the profile
981  // can be incorporated into the IR.
982  if (UsingSampleProfile)
983  NeedLocTracking = true;
984 
985  // If the user requested a flag that requires source locations available in
986  // the backend, make sure that the backend tracks source location information.
987  if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo)
988  Opts.setDebugInfo(codegenoptions::LocTrackingOnly);
989 
990  Opts.RewriteMapFiles = Args.getAllArgValues(OPT_frewrite_map_file);
991 
992  // Parse -fsanitize-recover= arguments.
993  // FIXME: Report unrecoverable sanitizers incorrectly specified here.
994  parseSanitizerKinds("-fsanitize-recover=",
995  Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
996  Opts.SanitizeRecover);
997  parseSanitizerKinds("-fsanitize-trap=",
998  Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
999  Opts.SanitizeTrap);
1000 
1001  Opts.CudaGpuBinaryFileNames =
1002  Args.getAllArgValues(OPT_fcuda_include_gpubinary);
1003 
1004  Opts.Backchain = Args.hasArg(OPT_mbackchain);
1005 
1006  Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
1007  Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
1008 
1009  return Success;
1010 }
1011 
1013  ArgList &Args) {
1014  using namespace options;
1015  Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
1016  Opts.Targets = Args.getAllArgValues(OPT_MT);
1017  Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
1018  Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
1019  Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
1020  Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
1021  Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
1022  Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
1023  Opts.PrintShowIncludes = Args.hasArg(OPT_show_includes);
1024  Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
1026  Args.getLastArgValue(OPT_module_dependency_dir);
1027  if (Args.hasArg(OPT_MV))
1029  // Add sanitizer blacklists as extra dependencies.
1030  // They won't be discovered by the regular preprocessor, so
1031  // we let make / ninja to know about this implicit dependency.
1032  Opts.ExtraDeps = Args.getAllArgValues(OPT_fdepfile_entry);
1033  // Only the -fmodule-file=<file> form.
1034  for (const Arg *A : Args.filtered(OPT_fmodule_file)) {
1035  StringRef Val = A->getValue();
1036  if (Val.find('=') == StringRef::npos)
1037  Opts.ExtraDeps.push_back(Val);
1038  }
1039 }
1040 
1041 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
1042  // Color diagnostics default to auto ("on" if terminal supports) in the driver
1043  // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
1044  // Support both clang's -f[no-]color-diagnostics and gcc's
1045  // -f[no-]diagnostics-colors[=never|always|auto].
1046  enum {
1047  Colors_On,
1048  Colors_Off,
1049  Colors_Auto
1050  } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
1051  for (Arg *A : Args) {
1052  const Option &O = A->getOption();
1053  if (O.matches(options::OPT_fcolor_diagnostics) ||
1054  O.matches(options::OPT_fdiagnostics_color)) {
1055  ShowColors = Colors_On;
1056  } else if (O.matches(options::OPT_fno_color_diagnostics) ||
1057  O.matches(options::OPT_fno_diagnostics_color)) {
1058  ShowColors = Colors_Off;
1059  } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
1060  StringRef Value(A->getValue());
1061  if (Value == "always")
1062  ShowColors = Colors_On;
1063  else if (Value == "never")
1064  ShowColors = Colors_Off;
1065  else if (Value == "auto")
1066  ShowColors = Colors_Auto;
1067  }
1068  }
1069  return ShowColors == Colors_On ||
1070  (ShowColors == Colors_Auto &&
1071  llvm::sys::Process::StandardErrHasColors());
1072 }
1073 
1074 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
1075  DiagnosticsEngine *Diags,
1076  bool DefaultDiagColor, bool DefaultShowOpt) {
1077  using namespace options;
1078  bool Success = true;
1079 
1080  Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
1081  if (Arg *A =
1082  Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
1083  Opts.DiagnosticSerializationFile = A->getValue();
1084  Opts.IgnoreWarnings = Args.hasArg(OPT_w);
1085  Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
1086  Opts.Pedantic = Args.hasArg(OPT_pedantic);
1087  Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
1088  Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
1089  Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
1090  Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
1091  OPT_fno_show_column,
1092  /*Default=*/true);
1093  Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
1094  Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
1095  Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
1096  Opts.ShowOptionNames =
1097  Args.hasFlag(OPT_fdiagnostics_show_option,
1098  OPT_fno_diagnostics_show_option, DefaultShowOpt);
1099 
1100  llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
1101 
1102  // Default behavior is to not to show note include stacks.
1103  Opts.ShowNoteIncludeStack = false;
1104  if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
1105  OPT_fno_diagnostics_show_note_include_stack))
1106  if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
1107  Opts.ShowNoteIncludeStack = true;
1108 
1109  StringRef ShowOverloads =
1110  Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
1111  if (ShowOverloads == "best")
1112  Opts.setShowOverloads(Ovl_Best);
1113  else if (ShowOverloads == "all")
1114  Opts.setShowOverloads(Ovl_All);
1115  else {
1116  Success = false;
1117  if (Diags)
1118  Diags->Report(diag::err_drv_invalid_value)
1119  << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1120  << ShowOverloads;
1121  }
1122 
1123  StringRef ShowCategory =
1124  Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
1125  if (ShowCategory == "none")
1126  Opts.ShowCategories = 0;
1127  else if (ShowCategory == "id")
1128  Opts.ShowCategories = 1;
1129  else if (ShowCategory == "name")
1130  Opts.ShowCategories = 2;
1131  else {
1132  Success = false;
1133  if (Diags)
1134  Diags->Report(diag::err_drv_invalid_value)
1135  << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1136  << ShowCategory;
1137  }
1138 
1139  StringRef Format =
1140  Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
1141  if (Format == "clang")
1142  Opts.setFormat(DiagnosticOptions::Clang);
1143  else if (Format == "msvc")
1144  Opts.setFormat(DiagnosticOptions::MSVC);
1145  else if (Format == "msvc-fallback") {
1146  Opts.setFormat(DiagnosticOptions::MSVC);
1147  Opts.CLFallbackMode = true;
1148  } else if (Format == "vi")
1149  Opts.setFormat(DiagnosticOptions::Vi);
1150  else {
1151  Success = false;
1152  if (Diags)
1153  Diags->Report(diag::err_drv_invalid_value)
1154  << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
1155  << Format;
1156  }
1157 
1158  Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
1159  Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
1160  Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
1161  Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
1163  Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
1164  Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
1165  Diags, DiagMask);
1166  if (Args.hasArg(OPT_verify_ignore_unexpected))
1167  DiagMask = DiagnosticLevelMask::All;
1168  Opts.setVerifyIgnoreUnexpected(DiagMask);
1169  Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
1170  Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
1171  Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
1172  Opts.MacroBacktraceLimit =
1173  getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
1175  Opts.TemplateBacktraceLimit = getLastArgIntValue(
1176  Args, OPT_ftemplate_backtrace_limit,
1178  Opts.ConstexprBacktraceLimit = getLastArgIntValue(
1179  Args, OPT_fconstexpr_backtrace_limit,
1181  Opts.SpellCheckingLimit = getLastArgIntValue(
1182  Args, OPT_fspell_checking_limit,
1184  Opts.SnippetLineLimit = getLastArgIntValue(
1185  Args, OPT_fcaret_diagnostics_max_lines,
1187  Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
1189  if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
1190  Opts.TabStop = DiagnosticOptions::DefaultTabStop;
1191  if (Diags)
1192  Diags->Report(diag::warn_ignoring_ftabstop_value)
1193  << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
1194  }
1195  Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
1196  addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
1197  addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
1198 
1199  return Success;
1200 }
1201 
1202 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1203  Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
1204 }
1205 
1206 /// Parse the argument to the -ftest-module-file-extension
1207 /// command-line argument.
1208 ///
1209 /// \returns true on error, false on success.
1210 static bool parseTestModuleFileExtensionArg(StringRef Arg,
1211  std::string &BlockName,
1212  unsigned &MajorVersion,
1213  unsigned &MinorVersion,
1214  bool &Hashed,
1215  std::string &UserInfo) {
1217  Arg.split(Args, ':', 5);
1218  if (Args.size() < 5)
1219  return true;
1220 
1221  BlockName = Args[0];
1222  if (Args[1].getAsInteger(10, MajorVersion)) return true;
1223  if (Args[2].getAsInteger(10, MinorVersion)) return true;
1224  if (Args[3].getAsInteger(2, Hashed)) return true;
1225  if (Args.size() > 4)
1226  UserInfo = Args[4];
1227  return false;
1228 }
1229 
1230 static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
1231  DiagnosticsEngine &Diags,
1232  bool &IsHeaderFile) {
1233  using namespace options;
1235  if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1236  switch (A->getOption().getID()) {
1237  default:
1238  llvm_unreachable("Invalid option in group!");
1239  case OPT_ast_list:
1240  Opts.ProgramAction = frontend::ASTDeclList; break;
1241  case OPT_ast_dump:
1242  case OPT_ast_dump_all:
1243  case OPT_ast_dump_lookups:
1244  Opts.ProgramAction = frontend::ASTDump; break;
1245  case OPT_ast_print:
1246  Opts.ProgramAction = frontend::ASTPrint; break;
1247  case OPT_ast_view:
1248  Opts.ProgramAction = frontend::ASTView; break;
1249  case OPT_dump_raw_tokens:
1250  Opts.ProgramAction = frontend::DumpRawTokens; break;
1251  case OPT_dump_tokens:
1252  Opts.ProgramAction = frontend::DumpTokens; break;
1253  case OPT_S:
1254  Opts.ProgramAction = frontend::EmitAssembly; break;
1255  case OPT_emit_llvm_bc:
1256  Opts.ProgramAction = frontend::EmitBC; break;
1257  case OPT_emit_html:
1258  Opts.ProgramAction = frontend::EmitHTML; break;
1259  case OPT_emit_llvm:
1260  Opts.ProgramAction = frontend::EmitLLVM; break;
1261  case OPT_emit_llvm_only:
1262  Opts.ProgramAction = frontend::EmitLLVMOnly; break;
1263  case OPT_emit_codegen_only:
1265  case OPT_emit_obj:
1266  Opts.ProgramAction = frontend::EmitObj; break;
1267  case OPT_fixit_EQ:
1268  Opts.FixItSuffix = A->getValue();
1269  // fall-through!
1270  case OPT_fixit:
1271  Opts.ProgramAction = frontend::FixIt; break;
1272  case OPT_emit_module:
1274  case OPT_emit_module_interface:
1276  case OPT_emit_pch:
1277  Opts.ProgramAction = frontend::GeneratePCH; break;
1278  case OPT_emit_pth:
1279  Opts.ProgramAction = frontend::GeneratePTH; break;
1280  case OPT_init_only:
1281  Opts.ProgramAction = frontend::InitOnly; break;
1282  case OPT_fsyntax_only:
1284  case OPT_module_file_info:
1286  case OPT_verify_pch:
1287  Opts.ProgramAction = frontend::VerifyPCH; break;
1288  case OPT_print_decl_contexts:
1290  case OPT_print_preamble:
1291  Opts.ProgramAction = frontend::PrintPreamble; break;
1292  case OPT_E:
1294  case OPT_rewrite_macros:
1295  Opts.ProgramAction = frontend::RewriteMacros; break;
1296  case OPT_rewrite_objc:
1297  Opts.ProgramAction = frontend::RewriteObjC; break;
1298  case OPT_rewrite_test:
1299  Opts.ProgramAction = frontend::RewriteTest; break;
1300  case OPT_analyze:
1301  Opts.ProgramAction = frontend::RunAnalysis; break;
1302  case OPT_migrate:
1303  Opts.ProgramAction = frontend::MigrateSource; break;
1304  case OPT_Eonly:
1306  }
1307  }
1308 
1309  if (const Arg* A = Args.getLastArg(OPT_plugin)) {
1310  Opts.Plugins.emplace_back(A->getValue(0));
1312  Opts.ActionName = A->getValue();
1313  }
1314  Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
1315  for (const Arg *AA : Args.filtered(OPT_plugin_arg))
1316  Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
1317 
1318  for (const std::string &Arg :
1319  Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
1320  std::string BlockName;
1321  unsigned MajorVersion;
1322  unsigned MinorVersion;
1323  bool Hashed;
1324  std::string UserInfo;
1325  if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion,
1326  MinorVersion, Hashed, UserInfo)) {
1327  Diags.Report(diag::err_test_module_file_extension_format) << Arg;
1328 
1329  continue;
1330  }
1331 
1332  // Add the testing module file extension.
1333  Opts.ModuleFileExtensions.push_back(
1334  std::make_shared<TestModuleFileExtension>(
1335  BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
1336  }
1337 
1338  if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1339  Opts.CodeCompletionAt =
1340  ParsedSourceLocation::FromString(A->getValue());
1341  if (Opts.CodeCompletionAt.FileName.empty())
1342  Diags.Report(diag::err_drv_invalid_value)
1343  << A->getAsString(Args) << A->getValue();
1344  }
1345  Opts.DisableFree = Args.hasArg(OPT_disable_free);
1346 
1347  Opts.OutputFile = Args.getLastArgValue(OPT_o);
1348  Opts.Plugins = Args.getAllArgValues(OPT_load);
1349  Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
1350  Opts.ShowHelp = Args.hasArg(OPT_help);
1351  Opts.ShowStats = Args.hasArg(OPT_print_stats);
1352  Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
1353  Opts.ShowVersion = Args.hasArg(OPT_version);
1354  Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1355  Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
1356  Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
1357  Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
1358  Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
1359  Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
1360  Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump);
1361  Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all);
1362  Opts.ASTDumpFilter = Args.getLastArgValue(OPT_ast_dump_filter);
1363  Opts.ASTDumpLookups = Args.hasArg(OPT_ast_dump_lookups);
1364  Opts.UseGlobalModuleIndex = !Args.hasArg(OPT_fno_modules_global_index);
1366  Opts.ModuleMapFiles = Args.getAllArgValues(OPT_fmodule_map_file);
1367  // Only the -fmodule-file=<file> form.
1368  for (const Arg *A : Args.filtered(OPT_fmodule_file)) {
1369  StringRef Val = A->getValue();
1370  if (Val.find('=') == StringRef::npos)
1371  Opts.ModuleFiles.push_back(Val);
1372  }
1373  Opts.ModulesEmbedFiles = Args.getAllArgValues(OPT_fmodules_embed_file_EQ);
1374  Opts.ModulesEmbedAllFiles = Args.hasArg(OPT_fmodules_embed_all_files);
1375  Opts.IncludeTimestamps = !Args.hasArg(OPT_fno_pch_timestamp);
1376 
1378  = Args.hasArg(OPT_code_completion_macros);
1380  = Args.hasArg(OPT_code_completion_patterns);
1382  = !Args.hasArg(OPT_no_code_completion_globals);
1384  = !Args.hasArg(OPT_no_code_completion_ns_level_decls);
1386  = Args.hasArg(OPT_code_completion_brief_comments);
1387 
1389  = Args.getLastArgValue(OPT_foverride_record_layout_EQ);
1390  Opts.AuxTriple =
1391  llvm::Triple::normalize(Args.getLastArgValue(OPT_aux_triple));
1392  Opts.FindPchSource = Args.getLastArgValue(OPT_find_pch_source_EQ);
1393  Opts.StatsFile = Args.getLastArgValue(OPT_stats_file);
1394 
1395  if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
1396  OPT_arcmt_modify,
1397  OPT_arcmt_migrate)) {
1398  switch (A->getOption().getID()) {
1399  default:
1400  llvm_unreachable("missed a case");
1401  case OPT_arcmt_check:
1403  break;
1404  case OPT_arcmt_modify:
1406  break;
1407  case OPT_arcmt_migrate:
1409  break;
1410  }
1411  }
1412  Opts.MTMigrateDir = Args.getLastArgValue(OPT_mt_migrate_directory);
1414  = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
1416  = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
1417 
1418  if (Args.hasArg(OPT_objcmt_migrate_literals))
1420  if (Args.hasArg(OPT_objcmt_migrate_subscripting))
1422  if (Args.hasArg(OPT_objcmt_migrate_property_dot_syntax))
1424  if (Args.hasArg(OPT_objcmt_migrate_property))
1426  if (Args.hasArg(OPT_objcmt_migrate_readonly_property))
1428  if (Args.hasArg(OPT_objcmt_migrate_readwrite_property))
1430  if (Args.hasArg(OPT_objcmt_migrate_annotation))
1432  if (Args.hasArg(OPT_objcmt_returns_innerpointer_property))
1434  if (Args.hasArg(OPT_objcmt_migrate_instancetype))
1436  if (Args.hasArg(OPT_objcmt_migrate_nsmacros))
1438  if (Args.hasArg(OPT_objcmt_migrate_protocol_conformance))
1440  if (Args.hasArg(OPT_objcmt_atomic_property))
1442  if (Args.hasArg(OPT_objcmt_ns_nonatomic_iosonly))
1444  if (Args.hasArg(OPT_objcmt_migrate_designated_init))
1446  if (Args.hasArg(OPT_objcmt_migrate_all))
1448 
1449  Opts.ObjCMTWhiteListPath = Args.getLastArgValue(OPT_objcmt_whitelist_dir_path);
1450 
1453  Diags.Report(diag::err_drv_argument_not_allowed_with)
1454  << "ARC migration" << "ObjC migration";
1455  }
1456 
1458  if (const Arg *A = Args.getLastArg(OPT_x)) {
1459  StringRef XValue = A->getValue();
1460 
1461  // Parse suffixes: '<lang>(-header|[-module-map][-cpp-output])'.
1462  // FIXME: Supporting '<lang>-header-cpp-output' would be useful.
1463  bool Preprocessed = XValue.consume_back("-cpp-output");
1464  bool ModuleMap = XValue.consume_back("-module-map");
1465  IsHeaderFile =
1466  !Preprocessed && !ModuleMap && XValue.consume_back("-header");
1467 
1468  // Principal languages.
1469  DashX = llvm::StringSwitch<InputKind>(XValue)
1470  .Case("c", InputKind::C)
1471  .Case("cl", InputKind::OpenCL)
1472  .Case("cuda", InputKind::CUDA)
1473  .Case("c++", InputKind::CXX)
1474  .Case("objective-c", InputKind::ObjC)
1475  .Case("objective-c++", InputKind::ObjCXX)
1476  .Case("renderscript", InputKind::RenderScript)
1477  .Default(InputKind::Unknown);
1478 
1479  // "objc[++]-cpp-output" is an acceptable synonym for
1480  // "objective-c[++]-cpp-output".
1481  if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap)
1482  DashX = llvm::StringSwitch<InputKind>(XValue)
1483  .Case("objc", InputKind::ObjC)
1484  .Case("objc++", InputKind::ObjCXX)
1485  .Default(InputKind::Unknown);
1486 
1487  // Some special cases cannot be combined with suffixes.
1488  if (DashX.isUnknown() && !Preprocessed && !ModuleMap && !IsHeaderFile)
1489  DashX = llvm::StringSwitch<InputKind>(XValue)
1490  .Case("cpp-output", InputKind(InputKind::C).getPreprocessed())
1491  .Case("assembler-with-cpp", InputKind::Asm)
1492  .Cases("ast", "pcm",
1494  .Case("ir", InputKind::LLVM_IR)
1495  .Default(InputKind::Unknown);
1496 
1497  if (DashX.isUnknown())
1498  Diags.Report(diag::err_drv_invalid_value)
1499  << A->getAsString(Args) << A->getValue();
1500 
1501  if (Preprocessed)
1502  DashX = DashX.getPreprocessed();
1503  if (ModuleMap)
1504  DashX = DashX.withFormat(InputKind::ModuleMap);
1505  }
1506 
1507  // '-' is the default input if none is given.
1508  std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
1509  Opts.Inputs.clear();
1510  if (Inputs.empty())
1511  Inputs.push_back("-");
1512  for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1513  InputKind IK = DashX;
1514  if (IK.isUnknown()) {
1516  StringRef(Inputs[i]).rsplit('.').second);
1517  // FIXME: Warn on this?
1518  if (IK.isUnknown())
1519  IK = InputKind::C;
1520  // FIXME: Remove this hack.
1521  if (i == 0)
1522  DashX = IK;
1523  }
1524 
1525  // The -emit-module action implicitly takes a module map.
1527  IK.getFormat() == InputKind::Source)
1529 
1530  Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
1531  }
1532 
1533  return DashX;
1534 }
1535 
1536 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
1537  void *MainAddr) {
1538  std::string ClangExecutable =
1539  llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
1540  StringRef Dir = llvm::sys::path::parent_path(ClangExecutable);
1541 
1542  // Compute the path to the resource directory.
1543  StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
1544  SmallString<128> P(Dir);
1545  if (ClangResourceDir != "")
1546  llvm::sys::path::append(P, ClangResourceDir);
1547  else
1548  llvm::sys::path::append(P, "..", Twine("lib") + CLANG_LIBDIR_SUFFIX,
1549  "clang", CLANG_VERSION_STRING);
1550 
1551  return P.str();
1552 }
1553 
1554 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
1555  const std::string &WorkingDir) {
1556  using namespace options;
1557  Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
1558  Opts.Verbose = Args.hasArg(OPT_v);
1559  Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
1560  Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
1561  Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
1562  if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
1563  Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
1564  Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
1565 
1566  // Canonicalize -fmodules-cache-path before storing it.
1567  SmallString<128> P(Args.getLastArgValue(OPT_fmodules_cache_path));
1568  if (!(P.empty() || llvm::sys::path::is_absolute(P))) {
1569  if (WorkingDir.empty())
1570  llvm::sys::fs::make_absolute(P);
1571  else
1572  llvm::sys::fs::make_absolute(WorkingDir, P);
1573  }
1574  llvm::sys::path::remove_dots(P);
1575  Opts.ModuleCachePath = P.str();
1576 
1577  Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path);
1578  // Only the -fmodule-file=<name>=<file> form.
1579  for (const Arg *A : Args.filtered(OPT_fmodule_file)) {
1580  StringRef Val = A->getValue();
1581  if (Val.find('=') != StringRef::npos)
1582  Opts.PrebuiltModuleFiles.insert(Val.split('='));
1583  }
1584  for (const Arg *A : Args.filtered(OPT_fprebuilt_module_path))
1585  Opts.AddPrebuiltModulePath(A->getValue());
1586  Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
1587  Opts.ModulesHashContent = Args.hasArg(OPT_fmodules_hash_content);
1589  !Args.hasArg(OPT_fmodules_disable_diagnostic_validation);
1590  Opts.ImplicitModuleMaps = Args.hasArg(OPT_fimplicit_module_maps);
1591  Opts.ModuleMapFileHomeIsCwd = Args.hasArg(OPT_fmodule_map_file_home_is_cwd);
1593  getLastArgIntValue(Args, OPT_fmodules_prune_interval, 7 * 24 * 60 * 60);
1594  Opts.ModuleCachePruneAfter =
1595  getLastArgIntValue(Args, OPT_fmodules_prune_after, 31 * 24 * 60 * 60);
1597  Args.hasArg(OPT_fmodules_validate_once_per_build_session);
1598  Opts.BuildSessionTimestamp =
1599  getLastArgUInt64Value(Args, OPT_fbuild_session_timestamp, 0);
1601  Args.hasArg(OPT_fmodules_validate_system_headers);
1602  if (const Arg *A = Args.getLastArg(OPT_fmodule_format_EQ))
1603  Opts.ModuleFormat = A->getValue();
1604 
1605  for (const Arg *A : Args.filtered(OPT_fmodules_ignore_macro)) {
1606  StringRef MacroDef = A->getValue();
1607  Opts.ModulesIgnoreMacros.insert(
1608  llvm::CachedHashString(MacroDef.split('=').first));
1609  }
1610 
1611  // Add -I..., -F..., and -index-header-map options in order.
1612  bool IsIndexHeaderMap = false;
1613  bool IsSysrootSpecified =
1614  Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
1615  for (const Arg *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
1616  if (A->getOption().matches(OPT_index_header_map)) {
1617  // -index-header-map applies to the next -I or -F.
1618  IsIndexHeaderMap = true;
1619  continue;
1620  }
1621 
1623  IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled;
1624 
1625  bool IsFramework = A->getOption().matches(OPT_F);
1626  std::string Path = A->getValue();
1627 
1628  if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {
1629  SmallString<32> Buffer;
1630  llvm::sys::path::append(Buffer, Opts.Sysroot,
1631  llvm::StringRef(A->getValue()).substr(1));
1632  Path = Buffer.str();
1633  }
1634 
1635  Opts.AddPath(Path, Group, IsFramework,
1636  /*IgnoreSysroot*/ true);
1637  IsIndexHeaderMap = false;
1638  }
1639 
1640  // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
1641  StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
1642  for (const Arg *A :
1643  Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
1644  if (A->getOption().matches(OPT_iprefix))
1645  Prefix = A->getValue();
1646  else if (A->getOption().matches(OPT_iwithprefix))
1647  Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
1648  else
1649  Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
1650  }
1651 
1652  for (const Arg *A : Args.filtered(OPT_idirafter))
1653  Opts.AddPath(A->getValue(), frontend::After, false, true);
1654  for (const Arg *A : Args.filtered(OPT_iquote))
1655  Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
1656  for (const Arg *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
1657  Opts.AddPath(A->getValue(), frontend::System, false,
1658  !A->getOption().matches(OPT_iwithsysroot));
1659  for (const Arg *A : Args.filtered(OPT_iframework))
1660  Opts.AddPath(A->getValue(), frontend::System, true, true);
1661  for (const Arg *A : Args.filtered(OPT_iframeworkwithsysroot))
1662  Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,
1663  /*IgnoreSysRoot=*/false);
1664 
1665  // Add the paths for the various language specific isystem flags.
1666  for (const Arg *A : Args.filtered(OPT_c_isystem))
1667  Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
1668  for (const Arg *A : Args.filtered(OPT_cxx_isystem))
1669  Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
1670  for (const Arg *A : Args.filtered(OPT_objc_isystem))
1671  Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
1672  for (const Arg *A : Args.filtered(OPT_objcxx_isystem))
1673  Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
1674 
1675  // Add the internal paths from a driver that detects standard include paths.
1676  for (const Arg *A :
1677  Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
1679  if (A->getOption().matches(OPT_internal_externc_isystem))
1680  Group = frontend::ExternCSystem;
1681  Opts.AddPath(A->getValue(), Group, false, true);
1682  }
1683 
1684  // Add the path prefixes which are implicitly treated as being system headers.
1685  for (const Arg *A :
1686  Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
1687  Opts.AddSystemHeaderPrefix(
1688  A->getValue(), A->getOption().matches(OPT_system_header_prefix));
1689 
1690  for (const Arg *A : Args.filtered(OPT_ivfsoverlay))
1691  Opts.AddVFSOverlayFile(A->getValue());
1692 }
1693 
1695  const llvm::Triple &T,
1696  PreprocessorOptions &PPOpts,
1697  LangStandard::Kind LangStd) {
1698  // Set some properties which depend solely on the input kind; it would be nice
1699  // to move these to the language standard, and have the driver resolve the
1700  // input kind + language standard.
1701  //
1702  // FIXME: Perhaps a better model would be for a single source file to have
1703  // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
1704  // simultaneously active?
1705  if (IK.getLanguage() == InputKind::Asm) {
1706  Opts.AsmPreprocessor = 1;
1707  } else if (IK.isObjectiveC()) {
1708  Opts.ObjC1 = Opts.ObjC2 = 1;
1709  }
1710 
1711  if (LangStd == LangStandard::lang_unspecified) {
1712  // Based on the base language, pick one.
1713  switch (IK.getLanguage()) {
1714  case InputKind::Unknown:
1715  case InputKind::LLVM_IR:
1716  llvm_unreachable("Invalid input kind!");
1717  case InputKind::OpenCL:
1718  LangStd = LangStandard::lang_opencl10;
1719  break;
1720  case InputKind::CUDA:
1721  LangStd = LangStandard::lang_cuda;
1722  break;
1723  case InputKind::Asm:
1724  case InputKind::C:
1725  // The PS4 uses C99 as the default C standard.
1726  if (T.isPS4())
1727  LangStd = LangStandard::lang_gnu99;
1728  else
1729  LangStd = LangStandard::lang_gnu11;
1730  break;
1731  case InputKind::ObjC:
1732  LangStd = LangStandard::lang_gnu11;
1733  break;
1734  case InputKind::CXX:
1735  case InputKind::ObjCXX:
1736  LangStd = LangStandard::lang_gnucxx14;
1737  break;
1739  LangStd = LangStandard::lang_c99;
1740  break;
1741  }
1742  }
1743 
1744  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1745  Opts.LineComment = Std.hasLineComments();
1746  Opts.C99 = Std.isC99();
1747  Opts.C11 = Std.isC11();
1748  Opts.C17 = Std.isC17();
1749  Opts.CPlusPlus = Std.isCPlusPlus();
1750  Opts.CPlusPlus11 = Std.isCPlusPlus11();
1751  Opts.CPlusPlus14 = Std.isCPlusPlus14();
1752  Opts.CPlusPlus17 = Std.isCPlusPlus17();
1753  Opts.CPlusPlus2a = Std.isCPlusPlus2a();
1754  Opts.Digraphs = Std.hasDigraphs();
1755  Opts.GNUMode = Std.isGNUMode();
1756  Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;
1757  Opts.HexFloats = Std.hasHexFloats();
1758  Opts.ImplicitInt = Std.hasImplicitInt();
1759 
1760  // Set OpenCL Version.
1761  Opts.OpenCL = Std.isOpenCL();
1762  if (LangStd == LangStandard::lang_opencl10)
1763  Opts.OpenCLVersion = 100;
1764  else if (LangStd == LangStandard::lang_opencl11)
1765  Opts.OpenCLVersion = 110;
1766  else if (LangStd == LangStandard::lang_opencl12)
1767  Opts.OpenCLVersion = 120;
1768  else if (LangStd == LangStandard::lang_opencl20)
1769  Opts.OpenCLVersion = 200;
1770 
1771  // OpenCL has some additional defaults.
1772  if (Opts.OpenCL) {
1773  Opts.AltiVec = 0;
1774  Opts.ZVector = 0;
1775  Opts.LaxVectorConversions = 0;
1776  Opts.setDefaultFPContractMode(LangOptions::FPC_On);
1777  Opts.NativeHalfType = 1;
1778  Opts.NativeHalfArgsAndReturns = 1;
1779  // Include default header file for OpenCL.
1780  if (Opts.IncludeDefaultHeader) {
1781  PPOpts.Includes.push_back("opencl-c.h");
1782  }
1783  }
1784 
1785  Opts.CUDA = IK.getLanguage() == InputKind::CUDA;
1786  if (Opts.CUDA)
1787  // Set default FP_CONTRACT to FAST.
1788  Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
1789 
1790  Opts.RenderScript = IK.getLanguage() == InputKind::RenderScript;
1791  if (Opts.RenderScript) {
1792  Opts.NativeHalfType = 1;
1793  Opts.NativeHalfArgsAndReturns = 1;
1794  }
1795 
1796  // OpenCL and C++ both have bool, true, false keywords.
1797  Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
1798 
1799  // OpenCL has half keyword
1800  Opts.Half = Opts.OpenCL;
1801 
1802  // C++ has wchar_t keyword.
1803  Opts.WChar = Opts.CPlusPlus;
1804 
1805  Opts.GNUKeywords = Opts.GNUMode;
1806  Opts.CXXOperatorNames = Opts.CPlusPlus;
1807 
1808  Opts.AlignedAllocation = Opts.CPlusPlus17;
1809 
1810  Opts.DollarIdents = !Opts.AsmPreprocessor;
1811 }
1812 
1813 /// Attempt to parse a visibility value out of the given argument.
1814 static Visibility parseVisibility(Arg *arg, ArgList &args,
1815  DiagnosticsEngine &diags) {
1816  StringRef value = arg->getValue();
1817  if (value == "default") {
1818  return DefaultVisibility;
1819  } else if (value == "hidden" || value == "internal") {
1820  return HiddenVisibility;
1821  } else if (value == "protected") {
1822  // FIXME: diagnose if target does not support protected visibility
1823  return ProtectedVisibility;
1824  }
1825 
1826  diags.Report(diag::err_drv_invalid_value)
1827  << arg->getAsString(args) << value;
1828  return DefaultVisibility;
1829 }
1830 
1831 /// Check if input file kind and language standard are compatible.
1833  const LangStandard &S) {
1834  switch (IK.getLanguage()) {
1835  case InputKind::Unknown:
1836  case InputKind::LLVM_IR:
1837  llvm_unreachable("should not parse language flags for this input");
1838 
1839  case InputKind::C:
1840  case InputKind::ObjC:
1842  return S.getLanguage() == InputKind::C;
1843 
1844  case InputKind::OpenCL:
1845  return S.getLanguage() == InputKind::OpenCL;
1846 
1847  case InputKind::CXX:
1848  case InputKind::ObjCXX:
1849  return S.getLanguage() == InputKind::CXX;
1850 
1851  case InputKind::CUDA:
1852  // FIXME: What -std= values should be permitted for CUDA compilations?
1853  return S.getLanguage() == InputKind::CUDA ||
1854  S.getLanguage() == InputKind::CXX;
1855 
1856  case InputKind::Asm:
1857  // Accept (and ignore) all -std= values.
1858  // FIXME: The -std= value is not ignored; it affects the tokenization
1859  // and preprocessing rules if we're preprocessing this asm input.
1860  return true;
1861  }
1862 
1863  llvm_unreachable("unexpected input language");
1864 }
1865 
1866 /// Get language name for given input kind.
1867 static const StringRef GetInputKindName(InputKind IK) {
1868  switch (IK.getLanguage()) {
1869  case InputKind::C:
1870  return "C";
1871  case InputKind::ObjC:
1872  return "Objective-C";
1873  case InputKind::CXX:
1874  return "C++";
1875  case InputKind::ObjCXX:
1876  return "Objective-C++";
1877  case InputKind::OpenCL:
1878  return "OpenCL";
1879  case InputKind::CUDA:
1880  return "CUDA";
1882  return "RenderScript";
1883 
1884  case InputKind::Asm:
1885  return "Asm";
1886  case InputKind::LLVM_IR:
1887  return "LLVM IR";
1888 
1889  case InputKind::Unknown:
1890  break;
1891  }
1892  llvm_unreachable("unknown input language");
1893 }
1894 
1895 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
1896  const TargetOptions &TargetOpts,
1897  PreprocessorOptions &PPOpts,
1898  DiagnosticsEngine &Diags) {
1899  // FIXME: Cleanup per-file based stuff.
1901  if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
1902  LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
1903 #define LANGSTANDARD(id, name, lang, desc, features) \
1904  .Case(name, LangStandard::lang_##id)
1905 #define LANGSTANDARD_ALIAS(id, alias) \
1906  .Case(alias, LangStandard::lang_##id)
1907 #include "clang/Frontend/LangStandards.def"
1909  if (LangStd == LangStandard::lang_unspecified) {
1910  Diags.Report(diag::err_drv_invalid_value)
1911  << A->getAsString(Args) << A->getValue();
1912  // Report supported standards with short description.
1913  for (unsigned KindValue = 0;
1914  KindValue != LangStandard::lang_unspecified;
1915  ++KindValue) {
1917  static_cast<LangStandard::Kind>(KindValue));
1918  if (IsInputCompatibleWithStandard(IK, Std)) {
1919  auto Diag = Diags.Report(diag::note_drv_use_standard);
1920  Diag << Std.getName() << Std.getDescription();
1921  unsigned NumAliases = 0;
1922 #define LANGSTANDARD(id, name, lang, desc, features)
1923 #define LANGSTANDARD_ALIAS(id, alias) \
1924  if (KindValue == LangStandard::lang_##id) ++NumAliases;
1925 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
1926 #include "clang/Frontend/LangStandards.def"
1927  Diag << NumAliases;
1928 #define LANGSTANDARD(id, name, lang, desc, features)
1929 #define LANGSTANDARD_ALIAS(id, alias) \
1930  if (KindValue == LangStandard::lang_##id) Diag << alias;
1931 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
1932 #include "clang/Frontend/LangStandards.def"
1933  }
1934  }
1935  } else {
1936  // Valid standard, check to make sure language and standard are
1937  // compatible.
1938  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1939  if (!IsInputCompatibleWithStandard(IK, Std)) {
1940  Diags.Report(diag::err_drv_argument_not_allowed_with)
1941  << A->getAsString(Args) << GetInputKindName(IK);
1942  }
1943  }
1944  }
1945 
1946  // -cl-std only applies for OpenCL language standards.
1947  // Override the -std option in this case.
1948  if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
1949  LangStandard::Kind OpenCLLangStd
1950  = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
1951  .Cases("cl", "CL", LangStandard::lang_opencl10)
1952  .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
1953  .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
1954  .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
1956 
1957  if (OpenCLLangStd == LangStandard::lang_unspecified) {
1958  Diags.Report(diag::err_drv_invalid_value)
1959  << A->getAsString(Args) << A->getValue();
1960  }
1961  else
1962  LangStd = OpenCLLangStd;
1963  }
1964 
1965  Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
1966 
1967  llvm::Triple T(TargetOpts.Triple);
1968  CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
1969 
1970  // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
1971  // This option should be deprecated for CL > 1.0 because
1972  // this option was added for compatibility with OpenCL 1.0.
1973  if (Args.getLastArg(OPT_cl_strict_aliasing)
1974  && Opts.OpenCLVersion > 100) {
1975  std::string VerSpec = llvm::to_string(Opts.OpenCLVersion / 100) +
1976  std::string(".") +
1977  llvm::to_string((Opts.OpenCLVersion % 100) / 10);
1978  Diags.Report(diag::warn_option_invalid_ocl_version)
1979  << VerSpec << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
1980  }
1981 
1982  // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1983  // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1984  // while a subset (the non-C++ GNU keywords) is provided by GCC's
1985  // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1986  // name, as it doesn't seem a useful distinction.
1987  Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
1988  Opts.GNUKeywords);
1989 
1990  if (Args.hasArg(OPT_fno_operator_names))
1991  Opts.CXXOperatorNames = 0;
1992 
1993  if (Args.hasArg(OPT_fcuda_is_device))
1994  Opts.CUDAIsDevice = 1;
1995 
1996  if (Args.hasArg(OPT_fcuda_allow_variadic_functions))
1997  Opts.CUDAAllowVariadicFunctions = 1;
1998 
1999  if (Args.hasArg(OPT_fno_cuda_host_device_constexpr))
2000  Opts.CUDAHostDeviceConstexpr = 0;
2001 
2002  if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_flush_denormals_to_zero))
2003  Opts.CUDADeviceFlushDenormalsToZero = 1;
2004 
2005  if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals))
2006  Opts.CUDADeviceApproxTranscendentals = 1;
2007 
2008  if (Opts.ObjC1) {
2009  if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
2010  StringRef value = arg->getValue();
2011  if (Opts.ObjCRuntime.tryParse(value))
2012  Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
2013  }
2014 
2015  if (Args.hasArg(OPT_fobjc_gc_only))
2016  Opts.setGC(LangOptions::GCOnly);
2017  else if (Args.hasArg(OPT_fobjc_gc))
2018  Opts.setGC(LangOptions::HybridGC);
2019  else if (Args.hasArg(OPT_fobjc_arc)) {
2020  Opts.ObjCAutoRefCount = 1;
2021  if (!Opts.ObjCRuntime.allowsARC())
2022  Diags.Report(diag::err_arc_unsupported_on_runtime);
2023  }
2024 
2025  // ObjCWeakRuntime tracks whether the runtime supports __weak, not
2026  // whether the feature is actually enabled. This is predominantly
2027  // determined by -fobjc-runtime, but we allow it to be overridden
2028  // from the command line for testing purposes.
2029  if (Args.hasArg(OPT_fobjc_runtime_has_weak))
2030  Opts.ObjCWeakRuntime = 1;
2031  else
2032  Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak();
2033 
2034  // ObjCWeak determines whether __weak is actually enabled.
2035  // Note that we allow -fno-objc-weak to disable this even in ARC mode.
2036  if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
2037  if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
2038  assert(!Opts.ObjCWeak);
2039  } else if (Opts.getGC() != LangOptions::NonGC) {
2040  Diags.Report(diag::err_objc_weak_with_gc);
2041  } else if (!Opts.ObjCWeakRuntime) {
2042  Diags.Report(diag::err_objc_weak_unsupported);
2043  } else {
2044  Opts.ObjCWeak = 1;
2045  }
2046  } else if (Opts.ObjCAutoRefCount) {
2047  Opts.ObjCWeak = Opts.ObjCWeakRuntime;
2048  }
2049 
2050  if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
2051  Opts.ObjCInferRelatedResultType = 0;
2052 
2053  if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
2054  Opts.ObjCSubscriptingLegacyRuntime =
2056  }
2057 
2058  if (Args.hasArg(OPT_fgnu89_inline)) {
2059  if (Opts.CPlusPlus)
2060  Diags.Report(diag::err_drv_argument_not_allowed_with)
2061  << "-fgnu89-inline" << GetInputKindName(IK);
2062  else
2063  Opts.GNUInline = 1;
2064  }
2065 
2066  if (Args.hasArg(OPT_fapple_kext)) {
2067  if (!Opts.CPlusPlus)
2068  Diags.Report(diag::warn_c_kext);
2069  else
2070  Opts.AppleKext = 1;
2071  }
2072 
2073  if (Args.hasArg(OPT_print_ivar_layout))
2074  Opts.ObjCGCBitmapPrint = 1;
2075  if (Args.hasArg(OPT_fno_constant_cfstrings))
2076  Opts.NoConstantCFStrings = 1;
2077 
2078  if (Args.hasArg(OPT_fzvector))
2079  Opts.ZVector = 1;
2080 
2081  if (Args.hasArg(OPT_pthread))
2082  Opts.POSIXThreads = 1;
2083 
2084  // The value-visibility mode defaults to "default".
2085  if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
2086  Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
2087  } else {
2088  Opts.setValueVisibilityMode(DefaultVisibility);
2089  }
2090 
2091  // The type-visibility mode defaults to the value-visibility mode.
2092  if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) {
2093  Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags));
2094  } else {
2095  Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
2096  }
2097 
2098  if (Args.hasArg(OPT_fvisibility_inlines_hidden))
2099  Opts.InlineVisibilityHidden = 1;
2100 
2101  if (Args.hasArg(OPT_ftrapv)) {
2102  Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
2103  // Set the handler, if one is specified.
2104  Opts.OverflowHandler =
2105  Args.getLastArgValue(OPT_ftrapv_handler);
2106  }
2107  else if (Args.hasArg(OPT_fwrapv))
2108  Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
2109 
2110  Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
2111  Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
2112  Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
2113  Opts.MSCompatibilityVersion = 0;
2114  if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
2115  VersionTuple VT;
2116  if (VT.tryParse(A->getValue()))
2117  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
2118  << A->getValue();
2119  Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
2120  VT.getMinor().getValueOr(0) * 100000 +
2121  VT.getSubminor().getValueOr(0);
2122  }
2123 
2124  // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
2125  // is specified, or -std is set to a conforming mode.
2126  // Trigraphs are disabled by default in c++1z onwards.
2127  Opts.Trigraphs = !Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17;
2128  Opts.Trigraphs =
2129  Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
2130 
2131  Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
2132  OPT_fno_dollars_in_identifiers,
2133  Opts.DollarIdents);
2134  Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
2135  Opts.VtorDispMode = getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags);
2136  Opts.Borland = Args.hasArg(OPT_fborland_extensions);
2137  Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
2138  Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
2139  Opts.ConstStrings);
2140  if (Args.hasArg(OPT_fno_lax_vector_conversions))
2141  Opts.LaxVectorConversions = 0;
2142  if (Args.hasArg(OPT_fno_threadsafe_statics))
2143  Opts.ThreadsafeStatics = 0;
2144  Opts.Exceptions = Args.hasArg(OPT_fexceptions);
2145  Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
2146  Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
2147 
2148  // Handle exception personalities
2149  Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions,
2150  options::OPT_fseh_exceptions,
2151  options::OPT_fdwarf_exceptions);
2152  if (A) {
2153  const Option &Opt = A->getOption();
2154  Opts.SjLjExceptions = Opt.matches(options::OPT_fsjlj_exceptions);
2155  Opts.SEHExceptions = Opt.matches(options::OPT_fseh_exceptions);
2156  Opts.DWARFExceptions = Opt.matches(options::OPT_fdwarf_exceptions);
2157  }
2158 
2159  Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
2160  Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
2161 
2162  Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
2163  Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
2164  Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
2165  && Opts.OpenCLVersion >= 200);
2166  Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
2167  Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
2168 
2169  // Enable [[]] attributes in C++11 by default.
2170  Opts.DoubleSquareBracketAttributes =
2171  Args.hasFlag(OPT_fdouble_square_bracket_attributes,
2172  OPT_fno_double_square_bracket_attributes, Opts.CPlusPlus11);
2173 
2174  Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
2175  Opts.Modules = Args.hasArg(OPT_fmodules) || Opts.ModulesTS;
2176  Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
2177  Opts.ModulesDeclUse =
2178  Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
2179  Opts.ModulesLocalVisibility =
2180  Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS;
2181  Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen);
2182  Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
2183  Opts.ModulesSearchAll = Opts.Modules &&
2184  !Args.hasArg(OPT_fno_modules_search_all) &&
2185  Args.hasArg(OPT_fmodules_search_all);
2186  Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
2187  Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
2188  Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
2189  Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
2190  if (const Arg *A = Args.getLastArg(OPT_fwchar_type_EQ)) {
2191  Opts.WCharSize = llvm::StringSwitch<unsigned>(A->getValue())
2192  .Case("char", 1)
2193  .Case("short", 2)
2194  .Case("int", 4)
2195  .Default(0);
2196  if (Opts.WCharSize == 0)
2197  Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue();
2198  }
2199  Opts.WCharIsSigned = Args.hasFlag(OPT_fsigned_wchar, OPT_fno_signed_wchar, true);
2200  Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
2201  Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
2202  Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
2203  if (!Opts.NoBuiltin)
2205  Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
2206  Opts.RelaxedTemplateTemplateArgs =
2207  Args.hasArg(OPT_frelaxed_template_template_args);
2208  Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
2209  Opts.AlignedAllocation =
2210  Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
2211  Opts.AlignedAllocation);
2212  Opts.AlignedAllocationUnavailable =
2213  Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable);
2214  Opts.NewAlignOverride =
2215  getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
2216  if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
2217  Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
2218  Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
2219  << A->getValue();
2220  Opts.NewAlignOverride = 0;
2221  }
2222  Opts.ConceptsTS = Args.hasArg(OPT_fconcepts_ts);
2223  Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
2224  Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
2225  Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
2226  Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
2227  Opts.InstantiationDepth =
2228  getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
2229  Opts.ArrowDepth =
2230  getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
2231  Opts.ConstexprCallDepth =
2232  getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
2233  Opts.ConstexprStepLimit =
2234  getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
2235  Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
2236  Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
2237  Opts.NumLargeByValueCopy =
2238  getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
2239  Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
2241  Args.getLastArgValue(OPT_fconstant_string_class);
2242  Opts.ObjCDefaultSynthProperties =
2243  !Args.hasArg(OPT_disable_objc_default_synthesize_properties);
2244  Opts.EncodeExtendedBlockSig =
2245  Args.hasArg(OPT_fencode_extended_block_signature);
2246  Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
2247  Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
2248  Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
2249  Opts.AlignDouble = Args.hasArg(OPT_malign_double);
2250  Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
2251  Opts.PIE = Args.hasArg(OPT_pic_is_pie);
2252  Opts.Static = Args.hasArg(OPT_static_define);
2253  Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
2254  Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
2255  || Args.hasArg(OPT_fdump_record_layouts);
2256  Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
2257  Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
2258  Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
2259  Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
2260  Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
2261  Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
2262  Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
2263  Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
2264  Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
2265  Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
2266  Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
2267  Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
2268  Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name_EQ);
2269  Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
2270  Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
2271  std::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end());
2272  Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
2273  Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns);
2274  // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns
2275  // is enabled.
2276  Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
2277  | Opts.NativeHalfArgsAndReturns;
2278  Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
2279 
2280  // __declspec is enabled by default for the PS4 by the driver, and also
2281  // enabled for Microsoft Extensions or Borland Extensions, here.
2282  //
2283  // FIXME: __declspec is also currently enabled for CUDA, but isn't really a
2284  // CUDA extension. However, it is required for supporting
2285  // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
2286  // been rewritten in terms of something more generic, remove the Opts.CUDA
2287  // term here.
2288  Opts.DeclSpecKeyword =
2289  Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec,
2290  (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA));
2291 
2292  if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) {
2293  switch (llvm::StringSwitch<unsigned>(A->getValue())
2294  .Case("target", LangOptions::ASMM_Target)
2295  .Case("no", LangOptions::ASMM_Off)
2296  .Case("yes", LangOptions::ASMM_On)
2297  .Default(255)) {
2298  default:
2299  Diags.Report(diag::err_drv_invalid_value)
2300  << "-faddress-space-map-mangling=" << A->getValue();
2301  break;
2303  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Target);
2304  break;
2305  case LangOptions::ASMM_On:
2306  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On);
2307  break;
2308  case LangOptions::ASMM_Off:
2309  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off);
2310  break;
2311  }
2312  }
2313 
2314  if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
2316  llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
2317  A->getValue())
2318  .Case("single",
2320  .Case("multiple",
2322  .Case("virtual",
2324  .Default(LangOptions::PPTMK_BestCase);
2325  if (InheritanceModel == LangOptions::PPTMK_BestCase)
2326  Diags.Report(diag::err_drv_invalid_value)
2327  << "-fms-memptr-rep=" << A->getValue();
2328 
2329  Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
2330  }
2331 
2332  // Check for MS default calling conventions being specified.
2333  if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
2335  llvm::StringSwitch<LangOptions::DefaultCallingConvention>(A->getValue())
2336  .Case("cdecl", LangOptions::DCC_CDecl)
2337  .Case("fastcall", LangOptions::DCC_FastCall)
2338  .Case("stdcall", LangOptions::DCC_StdCall)
2339  .Case("vectorcall", LangOptions::DCC_VectorCall)
2340  .Case("regcall", LangOptions::DCC_RegCall)
2341  .Default(LangOptions::DCC_None);
2342  if (DefaultCC == LangOptions::DCC_None)
2343  Diags.Report(diag::err_drv_invalid_value)
2344  << "-fdefault-calling-conv=" << A->getValue();
2345 
2346  llvm::Triple T(TargetOpts.Triple);
2347  llvm::Triple::ArchType Arch = T.getArch();
2348  bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||
2349  DefaultCC == LangOptions::DCC_StdCall) &&
2350  Arch != llvm::Triple::x86;
2351  emitError |= (DefaultCC == LangOptions::DCC_VectorCall ||
2352  DefaultCC == LangOptions::DCC_RegCall) &&
2353  !(Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64);
2354  if (emitError)
2355  Diags.Report(diag::err_drv_argument_not_allowed_with)
2356  << A->getSpelling() << T.getTriple();
2357  else
2358  Opts.setDefaultCallingConv(DefaultCC);
2359  }
2360 
2361  // -mrtd option
2362  if (Arg *A = Args.getLastArg(OPT_mrtd)) {
2363  if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
2364  Diags.Report(diag::err_drv_argument_not_allowed_with)
2365  << A->getSpelling() << "-fdefault-calling-conv";
2366  else {
2367  llvm::Triple T(TargetOpts.Triple);
2368  if (T.getArch() != llvm::Triple::x86)
2369  Diags.Report(diag::err_drv_argument_not_allowed_with)
2370  << A->getSpelling() << T.getTriple();
2371  else
2372  Opts.setDefaultCallingConv(LangOptions::DCC_StdCall);
2373  }
2374  }
2375 
2376  // Check if -fopenmp is specified.
2377  Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 1 : 0;
2378  Opts.OpenMPUseTLS =
2379  Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
2380  Opts.OpenMPIsDevice =
2381  Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
2382 
2383  if (Opts.OpenMP) {
2384  int Version =
2385  getLastArgIntValue(Args, OPT_fopenmp_version_EQ, Opts.OpenMP, Diags);
2386  if (Version != 0)
2387  Opts.OpenMP = Version;
2388  // Provide diagnostic when a given target is not expected to be an OpenMP
2389  // device or host.
2390  if (!Opts.OpenMPIsDevice) {
2391  switch (T.getArch()) {
2392  default:
2393  break;
2394  // Add unsupported host targets here:
2395  case llvm::Triple::nvptx:
2396  case llvm::Triple::nvptx64:
2397  Diags.Report(clang::diag::err_drv_omp_host_target_not_supported)
2398  << TargetOpts.Triple;
2399  break;
2400  }
2401  }
2402  }
2403 
2404  // Set the flag to prevent the implementation from emitting device exception
2405  // handling code for those requiring so.
2406  if (Opts.OpenMPIsDevice && T.isNVPTX()) {
2407  Opts.Exceptions = 0;
2408  Opts.CXXExceptions = 0;
2409  }
2410 
2411  // Get the OpenMP target triples if any.
2412  if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
2413 
2414  for (unsigned i = 0; i < A->getNumValues(); ++i) {
2415  llvm::Triple TT(A->getValue(i));
2416 
2417  if (TT.getArch() == llvm::Triple::UnknownArch ||
2418  !(TT.getArch() == llvm::Triple::ppc ||
2419  TT.getArch() == llvm::Triple::ppc64 ||
2420  TT.getArch() == llvm::Triple::ppc64le ||
2421  TT.getArch() == llvm::Triple::nvptx ||
2422  TT.getArch() == llvm::Triple::nvptx64 ||
2423  TT.getArch() == llvm::Triple::x86 ||
2424  TT.getArch() == llvm::Triple::x86_64))
2425  Diags.Report(clang::diag::err_drv_invalid_omp_target) << A->getValue(i);
2426  else
2427  Opts.OMPTargetTriples.push_back(TT);
2428  }
2429  }
2430 
2431  // Get OpenMP host file path if any and report if a non existent file is
2432  // found
2433  if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
2434  Opts.OMPHostIRFile = A->getValue();
2435  if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
2436  Diags.Report(clang::diag::err_drv_omp_host_ir_file_not_found)
2437  << Opts.OMPHostIRFile;
2438  }
2439 
2440  // Record whether the __DEPRECATED define was requested.
2441  Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
2442  OPT_fno_deprecated_macro,
2443  Opts.Deprecated);
2444 
2445  // FIXME: Eliminate this dependency.
2446  unsigned Opt = getOptimizationLevel(Args, IK, Diags),
2447  OptSize = getOptimizationLevelSize(Args);
2448  Opts.Optimize = Opt != 0;
2449  Opts.OptimizeSize = OptSize != 0;
2450 
2451  // This is the __NO_INLINE__ define, which just depends on things like the
2452  // optimization level and -fno-inline, not actually whether the backend has
2453  // inlining enabled.
2454  Opts.NoInlineDefine = !Opts.Optimize;
2455  if (Arg *InlineArg = Args.getLastArg(
2456  options::OPT_finline_functions, options::OPT_finline_hint_functions,
2457  options::OPT_fno_inline_functions, options::OPT_fno_inline))
2458  if (InlineArg->getOption().matches(options::OPT_fno_inline))
2459  Opts.NoInlineDefine = true;
2460 
2461  Opts.FastMath = Args.hasArg(OPT_ffast_math) ||
2462  Args.hasArg(OPT_cl_fast_relaxed_math);
2463  Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
2464  Args.hasArg(OPT_cl_finite_math_only) ||
2465  Args.hasArg(OPT_cl_fast_relaxed_math);
2466  Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
2467  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
2468  Args.hasArg(OPT_cl_fast_relaxed_math);
2469 
2470  if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
2471  StringRef Val = A->getValue();
2472  if (Val == "fast")
2473  Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
2474  else if (Val == "on")
2475  Opts.setDefaultFPContractMode(LangOptions::FPC_On);
2476  else if (Val == "off")
2477  Opts.setDefaultFPContractMode(LangOptions::FPC_Off);
2478  else
2479  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2480  }
2481 
2482  Opts.RetainCommentsFromSystemHeaders =
2483  Args.hasArg(OPT_fretain_comments_from_system_headers);
2484 
2485  unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
2486  switch (SSP) {
2487  default:
2488  Diags.Report(diag::err_drv_invalid_value)
2489  << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
2490  break;
2491  case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
2492  case 1: Opts.setStackProtector(LangOptions::SSPOn); break;
2493  case 2: Opts.setStackProtector(LangOptions::SSPStrong); break;
2494  case 3: Opts.setStackProtector(LangOptions::SSPReq); break;
2495  }
2496 
2497  // Parse -fsanitize= arguments.
2498  parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
2499  Diags, Opts.Sanitize);
2500  // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
2501  Opts.SanitizeAddressFieldPadding =
2502  getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
2503  Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
2504 
2505  // -fxray-instrument
2506  Opts.XRayInstrument =
2507  Args.hasFlag(OPT_fxray_instrument, OPT_fnoxray_instrument, false);
2508 
2509  // -fxray-always-emit-customevents
2510  Opts.XRayAlwaysEmitCustomEvents =
2511  Args.hasFlag(OPT_fxray_always_emit_customevents,
2512  OPT_fnoxray_always_emit_customevents, false);
2513 
2514  // -fxray-{always,never}-instrument= filenames.
2516  Args.getAllArgValues(OPT_fxray_always_instrument);
2518  Args.getAllArgValues(OPT_fxray_never_instrument);
2519 
2520  // -fallow-editor-placeholders
2521  Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders);
2522 }
2523 
2525  switch (Action) {
2526  case frontend::ASTDeclList:
2527  case frontend::ASTDump:
2528  case frontend::ASTPrint:
2529  case frontend::ASTView:
2531  case frontend::EmitBC:
2532  case frontend::EmitHTML:
2533  case frontend::EmitLLVM:
2536  case frontend::EmitObj:
2537  case frontend::FixIt:
2540  case frontend::GeneratePCH:
2541  case frontend::GeneratePTH:
2544  case frontend::VerifyPCH:
2547  case frontend::RewriteObjC:
2548  case frontend::RewriteTest:
2549  case frontend::RunAnalysis:
2551  return false;
2552 
2554  case frontend::DumpTokens:
2555  case frontend::InitOnly:
2560  return true;
2561  }
2562  llvm_unreachable("invalid frontend action");
2563 }
2564 
2565 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
2566  FileManager &FileMgr,
2567  DiagnosticsEngine &Diags,
2569  using namespace options;
2570  Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
2571  Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
2572  if (const Arg *A = Args.getLastArg(OPT_token_cache))
2573  Opts.TokenCache = A->getValue();
2574  else
2575  Opts.TokenCache = Opts.ImplicitPTHInclude;
2576  Opts.UsePredefines = !Args.hasArg(OPT_undef);
2577  Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
2578  Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
2579  Opts.AllowPCHWithCompilerErrors = Args.hasArg(OPT_fallow_pch_with_errors);
2580 
2581  Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
2582  for (const Arg *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
2583  Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue());
2584 
2585  if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
2586  StringRef Value(A->getValue());
2587  size_t Comma = Value.find(',');
2588  unsigned Bytes = 0;
2589  unsigned EndOfLine = 0;
2590 
2591  if (Comma == StringRef::npos ||
2592  Value.substr(0, Comma).getAsInteger(10, Bytes) ||
2593  Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
2594  Diags.Report(diag::err_drv_preamble_format);
2595  else {
2596  Opts.PrecompiledPreambleBytes.first = Bytes;
2597  Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
2598  }
2599  }
2600 
2601  // Add macros from the command line.
2602  for (const Arg *A : Args.filtered(OPT_D, OPT_U)) {
2603  if (A->getOption().matches(OPT_D))
2604  Opts.addMacroDef(A->getValue());
2605  else
2606  Opts.addMacroUndef(A->getValue());
2607  }
2608 
2609  Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
2610 
2611  // Add the ordered list of -includes.
2612  for (const Arg *A : Args.filtered(OPT_include))
2613  Opts.Includes.emplace_back(A->getValue());
2614 
2615  for (const Arg *A : Args.filtered(OPT_chain_include))
2616  Opts.ChainedIncludes.emplace_back(A->getValue());
2617 
2618  for (const Arg *A : Args.filtered(OPT_remap_file)) {
2619  std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');
2620 
2621  if (Split.second.empty()) {
2622  Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
2623  continue;
2624  }
2625 
2626  Opts.addRemappedFile(Split.first, Split.second);
2627  }
2628 
2629  if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
2630  StringRef Name = A->getValue();
2631  unsigned Library = llvm::StringSwitch<unsigned>(Name)
2632  .Case("libc++", ARCXX_libcxx)
2633  .Case("libstdc++", ARCXX_libstdcxx)
2634  .Case("none", ARCXX_nolib)
2635  .Default(~0U);
2636  if (Library == ~0U)
2637  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
2638  else
2640  }
2641 
2642  // Always avoid lexing editor placeholders when we're just running the
2643  // preprocessor as we never want to emit the
2644  // "editor placeholder in source file" error in PP only mode.
2645  if (isStrictlyPreprocessorAction(Action))
2646  Opts.LexEditorPlaceholders = false;
2647 }
2648 
2650  ArgList &Args,
2652  using namespace options;
2653 
2654  if (isStrictlyPreprocessorAction(Action))
2655  Opts.ShowCPP = !Args.hasArg(OPT_dM);
2656  else
2657  Opts.ShowCPP = 0;
2658 
2659  Opts.ShowComments = Args.hasArg(OPT_C);
2660  Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
2661  Opts.ShowMacroComments = Args.hasArg(OPT_CC);
2662  Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
2663  Opts.ShowIncludeDirectives = Args.hasArg(OPT_dI);
2664  Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
2665  Opts.RewriteImports = Args.hasArg(OPT_frewrite_imports);
2666  Opts.UseLineDirectives = Args.hasArg(OPT_fuse_line_directives);
2667 }
2668 
2669 static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
2670  DiagnosticsEngine &Diags) {
2671  using namespace options;
2672  Opts.ABI = Args.getLastArgValue(OPT_target_abi);
2673  if (Arg *A = Args.getLastArg(OPT_meabi)) {
2674  StringRef Value = A->getValue();
2675  llvm::EABI EABIVersion = llvm::StringSwitch<llvm::EABI>(Value)
2676  .Case("default", llvm::EABI::Default)
2677  .Case("4", llvm::EABI::EABI4)
2678  .Case("5", llvm::EABI::EABI5)
2679  .Case("gnu", llvm::EABI::GNU)
2680  .Default(llvm::EABI::Unknown);
2681  if (EABIVersion == llvm::EABI::Unknown)
2682  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
2683  << Value;
2684  else
2685  Opts.EABIVersion = EABIVersion;
2686  }
2687  Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
2688  Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
2689  Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
2690  Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
2691  Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
2692  // Use the default target triple if unspecified.
2693  if (Opts.Triple.empty())
2694  Opts.Triple = llvm::sys::getDefaultTargetTriple();
2695  Opts.OpenCLExtensionsAsWritten = Args.getAllArgValues(OPT_cl_ext_EQ);
2696 }
2697 
2699  const char *const *ArgBegin,
2700  const char *const *ArgEnd,
2701  DiagnosticsEngine &Diags) {
2702  bool Success = true;
2703 
2704  // Parse the arguments.
2705  std::unique_ptr<OptTable> Opts = createDriverOptTable();
2706  const unsigned IncludedFlagsBitmask = options::CC1Option;
2707  unsigned MissingArgIndex, MissingArgCount;
2708  InputArgList Args =
2709  Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex,
2710  MissingArgCount, IncludedFlagsBitmask);
2711  LangOptions &LangOpts = *Res.getLangOpts();
2712 
2713  // Check for missing argument error.
2714  if (MissingArgCount) {
2715  Diags.Report(diag::err_drv_missing_argument)
2716  << Args.getArgString(MissingArgIndex) << MissingArgCount;
2717  Success = false;
2718  }
2719 
2720  // Issue errors on unknown arguments.
2721  for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
2722  Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args);
2723  Success = false;
2724  }
2725 
2726  Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
2727  Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args);
2729  Success &=
2730  ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
2731  false /*DefaultDiagColor*/, false /*DefaultShowOpt*/);
2732  ParseCommentArgs(LangOpts.CommentOpts, Args);
2734  // FIXME: We shouldn't have to pass the DashX option around here
2735  InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
2736  LangOpts.IsHeaderFile);
2737  ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
2738  Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags,
2739  Res.getTargetOpts());
2742  if (DashX.getFormat() == InputKind::Precompiled ||
2743  DashX.getLanguage() == InputKind::LLVM_IR) {
2744  // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
2745  // PassManager in BackendUtil.cpp. They need to be initializd no matter
2746  // what the input type is.
2747  if (Args.hasArg(OPT_fobjc_arc))
2748  LangOpts.ObjCAutoRefCount = 1;
2749  // PIClevel and PIELevel are needed during code generation and this should be
2750  // set regardless of the input type.
2751  LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
2752  LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
2753  parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
2754  Diags, LangOpts.Sanitize);
2755  } else {
2756  // Other LangOpts are only initialzed when the input is not AST or LLVM IR.
2757  // FIXME: Should we really be calling this for an InputKind::Asm input?
2758  ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
2759  Res.getPreprocessorOpts(), Diags);
2761  LangOpts.ObjCExceptions = 1;
2762  }
2763 
2764  if (LangOpts.CUDA) {
2765  // During CUDA device-side compilation, the aux triple is the
2766  // triple used for host compilation.
2767  if (LangOpts.CUDAIsDevice)
2769  }
2770 
2771  // Set the triple of the host for OpenMP device compile.
2772  if (LangOpts.OpenMPIsDevice)
2774 
2775  // FIXME: Override value name discarding when asan or msan is used because the
2776  // backend passes depend on the name of the alloca in order to print out
2777  // names.
2778  Res.getCodeGenOpts().DiscardValueNames &=
2779  !LangOpts.Sanitize.has(SanitizerKind::Address) &&
2780  !LangOpts.Sanitize.has(SanitizerKind::Memory);
2781 
2782  // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
2783  // PCH file and find the original header name. Remove the need to do that in
2784  // ParsePreprocessorArgs and remove the FileManager
2785  // parameters from the function and the "FileManager.h" #include.
2786  FileManager FileMgr(Res.getFileSystemOpts());
2787  ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, FileMgr, Diags,
2791 
2792  // Turn on -Wspir-compat for SPIR target.
2793  llvm::Triple T(Res.getTargetOpts().Triple);
2794  auto Arch = T.getArch();
2795  if (Arch == llvm::Triple::spir || Arch == llvm::Triple::spir64) {
2796  Res.getDiagnosticOpts().Warnings.push_back("spir-compat");
2797  }
2798 
2799  // If sanitizer is enabled, disable OPT_ffine_grained_bitfield_accesses.
2800  if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&
2801  !Res.getLangOpts()->Sanitize.empty()) {
2802  Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;
2803  Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
2804  }
2805  return Success;
2806 }
2807 
2809  // Note: For QoI reasons, the things we use as a hash here should all be
2810  // dumped via the -module-info flag.
2811  using llvm::hash_code;
2812  using llvm::hash_value;
2813  using llvm::hash_combine;
2814 
2815  // Start the signature with the compiler version.
2816  // FIXME: We'd rather use something more cryptographically sound than
2817  // CityHash, but this will do for now.
2818  hash_code code = hash_value(getClangFullRepositoryVersion());
2819 
2820  // Extend the signature with the language options
2821 #define LANGOPT(Name, Bits, Default, Description) \
2822  code = hash_combine(code, LangOpts->Name);
2823 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
2824  code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
2825 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
2826 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
2827 #include "clang/Basic/LangOptions.def"
2828 
2829  for (StringRef Feature : LangOpts->ModuleFeatures)
2830  code = hash_combine(code, Feature);
2831 
2832  // Extend the signature with the target options.
2833  code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
2834  TargetOpts->ABI);
2835  for (unsigned i = 0, n = TargetOpts->FeaturesAsWritten.size(); i != n; ++i)
2836  code = hash_combine(code, TargetOpts->FeaturesAsWritten[i]);
2837 
2838  // Extend the signature with preprocessor options.
2839  const PreprocessorOptions &ppOpts = getPreprocessorOpts();
2840  const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
2841  code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord);
2842 
2843  for (std::vector<std::pair<std::string, bool/*isUndef*/>>::const_iterator
2844  I = getPreprocessorOpts().Macros.begin(),
2845  IEnd = getPreprocessorOpts().Macros.end();
2846  I != IEnd; ++I) {
2847  // If we're supposed to ignore this macro for the purposes of modules,
2848  // don't put it into the hash.
2849  if (!hsOpts.ModulesIgnoreMacros.empty()) {
2850  // Check whether we're ignoring this macro.
2851  StringRef MacroDef = I->first;
2852  if (hsOpts.ModulesIgnoreMacros.count(
2853  llvm::CachedHashString(MacroDef.split('=').first)))
2854  continue;
2855  }
2856 
2857  code = hash_combine(code, I->first, I->second);
2858  }
2859 
2860  // Extend the signature with the sysroot and other header search options.
2861  code = hash_combine(code, hsOpts.Sysroot,
2862  hsOpts.ModuleFormat,
2863  hsOpts.UseDebugInfo,
2864  hsOpts.UseBuiltinIncludes,
2866  hsOpts.UseStandardCXXIncludes,
2867  hsOpts.UseLibcxx,
2869  code = hash_combine(code, hsOpts.ResourceDir);
2870 
2871  // Extend the signature with the user build path.
2872  code = hash_combine(code, hsOpts.ModuleUserBuildPath);
2873 
2874  // Extend the signature with the module file extensions.
2875  const FrontendOptions &frontendOpts = getFrontendOpts();
2876  for (const auto &ext : frontendOpts.ModuleFileExtensions) {
2877  code = ext->hashExtension(code);
2878  }
2879 
2880  // Extend the signature with the enabled sanitizers, if at least one is
2881  // enabled. Sanitizers which cannot affect AST generation aren't hashed.
2882  SanitizerSet SanHash = LangOpts->Sanitize;
2883  SanHash.clear(getPPTransparentSanitizers());
2884  if (!SanHash.empty())
2885  code = hash_combine(code, SanHash.Mask);
2886 
2887  return llvm::APInt(64, code).toString(36, /*Signed=*/false);
2888 }
2889 
2890 namespace clang {
2891 
2892 template<typename IntTy>
2893 static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id,
2894  IntTy Default,
2895  DiagnosticsEngine *Diags) {
2896  IntTy Res = Default;
2897  if (Arg *A = Args.getLastArg(Id)) {
2898  if (StringRef(A->getValue()).getAsInteger(10, Res)) {
2899  if (Diags)
2900  Diags->Report(diag::err_drv_invalid_int_value) << A->getAsString(Args)
2901  << A->getValue();
2902  }
2903  }
2904  return Res;
2905 }
2906 
2907 
2908 // Declared in clang/Frontend/Utils.h.
2909 int getLastArgIntValue(const ArgList &Args, OptSpecifier Id, int Default,
2910  DiagnosticsEngine *Diags) {
2911  return getLastArgIntValueImpl<int>(Args, Id, Default, Diags);
2912 }
2913 
2914 uint64_t getLastArgUInt64Value(const ArgList &Args, OptSpecifier Id,
2915  uint64_t Default,
2916  DiagnosticsEngine *Diags) {
2917  return getLastArgIntValueImpl<uint64_t>(Args, Id, Default, Diags);
2918 }
2919 
2920 void BuryPointer(const void *Ptr) {
2921  // This function may be called only a small fixed amount of times per each
2922  // invocation, otherwise we do actually have a leak which we want to report.
2923  // If this function is called more than kGraveYardMaxSize times, the pointers
2924  // will not be properly buried and a leak detector will report a leak, which
2925  // is what we want in such case.
2926  static const size_t kGraveYardMaxSize = 16;
2927  LLVM_ATTRIBUTE_UNUSED static const void *GraveYard[kGraveYardMaxSize];
2928  static std::atomic<unsigned> GraveYardSize;
2929  unsigned Idx = GraveYardSize++;
2930  if (Idx >= kGraveYardMaxSize)
2931  return;
2932  GraveYard[Idx] = Ptr;
2933 }
2934 
2937  DiagnosticsEngine &Diags) {
2939 }
2940 
2943  DiagnosticsEngine &Diags,
2945  if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
2946  return BaseFS;
2947 
2949  new vfs::OverlayFileSystem(BaseFS));
2950  // earlier vfs files are on the bottom
2951  for (const std::string &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
2952  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
2953  BaseFS->getBufferForFile(File);
2954  if (!Buffer) {
2955  Diags.Report(diag::err_missing_vfs_overlay_file) << File;
2957  }
2958 
2960  std::move(Buffer.get()), /*DiagHandler*/ nullptr, File);
2961  if (!FS.get()) {
2962  Diags.Report(diag::err_invalid_vfs_overlay) << File;
2964  }
2965  Overlay->pushOverlay(FS);
2966  }
2967  return Overlay;
2968 }
2969 } // end 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)
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)
std::vector< std::pair< std::string, bool > > Macros
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.
Conform to the underlying platform&#39;s C and C++ ABIs as closely as we can.
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)
static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, bool &IsHeaderFile)
Generate pre-compiled module from a module map.
unsigned UseLibcxx
Use libc++ instead of the default libstdc++.
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
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)
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
Defines the clang::FileManager interface and associated types.
Parse and perform semantic analysis.
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
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:101
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.
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the &#39;real&#39; file system, as seen by the operating system.
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)
LangStandard - Information about the properties of a particular language standard.
Definition: LangStandard.h:42
Enable migration to modern ObjC subscripting.
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
unsigned IncludeModuleFiles
Include module file dependencies.
Parse ASTs and print them.
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.
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:1207
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.
#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...
static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, DiagnosticsEngine &Diags, const TargetOptions &TargetOpts)
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.
enum clang::FrontendOptions::@168 ARCMTAction
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition: Visibility.h:35
static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, const std::string &WorkingDir)
std::string ImplicitPTHInclude
The implicit PTH input included at the start of the translation unit, or empty.
Options for controlling the target.
Definition: TargetOptions.h:26
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)
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:33
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.
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
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.
std::vector< std::string > CudaGpuBinaryFileNames
A list of file names passed with -fcuda-include-gpubinary options to forward to CUDA runtime back-end...
void AddSystemHeaderPrefix(StringRef Prefix, bool IsSystemHeader)
AddSystemHeaderPrefix - Override whether #include directives naming a path starting with Prefix shoul...
std::string FindPchSource
If non-empty, search the pch input file as if it was a header included by this file.
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:37
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:110
bool isCPlusPlus14() const
isCPlusPlus14 - Language is a C++14 variant (or later).
Definition: LangStandard.h:84
use NS_NONATOMIC_IOSONLY for property &#39;atomic&#39; attribute
std::string FPMath
If given, the unit to use for floating point math.
Definition: TargetOptions.h:39
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.
unsigned IncludeSystemHeaders
Include system header dependencies.
IntrusiveRefCntPtr< FileSystem > getVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())
Gets a FileSystem for a virtual file system described in YAML format.
Translate input source into HTML.
Enable migration to modern ObjC readwrite property.
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:71
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
unsigned eagerlyAssumeBinOpBifurcation
The flag regulates if we should eagerly assume evaluations of conditionals, thus, bifurcating the pat...
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).
Print DeclContext and their Decls.
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:44
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:45
A file system that allows overlaying one AbstractFileSystem on top of another.
Generate LLVM IR, but do not emit anything.
static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
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)
Enable migration to NS_ENUM/NS_OPTIONS macros.
static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts, ArgList &Args)
static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
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:147
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
Optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
Definition: VersionTuple.h:77
unsigned FixWhatYouCan
Apply fixes even if there are unfixable errors.
std::unique_ptr< llvm::opt::OptTable > createDriverOptTable()
std::vector< std::string > Warnings
The list of -W...
static StringRef getRelocModel(ArgList &Args, DiagnosticsEngine &Diags)
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.
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.
static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName)
unsigned FixAndRecompile
Apply fixes and recompile.
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:137
PreprocessorOutputOptions & getPreprocessorOutputOpts()
std::string ThreadModel
The thread model to use.
FrontendOptions & getFrontendOpts()
std::vector< std::string > DependentLibraries
A list of dependent libraries.
Enable annotation of ObjCMethods of all kinds.
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id, IntTy Default, DiagnosticsEngine *Diags)
MigratorOptions & getMigratorOpts()
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:131
const char * getName() const
getName - Get the name of this standard.
Definition: LangStandard.h:57
AnalysisDiagClients AnalysisDiagOpt
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.
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.
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.
annotate property with NS_RETURNS_INNER_POINTER
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:140
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
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).
int Id
Definition: ASTDiff.cpp:191
const FunctionProtoType * T
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:151
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:48
Only execute frontend initialization.
Defines version macros and version-related utility functions for Clang.
std::string RelocationModel
The name of the relocation model to use.
unsigned IncludeNamespaceLevelDecls
Show decls in namespace (including the global namespace) in code completion results.
Print the "preamble" of the input file.
IntrusiveRefCntPtr< vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
Definition: ObjCRuntime.cpp:44
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
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:65
unsigned ModulesEmbedAllFiles
Whether we should embed all used files into the PCM file.
Enable migration to add conforming protocols.
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:40
unsigned ShowMacros
Print macro definitions.
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:117
static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, 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...
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
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:36
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:83
Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
Definition: Sanitizers.h:59
std::string ABI
If given, the name of the target ABI to use.
Definition: TargetOptions.h:42
AnalysisConstraints
AnalysisConstraints - Set of available constraint models.
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.
Enable migration to modern ObjC literals.
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.
Kind getKind() const
Definition: ObjCRuntime.h:75
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:62
unsigned visualizeExplodedGraphWithUbiGraph
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)
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.
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:51
std::vector< BitcodeFileToLink > LinkBitcodeFiles
The files specified here are linked in to the module before optimizations.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
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:45
&#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:140
DependencyOutputFormat OutputFormat
The format for the dependency file.
unsigned UseDebugInfo
Whether the module includes debug information (-gmodules).
Dataflow Directional Tag Classes.
uint64_t SanitizerMask
Definition: Sanitizers.h:24
Optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.
Definition: VersionTuple.h:84
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
Definition: LangOptions.h:125
bool tryParse(StringRef string)
Try to parse the given string as a version number.
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:147
std::string ARCMTMigrateReportOut
std::string PreferVectorWidth
The preferred width for auto-vectorization transforms.
Emit location information but do not generate debug info in the output.
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 at least one sanitizer is enabled.
Definition: Sanitizers.h:68
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
unsigned getMajor() const
Retrieve the major version number.
Definition: VersionTuple.h:74
AnalysisConstraints AnalysisConstraintsOpt
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:155
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:20
Run a plugin action,.
bool isGNUMode() const
isGNUMode - Language includes GNU extensions.
Definition: LangStandard.h:97
std::string StatsFile
Filename to write statistics to.
prefer &#39;atomic&#39; property over &#39;nonatomic&#39;.
Enable migration of ObjC methods to &#39;instancetype&#39;.
void BuryPointer(const void *Ptr)
Parse ASTs and dump them.
Don&#39;t generate debug info.
std::string CoverageDataFile
The filename with path we use for coverage data files.
std::vector< std::string > LinkerOptions
A list of linker options to embed in the object file.
Enable migration to modern ObjC readonly property.
static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, FileManager &FileMgr, DiagnosticsEngine &Diags, frontend::ActionKind Action)
Enable converting setter/getter expressions to property-dot syntx.
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.
Keeps track of options that affect how file operations are performed.
unsigned DisableFree
Disable memory freeing on exit.
Generate pre-compiled header.
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:13010
unsigned ShowMacroComments
Show comments, even in macros.
bool isUnknown() const
Is the input kind fully-unknown?
unsigned NoRetryExhausted
Do not re-analyze paths leading to exhausted nodes with a different strategy.
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:115
Enable migration to modern ObjC property.
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:143
bool isC99() const
isC99 - Language is a superset of C99.
Definition: LangStandard.h:69
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:50
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.
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:105
unsigned ShowCPP
Print normal preprocessed output.
std::vector< std::string > BackendOptions
A list of command-line options to forward to the LLVM backend.
Like Angled, but marks header maps used when building frameworks.
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
Generate pre-tokenized header.
static InputKind getInputKindForExtension(StringRef Extension)
getInputKindForExtension - Return the appropriate input kind for a file extension.
std::string ObjCConstantStringClass
Definition: LangOptions.h:119
#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC)
unsigned IncludeMacros
Show macros in code completion results.
AnalysisPurgeMode AnalysisPurgeOpt
unsigned PrintShowIncludes
Print cl.exe style /showIncludes info.
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.
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:29
#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:192
Attempt to be ABI-compatible with code generated by Clang 3.8.x (SVN r257626).
std::string DiagnosticLogFile
The file to log diagnostic output to.
std::string TokenCache
If given, a PTH cache file to use for speeding up header parsing.
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.