clang  5.0.0
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())),
64  TargetOpts(new TargetOptions(X.getTargetOpts())),
65  DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
66  HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
67  PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {}
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 = Triple.isPS4CPU();
531 
532  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
533  Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
534 
535  if (const Arg *A =
536  Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
537  Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
538 
539  Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
540  Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
541  Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
542  Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
543  Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
544  Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
545  OPT_fuse_register_sized_bitfield_access);
546  Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
547  Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
548  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
549  Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
550  Opts.NoCommon = Args.hasArg(OPT_fno_common);
551  Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
552  Opts.OptimizeSize = getOptimizationLevelSize(Args);
553  Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
554  Args.hasArg(OPT_ffreestanding));
555  if (Opts.SimplifyLibCalls)
557  Opts.UnrollLoops =
558  Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
559  (Opts.OptimizationLevel > 1));
560  Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
561 
562  Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
563  Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
564  Opts.SampleProfileFile = Args.getLastArgValue(OPT_fprofile_sample_use_EQ);
565  Opts.DebugInfoForProfiling = Args.hasFlag(
566  OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
567 
568  setPGOInstrumentor(Opts, Args, Diags);
569  Opts.InstrProfileOutput =
570  Args.getLastArgValue(OPT_fprofile_instrument_path_EQ);
572  Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ);
573  if (!Opts.ProfileInstrumentUsePath.empty())
575 
576  if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
577  Opts.setClangABICompat(CodeGenOptions::ClangABI::Latest);
578 
579  StringRef Ver = A->getValue();
580  std::pair<StringRef, StringRef> VerParts = Ver.split('.');
581  unsigned Major, Minor = 0;
582 
583  // Check the version number is valid: either 3.x (0 <= x <= 9) or
584  // y or y.0 (4 <= y <= current version).
585  if (!VerParts.first.startswith("0") &&
586  !VerParts.first.getAsInteger(10, Major) &&
587  3 <= Major && Major <= CLANG_VERSION_MAJOR &&
588  (Major == 3 ? VerParts.second.size() == 1 &&
589  !VerParts.second.getAsInteger(10, Minor)
590  : VerParts.first.size() == Ver.size() ||
591  VerParts.second == "0")) {
592  // Got a valid version number.
593  if (Major == 3 && Minor <= 8)
594  Opts.setClangABICompat(CodeGenOptions::ClangABI::Ver3_8);
595  else if (Major <= 4)
596  Opts.setClangABICompat(CodeGenOptions::ClangABI::Ver4);
597  } else if (Ver != "latest") {
598  Diags.Report(diag::err_drv_invalid_value)
599  << A->getAsString(Args) << A->getValue();
600  }
601  }
602 
603  Opts.CoverageMapping =
604  Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
605  Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
606  Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
607  Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
608  Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
609  Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
610  Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
611  Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
612  Opts.CodeModel = getCodeModel(Args, Diags);
613  Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
614  Opts.DisableFPElim =
615  (Args.hasArg(OPT_mdisable_fp_elim) || Args.hasArg(OPT_pg));
616  Opts.DisableFree = Args.hasArg(OPT_disable_free);
617  Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
618  Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
619  Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
620  Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable) ||
621  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
622  Args.hasArg(OPT_cl_fast_relaxed_math);
623  Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
624  Opts.NoInfsFPMath = (Args.hasArg(OPT_menable_no_infinities) ||
625  Args.hasArg(OPT_cl_finite_math_only) ||
626  Args.hasArg(OPT_cl_fast_relaxed_math));
627  Opts.NoNaNsFPMath = (Args.hasArg(OPT_menable_no_nans) ||
628  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
629  Args.hasArg(OPT_cl_finite_math_only) ||
630  Args.hasArg(OPT_cl_fast_relaxed_math));
631  Opts.NoSignedZeros = (Args.hasArg(OPT_fno_signed_zeros) ||
632  Args.hasArg(OPT_cl_no_signed_zeros) ||
633  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
634  Args.hasArg(OPT_cl_fast_relaxed_math));
635  Opts.FlushDenorm = Args.hasArg(OPT_cl_denorms_are_zero);
636  Opts.CorrectlyRoundedDivSqrt =
637  Args.hasArg(OPT_cl_fp32_correctly_rounded_divide_sqrt);
638  Opts.ReciprocalMath = Args.hasArg(OPT_freciprocal_math);
639  Opts.NoTrappingMath = Args.hasArg(OPT_fno_trapping_math);
640  Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
641  Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
642  Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
643  Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
644  Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
645  Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
646  Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
647  Opts.IncrementalLinkerCompatible =
648  Args.hasArg(OPT_mincremental_linker_compatible);
649  Opts.PIECopyRelocations =
650  Args.hasArg(OPT_mpie_copy_relocations);
651  Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
652  Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
653  Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
654  Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
655  Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
656  Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
657  Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
658  Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
659  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
660  Args.hasArg(OPT_cl_fast_relaxed_math);
661  Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
662  Opts.RelocationModel = getRelocModel(Args, Diags);
663  Opts.ThreadModel = Args.getLastArgValue(OPT_mthread_model, "posix");
664  if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
665  Diags.Report(diag::err_drv_invalid_value)
666  << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
667  << Opts.ThreadModel;
668  Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
669  Opts.UseInitArray = Args.hasArg(OPT_fuse_init_array);
670 
671  Opts.FunctionSections = Args.hasFlag(OPT_ffunction_sections,
672  OPT_fno_function_sections, false);
673  Opts.DataSections = Args.hasFlag(OPT_fdata_sections,
674  OPT_fno_data_sections, false);
675  Opts.UniqueSectionNames = Args.hasFlag(OPT_funique_section_names,
676  OPT_fno_unique_section_names, true);
677 
678  Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
679 
680  Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
681 
682  Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
683  Opts.EmitSummaryIndex = false;
684  if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
685  StringRef S = A->getValue();
686  if (S == "thin")
687  Opts.EmitSummaryIndex = true;
688  else if (S != "full")
689  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
690  }
691  Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false);
692  if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
693  if (IK.getLanguage() != InputKind::LLVM_IR)
694  Diags.Report(diag::err_drv_argument_only_allowed_with)
695  << A->getAsString(Args) << "-x ir";
696  Opts.ThinLTOIndexFile = Args.getLastArgValue(OPT_fthinlto_index_EQ);
697  }
698  Opts.ThinLinkBitcodeFile = Args.getLastArgValue(OPT_fthin_link_bitcode_EQ);
699 
700  Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
701 
702  Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
703  Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
704 
705  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
706  Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
707 
708  Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
709  Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
710  Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
711  if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
712  Opts.CoverageDataFile = Args.getLastArgValue(OPT_coverage_data_file);
713  Opts.CoverageNotesFile = Args.getLastArgValue(OPT_coverage_notes_file);
714  Opts.CoverageExtraChecksum = Args.hasArg(OPT_coverage_cfg_checksum);
715  Opts.CoverageNoFunctionNamesInData =
716  Args.hasArg(OPT_coverage_no_function_names_in_data);
717  Opts.CoverageExitBlockBeforeBody =
718  Args.hasArg(OPT_coverage_exit_block_before_body);
719  if (Args.hasArg(OPT_coverage_version_EQ)) {
720  StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
721  if (CoverageVersion.size() != 4) {
722  Diags.Report(diag::err_drv_invalid_value)
723  << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
724  << CoverageVersion;
725  } else {
726  memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
727  }
728  }
729  }
730  // Handle -fembed-bitcode option.
731  if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
732  StringRef Name = A->getValue();
733  unsigned Model = llvm::StringSwitch<unsigned>(Name)
734  .Case("off", CodeGenOptions::Embed_Off)
735  .Case("all", CodeGenOptions::Embed_All)
736  .Case("bitcode", CodeGenOptions::Embed_Bitcode)
737  .Case("marker", CodeGenOptions::Embed_Marker)
738  .Default(~0U);
739  if (Model == ~0U) {
740  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
741  Success = false;
742  } else
743  Opts.setEmbedBitcode(
744  static_cast<CodeGenOptions::EmbedBitcodeKind>(Model));
745  }
746  // FIXME: For backend options that are not yet recorded as function
747  // attributes in the IR, keep track of them so we can embed them in a
748  // separate data section and use them when building the bitcode.
749  if (Opts.getEmbedBitcode() == CodeGenOptions::Embed_All) {
750  for (const auto &A : Args) {
751  // Do not encode output and input.
752  if (A->getOption().getID() == options::OPT_o ||
753  A->getOption().getID() == options::OPT_INPUT ||
754  A->getOption().getID() == options::OPT_x ||
755  A->getOption().getID() == options::OPT_fembed_bitcode ||
756  (A->getOption().getGroup().isValid() &&
757  A->getOption().getGroup().getID() == options::OPT_W_Group))
758  continue;
759  ArgStringList ASL;
760  A->render(Args, ASL);
761  for (const auto &arg : ASL) {
762  StringRef ArgStr(arg);
763  Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
764  // using \00 to seperate each commandline options.
765  Opts.CmdArgs.push_back('\0');
766  }
767  }
768  }
769 
770  Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
771  Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
772  Opts.XRayInstrumentFunctions = Args.hasArg(OPT_fxray_instrument);
773  Opts.XRayInstructionThreshold =
774  getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
775  Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
776  Opts.CallFEntry = Args.hasArg(OPT_mfentry);
777  Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
778 
779  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
780  OPT_compress_debug_sections_EQ)) {
781  if (A->getOption().getID() == OPT_compress_debug_sections) {
782  // TODO: be more clever about the compression type auto-detection
783  Opts.setCompressDebugSections(llvm::DebugCompressionType::GNU);
784  } else {
785  auto DCT = llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
786  .Case("none", llvm::DebugCompressionType::None)
787  .Case("zlib", llvm::DebugCompressionType::Z)
788  .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
789  .Default(llvm::DebugCompressionType::None);
790  Opts.setCompressDebugSections(DCT);
791  }
792  }
793 
794  Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
795  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
796  for (auto A : Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_cuda_bitcode)) {
798  F.Filename = A->getValue();
799  if (A->getOption().matches(OPT_mlink_cuda_bitcode)) {
800  F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
801  // When linking CUDA bitcode, propagate function attributes so that
802  // e.g. libdevice gets fast-math attrs if we're building with fast-math.
803  F.PropagateAttrs = true;
804  F.Internalize = true;
805  }
806  Opts.LinkBitcodeFiles.push_back(F);
807  }
808  Opts.SanitizeCoverageType =
809  getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
810  Opts.SanitizeCoverageIndirectCalls =
811  Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
812  Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
813  Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
814  Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
815  Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
816  Opts.SanitizeCoverage8bitCounters =
817  Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
818  Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
819  Opts.SanitizeCoverageTracePCGuard =
820  Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
821  Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune);
822  Opts.SanitizeCoverageInline8bitCounters =
823  Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters);
824  Opts.SanitizeMemoryTrackOrigins =
825  getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
826  Opts.SanitizeMemoryUseAfterDtor =
827  Args.hasArg(OPT_fsanitize_memory_use_after_dtor);
828  Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
829  Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
830  if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope,
831  OPT_fno_sanitize_address_use_after_scope)) {
832  Opts.SanitizeAddressUseAfterScope =
833  A->getOption().getID() == OPT_fsanitize_address_use_after_scope;
834  }
835  Opts.SanitizeAddressGlobalsDeadStripping =
836  Args.hasArg(OPT_fsanitize_address_globals_dead_stripping);
837  Opts.SSPBufferSize =
838  getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
839  Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
840  if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
841  StringRef Val = A->getValue();
842  unsigned StackAlignment = Opts.StackAlignment;
843  Val.getAsInteger(10, StackAlignment);
844  Opts.StackAlignment = StackAlignment;
845  }
846 
847  if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) {
848  StringRef Val = A->getValue();
849  unsigned StackProbeSize = Opts.StackProbeSize;
850  Val.getAsInteger(0, StackProbeSize);
851  Opts.StackProbeSize = StackProbeSize;
852  }
853 
854  if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
855  StringRef Name = A->getValue();
856  unsigned Method = llvm::StringSwitch<unsigned>(Name)
857  .Case("legacy", CodeGenOptions::Legacy)
858  .Case("non-legacy", CodeGenOptions::NonLegacy)
859  .Case("mixed", CodeGenOptions::Mixed)
860  .Default(~0U);
861  if (Method == ~0U) {
862  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
863  Success = false;
864  } else {
865  Opts.setObjCDispatchMethod(
866  static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
867  }
868  }
869 
870  Opts.EmulatedTLS =
871  Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
872 
873  if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
874  StringRef Name = A->getValue();
875  unsigned Model = llvm::StringSwitch<unsigned>(Name)
876  .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
877  .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
878  .Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
879  .Case("local-exec", CodeGenOptions::LocalExecTLSModel)
880  .Default(~0U);
881  if (Model == ~0U) {
882  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
883  Success = false;
884  } else {
885  Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
886  }
887  }
888 
889  if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
890  StringRef Val = A->getValue();
891  if (Val == "ieee")
892  Opts.FPDenormalMode = "ieee";
893  else if (Val == "preserve-sign")
894  Opts.FPDenormalMode = "preserve-sign";
895  else if (Val == "positive-zero")
896  Opts.FPDenormalMode = "positive-zero";
897  else
898  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
899  }
900 
901  if (Arg *A = Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return)) {
902  if (A->getOption().matches(OPT_fpcc_struct_return)) {
903  Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
904  } else {
905  assert(A->getOption().matches(OPT_freg_struct_return));
906  Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
907  }
908  }
909 
910  Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
911  Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
912  bool NeedLocTracking = false;
913 
914  Opts.OptRecordFile = Args.getLastArgValue(OPT_opt_record_file);
915  if (!Opts.OptRecordFile.empty())
916  NeedLocTracking = true;
917 
918  if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
920  GenerateOptimizationRemarkRegex(Diags, Args, A);
921  NeedLocTracking = true;
922  }
923 
924  if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) {
926  GenerateOptimizationRemarkRegex(Diags, Args, A);
927  NeedLocTracking = true;
928  }
929 
930  if (Arg *A = Args.getLastArg(OPT_Rpass_analysis_EQ)) {
932  GenerateOptimizationRemarkRegex(Diags, Args, A);
933  NeedLocTracking = true;
934  }
935 
936  Opts.DiagnosticsWithHotness =
937  Args.hasArg(options::OPT_fdiagnostics_show_hotness);
938  bool UsingSampleProfile = !Opts.SampleProfileFile.empty();
939  bool UsingProfile = UsingSampleProfile ||
940  (Opts.getProfileUse() != CodeGenOptions::ProfileNone);
941 
942  if (Opts.DiagnosticsWithHotness && !UsingProfile)
943  Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
944  << "-fdiagnostics-show-hotness";
945 
946  Opts.DiagnosticsHotnessThreshold = getLastArgUInt64Value(
947  Args, options::OPT_fdiagnostics_hotness_threshold_EQ, 0);
948  if (Opts.DiagnosticsHotnessThreshold > 0 && !UsingProfile)
949  Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
950  << "-fdiagnostics-hotness-threshold=";
951 
952  // If the user requested to use a sample profile for PGO, then the
953  // backend will need to track source location information so the profile
954  // can be incorporated into the IR.
955  if (UsingSampleProfile)
956  NeedLocTracking = true;
957 
958  // If the user requested a flag that requires source locations available in
959  // the backend, make sure that the backend tracks source location information.
960  if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo)
961  Opts.setDebugInfo(codegenoptions::LocTrackingOnly);
962 
963  Opts.RewriteMapFiles = Args.getAllArgValues(OPT_frewrite_map_file);
964 
965  // Parse -fsanitize-recover= arguments.
966  // FIXME: Report unrecoverable sanitizers incorrectly specified here.
967  parseSanitizerKinds("-fsanitize-recover=",
968  Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
969  Opts.SanitizeRecover);
970  parseSanitizerKinds("-fsanitize-trap=",
971  Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
972  Opts.SanitizeTrap);
973 
975  Args.getAllArgValues(OPT_fcuda_include_gpubinary);
976 
977  Opts.Backchain = Args.hasArg(OPT_mbackchain);
978 
979  Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
980  Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
981 
982  return Success;
983 }
984 
986  ArgList &Args) {
987  using namespace options;
988  Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
989  Opts.Targets = Args.getAllArgValues(OPT_MT);
990  Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
991  Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
992  Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
993  Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
994  Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
995  Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
996  Opts.PrintShowIncludes = Args.hasArg(OPT_show_includes);
997  Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
999  Args.getLastArgValue(OPT_module_dependency_dir);
1000  if (Args.hasArg(OPT_MV))
1002  // Add sanitizer blacklists as extra dependencies.
1003  // They won't be discovered by the regular preprocessor, so
1004  // we let make / ninja to know about this implicit dependency.
1005  Opts.ExtraDeps = Args.getAllArgValues(OPT_fdepfile_entry);
1006  auto ModuleFiles = Args.getAllArgValues(OPT_fmodule_file);
1007  Opts.ExtraDeps.insert(Opts.ExtraDeps.end(), ModuleFiles.begin(),
1008  ModuleFiles.end());
1009 }
1010 
1011 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
1012  // Color diagnostics default to auto ("on" if terminal supports) in the driver
1013  // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
1014  // Support both clang's -f[no-]color-diagnostics and gcc's
1015  // -f[no-]diagnostics-colors[=never|always|auto].
1016  enum {
1017  Colors_On,
1018  Colors_Off,
1019  Colors_Auto
1020  } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
1021  for (Arg *A : Args) {
1022  const Option &O = A->getOption();
1023  if (O.matches(options::OPT_fcolor_diagnostics) ||
1024  O.matches(options::OPT_fdiagnostics_color)) {
1025  ShowColors = Colors_On;
1026  } else if (O.matches(options::OPT_fno_color_diagnostics) ||
1027  O.matches(options::OPT_fno_diagnostics_color)) {
1028  ShowColors = Colors_Off;
1029  } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
1030  StringRef Value(A->getValue());
1031  if (Value == "always")
1032  ShowColors = Colors_On;
1033  else if (Value == "never")
1034  ShowColors = Colors_Off;
1035  else if (Value == "auto")
1036  ShowColors = Colors_Auto;
1037  }
1038  }
1039  return ShowColors == Colors_On ||
1040  (ShowColors == Colors_Auto &&
1041  llvm::sys::Process::StandardErrHasColors());
1042 }
1043 
1044 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
1045  DiagnosticsEngine *Diags,
1046  bool DefaultDiagColor, bool DefaultShowOpt) {
1047  using namespace options;
1048  bool Success = true;
1049 
1050  Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
1051  if (Arg *A =
1052  Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
1053  Opts.DiagnosticSerializationFile = A->getValue();
1054  Opts.IgnoreWarnings = Args.hasArg(OPT_w);
1055  Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
1056  Opts.Pedantic = Args.hasArg(OPT_pedantic);
1057  Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
1058  Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
1059  Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
1060  Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
1061  OPT_fno_show_column,
1062  /*Default=*/true);
1063  Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
1064  Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
1065  Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
1066  Opts.ShowOptionNames =
1067  Args.hasFlag(OPT_fdiagnostics_show_option,
1068  OPT_fno_diagnostics_show_option, DefaultShowOpt);
1069 
1070  llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
1071 
1072  // Default behavior is to not to show note include stacks.
1073  Opts.ShowNoteIncludeStack = false;
1074  if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
1075  OPT_fno_diagnostics_show_note_include_stack))
1076  if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
1077  Opts.ShowNoteIncludeStack = true;
1078 
1079  StringRef ShowOverloads =
1080  Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
1081  if (ShowOverloads == "best")
1082  Opts.setShowOverloads(Ovl_Best);
1083  else if (ShowOverloads == "all")
1084  Opts.setShowOverloads(Ovl_All);
1085  else {
1086  Success = false;
1087  if (Diags)
1088  Diags->Report(diag::err_drv_invalid_value)
1089  << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1090  << ShowOverloads;
1091  }
1092 
1093  StringRef ShowCategory =
1094  Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
1095  if (ShowCategory == "none")
1096  Opts.ShowCategories = 0;
1097  else if (ShowCategory == "id")
1098  Opts.ShowCategories = 1;
1099  else if (ShowCategory == "name")
1100  Opts.ShowCategories = 2;
1101  else {
1102  Success = false;
1103  if (Diags)
1104  Diags->Report(diag::err_drv_invalid_value)
1105  << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1106  << ShowCategory;
1107  }
1108 
1109  StringRef Format =
1110  Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
1111  if (Format == "clang")
1112  Opts.setFormat(DiagnosticOptions::Clang);
1113  else if (Format == "msvc")
1114  Opts.setFormat(DiagnosticOptions::MSVC);
1115  else if (Format == "msvc-fallback") {
1116  Opts.setFormat(DiagnosticOptions::MSVC);
1117  Opts.CLFallbackMode = true;
1118  } else if (Format == "vi")
1119  Opts.setFormat(DiagnosticOptions::Vi);
1120  else {
1121  Success = false;
1122  if (Diags)
1123  Diags->Report(diag::err_drv_invalid_value)
1124  << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
1125  << Format;
1126  }
1127 
1128  Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
1129  Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
1130  Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
1131  Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
1133  Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
1134  Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
1135  Diags, DiagMask);
1136  if (Args.hasArg(OPT_verify_ignore_unexpected))
1137  DiagMask = DiagnosticLevelMask::All;
1138  Opts.setVerifyIgnoreUnexpected(DiagMask);
1139  Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
1140  Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
1141  Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
1142  Opts.MacroBacktraceLimit =
1143  getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
1145  Opts.TemplateBacktraceLimit = getLastArgIntValue(
1146  Args, OPT_ftemplate_backtrace_limit,
1148  Opts.ConstexprBacktraceLimit = getLastArgIntValue(
1149  Args, OPT_fconstexpr_backtrace_limit,
1151  Opts.SpellCheckingLimit = getLastArgIntValue(
1152  Args, OPT_fspell_checking_limit,
1154  Opts.SnippetLineLimit = getLastArgIntValue(
1155  Args, OPT_fcaret_diagnostics_max_lines,
1157  Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
1159  if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
1160  Opts.TabStop = DiagnosticOptions::DefaultTabStop;
1161  if (Diags)
1162  Diags->Report(diag::warn_ignoring_ftabstop_value)
1163  << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
1164  }
1165  Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
1166  addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
1167  addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
1168 
1169  return Success;
1170 }
1171 
1172 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1173  Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
1174 }
1175 
1176 /// Parse the argument to the -ftest-module-file-extension
1177 /// command-line argument.
1178 ///
1179 /// \returns true on error, false on success.
1180 static bool parseTestModuleFileExtensionArg(StringRef Arg,
1181  std::string &BlockName,
1182  unsigned &MajorVersion,
1183  unsigned &MinorVersion,
1184  bool &Hashed,
1185  std::string &UserInfo) {
1187  Arg.split(Args, ':', 5);
1188  if (Args.size() < 5)
1189  return true;
1190 
1191  BlockName = Args[0];
1192  if (Args[1].getAsInteger(10, MajorVersion)) return true;
1193  if (Args[2].getAsInteger(10, MinorVersion)) return true;
1194  if (Args[3].getAsInteger(2, Hashed)) return true;
1195  if (Args.size() > 4)
1196  UserInfo = Args[4];
1197  return false;
1198 }
1199 
1200 static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
1201  DiagnosticsEngine &Diags,
1202  bool &IsHeaderFile) {
1203  using namespace options;
1205  if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1206  switch (A->getOption().getID()) {
1207  default:
1208  llvm_unreachable("Invalid option in group!");
1209  case OPT_ast_list:
1210  Opts.ProgramAction = frontend::ASTDeclList; break;
1211  case OPT_ast_dump:
1212  case OPT_ast_dump_all:
1213  case OPT_ast_dump_lookups:
1214  Opts.ProgramAction = frontend::ASTDump; break;
1215  case OPT_ast_print:
1216  Opts.ProgramAction = frontend::ASTPrint; break;
1217  case OPT_ast_view:
1218  Opts.ProgramAction = frontend::ASTView; break;
1219  case OPT_dump_raw_tokens:
1220  Opts.ProgramAction = frontend::DumpRawTokens; break;
1221  case OPT_dump_tokens:
1222  Opts.ProgramAction = frontend::DumpTokens; break;
1223  case OPT_S:
1224  Opts.ProgramAction = frontend::EmitAssembly; break;
1225  case OPT_emit_llvm_bc:
1226  Opts.ProgramAction = frontend::EmitBC; break;
1227  case OPT_emit_html:
1228  Opts.ProgramAction = frontend::EmitHTML; break;
1229  case OPT_emit_llvm:
1230  Opts.ProgramAction = frontend::EmitLLVM; break;
1231  case OPT_emit_llvm_only:
1232  Opts.ProgramAction = frontend::EmitLLVMOnly; break;
1233  case OPT_emit_codegen_only:
1235  case OPT_emit_obj:
1236  Opts.ProgramAction = frontend::EmitObj; break;
1237  case OPT_fixit_EQ:
1238  Opts.FixItSuffix = A->getValue();
1239  // fall-through!
1240  case OPT_fixit:
1241  Opts.ProgramAction = frontend::FixIt; break;
1242  case OPT_emit_module:
1244  case OPT_emit_module_interface:
1246  case OPT_emit_pch:
1247  Opts.ProgramAction = frontend::GeneratePCH; break;
1248  case OPT_emit_pth:
1249  Opts.ProgramAction = frontend::GeneratePTH; break;
1250  case OPT_init_only:
1251  Opts.ProgramAction = frontend::InitOnly; break;
1252  case OPT_fsyntax_only:
1254  case OPT_module_file_info:
1256  case OPT_verify_pch:
1257  Opts.ProgramAction = frontend::VerifyPCH; break;
1258  case OPT_print_decl_contexts:
1260  case OPT_print_preamble:
1261  Opts.ProgramAction = frontend::PrintPreamble; break;
1262  case OPT_E:
1264  case OPT_rewrite_macros:
1265  Opts.ProgramAction = frontend::RewriteMacros; break;
1266  case OPT_rewrite_objc:
1267  Opts.ProgramAction = frontend::RewriteObjC; break;
1268  case OPT_rewrite_test:
1269  Opts.ProgramAction = frontend::RewriteTest; break;
1270  case OPT_analyze:
1271  Opts.ProgramAction = frontend::RunAnalysis; break;
1272  case OPT_migrate:
1273  Opts.ProgramAction = frontend::MigrateSource; break;
1274  case OPT_Eonly:
1276  }
1277  }
1278 
1279  if (const Arg* A = Args.getLastArg(OPT_plugin)) {
1280  Opts.Plugins.emplace_back(A->getValue(0));
1282  Opts.ActionName = A->getValue();
1283  }
1284  Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
1285  for (const Arg *AA : Args.filtered(OPT_plugin_arg))
1286  Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
1287 
1288  for (const std::string &Arg :
1289  Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
1290  std::string BlockName;
1291  unsigned MajorVersion;
1292  unsigned MinorVersion;
1293  bool Hashed;
1294  std::string UserInfo;
1295  if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion,
1296  MinorVersion, Hashed, UserInfo)) {
1297  Diags.Report(diag::err_test_module_file_extension_format) << Arg;
1298 
1299  continue;
1300  }
1301 
1302  // Add the testing module file extension.
1303  Opts.ModuleFileExtensions.push_back(
1304  std::make_shared<TestModuleFileExtension>(
1305  BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
1306  }
1307 
1308  if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1309  Opts.CodeCompletionAt =
1310  ParsedSourceLocation::FromString(A->getValue());
1311  if (Opts.CodeCompletionAt.FileName.empty())
1312  Diags.Report(diag::err_drv_invalid_value)
1313  << A->getAsString(Args) << A->getValue();
1314  }
1315  Opts.DisableFree = Args.hasArg(OPT_disable_free);
1316 
1317  Opts.OutputFile = Args.getLastArgValue(OPT_o);
1318  Opts.Plugins = Args.getAllArgValues(OPT_load);
1319  Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
1320  Opts.ShowHelp = Args.hasArg(OPT_help);
1321  Opts.ShowStats = Args.hasArg(OPT_print_stats);
1322  Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
1323  Opts.ShowVersion = Args.hasArg(OPT_version);
1324  Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1325  Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
1326  Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
1327  Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
1328  Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
1329  Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
1330  Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump);
1331  Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all);
1332  Opts.ASTDumpFilter = Args.getLastArgValue(OPT_ast_dump_filter);
1333  Opts.ASTDumpLookups = Args.hasArg(OPT_ast_dump_lookups);
1334  Opts.UseGlobalModuleIndex = !Args.hasArg(OPT_fno_modules_global_index);
1336  Opts.ModuleMapFiles = Args.getAllArgValues(OPT_fmodule_map_file);
1337  Opts.ModuleFiles = Args.getAllArgValues(OPT_fmodule_file);
1338  Opts.ModulesEmbedFiles = Args.getAllArgValues(OPT_fmodules_embed_file_EQ);
1339  Opts.ModulesEmbedAllFiles = Args.hasArg(OPT_fmodules_embed_all_files);
1340  Opts.IncludeTimestamps = !Args.hasArg(OPT_fno_pch_timestamp);
1341 
1343  = Args.hasArg(OPT_code_completion_macros);
1345  = Args.hasArg(OPT_code_completion_patterns);
1347  = !Args.hasArg(OPT_no_code_completion_globals);
1349  = Args.hasArg(OPT_code_completion_brief_comments);
1350 
1352  = Args.getLastArgValue(OPT_foverride_record_layout_EQ);
1353  Opts.AuxTriple =
1354  llvm::Triple::normalize(Args.getLastArgValue(OPT_aux_triple));
1355  Opts.FindPchSource = Args.getLastArgValue(OPT_find_pch_source_EQ);
1356  Opts.StatsFile = Args.getLastArgValue(OPT_stats_file);
1357 
1358  if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
1359  OPT_arcmt_modify,
1360  OPT_arcmt_migrate)) {
1361  switch (A->getOption().getID()) {
1362  default:
1363  llvm_unreachable("missed a case");
1364  case OPT_arcmt_check:
1366  break;
1367  case OPT_arcmt_modify:
1369  break;
1370  case OPT_arcmt_migrate:
1372  break;
1373  }
1374  }
1375  Opts.MTMigrateDir = Args.getLastArgValue(OPT_mt_migrate_directory);
1377  = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
1379  = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
1380 
1381  if (Args.hasArg(OPT_objcmt_migrate_literals))
1383  if (Args.hasArg(OPT_objcmt_migrate_subscripting))
1385  if (Args.hasArg(OPT_objcmt_migrate_property_dot_syntax))
1387  if (Args.hasArg(OPT_objcmt_migrate_property))
1389  if (Args.hasArg(OPT_objcmt_migrate_readonly_property))
1391  if (Args.hasArg(OPT_objcmt_migrate_readwrite_property))
1393  if (Args.hasArg(OPT_objcmt_migrate_annotation))
1395  if (Args.hasArg(OPT_objcmt_returns_innerpointer_property))
1397  if (Args.hasArg(OPT_objcmt_migrate_instancetype))
1399  if (Args.hasArg(OPT_objcmt_migrate_nsmacros))
1401  if (Args.hasArg(OPT_objcmt_migrate_protocol_conformance))
1403  if (Args.hasArg(OPT_objcmt_atomic_property))
1405  if (Args.hasArg(OPT_objcmt_ns_nonatomic_iosonly))
1407  if (Args.hasArg(OPT_objcmt_migrate_designated_init))
1409  if (Args.hasArg(OPT_objcmt_migrate_all))
1411 
1412  Opts.ObjCMTWhiteListPath = Args.getLastArgValue(OPT_objcmt_whitelist_dir_path);
1413 
1416  Diags.Report(diag::err_drv_argument_not_allowed_with)
1417  << "ARC migration" << "ObjC migration";
1418  }
1419 
1421  if (const Arg *A = Args.getLastArg(OPT_x)) {
1422  StringRef XValue = A->getValue();
1423 
1424  // Parse suffixes: '<lang>(-header|[-module-map][-cpp-output])'.
1425  // FIXME: Supporting '<lang>-header-cpp-output' would be useful.
1426  bool Preprocessed = XValue.consume_back("-cpp-output");
1427  bool ModuleMap = XValue.consume_back("-module-map");
1428  IsHeaderFile =
1429  !Preprocessed && !ModuleMap && XValue.consume_back("-header");
1430 
1431  // Principal languages.
1432  DashX = llvm::StringSwitch<InputKind>(XValue)
1433  .Case("c", InputKind::C)
1434  .Case("cl", InputKind::OpenCL)
1435  .Case("cuda", InputKind::CUDA)
1436  .Case("c++", InputKind::CXX)
1437  .Case("objective-c", InputKind::ObjC)
1438  .Case("objective-c++", InputKind::ObjCXX)
1439  .Case("renderscript", InputKind::RenderScript)
1440  .Default(InputKind::Unknown);
1441 
1442  // "objc[++]-cpp-output" is an acceptable synonym for
1443  // "objective-c[++]-cpp-output".
1444  if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap)
1445  DashX = llvm::StringSwitch<InputKind>(XValue)
1446  .Case("objc", InputKind::ObjC)
1447  .Case("objc++", InputKind::ObjCXX)
1448  .Default(InputKind::Unknown);
1449 
1450  // Some special cases cannot be combined with suffixes.
1451  if (DashX.isUnknown() && !Preprocessed && !ModuleMap && !IsHeaderFile)
1452  DashX = llvm::StringSwitch<InputKind>(XValue)
1453  .Case("cpp-output", InputKind(InputKind::C).getPreprocessed())
1454  .Case("assembler-with-cpp", InputKind::Asm)
1455  .Cases("ast", "pcm",
1457  .Case("ir", InputKind::LLVM_IR)
1458  .Default(InputKind::Unknown);
1459 
1460  if (DashX.isUnknown())
1461  Diags.Report(diag::err_drv_invalid_value)
1462  << A->getAsString(Args) << A->getValue();
1463 
1464  if (Preprocessed)
1465  DashX = DashX.getPreprocessed();
1466  if (ModuleMap)
1467  DashX = DashX.withFormat(InputKind::ModuleMap);
1468  }
1469 
1470  // '-' is the default input if none is given.
1471  std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
1472  Opts.Inputs.clear();
1473  if (Inputs.empty())
1474  Inputs.push_back("-");
1475  for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1476  InputKind IK = DashX;
1477  if (IK.isUnknown()) {
1479  StringRef(Inputs[i]).rsplit('.').second);
1480  // FIXME: Warn on this?
1481  if (IK.isUnknown())
1482  IK = InputKind::C;
1483  // FIXME: Remove this hack.
1484  if (i == 0)
1485  DashX = IK;
1486  }
1487 
1488  // The -emit-module action implicitly takes a module map.
1490  IK.getFormat() == InputKind::Source)
1492 
1493  Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
1494  }
1495 
1496  return DashX;
1497 }
1498 
1499 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
1500  void *MainAddr) {
1501  std::string ClangExecutable =
1502  llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
1503  StringRef Dir = llvm::sys::path::parent_path(ClangExecutable);
1504 
1505  // Compute the path to the resource directory.
1506  StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
1507  SmallString<128> P(Dir);
1508  if (ClangResourceDir != "")
1509  llvm::sys::path::append(P, ClangResourceDir);
1510  else
1511  llvm::sys::path::append(P, "..", Twine("lib") + CLANG_LIBDIR_SUFFIX,
1512  "clang", CLANG_VERSION_STRING);
1513 
1514  return P.str();
1515 }
1516 
1517 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
1518  const std::string &WorkingDir) {
1519  using namespace options;
1520  Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
1521  Opts.Verbose = Args.hasArg(OPT_v);
1522  Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
1523  Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
1524  Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
1525  if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
1526  Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
1527  Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
1528 
1529  // Canonicalize -fmodules-cache-path before storing it.
1530  SmallString<128> P(Args.getLastArgValue(OPT_fmodules_cache_path));
1531  if (!(P.empty() || llvm::sys::path::is_absolute(P))) {
1532  if (WorkingDir.empty())
1533  llvm::sys::fs::make_absolute(P);
1534  else
1535  llvm::sys::fs::make_absolute(WorkingDir, P);
1536  }
1537  llvm::sys::path::remove_dots(P);
1538  Opts.ModuleCachePath = P.str();
1539 
1540  Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path);
1541  for (const Arg *A : Args.filtered(OPT_fprebuilt_module_path))
1542  Opts.AddPrebuiltModulePath(A->getValue());
1543  Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
1544  Opts.ModulesHashContent = Args.hasArg(OPT_fmodules_hash_content);
1546  !Args.hasArg(OPT_fmodules_disable_diagnostic_validation);
1547  Opts.ImplicitModuleMaps = Args.hasArg(OPT_fimplicit_module_maps);
1548  Opts.ModuleMapFileHomeIsCwd = Args.hasArg(OPT_fmodule_map_file_home_is_cwd);
1550  getLastArgIntValue(Args, OPT_fmodules_prune_interval, 7 * 24 * 60 * 60);
1551  Opts.ModuleCachePruneAfter =
1552  getLastArgIntValue(Args, OPT_fmodules_prune_after, 31 * 24 * 60 * 60);
1554  Args.hasArg(OPT_fmodules_validate_once_per_build_session);
1555  Opts.BuildSessionTimestamp =
1556  getLastArgUInt64Value(Args, OPT_fbuild_session_timestamp, 0);
1558  Args.hasArg(OPT_fmodules_validate_system_headers);
1559  if (const Arg *A = Args.getLastArg(OPT_fmodule_format_EQ))
1560  Opts.ModuleFormat = A->getValue();
1561 
1562  for (const Arg *A : Args.filtered(OPT_fmodules_ignore_macro)) {
1563  StringRef MacroDef = A->getValue();
1564  Opts.ModulesIgnoreMacros.insert(
1565  llvm::CachedHashString(MacroDef.split('=').first));
1566  }
1567 
1568  // Add -I..., -F..., and -index-header-map options in order.
1569  bool IsIndexHeaderMap = false;
1570  bool IsSysrootSpecified =
1571  Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
1572  for (const Arg *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
1573  if (A->getOption().matches(OPT_index_header_map)) {
1574  // -index-header-map applies to the next -I or -F.
1575  IsIndexHeaderMap = true;
1576  continue;
1577  }
1578 
1580  IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled;
1581 
1582  bool IsFramework = A->getOption().matches(OPT_F);
1583  std::string Path = A->getValue();
1584 
1585  if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {
1587  llvm::sys::path::append(Buffer, Opts.Sysroot,
1588  llvm::StringRef(A->getValue()).substr(1));
1589  Path = Buffer.str();
1590  }
1591 
1592  Opts.AddPath(Path, Group, IsFramework,
1593  /*IgnoreSysroot*/ true);
1594  IsIndexHeaderMap = false;
1595  }
1596 
1597  // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
1598  StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
1599  for (const Arg *A :
1600  Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
1601  if (A->getOption().matches(OPT_iprefix))
1602  Prefix = A->getValue();
1603  else if (A->getOption().matches(OPT_iwithprefix))
1604  Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
1605  else
1606  Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
1607  }
1608 
1609  for (const Arg *A : Args.filtered(OPT_idirafter))
1610  Opts.AddPath(A->getValue(), frontend::After, false, true);
1611  for (const Arg *A : Args.filtered(OPT_iquote))
1612  Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
1613  for (const Arg *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
1614  Opts.AddPath(A->getValue(), frontend::System, false,
1615  !A->getOption().matches(OPT_iwithsysroot));
1616  for (const Arg *A : Args.filtered(OPT_iframework))
1617  Opts.AddPath(A->getValue(), frontend::System, true, true);
1618  for (const Arg *A : Args.filtered(OPT_iframeworkwithsysroot))
1619  Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,
1620  /*IgnoreSysRoot=*/false);
1621 
1622  // Add the paths for the various language specific isystem flags.
1623  for (const Arg *A : Args.filtered(OPT_c_isystem))
1624  Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
1625  for (const Arg *A : Args.filtered(OPT_cxx_isystem))
1626  Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
1627  for (const Arg *A : Args.filtered(OPT_objc_isystem))
1628  Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
1629  for (const Arg *A : Args.filtered(OPT_objcxx_isystem))
1630  Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
1631 
1632  // Add the internal paths from a driver that detects standard include paths.
1633  for (const Arg *A :
1634  Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
1636  if (A->getOption().matches(OPT_internal_externc_isystem))
1637  Group = frontend::ExternCSystem;
1638  Opts.AddPath(A->getValue(), Group, false, true);
1639  }
1640 
1641  // Add the path prefixes which are implicitly treated as being system headers.
1642  for (const Arg *A :
1643  Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
1644  Opts.AddSystemHeaderPrefix(
1645  A->getValue(), A->getOption().matches(OPT_system_header_prefix));
1646 
1647  for (const Arg *A : Args.filtered(OPT_ivfsoverlay))
1648  Opts.AddVFSOverlayFile(A->getValue());
1649 }
1650 
1652  const llvm::Triple &T,
1653  PreprocessorOptions &PPOpts,
1654  LangStandard::Kind LangStd) {
1655  // Set some properties which depend solely on the input kind; it would be nice
1656  // to move these to the language standard, and have the driver resolve the
1657  // input kind + language standard.
1658  //
1659  // FIXME: Perhaps a better model would be for a single source file to have
1660  // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
1661  // simultaneously active?
1662  if (IK.getLanguage() == InputKind::Asm) {
1663  Opts.AsmPreprocessor = 1;
1664  } else if (IK.isObjectiveC()) {
1665  Opts.ObjC1 = Opts.ObjC2 = 1;
1666  }
1667 
1668  if (LangStd == LangStandard::lang_unspecified) {
1669  // Based on the base language, pick one.
1670  switch (IK.getLanguage()) {
1671  case InputKind::Unknown:
1672  case InputKind::LLVM_IR:
1673  llvm_unreachable("Invalid input kind!");
1674  case InputKind::OpenCL:
1675  LangStd = LangStandard::lang_opencl10;
1676  break;
1677  case InputKind::CUDA:
1678  LangStd = LangStandard::lang_cuda;
1679  break;
1680  case InputKind::Asm:
1681  case InputKind::C:
1682  // The PS4 uses C99 as the default C standard.
1683  if (T.isPS4())
1684  LangStd = LangStandard::lang_gnu99;
1685  else
1686  LangStd = LangStandard::lang_gnu11;
1687  break;
1688  case InputKind::ObjC:
1689  LangStd = LangStandard::lang_gnu11;
1690  break;
1691  case InputKind::CXX:
1692  case InputKind::ObjCXX:
1693  // The PS4 uses C++11 as the default C++ standard.
1694  if (T.isPS4())
1695  LangStd = LangStandard::lang_gnucxx11;
1696  else
1697  LangStd = LangStandard::lang_gnucxx98;
1698  break;
1700  LangStd = LangStandard::lang_c99;
1701  break;
1702  }
1703  }
1704 
1705  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1706  Opts.LineComment = Std.hasLineComments();
1707  Opts.C99 = Std.isC99();
1708  Opts.C11 = Std.isC11();
1709  Opts.CPlusPlus = Std.isCPlusPlus();
1710  Opts.CPlusPlus11 = Std.isCPlusPlus11();
1711  Opts.CPlusPlus14 = Std.isCPlusPlus14();
1712  Opts.CPlusPlus1z = Std.isCPlusPlus1z();
1713  Opts.CPlusPlus2a = Std.isCPlusPlus2a();
1714  Opts.Digraphs = Std.hasDigraphs();
1715  Opts.GNUMode = Std.isGNUMode();
1716  Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;
1717  Opts.HexFloats = Std.hasHexFloats();
1718  Opts.ImplicitInt = Std.hasImplicitInt();
1719 
1720  // Set OpenCL Version.
1721  Opts.OpenCL = Std.isOpenCL();
1722  if (LangStd == LangStandard::lang_opencl10)
1723  Opts.OpenCLVersion = 100;
1724  else if (LangStd == LangStandard::lang_opencl11)
1725  Opts.OpenCLVersion = 110;
1726  else if (LangStd == LangStandard::lang_opencl12)
1727  Opts.OpenCLVersion = 120;
1728  else if (LangStd == LangStandard::lang_opencl20)
1729  Opts.OpenCLVersion = 200;
1730 
1731  // OpenCL has some additional defaults.
1732  if (Opts.OpenCL) {
1733  Opts.AltiVec = 0;
1734  Opts.ZVector = 0;
1735  Opts.LaxVectorConversions = 0;
1736  Opts.setDefaultFPContractMode(LangOptions::FPC_On);
1737  Opts.NativeHalfType = 1;
1738  Opts.NativeHalfArgsAndReturns = 1;
1739  // Include default header file for OpenCL.
1740  if (Opts.IncludeDefaultHeader) {
1741  PPOpts.Includes.push_back("opencl-c.h");
1742  }
1743  }
1744 
1745  Opts.CUDA = IK.getLanguage() == InputKind::CUDA;
1746  if (Opts.CUDA)
1747  // Set default FP_CONTRACT to FAST.
1748  Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
1749 
1750  Opts.RenderScript = IK.getLanguage() == InputKind::RenderScript;
1751  if (Opts.RenderScript) {
1752  Opts.NativeHalfType = 1;
1753  Opts.NativeHalfArgsAndReturns = 1;
1754  }
1755 
1756  // OpenCL and C++ both have bool, true, false keywords.
1757  Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
1758 
1759  // OpenCL has half keyword
1760  Opts.Half = Opts.OpenCL;
1761 
1762  // C++ has wchar_t keyword.
1763  Opts.WChar = Opts.CPlusPlus;
1764 
1765  Opts.GNUKeywords = Opts.GNUMode;
1766  Opts.CXXOperatorNames = Opts.CPlusPlus;
1767 
1768  Opts.AlignedAllocation = Opts.CPlusPlus1z;
1769 
1770  Opts.DollarIdents = !Opts.AsmPreprocessor;
1771 }
1772 
1773 /// Attempt to parse a visibility value out of the given argument.
1774 static Visibility parseVisibility(Arg *arg, ArgList &args,
1775  DiagnosticsEngine &diags) {
1776  StringRef value = arg->getValue();
1777  if (value == "default") {
1778  return DefaultVisibility;
1779  } else if (value == "hidden" || value == "internal") {
1780  return HiddenVisibility;
1781  } else if (value == "protected") {
1782  // FIXME: diagnose if target does not support protected visibility
1783  return ProtectedVisibility;
1784  }
1785 
1786  diags.Report(diag::err_drv_invalid_value)
1787  << arg->getAsString(args) << value;
1788  return DefaultVisibility;
1789 }
1790 
1791 /// Check if input file kind and language standard are compatible.
1793  const LangStandard &S) {
1794  switch (IK.getLanguage()) {
1795  case InputKind::Unknown:
1796  case InputKind::LLVM_IR:
1797  llvm_unreachable("should not parse language flags for this input");
1798 
1799  case InputKind::C:
1800  case InputKind::ObjC:
1802  return S.getLanguage() == InputKind::C;
1803 
1804  case InputKind::OpenCL:
1805  return S.getLanguage() == InputKind::OpenCL;
1806 
1807  case InputKind::CXX:
1808  case InputKind::ObjCXX:
1809  return S.getLanguage() == InputKind::CXX;
1810 
1811  case InputKind::CUDA:
1812  // FIXME: What -std= values should be permitted for CUDA compilations?
1813  return S.getLanguage() == InputKind::CUDA ||
1814  S.getLanguage() == InputKind::CXX;
1815 
1816  case InputKind::Asm:
1817  // Accept (and ignore) all -std= values.
1818  // FIXME: The -std= value is not ignored; it affects the tokenization
1819  // and preprocessing rules if we're preprocessing this asm input.
1820  return true;
1821  }
1822 
1823  llvm_unreachable("unexpected input language");
1824 }
1825 
1826 /// Get language name for given input kind.
1827 static const StringRef GetInputKindName(InputKind IK) {
1828  switch (IK.getLanguage()) {
1829  case InputKind::C:
1830  return "C";
1831  case InputKind::ObjC:
1832  return "Objective-C";
1833  case InputKind::CXX:
1834  return "C++";
1835  case InputKind::ObjCXX:
1836  return "Objective-C++";
1837  case InputKind::OpenCL:
1838  return "OpenCL";
1839  case InputKind::CUDA:
1840  return "CUDA";
1842  return "RenderScript";
1843 
1844  case InputKind::Asm:
1845  return "Asm";
1846  case InputKind::LLVM_IR:
1847  return "LLVM IR";
1848 
1849  case InputKind::Unknown:
1850  break;
1851  }
1852  llvm_unreachable("unknown input language");
1853 }
1854 
1855 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
1856  const TargetOptions &TargetOpts,
1857  PreprocessorOptions &PPOpts,
1858  DiagnosticsEngine &Diags) {
1859  // FIXME: Cleanup per-file based stuff.
1861  if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
1862  LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
1863 #define LANGSTANDARD(id, name, lang, desc, features) \
1864  .Case(name, LangStandard::lang_##id)
1865 #define LANGSTANDARD_ALIAS(id, alias) \
1866  .Case(alias, LangStandard::lang_##id)
1867 #include "clang/Frontend/LangStandards.def"
1869  if (LangStd == LangStandard::lang_unspecified) {
1870  Diags.Report(diag::err_drv_invalid_value)
1871  << A->getAsString(Args) << A->getValue();
1872  // Report supported standards with short description.
1873  for (unsigned KindValue = 0;
1874  KindValue != LangStandard::lang_unspecified;
1875  ++KindValue) {
1877  static_cast<LangStandard::Kind>(KindValue));
1878  if (IsInputCompatibleWithStandard(IK, Std)) {
1879  auto Diag = Diags.Report(diag::note_drv_use_standard);
1880  Diag << Std.getName() << Std.getDescription();
1881  unsigned NumAliases = 0;
1882 #define LANGSTANDARD(id, name, lang, desc, features)
1883 #define LANGSTANDARD_ALIAS(id, alias) \
1884  if (KindValue == LangStandard::lang_##id) ++NumAliases;
1885 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
1886 #include "clang/Frontend/LangStandards.def"
1887  Diag << NumAliases;
1888 #define LANGSTANDARD(id, name, lang, desc, features)
1889 #define LANGSTANDARD_ALIAS(id, alias) \
1890  if (KindValue == LangStandard::lang_##id) Diag << alias;
1891 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
1892 #include "clang/Frontend/LangStandards.def"
1893  }
1894  }
1895  } else {
1896  // Valid standard, check to make sure language and standard are
1897  // compatible.
1898  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1899  if (!IsInputCompatibleWithStandard(IK, Std)) {
1900  Diags.Report(diag::err_drv_argument_not_allowed_with)
1901  << A->getAsString(Args) << GetInputKindName(IK);
1902  }
1903  }
1904  }
1905 
1906  // -cl-std only applies for OpenCL language standards.
1907  // Override the -std option in this case.
1908  if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
1909  LangStandard::Kind OpenCLLangStd
1910  = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
1911  .Cases("cl", "CL", LangStandard::lang_opencl10)
1912  .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
1913  .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
1914  .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
1916 
1917  if (OpenCLLangStd == LangStandard::lang_unspecified) {
1918  Diags.Report(diag::err_drv_invalid_value)
1919  << A->getAsString(Args) << A->getValue();
1920  }
1921  else
1922  LangStd = OpenCLLangStd;
1923  }
1924 
1925  Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
1926 
1927  llvm::Triple T(TargetOpts.Triple);
1928  CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
1929 
1930  // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
1931  // This option should be deprecated for CL > 1.0 because
1932  // this option was added for compatibility with OpenCL 1.0.
1933  if (Args.getLastArg(OPT_cl_strict_aliasing)
1934  && Opts.OpenCLVersion > 100) {
1935  std::string VerSpec = llvm::to_string(Opts.OpenCLVersion / 100) +
1936  std::string(".") +
1937  llvm::to_string((Opts.OpenCLVersion % 100) / 10);
1938  Diags.Report(diag::warn_option_invalid_ocl_version)
1939  << VerSpec << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
1940  }
1941 
1942  // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1943  // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1944  // while a subset (the non-C++ GNU keywords) is provided by GCC's
1945  // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1946  // name, as it doesn't seem a useful distinction.
1947  Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
1948  Opts.GNUKeywords);
1949 
1950  if (Args.hasArg(OPT_fno_operator_names))
1951  Opts.CXXOperatorNames = 0;
1952 
1953  if (Args.hasArg(OPT_fcuda_is_device))
1954  Opts.CUDAIsDevice = 1;
1955 
1956  if (Args.hasArg(OPT_fcuda_allow_variadic_functions))
1957  Opts.CUDAAllowVariadicFunctions = 1;
1958 
1959  if (Args.hasArg(OPT_fno_cuda_host_device_constexpr))
1960  Opts.CUDAHostDeviceConstexpr = 0;
1961 
1962  if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_flush_denormals_to_zero))
1963  Opts.CUDADeviceFlushDenormalsToZero = 1;
1964 
1965  if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals))
1966  Opts.CUDADeviceApproxTranscendentals = 1;
1967 
1968  if (Opts.ObjC1) {
1969  if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
1970  StringRef value = arg->getValue();
1971  if (Opts.ObjCRuntime.tryParse(value))
1972  Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
1973  }
1974 
1975  if (Args.hasArg(OPT_fobjc_gc_only))
1976  Opts.setGC(LangOptions::GCOnly);
1977  else if (Args.hasArg(OPT_fobjc_gc))
1978  Opts.setGC(LangOptions::HybridGC);
1979  else if (Args.hasArg(OPT_fobjc_arc)) {
1980  Opts.ObjCAutoRefCount = 1;
1981  if (!Opts.ObjCRuntime.allowsARC())
1982  Diags.Report(diag::err_arc_unsupported_on_runtime);
1983  }
1984 
1985  // ObjCWeakRuntime tracks whether the runtime supports __weak, not
1986  // whether the feature is actually enabled. This is predominantly
1987  // determined by -fobjc-runtime, but we allow it to be overridden
1988  // from the command line for testing purposes.
1989  if (Args.hasArg(OPT_fobjc_runtime_has_weak))
1990  Opts.ObjCWeakRuntime = 1;
1991  else
1992  Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak();
1993 
1994  // ObjCWeak determines whether __weak is actually enabled.
1995  // Note that we allow -fno-objc-weak to disable this even in ARC mode.
1996  if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
1997  if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
1998  assert(!Opts.ObjCWeak);
1999  } else if (Opts.getGC() != LangOptions::NonGC) {
2000  Diags.Report(diag::err_objc_weak_with_gc);
2001  } else if (!Opts.ObjCWeakRuntime) {
2002  Diags.Report(diag::err_objc_weak_unsupported);
2003  } else {
2004  Opts.ObjCWeak = 1;
2005  }
2006  } else if (Opts.ObjCAutoRefCount) {
2007  Opts.ObjCWeak = Opts.ObjCWeakRuntime;
2008  }
2009 
2010  if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
2011  Opts.ObjCInferRelatedResultType = 0;
2012 
2013  if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
2014  Opts.ObjCSubscriptingLegacyRuntime =
2016  }
2017 
2018  if (Args.hasArg(OPT_fgnu89_inline)) {
2019  if (Opts.CPlusPlus)
2020  Diags.Report(diag::err_drv_argument_not_allowed_with)
2021  << "-fgnu89-inline" << GetInputKindName(IK);
2022  else
2023  Opts.GNUInline = 1;
2024  }
2025 
2026  if (Args.hasArg(OPT_fapple_kext)) {
2027  if (!Opts.CPlusPlus)
2028  Diags.Report(diag::warn_c_kext);
2029  else
2030  Opts.AppleKext = 1;
2031  }
2032 
2033  if (Args.hasArg(OPT_print_ivar_layout))
2034  Opts.ObjCGCBitmapPrint = 1;
2035  if (Args.hasArg(OPT_fno_constant_cfstrings))
2036  Opts.NoConstantCFStrings = 1;
2037 
2038  if (Args.hasArg(OPT_fzvector))
2039  Opts.ZVector = 1;
2040 
2041  if (Args.hasArg(OPT_pthread))
2042  Opts.POSIXThreads = 1;
2043 
2044  // The value-visibility mode defaults to "default".
2045  if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
2046  Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
2047  } else {
2048  Opts.setValueVisibilityMode(DefaultVisibility);
2049  }
2050 
2051  // The type-visibility mode defaults to the value-visibility mode.
2052  if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) {
2053  Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags));
2054  } else {
2055  Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
2056  }
2057 
2058  if (Args.hasArg(OPT_fvisibility_inlines_hidden))
2059  Opts.InlineVisibilityHidden = 1;
2060 
2061  if (Args.hasArg(OPT_ftrapv)) {
2062  Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
2063  // Set the handler, if one is specified.
2064  Opts.OverflowHandler =
2065  Args.getLastArgValue(OPT_ftrapv_handler);
2066  }
2067  else if (Args.hasArg(OPT_fwrapv))
2068  Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
2069 
2070  Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
2071  Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
2072  Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
2073  Opts.MSCompatibilityVersion = 0;
2074  if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
2075  VersionTuple VT;
2076  if (VT.tryParse(A->getValue()))
2077  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
2078  << A->getValue();
2079  Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
2080  VT.getMinor().getValueOr(0) * 100000 +
2081  VT.getSubminor().getValueOr(0);
2082  }
2083 
2084  // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
2085  // is specified, or -std is set to a conforming mode.
2086  // Trigraphs are disabled by default in c++1z onwards.
2087  Opts.Trigraphs = !Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus1z;
2088  Opts.Trigraphs =
2089  Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
2090 
2091  Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
2092  OPT_fno_dollars_in_identifiers,
2093  Opts.DollarIdents);
2094  Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
2095  Opts.VtorDispMode = getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags);
2096  Opts.Borland = Args.hasArg(OPT_fborland_extensions);
2097  Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
2098  Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
2099  Opts.ConstStrings);
2100  if (Args.hasArg(OPT_fno_lax_vector_conversions))
2101  Opts.LaxVectorConversions = 0;
2102  if (Args.hasArg(OPT_fno_threadsafe_statics))
2103  Opts.ThreadsafeStatics = 0;
2104  Opts.Exceptions = Args.hasArg(OPT_fexceptions);
2105  Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
2106  Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
2107  Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
2108  Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
2109  Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
2110 
2111  Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
2112  Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
2113  Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
2114  && Opts.OpenCLVersion >= 200);
2115  Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
2116  Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
2117  Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
2118  Opts.Modules = Args.hasArg(OPT_fmodules) || Opts.ModulesTS;
2119  Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
2120  Opts.ModulesDeclUse =
2121  Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
2122  Opts.ModulesLocalVisibility =
2123  Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS;
2124  Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen);
2125  Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
2126  Opts.ModulesSearchAll = Opts.Modules &&
2127  !Args.hasArg(OPT_fno_modules_search_all) &&
2128  Args.hasArg(OPT_fmodules_search_all);
2129  Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
2130  Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
2131  Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
2132  Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
2133  Opts.ShortWChar = Args.hasFlag(OPT_fshort_wchar, OPT_fno_short_wchar, false);
2134  Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
2135  Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
2136  Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
2137  if (!Opts.NoBuiltin)
2139  Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
2140  Opts.RelaxedTemplateTemplateArgs =
2141  Args.hasArg(OPT_frelaxed_template_template_args);
2142  Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
2143  Opts.AlignedAllocation =
2144  Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
2145  Opts.AlignedAllocation);
2146  Opts.AlignedAllocationUnavailable =
2147  Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable);
2148  Opts.NewAlignOverride =
2149  getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
2150  if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
2151  Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
2152  Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
2153  << A->getValue();
2154  Opts.NewAlignOverride = 0;
2155  }
2156  Opts.ConceptsTS = Args.hasArg(OPT_fconcepts_ts);
2157  Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
2158  Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
2159  Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
2160  Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
2161  Opts.InstantiationDepth =
2162  getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
2163  Opts.ArrowDepth =
2164  getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
2165  Opts.ConstexprCallDepth =
2166  getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
2167  Opts.ConstexprStepLimit =
2168  getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
2169  Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
2170  Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
2171  Opts.NumLargeByValueCopy =
2172  getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
2173  Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
2175  Args.getLastArgValue(OPT_fconstant_string_class);
2176  Opts.ObjCDefaultSynthProperties =
2177  !Args.hasArg(OPT_disable_objc_default_synthesize_properties);
2178  Opts.EncodeExtendedBlockSig =
2179  Args.hasArg(OPT_fencode_extended_block_signature);
2180  Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
2181  Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
2182  Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
2183  Opts.AlignDouble = Args.hasArg(OPT_malign_double);
2184  Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
2185  Opts.PIE = Args.hasArg(OPT_pic_is_pie);
2186  Opts.Static = Args.hasArg(OPT_static_define);
2187  Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
2188  Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
2189  || Args.hasArg(OPT_fdump_record_layouts);
2190  Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
2191  Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
2192  Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
2193  Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
2194  Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
2195  Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
2196  Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
2197  Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
2198  Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
2199  Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
2200  Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
2201  Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
2202  Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name_EQ);
2203  Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
2204  Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
2205  std::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end());
2206  Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
2207  Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns);
2208  // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns
2209  // is enabled.
2210  Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
2211  | Opts.NativeHalfArgsAndReturns;
2212  Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
2213 
2214  // __declspec is enabled by default for the PS4 by the driver, and also
2215  // enabled for Microsoft Extensions or Borland Extensions, here.
2216  //
2217  // FIXME: __declspec is also currently enabled for CUDA, but isn't really a
2218  // CUDA extension. However, it is required for supporting
2219  // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
2220  // been rewritten in terms of something more generic, remove the Opts.CUDA
2221  // term here.
2222  Opts.DeclSpecKeyword =
2223  Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec,
2224  (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA));
2225 
2226  if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) {
2227  switch (llvm::StringSwitch<unsigned>(A->getValue())
2228  .Case("target", LangOptions::ASMM_Target)
2229  .Case("no", LangOptions::ASMM_Off)
2230  .Case("yes", LangOptions::ASMM_On)
2231  .Default(255)) {
2232  default:
2233  Diags.Report(diag::err_drv_invalid_value)
2234  << "-faddress-space-map-mangling=" << A->getValue();
2235  break;
2237  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Target);
2238  break;
2239  case LangOptions::ASMM_On:
2240  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On);
2241  break;
2242  case LangOptions::ASMM_Off:
2243  Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off);
2244  break;
2245  }
2246  }
2247 
2248  if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
2250  llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
2251  A->getValue())
2252  .Case("single",
2254  .Case("multiple",
2256  .Case("virtual",
2258  .Default(LangOptions::PPTMK_BestCase);
2259  if (InheritanceModel == LangOptions::PPTMK_BestCase)
2260  Diags.Report(diag::err_drv_invalid_value)
2261  << "-fms-memptr-rep=" << A->getValue();
2262 
2263  Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
2264  }
2265 
2266  // Check for MS default calling conventions being specified.
2267  if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
2269  llvm::StringSwitch<LangOptions::DefaultCallingConvention>(
2270  A->getValue())
2271  .Case("cdecl", LangOptions::DCC_CDecl)
2272  .Case("fastcall", LangOptions::DCC_FastCall)
2273  .Case("stdcall", LangOptions::DCC_StdCall)
2274  .Case("vectorcall", LangOptions::DCC_VectorCall)
2275  .Default(LangOptions::DCC_None);
2276  if (DefaultCC == LangOptions::DCC_None)
2277  Diags.Report(diag::err_drv_invalid_value)
2278  << "-fdefault-calling-conv=" << A->getValue();
2279 
2280  llvm::Triple T(TargetOpts.Triple);
2281  llvm::Triple::ArchType Arch = T.getArch();
2282  bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||
2283  DefaultCC == LangOptions::DCC_StdCall) &&
2284  Arch != llvm::Triple::x86;
2285  emitError |= DefaultCC == LangOptions::DCC_VectorCall &&
2286  !(Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64);
2287  if (emitError)
2288  Diags.Report(diag::err_drv_argument_not_allowed_with)
2289  << A->getSpelling() << T.getTriple();
2290  else
2291  Opts.setDefaultCallingConv(DefaultCC);
2292  }
2293 
2294  // -mrtd option
2295  if (Arg *A = Args.getLastArg(OPT_mrtd)) {
2296  if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
2297  Diags.Report(diag::err_drv_argument_not_allowed_with)
2298  << A->getSpelling() << "-fdefault-calling-conv";
2299  else {
2300  llvm::Triple T(TargetOpts.Triple);
2301  if (T.getArch() != llvm::Triple::x86)
2302  Diags.Report(diag::err_drv_argument_not_allowed_with)
2303  << A->getSpelling() << T.getTriple();
2304  else
2305  Opts.setDefaultCallingConv(LangOptions::DCC_StdCall);
2306  }
2307  }
2308 
2309  // Check if -fopenmp is specified.
2310  Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 1 : 0;
2311  Opts.OpenMPUseTLS =
2312  Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
2313  Opts.OpenMPIsDevice =
2314  Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
2315 
2316  if (Opts.OpenMP) {
2317  int Version =
2318  getLastArgIntValue(Args, OPT_fopenmp_version_EQ, Opts.OpenMP, Diags);
2319  if (Version != 0)
2320  Opts.OpenMP = Version;
2321  // Provide diagnostic when a given target is not expected to be an OpenMP
2322  // device or host.
2323  if (!Opts.OpenMPIsDevice) {
2324  switch (T.getArch()) {
2325  default:
2326  break;
2327  // Add unsupported host targets here:
2328  case llvm::Triple::nvptx:
2329  case llvm::Triple::nvptx64:
2330  Diags.Report(clang::diag::err_drv_omp_host_target_not_supported)
2331  << TargetOpts.Triple;
2332  break;
2333  }
2334  }
2335  }
2336 
2337  // Get the OpenMP target triples if any.
2338  if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
2339 
2340  for (unsigned i = 0; i < A->getNumValues(); ++i) {
2341  llvm::Triple TT(A->getValue(i));
2342 
2343  if (TT.getArch() == llvm::Triple::UnknownArch)
2344  Diags.Report(clang::diag::err_drv_invalid_omp_target) << A->getValue(i);
2345  else
2346  Opts.OMPTargetTriples.push_back(TT);
2347  }
2348  }
2349 
2350  // Get OpenMP host file path if any and report if a non existent file is
2351  // found
2352  if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
2353  Opts.OMPHostIRFile = A->getValue();
2354  if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
2355  Diags.Report(clang::diag::err_drv_omp_host_ir_file_not_found)
2356  << Opts.OMPHostIRFile;
2357  }
2358 
2359  // Record whether the __DEPRECATED define was requested.
2360  Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
2361  OPT_fno_deprecated_macro,
2362  Opts.Deprecated);
2363 
2364  // FIXME: Eliminate this dependency.
2365  unsigned Opt = getOptimizationLevel(Args, IK, Diags),
2366  OptSize = getOptimizationLevelSize(Args);
2367  Opts.Optimize = Opt != 0;
2368  Opts.OptimizeSize = OptSize != 0;
2369 
2370  // This is the __NO_INLINE__ define, which just depends on things like the
2371  // optimization level and -fno-inline, not actually whether the backend has
2372  // inlining enabled.
2373  Opts.NoInlineDefine = !Opts.Optimize;
2374  if (Arg *InlineArg = Args.getLastArg(
2375  options::OPT_finline_functions, options::OPT_finline_hint_functions,
2376  options::OPT_fno_inline_functions, options::OPT_fno_inline))
2377  if (InlineArg->getOption().matches(options::OPT_fno_inline))
2378  Opts.NoInlineDefine = true;
2379 
2380  Opts.FastMath = Args.hasArg(OPT_ffast_math) ||
2381  Args.hasArg(OPT_cl_fast_relaxed_math);
2382  Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
2383  Args.hasArg(OPT_cl_finite_math_only) ||
2384  Args.hasArg(OPT_cl_fast_relaxed_math);
2385  Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
2386  Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
2387  Args.hasArg(OPT_cl_fast_relaxed_math);
2388 
2389  if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
2390  StringRef Val = A->getValue();
2391  if (Val == "fast")
2392  Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
2393  else if (Val == "on")
2394  Opts.setDefaultFPContractMode(LangOptions::FPC_On);
2395  else if (Val == "off")
2396  Opts.setDefaultFPContractMode(LangOptions::FPC_Off);
2397  else
2398  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2399  }
2400 
2401  Opts.RetainCommentsFromSystemHeaders =
2402  Args.hasArg(OPT_fretain_comments_from_system_headers);
2403 
2404  unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
2405  switch (SSP) {
2406  default:
2407  Diags.Report(diag::err_drv_invalid_value)
2408  << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
2409  break;
2410  case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
2411  case 1: Opts.setStackProtector(LangOptions::SSPOn); break;
2412  case 2: Opts.setStackProtector(LangOptions::SSPStrong); break;
2413  case 3: Opts.setStackProtector(LangOptions::SSPReq); break;
2414  }
2415 
2416  // Parse -fsanitize= arguments.
2417  parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
2418  Diags, Opts.Sanitize);
2419  // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
2420  Opts.SanitizeAddressFieldPadding =
2421  getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
2422  Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
2423 
2424  // -fxray-instrument
2425  Opts.XRayInstrument =
2426  Args.hasFlag(OPT_fxray_instrument, OPT_fnoxray_instrument, false);
2427 
2428  // -fxray-{always,never}-instrument= filenames.
2430  Args.getAllArgValues(OPT_fxray_always_instrument);
2432  Args.getAllArgValues(OPT_fxray_never_instrument);
2433 
2434  // -fallow-editor-placeholders
2435  Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders);
2436 }
2437 
2439  switch (Action) {
2440  case frontend::ASTDeclList:
2441  case frontend::ASTDump:
2442  case frontend::ASTPrint:
2443  case frontend::ASTView:
2445  case frontend::EmitBC:
2446  case frontend::EmitHTML:
2447  case frontend::EmitLLVM:
2450  case frontend::EmitObj:
2451  case frontend::FixIt:
2454  case frontend::GeneratePCH:
2455  case frontend::GeneratePTH:
2458  case frontend::VerifyPCH:
2461  case frontend::RewriteObjC:
2462  case frontend::RewriteTest:
2463  case frontend::RunAnalysis:
2465  return false;
2466 
2468  case frontend::DumpTokens:
2469  case frontend::InitOnly:
2474  return true;
2475  }
2476  llvm_unreachable("invalid frontend action");
2477 }
2478 
2479 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
2480  FileManager &FileMgr,
2481  DiagnosticsEngine &Diags,
2483  using namespace options;
2484  Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
2485  Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
2486  if (const Arg *A = Args.getLastArg(OPT_token_cache))
2487  Opts.TokenCache = A->getValue();
2488  else
2489  Opts.TokenCache = Opts.ImplicitPTHInclude;
2490  Opts.UsePredefines = !Args.hasArg(OPT_undef);
2491  Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
2492  Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
2493  Opts.AllowPCHWithCompilerErrors = Args.hasArg(OPT_fallow_pch_with_errors);
2494 
2495  Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
2496  for (const Arg *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
2497  Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue());
2498 
2499  if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
2500  StringRef Value(A->getValue());
2501  size_t Comma = Value.find(',');
2502  unsigned Bytes = 0;
2503  unsigned EndOfLine = 0;
2504 
2505  if (Comma == StringRef::npos ||
2506  Value.substr(0, Comma).getAsInteger(10, Bytes) ||
2507  Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
2508  Diags.Report(diag::err_drv_preamble_format);
2509  else {
2510  Opts.PrecompiledPreambleBytes.first = Bytes;
2511  Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
2512  }
2513  }
2514 
2515  // Add macros from the command line.
2516  for (const Arg *A : Args.filtered(OPT_D, OPT_U)) {
2517  if (A->getOption().matches(OPT_D))
2518  Opts.addMacroDef(A->getValue());
2519  else
2520  Opts.addMacroUndef(A->getValue());
2521  }
2522 
2523  Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
2524 
2525  // Add the ordered list of -includes.
2526  for (const Arg *A : Args.filtered(OPT_include))
2527  Opts.Includes.emplace_back(A->getValue());
2528 
2529  for (const Arg *A : Args.filtered(OPT_chain_include))
2530  Opts.ChainedIncludes.emplace_back(A->getValue());
2531 
2532  for (const Arg *A : Args.filtered(OPT_remap_file)) {
2533  std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');
2534 
2535  if (Split.second.empty()) {
2536  Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
2537  continue;
2538  }
2539 
2540  Opts.addRemappedFile(Split.first, Split.second);
2541  }
2542 
2543  if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
2544  StringRef Name = A->getValue();
2545  unsigned Library = llvm::StringSwitch<unsigned>(Name)
2546  .Case("libc++", ARCXX_libcxx)
2547  .Case("libstdc++", ARCXX_libstdcxx)
2548  .Case("none", ARCXX_nolib)
2549  .Default(~0U);
2550  if (Library == ~0U)
2551  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
2552  else
2554  }
2555 
2556  // Always avoid lexing editor placeholders when we're just running the
2557  // preprocessor as we never want to emit the
2558  // "editor placeholder in source file" error in PP only mode.
2559  if (isStrictlyPreprocessorAction(Action))
2560  Opts.LexEditorPlaceholders = false;
2561 }
2562 
2564  ArgList &Args,
2566  using namespace options;
2567 
2568  if (isStrictlyPreprocessorAction(Action))
2569  Opts.ShowCPP = !Args.hasArg(OPT_dM);
2570  else
2571  Opts.ShowCPP = 0;
2572 
2573  Opts.ShowComments = Args.hasArg(OPT_C);
2574  Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
2575  Opts.ShowMacroComments = Args.hasArg(OPT_CC);
2576  Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
2577  Opts.ShowIncludeDirectives = Args.hasArg(OPT_dI);
2578  Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
2579  Opts.RewriteImports = Args.hasArg(OPT_frewrite_imports);
2580  Opts.UseLineDirectives = Args.hasArg(OPT_fuse_line_directives);
2581 }
2582 
2583 static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
2584  DiagnosticsEngine &Diags) {
2585  using namespace options;
2586  Opts.ABI = Args.getLastArgValue(OPT_target_abi);
2587  if (Arg *A = Args.getLastArg(OPT_meabi)) {
2588  StringRef Value = A->getValue();
2589  llvm::EABI EABIVersion = llvm::StringSwitch<llvm::EABI>(Value)
2590  .Case("default", llvm::EABI::Default)
2591  .Case("4", llvm::EABI::EABI4)
2592  .Case("5", llvm::EABI::EABI5)
2593  .Case("gnu", llvm::EABI::GNU)
2594  .Default(llvm::EABI::Unknown);
2595  if (EABIVersion == llvm::EABI::Unknown)
2596  Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
2597  << Value;
2598  else
2599  Opts.EABIVersion = EABIVersion;
2600  }
2601  Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
2602  Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
2603  Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
2604  Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
2605  Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
2606  Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
2607  // Use the default target triple if unspecified.
2608  if (Opts.Triple.empty())
2609  Opts.Triple = llvm::sys::getDefaultTargetTriple();
2610  Opts.OpenCLExtensionsAsWritten = Args.getAllArgValues(OPT_cl_ext_EQ);
2611 }
2612 
2614  const char *const *ArgBegin,
2615  const char *const *ArgEnd,
2616  DiagnosticsEngine &Diags) {
2617  bool Success = true;
2618 
2619  // Parse the arguments.
2620  std::unique_ptr<OptTable> Opts = createDriverOptTable();
2621  const unsigned IncludedFlagsBitmask = options::CC1Option;
2622  unsigned MissingArgIndex, MissingArgCount;
2623  InputArgList Args =
2624  Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex,
2625  MissingArgCount, IncludedFlagsBitmask);
2626  LangOptions &LangOpts = *Res.getLangOpts();
2627 
2628  // Check for missing argument error.
2629  if (MissingArgCount) {
2630  Diags.Report(diag::err_drv_missing_argument)
2631  << Args.getArgString(MissingArgIndex) << MissingArgCount;
2632  Success = false;
2633  }
2634 
2635  // Issue errors on unknown arguments.
2636  for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
2637  Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args);
2638  Success = false;
2639  }
2640 
2641  Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
2642  Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args);
2644  Success &=
2645  ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
2646  false /*DefaultDiagColor*/, false /*DefaultShowOpt*/);
2647  ParseCommentArgs(LangOpts.CommentOpts, Args);
2649  // FIXME: We shouldn't have to pass the DashX option around here
2650  InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
2651  LangOpts.IsHeaderFile);
2652  ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
2653  Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags,
2654  Res.getTargetOpts());
2657  if (DashX.getFormat() == InputKind::Precompiled ||
2658  DashX.getLanguage() == InputKind::LLVM_IR) {
2659  // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
2660  // PassManager in BackendUtil.cpp. They need to be initializd no matter
2661  // what the input type is.
2662  if (Args.hasArg(OPT_fobjc_arc))
2663  LangOpts.ObjCAutoRefCount = 1;
2664  // PIClevel and PIELevel are needed during code generation and this should be
2665  // set regardless of the input type.
2666  LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
2667  LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
2668  parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
2669  Diags, LangOpts.Sanitize);
2670  } else {
2671  // Other LangOpts are only initialzed when the input is not AST or LLVM IR.
2672  // FIXME: Should we really be calling this for an InputKind::Asm input?
2673  ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
2674  Res.getPreprocessorOpts(), Diags);
2676  LangOpts.ObjCExceptions = 1;
2677  }
2678 
2679  if (LangOpts.CUDA) {
2680  // During CUDA device-side compilation, the aux triple is the
2681  // triple used for host compilation.
2682  if (LangOpts.CUDAIsDevice)
2684  }
2685 
2686  // Set the triple of the host for OpenMP device compile.
2687  if (LangOpts.OpenMPIsDevice)
2689 
2690  // FIXME: Override value name discarding when asan or msan is used because the
2691  // backend passes depend on the name of the alloca in order to print out
2692  // names.
2693  Res.getCodeGenOpts().DiscardValueNames &=
2694  !LangOpts.Sanitize.has(SanitizerKind::Address) &&
2695  !LangOpts.Sanitize.has(SanitizerKind::Memory);
2696 
2697  // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
2698  // PCH file and find the original header name. Remove the need to do that in
2699  // ParsePreprocessorArgs and remove the FileManager
2700  // parameters from the function and the "FileManager.h" #include.
2701  FileManager FileMgr(Res.getFileSystemOpts());
2702  ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, FileMgr, Diags,
2706 
2707  // Turn on -Wspir-compat for SPIR target.
2708  llvm::Triple T(Res.getTargetOpts().Triple);
2709  auto Arch = T.getArch();
2710  if (Arch == llvm::Triple::spir || Arch == llvm::Triple::spir64) {
2711  Res.getDiagnosticOpts().Warnings.push_back("spir-compat");
2712  }
2713  return Success;
2714 }
2715 
2717  // Note: For QoI reasons, the things we use as a hash here should all be
2718  // dumped via the -module-info flag.
2719  using llvm::hash_code;
2720  using llvm::hash_value;
2721  using llvm::hash_combine;
2722 
2723  // Start the signature with the compiler version.
2724  // FIXME: We'd rather use something more cryptographically sound than
2725  // CityHash, but this will do for now.
2726  hash_code code = hash_value(getClangFullRepositoryVersion());
2727 
2728  // Extend the signature with the language options
2729 #define LANGOPT(Name, Bits, Default, Description) \
2730  code = hash_combine(code, LangOpts->Name);
2731 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
2732  code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
2733 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
2734 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
2735 #include "clang/Basic/LangOptions.def"
2736 
2737  for (StringRef Feature : LangOpts->ModuleFeatures)
2738  code = hash_combine(code, Feature);
2739 
2740  // Extend the signature with the target options.
2741  code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
2742  TargetOpts->ABI);
2743  for (unsigned i = 0, n = TargetOpts->FeaturesAsWritten.size(); i != n; ++i)
2744  code = hash_combine(code, TargetOpts->FeaturesAsWritten[i]);
2745 
2746  // Extend the signature with preprocessor options.
2747  const PreprocessorOptions &ppOpts = getPreprocessorOpts();
2748  const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
2749  code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord);
2750 
2751  for (std::vector<std::pair<std::string, bool/*isUndef*/>>::const_iterator
2752  I = getPreprocessorOpts().Macros.begin(),
2753  IEnd = getPreprocessorOpts().Macros.end();
2754  I != IEnd; ++I) {
2755  // If we're supposed to ignore this macro for the purposes of modules,
2756  // don't put it into the hash.
2757  if (!hsOpts.ModulesIgnoreMacros.empty()) {
2758  // Check whether we're ignoring this macro.
2759  StringRef MacroDef = I->first;
2760  if (hsOpts.ModulesIgnoreMacros.count(
2761  llvm::CachedHashString(MacroDef.split('=').first)))
2762  continue;
2763  }
2764 
2765  code = hash_combine(code, I->first, I->second);
2766  }
2767 
2768  // Extend the signature with the sysroot and other header search options.
2769  code = hash_combine(code, hsOpts.Sysroot,
2770  hsOpts.ModuleFormat,
2771  hsOpts.UseDebugInfo,
2772  hsOpts.UseBuiltinIncludes,
2774  hsOpts.UseStandardCXXIncludes,
2775  hsOpts.UseLibcxx,
2777  code = hash_combine(code, hsOpts.ResourceDir);
2778 
2779  // Extend the signature with the user build path.
2780  code = hash_combine(code, hsOpts.ModuleUserBuildPath);
2781 
2782  // Extend the signature with the module file extensions.
2783  const FrontendOptions &frontendOpts = getFrontendOpts();
2784  for (const auto &ext : frontendOpts.ModuleFileExtensions) {
2785  code = ext->hashExtension(code);
2786  }
2787 
2788  // Extend the signature with the enabled sanitizers, if at least one is
2789  // enabled. Sanitizers which cannot affect AST generation aren't hashed.
2790  SanitizerSet SanHash = LangOpts->Sanitize;
2791  SanHash.clear(getPPTransparentSanitizers());
2792  if (!SanHash.empty())
2793  code = hash_combine(code, SanHash.Mask);
2794 
2795  return llvm::APInt(64, code).toString(36, /*Signed=*/false);
2796 }
2797 
2798 namespace clang {
2799 
2800 template<typename IntTy>
2801 static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id,
2802  IntTy Default,
2803  DiagnosticsEngine *Diags) {
2804  IntTy Res = Default;
2805  if (Arg *A = Args.getLastArg(Id)) {
2806  if (StringRef(A->getValue()).getAsInteger(10, Res)) {
2807  if (Diags)
2808  Diags->Report(diag::err_drv_invalid_int_value) << A->getAsString(Args)
2809  << A->getValue();
2810  }
2811  }
2812  return Res;
2813 }
2814 
2815 
2816 // Declared in clang/Frontend/Utils.h.
2817 int getLastArgIntValue(const ArgList &Args, OptSpecifier Id, int Default,
2818  DiagnosticsEngine *Diags) {
2819  return getLastArgIntValueImpl<int>(Args, Id, Default, Diags);
2820 }
2821 
2822 uint64_t getLastArgUInt64Value(const ArgList &Args, OptSpecifier Id,
2823  uint64_t Default,
2824  DiagnosticsEngine *Diags) {
2825  return getLastArgIntValueImpl<uint64_t>(Args, Id, Default, Diags);
2826 }
2827 
2828 void BuryPointer(const void *Ptr) {
2829  // This function may be called only a small fixed amount of times per each
2830  // invocation, otherwise we do actually have a leak which we want to report.
2831  // If this function is called more than kGraveYardMaxSize times, the pointers
2832  // will not be properly buried and a leak detector will report a leak, which
2833  // is what we want in such case.
2834  static const size_t kGraveYardMaxSize = 16;
2835  LLVM_ATTRIBUTE_UNUSED static const void *GraveYard[kGraveYardMaxSize];
2836  static std::atomic<unsigned> GraveYardSize;
2837  unsigned Idx = GraveYardSize++;
2838  if (Idx >= kGraveYardMaxSize)
2839  return;
2840  GraveYard[Idx] = Ptr;
2841 }
2842 
2845  DiagnosticsEngine &Diags) {
2847 }
2848 
2851  DiagnosticsEngine &Diags,
2853  if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
2854  return BaseFS;
2855 
2857  new vfs::OverlayFileSystem(BaseFS));
2858  // earlier vfs files are on the bottom
2859  for (const std::string &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
2860  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
2861  BaseFS->getBufferForFile(File);
2862  if (!Buffer) {
2863  Diags.Report(diag::err_missing_vfs_overlay_file) << File;
2865  }
2866 
2868  std::move(Buffer.get()), /*DiagHandler*/ nullptr, File);
2869  if (!FS.get()) {
2870  Diags.Report(diag::err_invalid_vfs_overlay) << File;
2872  }
2873  Overlay->pushOverlay(FS);
2874  }
2875  return Overlay;
2876 }
2877 } // 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)
annotate property with NS_RETURNS_INNER_POINTER
unsigned InlineMaxStackDepth
The inlining stack depth limit.
Paths for '#include <>' added by '-I'.
std::string ModuleDependencyOutputDir
The directory to copy module dependencies to when collecting them.
Conform to the underlying platform'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.
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 SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
Definition: Sanitizers.h:83
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:100
Like System, but headers are implicitly wrapped in extern "C".
DependencyOutputOptions & getDependencyOutputOpts()
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' 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:41
static bool isBuiltinFunc(const char *Name)
Returns true if this is a libc/libm function without the '__builtin_' prefix.
Definition: Builtins.cpp:51
Enable annotation of ObjCMethods of all kinds.
bool isGNUMode() const
isGNUMode - Language includes GNU extensions.
Definition: LangStandard.h:93
unsigned IncludeModuleFiles
Include module file dependencies.
Parse ASTs and print them.
Enable migration to modern ObjC readonly property.
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.
Optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
Definition: VersionTuple.h:77
Enable migration to modern ObjC readwrite property.
unsigned visualizeExplodedGraphWithGraphViz
Language getLanguage() const
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
Show all overloads.
Like System, but only used for ObjC++.
std::unique_ptr< llvm::MemoryBuffer > Buffer
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1205
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.
bool allowsWeak() const
Does this runtime allow the use of __weak?
Definition: ObjCRuntime.h:192
#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN)
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 > RewriteMapFiles
Set of files defining the rules for the symbol rewriting.
bool hasLineComments() const
Language supports '//' comments.
Definition: LangStandard.h:65
Options for controlling comment parsing.
static const LangStandard & getLangStandardForKind(Kind K)
std::string ASTDumpFilter
If given, filter dumped AST Decl nodes by this substring.
const char * getDescription() const
getDescription - Get the description of this standard.
Definition: LangStandard.h:59
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
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...
InputKind::Language getLanguage() const
Get the language that this standard describes.
Definition: LangStandard.h:62
void AddPath(StringRef Path, frontend::IncludeDirGroup Group, bool IsFramework, bool IgnoreSysRoot)
AddPath - Add the Path path to the specified Group list.
bool allowsARC() const
Does this runtime allow ARC at all?
Definition: ObjCRuntime.h:140
void addRemappedFile(StringRef From, StringRef To)
std::string FixItSuffix
If given, the new suffix for fix-it rewritten files.
Enable migration to modern ObjC literals.
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'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 > Reciprocals
Definition: TargetOptions.h:57
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)
'macosx-fragile' 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:109
std::string FPMath
If given, the unit to use for floating point math.
Definition: TargetOptions.h:39
bool isCPlusPlus11() const
isCPlusPlus11 - Language is a C++11 variant (or later).
Definition: LangStandard.h:77
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.
bool isCPlusPlus() const
isCPlusPlus - Language is a C++ variant.
Definition: LangStandard.h:74
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 NS_ENUM/NS_OPTIONS macros.
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:71
unsigned DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
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...
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
unsigned IncludeCodePatterns
Show code patterns in code completion results.
Enable migration to modern ObjC property.
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()
unsigned ShowStats
Show frontend performance metrics and statistics.
Enable migration to add conforming protocols.
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.
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.).
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.
detail::InMemoryDirectory::const_iterator I
bool DisablePCHValidation
When true, disables most of the normal validation performed on precompiled headers.
static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName)
bool isObjectiveC() const
Is the language of the input some dialect of Objective-C?
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 'requires' decls in addition to the hard-coded list in ...
Definition: LangOptions.h:136
PreprocessorOutputOptions & getPreprocessorOutputOpts()
std::string ThreadModel
The thread model to use.
FrontendOptions & getFrontendOpts()
std::vector< std::string > DependentLibraries
A list of dependent libraries.
static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id, IntTy Default, DiagnosticsEngine *Diags)
Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
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:130
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.
const char * getName() const
getName - Get the name of this standard.
Definition: LangStandard.h:56
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.
bool isCPlusPlus14() const
isCPlusPlus14 - Language is a C++14 variant (or later).
Definition: LangStandard.h:80
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...
unsigned UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
AnalysisInliningMode InliningMode
The mode of function selection used during inlining.
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:139
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 isOpenCL() const
isOpenCL - Language is a OpenCL variant.
Definition: LangStandard.h:102
bool hasDigraphs() const
hasDigraphs - Language supports digraphs.
Definition: LangStandard.h:90
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).
bool isCPlusPlus2a() const
isCPlusPlus2a - Language is a post-C++17 variant (or later).
Definition: LangStandard.h:86
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:150
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...
prefer 'atomic' property over 'nonatomic'.
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.
bool isCPlusPlus1z() const
isCPlusPlus1z - Language is a C++17 variant (or later).
Definition: LangStandard.h:83
Defines version macros and version-related utility functions for Clang.
std::string RelocationModel
The name of the relocation model to use.
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.
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.
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:116
static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, frontend::ActionKind Action)
bool empty() const
Returns true if at least one sanitizer is enabled.
Definition: Sanitizers.h:68
unsigned FixOnlyWarnings
Apply fixes only for warnings.
unsigned ModulesValidateOncePerBuildSession
If true, skip verifying input files used by modules if the module was already verified during this bu...
bool hasImplicitInt() const
hasImplicitInt - Language allows variables to be typed as int implicitly.
Definition: LangStandard.h:99
InputKind withFormat(Format F) const
static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, OptSpecifier GroupWithValue, std::vector< std::string > &Diagnostics)
std::string AuxTriple
Auxiliary triple for CUDA compilation.
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
unsigned ShowIncludeDirectives
Print includes, imports etc. within preprocessed output.
enum clang::FrontendOptions::@166 ARCMTAction
bool isC99() const
isC99 - Language is a superset of C99.
Definition: LangStandard.h:68
Enable migration to modern ObjC subscripting.
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.
bool isC11() const
isC11 - Language is a superset of C11.
Definition: LangStandard.h:71
AnalysisStores AnalysisStoreOpt
Encodes a location in the source.
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
Generate machine code, but don'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.
Enable converting setter/getter expressions to property-dot syntx.
Limit generated debug info to reduce size (-fno-standalone-debug).
Options for controlling the compiler diagnostics engine.
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
std::vector< FrontendInputFile > Inputs
The input files and their types.
unsigned ModulesValidateSystemHeaders
Whether to validate system input files when a module is loaded.
AnalyzerOptionsRef getAnalyzerOpts() const
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'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:64
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.
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
unsigned getMajor() const
Retrieve the major version number.
Definition: VersionTuple.h:74
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.
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
'#include ""' paths, added by 'gcc -iquote'.
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...
use NS_NONATOMIC_IOSONLY for property 'atomic' attribute
unsigned FixToTemporaries
Apply fixes to temporary files.
building frameworks.
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.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
DependencyOutputFormat OutputFormat
The format for the dependency file.
unsigned UseDebugInfo
Whether the module includes debug information (-gmodules).
uint64_t SanitizerMask
Definition: Sanitizers.h:24
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
Definition: LangOptions.h:124
bool tryParse(StringRef string)
Try to parse the given string as a version number.
StringRef Name
Definition: USRFinder.cpp:123
static ParsedSourceLocation FromString(StringRef Str)
Construct a parsed source location from a string; the Filename is empty on error. ...
PreprocessorOptions & getPreprocessorOpts()
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:146
std::string ARCMTMigrateReportOut
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.
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
AnalysisConstraints AnalysisConstraintsOpt
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action)
Helper class for holding the data necessary to invoke the compiler.
DiagnosticOptions & getDiagnosticOpts() const
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 'make' problems.
std::string AnalyzeSpecificFunction
detail::InMemoryDirectory::const_iterator E
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i...
Definition: LangOptions.h:154
FrontendOptions - Options for controlling the behavior of the frontend.
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,.
Format getFormat() const
std::string StatsFile
Filename to write statistics to.
void BuryPointer(const void *Ptr)
Parse ASTs and dump them.
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.
static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, FileManager &FileMgr, DiagnosticsEngine &Diags, frontend::ActionKind Action)
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:50
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)
std::vector< std::string > AddPluginActions
The list of plugin actions to run in addition to the normal action.
Optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.
Definition: VersionTuple.h:84
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:13074
Kind getKind() const
Definition: ObjCRuntime.h:75
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:114
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:142
InputKind getPreprocessed() const
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.
FileSystemOptions & getFileSystemOpts()
static unsigned getOptimizationLevelSize(ArgList &Args)
Run one or more source code analyses.
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'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.
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 'home directory' 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:104
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.
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:118
#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC)
unsigned IncludeMacros
Show macros in code completion results.
AnalysisPurgeMode AnalysisPurgeOpt
Enable migration of ObjC methods to 'instancetype'.
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.
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 ModuleFormat
The module/pch container format.
static void parseSanitizerKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S)
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 hasHexFloats() const
hasHexFloats - Language supports hexadecimal float constants.
Definition: LangStandard.h:96
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.