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