xref: /llvm-project/clang/lib/Frontend/CompilerInvocation.cpp (revision 10658691951f7e3ffd257f24e29e81a101daa204)
1 //===- CompilerInvocation.cpp ---------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/Frontend/CompilerInvocation.h"
10 #include "TestModuleFileExtension.h"
11 #include "clang/Basic/Builtins.h"
12 #include "clang/Basic/CharInfo.h"
13 #include "clang/Basic/CodeGenOptions.h"
14 #include "clang/Basic/CommentOptions.h"
15 #include "clang/Basic/DebugInfoOptions.h"
16 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Basic/DiagnosticOptions.h"
18 #include "clang/Basic/FileSystemOptions.h"
19 #include "clang/Basic/LLVM.h"
20 #include "clang/Basic/LangOptions.h"
21 #include "clang/Basic/LangStandard.h"
22 #include "clang/Basic/ObjCRuntime.h"
23 #include "clang/Basic/Sanitizers.h"
24 #include "clang/Basic/SourceLocation.h"
25 #include "clang/Basic/TargetOptions.h"
26 #include "clang/Basic/Version.h"
27 #include "clang/Basic/Visibility.h"
28 #include "clang/Basic/XRayInstr.h"
29 #include "clang/Config/config.h"
30 #include "clang/Driver/Driver.h"
31 #include "clang/Driver/DriverDiagnostic.h"
32 #include "clang/Driver/Options.h"
33 #include "clang/Frontend/CommandLineSourceLoc.h"
34 #include "clang/Frontend/DependencyOutputOptions.h"
35 #include "clang/Frontend/FrontendDiagnostic.h"
36 #include "clang/Frontend/FrontendOptions.h"
37 #include "clang/Frontend/FrontendPluginRegistry.h"
38 #include "clang/Frontend/MigratorOptions.h"
39 #include "clang/Frontend/PreprocessorOutputOptions.h"
40 #include "clang/Frontend/Utils.h"
41 #include "clang/Lex/HeaderSearchOptions.h"
42 #include "clang/Lex/PreprocessorOptions.h"
43 #include "clang/Sema/CodeCompleteOptions.h"
44 #include "clang/Serialization/ASTBitCodes.h"
45 #include "clang/Serialization/ModuleFileExtension.h"
46 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
47 #include "llvm/ADT/APInt.h"
48 #include "llvm/ADT/ArrayRef.h"
49 #include "llvm/ADT/CachedHashString.h"
50 #include "llvm/ADT/FloatingPointMode.h"
51 #include "llvm/ADT/Hashing.h"
52 #include "llvm/ADT/None.h"
53 #include "llvm/ADT/Optional.h"
54 #include "llvm/ADT/SmallString.h"
55 #include "llvm/ADT/SmallVector.h"
56 #include "llvm/ADT/StringRef.h"
57 #include "llvm/ADT/StringSwitch.h"
58 #include "llvm/ADT/Triple.h"
59 #include "llvm/ADT/Twine.h"
60 #include "llvm/IR/DebugInfoMetadata.h"
61 #include "llvm/Linker/Linker.h"
62 #include "llvm/MC/MCTargetOptions.h"
63 #include "llvm/Option/Arg.h"
64 #include "llvm/Option/ArgList.h"
65 #include "llvm/Option/OptSpecifier.h"
66 #include "llvm/Option/OptTable.h"
67 #include "llvm/Option/Option.h"
68 #include "llvm/ProfileData/InstrProfReader.h"
69 #include "llvm/Support/CodeGen.h"
70 #include "llvm/Support/Compiler.h"
71 #include "llvm/Support/Error.h"
72 #include "llvm/Support/ErrorHandling.h"
73 #include "llvm/Support/ErrorOr.h"
74 #include "llvm/Support/FileSystem.h"
75 #include "llvm/Support/Host.h"
76 #include "llvm/Support/MathExtras.h"
77 #include "llvm/Support/MemoryBuffer.h"
78 #include "llvm/Support/Path.h"
79 #include "llvm/Support/Process.h"
80 #include "llvm/Support/Regex.h"
81 #include "llvm/Support/VersionTuple.h"
82 #include "llvm/Support/VirtualFileSystem.h"
83 #include "llvm/Support/raw_ostream.h"
84 #include "llvm/Target/TargetOptions.h"
85 #include <algorithm>
86 #include <atomic>
87 #include <cassert>
88 #include <cstddef>
89 #include <cstring>
90 #include <memory>
91 #include <string>
92 #include <tuple>
93 #include <utility>
94 #include <vector>
95 
96 using namespace clang;
97 using namespace driver;
98 using namespace options;
99 using namespace llvm::opt;
100 
101 //===----------------------------------------------------------------------===//
102 // Initialization.
103 //===----------------------------------------------------------------------===//
104 
105 CompilerInvocationBase::CompilerInvocationBase()
106     : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
107       DiagnosticOpts(new DiagnosticOptions()),
108       HeaderSearchOpts(new HeaderSearchOptions()),
109       PreprocessorOpts(new PreprocessorOptions()) {}
110 
111 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X)
112     : LangOpts(new LangOptions(*X.getLangOpts())),
113       TargetOpts(new TargetOptions(X.getTargetOpts())),
114       DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
115       HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
116       PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {}
117 
118 CompilerInvocationBase::~CompilerInvocationBase() = default;
119 
120 //===----------------------------------------------------------------------===//
121 // Deserialization (from args)
122 //===----------------------------------------------------------------------===//
123 
124 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
125                                      DiagnosticsEngine &Diags) {
126   unsigned DefaultOpt = llvm::CodeGenOpt::None;
127   if (IK.getLanguage() == Language::OpenCL && !Args.hasArg(OPT_cl_opt_disable))
128     DefaultOpt = llvm::CodeGenOpt::Default;
129 
130   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
131     if (A->getOption().matches(options::OPT_O0))
132       return llvm::CodeGenOpt::None;
133 
134     if (A->getOption().matches(options::OPT_Ofast))
135       return llvm::CodeGenOpt::Aggressive;
136 
137     assert(A->getOption().matches(options::OPT_O));
138 
139     StringRef S(A->getValue());
140     if (S == "s" || S == "z" || S.empty())
141       return llvm::CodeGenOpt::Default;
142 
143     if (S == "g")
144       return llvm::CodeGenOpt::Less;
145 
146     return getLastArgIntValue(Args, OPT_O, DefaultOpt, Diags);
147   }
148 
149   return DefaultOpt;
150 }
151 
152 static unsigned getOptimizationLevelSize(ArgList &Args) {
153   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
154     if (A->getOption().matches(options::OPT_O)) {
155       switch (A->getValue()[0]) {
156       default:
157         return 0;
158       case 's':
159         return 1;
160       case 'z':
161         return 2;
162       }
163     }
164   }
165   return 0;
166 }
167 
168 static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
169                               OptSpecifier GroupWithValue,
170                               std::vector<std::string> &Diagnostics) {
171   for (auto *A : Args.filtered(Group)) {
172     if (A->getOption().getKind() == Option::FlagClass) {
173       // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
174       // its name (minus the "W" or "R" at the beginning) to the warning list.
175       Diagnostics.push_back(
176           std::string(A->getOption().getName().drop_front(1)));
177     } else if (A->getOption().matches(GroupWithValue)) {
178       // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group.
179       Diagnostics.push_back(
180           std::string(A->getOption().getName().drop_front(1).rtrim("=-")));
181     } else {
182       // Otherwise, add its value (for OPT_W_Joined and similar).
183       for (const auto *Arg : A->getValues())
184         Diagnostics.emplace_back(Arg);
185     }
186   }
187 }
188 
189 // Parse the Static Analyzer configuration. If \p Diags is set to nullptr,
190 // it won't verify the input.
191 static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,
192                                  DiagnosticsEngine *Diags);
193 
194 static void getAllNoBuiltinFuncValues(ArgList &Args,
195                                       std::vector<std::string> &Funcs) {
196   SmallVector<const char *, 8> Values;
197   for (const auto &Arg : Args) {
198     const Option &O = Arg->getOption();
199     if (O.matches(options::OPT_fno_builtin_)) {
200       const char *FuncName = Arg->getValue();
201       if (Builtin::Context::isBuiltinFunc(FuncName))
202         Values.push_back(FuncName);
203     }
204   }
205   Funcs.insert(Funcs.end(), Values.begin(), Values.end());
206 }
207 
208 static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
209                               DiagnosticsEngine &Diags) {
210   bool Success = true;
211   if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
212     StringRef Name = A->getValue();
213     AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
214 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
215       .Case(CMDFLAG, NAME##Model)
216 #include "clang/StaticAnalyzer/Core/Analyses.def"
217       .Default(NumStores);
218     if (Value == NumStores) {
219       Diags.Report(diag::err_drv_invalid_value)
220         << A->getAsString(Args) << Name;
221       Success = false;
222     } else {
223       Opts.AnalysisStoreOpt = Value;
224     }
225   }
226 
227   if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
228     StringRef Name = A->getValue();
229     AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
230 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
231       .Case(CMDFLAG, NAME##Model)
232 #include "clang/StaticAnalyzer/Core/Analyses.def"
233       .Default(NumConstraints);
234     if (Value == NumConstraints) {
235       Diags.Report(diag::err_drv_invalid_value)
236         << A->getAsString(Args) << Name;
237       Success = false;
238     } else {
239       Opts.AnalysisConstraintsOpt = Value;
240     }
241   }
242 
243   if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
244     StringRef Name = A->getValue();
245     AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
246 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
247       .Case(CMDFLAG, PD_##NAME)
248 #include "clang/StaticAnalyzer/Core/Analyses.def"
249       .Default(NUM_ANALYSIS_DIAG_CLIENTS);
250     if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
251       Diags.Report(diag::err_drv_invalid_value)
252         << A->getAsString(Args) << Name;
253       Success = false;
254     } else {
255       Opts.AnalysisDiagOpt = Value;
256     }
257   }
258 
259   if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
260     StringRef Name = A->getValue();
261     AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
262 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
263       .Case(CMDFLAG, NAME)
264 #include "clang/StaticAnalyzer/Core/Analyses.def"
265       .Default(NumPurgeModes);
266     if (Value == NumPurgeModes) {
267       Diags.Report(diag::err_drv_invalid_value)
268         << A->getAsString(Args) << Name;
269       Success = false;
270     } else {
271       Opts.AnalysisPurgeOpt = Value;
272     }
273   }
274 
275   if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
276     StringRef Name = A->getValue();
277     AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name)
278 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
279       .Case(CMDFLAG, NAME)
280 #include "clang/StaticAnalyzer/Core/Analyses.def"
281       .Default(NumInliningModes);
282     if (Value == NumInliningModes) {
283       Diags.Report(diag::err_drv_invalid_value)
284         << A->getAsString(Args) << Name;
285       Success = false;
286     } else {
287       Opts.InliningMode = Value;
288     }
289   }
290 
291   Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
292   Opts.ShowCheckerHelpAlpha = Args.hasArg(OPT_analyzer_checker_help_alpha);
293   Opts.ShowCheckerHelpDeveloper =
294       Args.hasArg(OPT_analyzer_checker_help_developer);
295 
296   Opts.ShowCheckerOptionList = Args.hasArg(OPT_analyzer_checker_option_help);
297   Opts.ShowCheckerOptionAlphaList =
298       Args.hasArg(OPT_analyzer_checker_option_help_alpha);
299   Opts.ShowCheckerOptionDeveloperList =
300       Args.hasArg(OPT_analyzer_checker_option_help_developer);
301 
302   Opts.ShowConfigOptionsList = Args.hasArg(OPT_analyzer_config_help);
303   Opts.ShowEnabledCheckerList = Args.hasArg(OPT_analyzer_list_enabled_checkers);
304   Opts.ShouldEmitErrorsOnInvalidConfigValue =
305       /* negated */!llvm::StringSwitch<bool>(
306                    Args.getLastArgValue(OPT_analyzer_config_compatibility_mode))
307         .Case("true", true)
308         .Case("false", false)
309         .Default(false);
310   Opts.DisableAllCheckers = Args.hasArg(OPT_analyzer_disable_all_checks);
311 
312   Opts.visualizeExplodedGraphWithGraphViz =
313     Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
314   Opts.DumpExplodedGraphTo =
315       std::string(Args.getLastArgValue(OPT_analyzer_dump_egraph));
316   Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted);
317   Opts.AnalyzerWerror = Args.hasArg(OPT_analyzer_werror);
318   Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
319   Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
320   Opts.AnalyzeNestedBlocks =
321     Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
322   Opts.AnalyzeSpecificFunction =
323       std::string(Args.getLastArgValue(OPT_analyze_function));
324   Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
325   Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
326   Opts.maxBlockVisitOnPath =
327       getLastArgIntValue(Args, OPT_analyzer_max_loop, 4, Diags);
328   Opts.PrintStats = Args.hasArg(OPT_analyzer_stats);
329   Opts.InlineMaxStackDepth =
330       getLastArgIntValue(Args, OPT_analyzer_inline_max_stack_depth,
331                          Opts.InlineMaxStackDepth, Diags);
332 
333   Opts.CheckersAndPackages.clear();
334   for (const Arg *A :
335        Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
336     A->claim();
337     bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
338     // We can have a list of comma separated checker names, e.g:
339     // '-analyzer-checker=cocoa,unix'
340     StringRef CheckerAndPackageList = A->getValue();
341     SmallVector<StringRef, 16> CheckersAndPackages;
342     CheckerAndPackageList.split(CheckersAndPackages, ",");
343     for (const StringRef &CheckerOrPackage : CheckersAndPackages)
344       Opts.CheckersAndPackages.emplace_back(std::string(CheckerOrPackage),
345                                             IsEnabled);
346   }
347 
348   // Go through the analyzer configuration options.
349   for (const auto *A : Args.filtered(OPT_analyzer_config)) {
350 
351     // We can have a list of comma separated config names, e.g:
352     // '-analyzer-config key1=val1,key2=val2'
353     StringRef configList = A->getValue();
354     SmallVector<StringRef, 4> configVals;
355     configList.split(configVals, ",");
356     for (const auto &configVal : configVals) {
357       StringRef key, val;
358       std::tie(key, val) = configVal.split("=");
359       if (val.empty()) {
360         Diags.Report(SourceLocation(),
361                      diag::err_analyzer_config_no_value) << configVal;
362         Success = false;
363         break;
364       }
365       if (val.find('=') != StringRef::npos) {
366         Diags.Report(SourceLocation(),
367                      diag::err_analyzer_config_multiple_values)
368           << configVal;
369         Success = false;
370         break;
371       }
372 
373       // TODO: Check checker options too, possibly in CheckerRegistry.
374       // Leave unknown non-checker configs unclaimed.
375       if (!key.contains(":") && Opts.isUnknownAnalyzerConfig(key)) {
376         if (Opts.ShouldEmitErrorsOnInvalidConfigValue)
377           Diags.Report(diag::err_analyzer_config_unknown) << key;
378         continue;
379       }
380 
381       A->claim();
382       Opts.Config[key] = std::string(val);
383     }
384   }
385 
386   if (Opts.ShouldEmitErrorsOnInvalidConfigValue)
387     parseAnalyzerConfigs(Opts, &Diags);
388   else
389     parseAnalyzerConfigs(Opts, nullptr);
390 
391   llvm::raw_string_ostream os(Opts.FullCompilerInvocation);
392   for (unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
393     if (i != 0)
394       os << " ";
395     os << Args.getArgString(i);
396   }
397   os.flush();
398 
399   return Success;
400 }
401 
402 static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config,
403                                  StringRef OptionName, StringRef DefaultVal) {
404   return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
405 }
406 
407 static void initOption(AnalyzerOptions::ConfigTable &Config,
408                        DiagnosticsEngine *Diags,
409                        StringRef &OptionField, StringRef Name,
410                        StringRef DefaultVal) {
411   // String options may be known to invalid (e.g. if the expected string is a
412   // file name, but the file does not exist), those will have to be checked in
413   // parseConfigs.
414   OptionField = getStringOption(Config, Name, DefaultVal);
415 }
416 
417 static void initOption(AnalyzerOptions::ConfigTable &Config,
418                        DiagnosticsEngine *Diags,
419                        bool &OptionField, StringRef Name, bool DefaultVal) {
420   auto PossiblyInvalidVal = llvm::StringSwitch<Optional<bool>>(
421                  getStringOption(Config, Name, (DefaultVal ? "true" : "false")))
422       .Case("true", true)
423       .Case("false", false)
424       .Default(None);
425 
426   if (!PossiblyInvalidVal) {
427     if (Diags)
428       Diags->Report(diag::err_analyzer_config_invalid_input)
429         << Name << "a boolean";
430     else
431       OptionField = DefaultVal;
432   } else
433     OptionField = PossiblyInvalidVal.getValue();
434 }
435 
436 static void initOption(AnalyzerOptions::ConfigTable &Config,
437                        DiagnosticsEngine *Diags,
438                        unsigned &OptionField, StringRef Name,
439                        unsigned DefaultVal) {
440 
441   OptionField = DefaultVal;
442   bool HasFailed = getStringOption(Config, Name, std::to_string(DefaultVal))
443                      .getAsInteger(0, OptionField);
444   if (Diags && HasFailed)
445     Diags->Report(diag::err_analyzer_config_invalid_input)
446       << Name << "an unsigned";
447 }
448 
449 static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,
450                                  DiagnosticsEngine *Diags) {
451   // TODO: There's no need to store the entire configtable, it'd be plenty
452   // enough tostore checker options.
453 
454 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
455   initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
456 
457 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
458                                            SHALLOW_VAL, DEEP_VAL)              \
459   switch (AnOpts.getUserMode()) {                                              \
460   case UMK_Shallow:                                                            \
461     initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, SHALLOW_VAL);       \
462     break;                                                                     \
463   case UMK_Deep:                                                               \
464     initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEEP_VAL);          \
465     break;                                                                     \
466   }                                                                            \
467 
468 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
469 #undef ANALYZER_OPTION
470 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
471 
472   // At this point, AnalyzerOptions is configured. Let's validate some options.
473 
474   // FIXME: Here we try to validate the silenced checkers or packages are valid.
475   // The current approach only validates the registered checkers which does not
476   // contain the runtime enabled checkers and optimally we would validate both.
477   if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
478     std::vector<StringRef> Checkers =
479         AnOpts.getRegisteredCheckers(/*IncludeExperimental=*/true);
480     std::vector<StringRef> Packages =
481         AnOpts.getRegisteredPackages(/*IncludeExperimental=*/true);
482 
483     SmallVector<StringRef, 16> CheckersAndPackages;
484     AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages, ";");
485 
486     for (const StringRef &CheckerOrPackage : CheckersAndPackages) {
487       if (Diags) {
488         bool IsChecker = CheckerOrPackage.contains('.');
489         bool IsValidName =
490             IsChecker
491                 ? llvm::find(Checkers, CheckerOrPackage) != Checkers.end()
492                 : llvm::find(Packages, CheckerOrPackage) != Packages.end();
493 
494         if (!IsValidName)
495           Diags->Report(diag::err_unknown_analyzer_checker_or_package)
496               << CheckerOrPackage;
497       }
498 
499       AnOpts.SilencedCheckersAndPackages.emplace_back(CheckerOrPackage);
500     }
501   }
502 
503   if (!Diags)
504     return;
505 
506   if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
507     Diags->Report(diag::err_analyzer_config_invalid_input)
508         << "track-conditions-debug" << "'track-conditions' to also be enabled";
509 
510   if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
511     Diags->Report(diag::err_analyzer_config_invalid_input) << "ctu-dir"
512                                                            << "a filename";
513 
514   if (!AnOpts.ModelPath.empty() &&
515       !llvm::sys::fs::is_directory(AnOpts.ModelPath))
516     Diags->Report(diag::err_analyzer_config_invalid_input) << "model-path"
517                                                            << "a filename";
518 }
519 
520 static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args) {
521   Opts.NoNSAllocReallocError = Args.hasArg(OPT_migrator_no_nsalloc_error);
522   Opts.NoFinalizeRemoval = Args.hasArg(OPT_migrator_no_finalize_removal);
523   return true;
524 }
525 
526 static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args) {
527   Opts.BlockCommandNames = Args.getAllArgValues(OPT_fcomment_block_commands);
528   Opts.ParseAllComments = Args.hasArg(OPT_fparse_all_comments);
529 }
530 
531 static llvm::Reloc::Model getRelocModel(ArgList &Args,
532                                         DiagnosticsEngine &Diags) {
533   if (Arg *A = Args.getLastArg(OPT_mrelocation_model)) {
534     StringRef Value = A->getValue();
535     auto RM = llvm::StringSwitch<llvm::Optional<llvm::Reloc::Model>>(Value)
536                   .Case("static", llvm::Reloc::Static)
537                   .Case("pic", llvm::Reloc::PIC_)
538                   .Case("ropi", llvm::Reloc::ROPI)
539                   .Case("rwpi", llvm::Reloc::RWPI)
540                   .Case("ropi-rwpi", llvm::Reloc::ROPI_RWPI)
541                   .Case("dynamic-no-pic", llvm::Reloc::DynamicNoPIC)
542                   .Default(None);
543     if (RM.hasValue())
544       return *RM;
545     Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
546   }
547   return llvm::Reloc::PIC_;
548 }
549 
550 /// Create a new Regex instance out of the string value in \p RpassArg.
551 /// It returns a pointer to the newly generated Regex instance.
552 static std::shared_ptr<llvm::Regex>
553 GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args,
554                                 Arg *RpassArg) {
555   StringRef Val = RpassArg->getValue();
556   std::string RegexError;
557   std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val);
558   if (!Pattern->isValid(RegexError)) {
559     Diags.Report(diag::err_drv_optimization_remark_pattern)
560         << RegexError << RpassArg->getAsString(Args);
561     Pattern.reset();
562   }
563   return Pattern;
564 }
565 
566 static bool parseDiagnosticLevelMask(StringRef FlagName,
567                                      const std::vector<std::string> &Levels,
568                                      DiagnosticsEngine *Diags,
569                                      DiagnosticLevelMask &M) {
570   bool Success = true;
571   for (const auto &Level : Levels) {
572     DiagnosticLevelMask const PM =
573       llvm::StringSwitch<DiagnosticLevelMask>(Level)
574         .Case("note",    DiagnosticLevelMask::Note)
575         .Case("remark",  DiagnosticLevelMask::Remark)
576         .Case("warning", DiagnosticLevelMask::Warning)
577         .Case("error",   DiagnosticLevelMask::Error)
578         .Default(DiagnosticLevelMask::None);
579     if (PM == DiagnosticLevelMask::None) {
580       Success = false;
581       if (Diags)
582         Diags->Report(diag::err_drv_invalid_value) << FlagName << Level;
583     }
584     M = M | PM;
585   }
586   return Success;
587 }
588 
589 static void parseSanitizerKinds(StringRef FlagName,
590                                 const std::vector<std::string> &Sanitizers,
591                                 DiagnosticsEngine &Diags, SanitizerSet &S) {
592   for (const auto &Sanitizer : Sanitizers) {
593     SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
594     if (K == SanitizerMask())
595       Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
596     else
597       S.set(K, true);
598   }
599 }
600 
601 static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle,
602                                            ArgList &Args, DiagnosticsEngine &D,
603                                            XRayInstrSet &S) {
604   llvm::SmallVector<StringRef, 2> BundleParts;
605   llvm::SplitString(Bundle, BundleParts, ",");
606   for (const auto &B : BundleParts) {
607     auto Mask = parseXRayInstrValue(B);
608     if (Mask == XRayInstrKind::None)
609       if (B != "none")
610         D.Report(diag::err_drv_invalid_value) << FlagName << Bundle;
611       else
612         S.Mask = Mask;
613     else if (Mask == XRayInstrKind::All)
614       S.Mask = Mask;
615     else
616       S.set(Mask, true);
617   }
618 }
619 
620 // Set the profile kind for fprofile-instrument.
621 static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args,
622                                DiagnosticsEngine &Diags) {
623   Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ);
624   if (A == nullptr)
625     return;
626   StringRef S = A->getValue();
627   unsigned I = llvm::StringSwitch<unsigned>(S)
628                    .Case("none", CodeGenOptions::ProfileNone)
629                    .Case("clang", CodeGenOptions::ProfileClangInstr)
630                    .Case("llvm", CodeGenOptions::ProfileIRInstr)
631                    .Case("csllvm", CodeGenOptions::ProfileCSIRInstr)
632                    .Default(~0U);
633   if (I == ~0U) {
634     Diags.Report(diag::err_drv_invalid_pgo_instrumentor) << A->getAsString(Args)
635                                                          << S;
636     return;
637   }
638   auto Instrumentor = static_cast<CodeGenOptions::ProfileInstrKind>(I);
639   Opts.setProfileInstr(Instrumentor);
640 }
641 
642 // Set the profile kind using fprofile-instrument-use-path.
643 static void setPGOUseInstrumentor(CodeGenOptions &Opts,
644                                   const Twine &ProfileName) {
645   auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName);
646   // In error, return silently and let Clang PGOUse report the error message.
647   if (auto E = ReaderOrErr.takeError()) {
648     llvm::consumeError(std::move(E));
649     Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
650     return;
651   }
652   std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
653     std::move(ReaderOrErr.get());
654   if (PGOReader->isIRLevelProfile()) {
655     if (PGOReader->hasCSIRLevelProfile())
656       Opts.setProfileUse(CodeGenOptions::ProfileCSIRInstr);
657     else
658       Opts.setProfileUse(CodeGenOptions::ProfileIRInstr);
659   } else
660     Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
661 }
662 
663 static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
664                              DiagnosticsEngine &Diags,
665                              const TargetOptions &TargetOpts,
666                              const FrontendOptions &FrontendOpts) {
667   bool Success = true;
668   llvm::Triple Triple = llvm::Triple(TargetOpts.Triple);
669 
670   unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
671   // TODO: This could be done in Driver
672   unsigned MaxOptLevel = 3;
673   if (OptimizationLevel > MaxOptLevel) {
674     // If the optimization level is not supported, fall back on the default
675     // optimization
676     Diags.Report(diag::warn_drv_optimization_value)
677         << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel;
678     OptimizationLevel = MaxOptLevel;
679   }
680   Opts.OptimizationLevel = OptimizationLevel;
681 
682   // At O0 we want to fully disable inlining outside of cases marked with
683   // 'alwaysinline' that are required for correctness.
684   Opts.setInlining((Opts.OptimizationLevel == 0)
685                        ? CodeGenOptions::OnlyAlwaysInlining
686                        : CodeGenOptions::NormalInlining);
687   // Explicit inlining flags can disable some or all inlining even at
688   // optimization levels above zero.
689   if (Arg *InlineArg = Args.getLastArg(
690           options::OPT_finline_functions, options::OPT_finline_hint_functions,
691           options::OPT_fno_inline_functions, options::OPT_fno_inline)) {
692     if (Opts.OptimizationLevel > 0) {
693       const Option &InlineOpt = InlineArg->getOption();
694       if (InlineOpt.matches(options::OPT_finline_functions))
695         Opts.setInlining(CodeGenOptions::NormalInlining);
696       else if (InlineOpt.matches(options::OPT_finline_hint_functions))
697         Opts.setInlining(CodeGenOptions::OnlyHintInlining);
698       else
699         Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
700     }
701   }
702 
703   Opts.ExperimentalNewPassManager = Args.hasFlag(
704       OPT_fexperimental_new_pass_manager, OPT_fno_experimental_new_pass_manager,
705       /* Default */ ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER);
706 
707   Opts.DebugPassManager =
708       Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
709                    /* Default */ false);
710 
711   if (Arg *A = Args.getLastArg(OPT_fveclib)) {
712     StringRef Name = A->getValue();
713     if (Name == "Accelerate")
714       Opts.setVecLib(CodeGenOptions::Accelerate);
715     else if (Name == "MASSV")
716       Opts.setVecLib(CodeGenOptions::MASSV);
717     else if (Name == "SVML")
718       Opts.setVecLib(CodeGenOptions::SVML);
719     else if (Name == "none")
720       Opts.setVecLib(CodeGenOptions::NoLibrary);
721     else
722       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
723   }
724 
725   if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
726     unsigned Val =
727         llvm::StringSwitch<unsigned>(A->getValue())
728             .Case("line-tables-only", codegenoptions::DebugLineTablesOnly)
729             .Case("line-directives-only", codegenoptions::DebugDirectivesOnly)
730             .Case("constructor", codegenoptions::DebugInfoConstructor)
731             .Case("limited", codegenoptions::LimitedDebugInfo)
732             .Case("standalone", codegenoptions::FullDebugInfo)
733             .Default(~0U);
734     if (Val == ~0U)
735       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
736                                                 << A->getValue();
737     else
738       Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val));
739   }
740   if (Arg *A = Args.getLastArg(OPT_debugger_tuning_EQ)) {
741     unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
742                        .Case("gdb", unsigned(llvm::DebuggerKind::GDB))
743                        .Case("lldb", unsigned(llvm::DebuggerKind::LLDB))
744                        .Case("sce", unsigned(llvm::DebuggerKind::SCE))
745                        .Default(~0U);
746     if (Val == ~0U)
747       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
748                                                 << A->getValue();
749     else
750       Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val));
751   }
752   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
753   Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
754   Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
755   Opts.CodeViewGHash = Args.hasArg(OPT_gcodeview_ghash);
756   Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro);
757   Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
758   Opts.VirtualFunctionElimination =
759       Args.hasArg(OPT_fvirtual_function_elimination);
760   Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std);
761   Opts.SplitDwarfFile = std::string(Args.getLastArgValue(OPT_split_dwarf_file));
762   Opts.SplitDwarfOutput =
763       std::string(Args.getLastArgValue(OPT_split_dwarf_output));
764   Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining);
765   Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
766   Opts.DebugExplicitImport = Args.hasArg(OPT_dwarf_explicit_import);
767   Opts.DebugFwdTemplateParams = Args.hasArg(OPT_debug_forward_template_params);
768   Opts.EmbedSource = Args.hasArg(OPT_gembed_source);
769   Opts.ForceDwarfFrameSection = Args.hasArg(OPT_fforce_dwarf_frame);
770 
771   for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
772     auto Split = StringRef(Arg).split('=');
773     Opts.DebugPrefixMap.insert(
774         {std::string(Split.first), std::string(Split.second)});
775   }
776 
777   if (const Arg *A =
778           Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
779     Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
780 
781   Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
782   Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
783 
784   const llvm::Triple::ArchType DebugEntryValueArchs[] = {
785       llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
786       llvm::Triple::arm, llvm::Triple::armeb};
787 
788   llvm::Triple T(TargetOpts.Triple);
789   if (Opts.OptimizationLevel > 0 && Opts.hasReducedDebugInfo() &&
790       llvm::is_contained(DebugEntryValueArchs, T.getArch()))
791     Opts.EmitCallSiteInfo = true;
792 
793   Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
794   Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
795   Opts.IndirectTlsSegRefs = Args.hasArg(OPT_mno_tls_direct_seg_refs);
796   Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
797   Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
798     OPT_fuse_register_sized_bitfield_access);
799   Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
800   Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
801   Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
802                            Args.hasArg(OPT_new_struct_path_tbaa);
803   Opts.FineGrainedBitfieldAccesses =
804       Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
805                    OPT_fno_fine_grained_bitfield_accesses, false);
806   Opts.DwarfDebugFlags =
807       std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
808   Opts.RecordCommandLine =
809       std::string(Args.getLastArgValue(OPT_record_command_line));
810   Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants);
811   Opts.NoCommon = !Args.hasArg(OPT_fcommon);
812   Opts.NoInlineLineTables = Args.hasArg(OPT_gno_inline_line_tables);
813   Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
814   Opts.OptimizeSize = getOptimizationLevelSize(Args);
815   Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
816                             Args.hasArg(OPT_ffreestanding));
817   if (Opts.SimplifyLibCalls)
818     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
819   Opts.UnrollLoops =
820       Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
821                    (Opts.OptimizationLevel > 1));
822   Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
823 
824   Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
825   Opts.CallGraphProfile = !Opts.DisableIntegratedAS;
826   Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
827   Opts.SampleProfileFile =
828       std::string(Args.getLastArgValue(OPT_fprofile_sample_use_EQ));
829   Opts.DebugInfoForProfiling = Args.hasFlag(
830       OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
831   Opts.DebugNameTable = static_cast<unsigned>(
832       Args.hasArg(OPT_ggnu_pubnames)
833           ? llvm::DICompileUnit::DebugNameTableKind::GNU
834           : Args.hasArg(OPT_gpubnames)
835                 ? llvm::DICompileUnit::DebugNameTableKind::Default
836                 : llvm::DICompileUnit::DebugNameTableKind::None);
837   Opts.DebugRangesBaseAddress = Args.hasArg(OPT_fdebug_ranges_base_address);
838 
839   setPGOInstrumentor(Opts, Args, Diags);
840   Opts.InstrProfileOutput =
841       std::string(Args.getLastArgValue(OPT_fprofile_instrument_path_EQ));
842   Opts.ProfileInstrumentUsePath =
843       std::string(Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ));
844   if (!Opts.ProfileInstrumentUsePath.empty())
845     setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath);
846   Opts.ProfileRemappingFile =
847       std::string(Args.getLastArgValue(OPT_fprofile_remapping_file_EQ));
848   if (!Opts.ProfileRemappingFile.empty() && !Opts.ExperimentalNewPassManager) {
849     Diags.Report(diag::err_drv_argument_only_allowed_with)
850       << Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args)
851       << "-fexperimental-new-pass-manager";
852   }
853 
854   Opts.CoverageMapping =
855       Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
856   Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
857   Opts.AsmVerbose = !Args.hasArg(OPT_fno_verbose_asm);
858   Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
859   Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
860   Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
861   Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
862   Opts.RegisterGlobalDtorsWithAtExit =
863       Args.hasArg(OPT_fregister_global_dtors_with_atexit);
864   Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
865   Opts.CodeModel = TargetOpts.CodeModel;
866   Opts.DebugPass = std::string(Args.getLastArgValue(OPT_mdebug_pass));
867 
868   // Handle -mframe-pointer option.
869   if (Arg *A = Args.getLastArg(OPT_mframe_pointer_EQ)) {
870     CodeGenOptions::FramePointerKind FP;
871     StringRef Name = A->getValue();
872     bool ValidFP = true;
873     if (Name == "none")
874       FP = CodeGenOptions::FramePointerKind::None;
875     else if (Name == "non-leaf")
876       FP = CodeGenOptions::FramePointerKind::NonLeaf;
877     else if (Name == "all")
878       FP = CodeGenOptions::FramePointerKind::All;
879     else {
880       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
881       Success = false;
882       ValidFP = false;
883     }
884     if (ValidFP)
885       Opts.setFramePointer(FP);
886   }
887 
888   Opts.DisableFree = Args.hasArg(OPT_disable_free);
889   Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
890   Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
891   Opts.NoEscapingBlockTailCalls =
892       Args.hasArg(OPT_fno_escaping_block_tail_calls);
893   Opts.FloatABI = std::string(Args.getLastArgValue(OPT_mfloat_abi));
894   Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable) ||
895                           Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
896                           Args.hasArg(OPT_cl_fast_relaxed_math);
897   Opts.LimitFloatPrecision =
898       std::string(Args.getLastArgValue(OPT_mlimit_float_precision));
899   Opts.NoInfsFPMath = (Args.hasArg(OPT_menable_no_infinities) ||
900                        Args.hasArg(OPT_cl_finite_math_only) ||
901                        Args.hasArg(OPT_cl_fast_relaxed_math));
902   Opts.NoNaNsFPMath = (Args.hasArg(OPT_menable_no_nans) ||
903                        Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
904                        Args.hasArg(OPT_cl_finite_math_only) ||
905                        Args.hasArg(OPT_cl_fast_relaxed_math));
906   Opts.NoSignedZeros = (Args.hasArg(OPT_fno_signed_zeros) ||
907                         Args.hasArg(OPT_cl_no_signed_zeros) ||
908                         Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
909                         Args.hasArg(OPT_cl_fast_relaxed_math));
910   Opts.Reassociate = Args.hasArg(OPT_mreassociate);
911   Opts.CorrectlyRoundedDivSqrt =
912       Args.hasArg(OPT_cl_fp32_correctly_rounded_divide_sqrt);
913   Opts.UniformWGSize =
914       Args.hasArg(OPT_cl_uniform_work_group_size);
915   Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
916   Opts.ReciprocalMath = Args.hasArg(OPT_freciprocal_math);
917   Opts.NoTrappingMath = Args.hasArg(OPT_fno_trapping_math);
918   Opts.StrictFloatCastOverflow =
919       !Args.hasArg(OPT_fno_strict_float_cast_overflow);
920 
921   Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
922   Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
923   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
924   Opts.SmallDataLimit =
925       getLastArgIntValue(Args, OPT_msmall_data_limit, 0, Diags);
926   Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
927   Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
928   Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
929   Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
930   Opts.IncrementalLinkerCompatible =
931       Args.hasArg(OPT_mincremental_linker_compatible);
932   Opts.PIECopyRelocations =
933       Args.hasArg(OPT_mpie_copy_relocations);
934   Opts.NoPLT = Args.hasArg(OPT_fno_plt);
935   Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
936   Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
937   Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
938   Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
939   Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
940   Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
941   Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables);
942   Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
943                       Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
944                       Args.hasArg(OPT_cl_fast_relaxed_math);
945   Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
946   Opts.RelocationModel = getRelocModel(Args, Diags);
947   Opts.ThreadModel =
948       std::string(Args.getLastArgValue(OPT_mthread_model, "posix"));
949   if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
950     Diags.Report(diag::err_drv_invalid_value)
951         << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
952         << Opts.ThreadModel;
953   Opts.TrapFuncName = std::string(Args.getLastArgValue(OPT_ftrap_function_EQ));
954   Opts.UseInitArray = !Args.hasArg(OPT_fno_use_init_array);
955 
956   Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections);
957   Opts.DataSections = Args.hasArg(OPT_fdata_sections);
958   Opts.StackSizeSection = Args.hasArg(OPT_fstack_size_section);
959   Opts.UniqueSectionNames = !Args.hasArg(OPT_fno_unique_section_names);
960   Opts.UniqueInternalLinkageNames =
961       Args.hasArg(OPT_funique_internal_linkage_names);
962 
963   Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
964 
965   Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
966 
967   Opts.NullPointerIsValid = Args.hasArg(OPT_fno_delete_null_pointer_checks);
968 
969   Opts.ProfileSampleAccurate = Args.hasArg(OPT_fprofile_sample_accurate);
970 
971   Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
972   Opts.PrepareForThinLTO = false;
973   if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
974     StringRef S = A->getValue();
975     if (S == "thin")
976       Opts.PrepareForThinLTO = true;
977     else if (S != "full")
978       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
979   }
980   Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false);
981   Opts.EnableSplitLTOUnit = Args.hasArg(OPT_fsplit_lto_unit);
982   if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
983     if (IK.getLanguage() != Language::LLVM_IR)
984       Diags.Report(diag::err_drv_argument_only_allowed_with)
985           << A->getAsString(Args) << "-x ir";
986     Opts.ThinLTOIndexFile =
987         std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
988   }
989   if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
990     Opts.SaveTempsFilePrefix =
991         llvm::StringSwitch<std::string>(A->getValue())
992             .Case("obj", FrontendOpts.OutputFile)
993             .Default(llvm::sys::path::filename(FrontendOpts.OutputFile).str());
994 
995   Opts.ThinLinkBitcodeFile =
996       std::string(Args.getLastArgValue(OPT_fthin_link_bitcode_EQ));
997 
998   Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
999 
1000   Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
1001   Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
1002 
1003   Opts.PreferVectorWidth =
1004       std::string(Args.getLastArgValue(OPT_mprefer_vector_width_EQ));
1005 
1006   Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name));
1007   Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
1008 
1009   Opts.ControlFlowGuardNoChecks = Args.hasArg(OPT_cfguard_no_checks);
1010   Opts.ControlFlowGuard = Args.hasArg(OPT_cfguard);
1011 
1012   Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
1013   Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
1014   Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
1015   if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
1016     Opts.CoverageDataFile =
1017         std::string(Args.getLastArgValue(OPT_coverage_data_file));
1018     Opts.CoverageNotesFile =
1019         std::string(Args.getLastArgValue(OPT_coverage_notes_file));
1020     Opts.ProfileFilterFiles =
1021         std::string(Args.getLastArgValue(OPT_fprofile_filter_files_EQ));
1022     Opts.ProfileExcludeFiles =
1023         std::string(Args.getLastArgValue(OPT_fprofile_exclude_files_EQ));
1024     Opts.CoverageExitBlockBeforeBody =
1025         Args.hasArg(OPT_coverage_exit_block_before_body);
1026     if (Args.hasArg(OPT_coverage_version_EQ)) {
1027       StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1028       if (CoverageVersion.size() != 4) {
1029         Diags.Report(diag::err_drv_invalid_value)
1030             << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1031             << CoverageVersion;
1032       } else {
1033         memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
1034       }
1035     }
1036   }
1037   // Handle -fembed-bitcode option.
1038   if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
1039     StringRef Name = A->getValue();
1040     unsigned Model = llvm::StringSwitch<unsigned>(Name)
1041         .Case("off", CodeGenOptions::Embed_Off)
1042         .Case("all", CodeGenOptions::Embed_All)
1043         .Case("bitcode", CodeGenOptions::Embed_Bitcode)
1044         .Case("marker", CodeGenOptions::Embed_Marker)
1045         .Default(~0U);
1046     if (Model == ~0U) {
1047       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1048       Success = false;
1049     } else
1050       Opts.setEmbedBitcode(
1051           static_cast<CodeGenOptions::EmbedBitcodeKind>(Model));
1052   }
1053   // FIXME: For backend options that are not yet recorded as function
1054   // attributes in the IR, keep track of them so we can embed them in a
1055   // separate data section and use them when building the bitcode.
1056   if (Opts.getEmbedBitcode() == CodeGenOptions::Embed_All) {
1057     for (const auto &A : Args) {
1058       // Do not encode output and input.
1059       if (A->getOption().getID() == options::OPT_o ||
1060           A->getOption().getID() == options::OPT_INPUT ||
1061           A->getOption().getID() == options::OPT_x ||
1062           A->getOption().getID() == options::OPT_fembed_bitcode ||
1063           (A->getOption().getGroup().isValid() &&
1064            A->getOption().getGroup().getID() == options::OPT_W_Group))
1065         continue;
1066       ArgStringList ASL;
1067       A->render(Args, ASL);
1068       for (const auto &arg : ASL) {
1069         StringRef ArgStr(arg);
1070         Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1071         // using \00 to separate each commandline options.
1072         Opts.CmdArgs.push_back('\0');
1073       }
1074     }
1075   }
1076 
1077   Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
1078   Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
1079   Opts.InstrumentFunctionsAfterInlining =
1080       Args.hasArg(OPT_finstrument_functions_after_inlining);
1081   Opts.InstrumentFunctionEntryBare =
1082       Args.hasArg(OPT_finstrument_function_entry_bare);
1083 
1084   Opts.XRayInstrumentFunctions =
1085       Args.hasArg(OPT_fxray_instrument);
1086   Opts.XRayAlwaysEmitCustomEvents =
1087       Args.hasArg(OPT_fxray_always_emit_customevents);
1088   Opts.XRayAlwaysEmitTypedEvents =
1089       Args.hasArg(OPT_fxray_always_emit_typedevents);
1090   Opts.XRayInstructionThreshold =
1091       getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
1092   Opts.XRayIgnoreLoops = Args.hasArg(OPT_fxray_ignore_loops);
1093 
1094   auto XRayInstrBundles =
1095       Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1096   if (XRayInstrBundles.empty())
1097     Opts.XRayInstrumentationBundle.Mask = XRayInstrKind::All;
1098   else
1099     for (const auto &A : XRayInstrBundles)
1100       parseXRayInstrumentationBundle("-fxray-instrumentation-bundle=", A, Args,
1101                                      Diags, Opts.XRayInstrumentationBundle);
1102 
1103   Opts.PatchableFunctionEntryCount =
1104       getLastArgIntValue(Args, OPT_fpatchable_function_entry_EQ, 0, Diags);
1105   Opts.PatchableFunctionEntryOffset = getLastArgIntValue(
1106       Args, OPT_fpatchable_function_entry_offset_EQ, 0, Diags);
1107   Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
1108   Opts.CallFEntry = Args.hasArg(OPT_mfentry);
1109   Opts.MNopMCount = Args.hasArg(OPT_mnop_mcount);
1110   Opts.RecordMCount = Args.hasArg(OPT_mrecord_mcount);
1111   Opts.PackedStack = Args.hasArg(OPT_mpacked_stack);
1112   Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
1113 
1114   if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1115     StringRef Name = A->getValue();
1116     if (Name == "full") {
1117       Opts.CFProtectionReturn = 1;
1118       Opts.CFProtectionBranch = 1;
1119     } else if (Name == "return")
1120       Opts.CFProtectionReturn = 1;
1121     else if (Name == "branch")
1122       Opts.CFProtectionBranch = 1;
1123     else if (Name != "none") {
1124       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1125       Success = false;
1126     }
1127   }
1128 
1129   if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
1130                                      OPT_compress_debug_sections_EQ)) {
1131     if (A->getOption().getID() == OPT_compress_debug_sections) {
1132       // TODO: be more clever about the compression type auto-detection
1133       Opts.setCompressDebugSections(llvm::DebugCompressionType::GNU);
1134     } else {
1135       auto DCT = llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
1136                      .Case("none", llvm::DebugCompressionType::None)
1137                      .Case("zlib", llvm::DebugCompressionType::Z)
1138                      .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
1139                      .Default(llvm::DebugCompressionType::None);
1140       Opts.setCompressDebugSections(DCT);
1141     }
1142   }
1143 
1144   Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
1145   Opts.DebugCompilationDir =
1146       std::string(Args.getLastArgValue(OPT_fdebug_compilation_dir));
1147   for (auto *A :
1148        Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1149     CodeGenOptions::BitcodeFileToLink F;
1150     F.Filename = A->getValue();
1151     if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1152       F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1153       // When linking CUDA bitcode, propagate function attributes so that
1154       // e.g. libdevice gets fast-math attrs if we're building with fast-math.
1155       F.PropagateAttrs = true;
1156       F.Internalize = true;
1157     }
1158     Opts.LinkBitcodeFiles.push_back(F);
1159   }
1160   Opts.SanitizeCoverageType =
1161       getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
1162   Opts.SanitizeCoverageIndirectCalls =
1163       Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
1164   Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
1165   Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
1166   Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
1167   Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
1168   Opts.SanitizeCoverage8bitCounters =
1169       Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
1170   Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
1171   Opts.SanitizeCoverageTracePCGuard =
1172       Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
1173   Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune);
1174   Opts.SanitizeCoverageInline8bitCounters =
1175       Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters);
1176   Opts.SanitizeCoverageInlineBoolFlag =
1177       Args.hasArg(OPT_fsanitize_coverage_inline_bool_flag);
1178   Opts.SanitizeCoveragePCTable = Args.hasArg(OPT_fsanitize_coverage_pc_table);
1179   Opts.SanitizeCoverageStackDepth =
1180       Args.hasArg(OPT_fsanitize_coverage_stack_depth);
1181   Opts.SanitizeCoverageWhitelistFiles =
1182       Args.getAllArgValues(OPT_fsanitize_coverage_whitelist);
1183   Opts.SanitizeCoverageBlacklistFiles =
1184       Args.getAllArgValues(OPT_fsanitize_coverage_blacklist);
1185   Opts.SanitizeMemoryTrackOrigins =
1186       getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
1187   Opts.SanitizeMemoryUseAfterDtor =
1188       Args.hasFlag(OPT_fsanitize_memory_use_after_dtor,
1189                    OPT_fno_sanitize_memory_use_after_dtor,
1190                    false);
1191   Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime);
1192   Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
1193   Opts.SanitizeCfiICallGeneralizePointers =
1194       Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers);
1195   Opts.SanitizeCfiCanonicalJumpTables =
1196       Args.hasArg(OPT_fsanitize_cfi_canonical_jump_tables);
1197   Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
1198   if (Arg *A = Args.getLastArg(
1199           OPT_fsanitize_address_poison_custom_array_cookie,
1200           OPT_fno_sanitize_address_poison_custom_array_cookie)) {
1201     Opts.SanitizeAddressPoisonCustomArrayCookie =
1202         A->getOption().getID() ==
1203         OPT_fsanitize_address_poison_custom_array_cookie;
1204   }
1205   if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope,
1206                                OPT_fno_sanitize_address_use_after_scope)) {
1207     Opts.SanitizeAddressUseAfterScope =
1208         A->getOption().getID() == OPT_fsanitize_address_use_after_scope;
1209   }
1210   Opts.SanitizeAddressGlobalsDeadStripping =
1211       Args.hasArg(OPT_fsanitize_address_globals_dead_stripping);
1212   if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_odr_indicator,
1213                                OPT_fno_sanitize_address_use_odr_indicator)) {
1214     Opts.SanitizeAddressUseOdrIndicator =
1215         A->getOption().getID() == OPT_fsanitize_address_use_odr_indicator;
1216   }
1217   Opts.SSPBufferSize =
1218       getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
1219   Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
1220   if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
1221     StringRef Val = A->getValue();
1222     unsigned StackAlignment = Opts.StackAlignment;
1223     Val.getAsInteger(10, StackAlignment);
1224     Opts.StackAlignment = StackAlignment;
1225   }
1226 
1227   if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) {
1228     StringRef Val = A->getValue();
1229     unsigned StackProbeSize = Opts.StackProbeSize;
1230     Val.getAsInteger(0, StackProbeSize);
1231     Opts.StackProbeSize = StackProbeSize;
1232   }
1233 
1234   Opts.NoStackArgProbe = Args.hasArg(OPT_mno_stack_arg_probe);
1235 
1236   Opts.StackClashProtector = Args.hasArg(OPT_fstack_clash_protection);
1237 
1238   if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
1239     StringRef Name = A->getValue();
1240     unsigned Method = llvm::StringSwitch<unsigned>(Name)
1241       .Case("legacy", CodeGenOptions::Legacy)
1242       .Case("non-legacy", CodeGenOptions::NonLegacy)
1243       .Case("mixed", CodeGenOptions::Mixed)
1244       .Default(~0U);
1245     if (Method == ~0U) {
1246       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1247       Success = false;
1248     } else {
1249       Opts.setObjCDispatchMethod(
1250         static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
1251     }
1252   }
1253 
1254 
1255   if (Args.hasArg(OPT_fno_objc_convert_messages_to_runtime_calls))
1256     Opts.ObjCConvertMessagesToRuntimeCalls = 0;
1257 
1258   if (Args.getLastArg(OPT_femulated_tls) ||
1259       Args.getLastArg(OPT_fno_emulated_tls)) {
1260     Opts.ExplicitEmulatedTLS = true;
1261     Opts.EmulatedTLS =
1262         Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
1263   }
1264 
1265   if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
1266     StringRef Name = A->getValue();
1267     unsigned Model = llvm::StringSwitch<unsigned>(Name)
1268         .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
1269         .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
1270         .Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
1271         .Case("local-exec", CodeGenOptions::LocalExecTLSModel)
1272         .Default(~0U);
1273     if (Model == ~0U) {
1274       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1275       Success = false;
1276     } else {
1277       Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
1278     }
1279   }
1280 
1281   Opts.TLSSize = getLastArgIntValue(Args, OPT_mtls_size_EQ, 0, Diags);
1282 
1283   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1284     StringRef Val = A->getValue();
1285     Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val);
1286     if (!Opts.FPDenormalMode.isValid())
1287       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1288   }
1289 
1290   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
1291     StringRef Val = A->getValue();
1292     Opts.FP32DenormalMode = llvm::parseDenormalFPAttribute(Val);
1293     if (!Opts.FP32DenormalMode.isValid())
1294       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1295   }
1296 
1297   // X86_32 has -fppc-struct-return and -freg-struct-return.
1298   // PPC32 has -maix-struct-return and -msvr4-struct-return.
1299   if (Arg *A =
1300           Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
1301                           OPT_maix_struct_return, OPT_msvr4_struct_return)) {
1302     const Option &O = A->getOption();
1303     if (O.matches(OPT_fpcc_struct_return) ||
1304         O.matches(OPT_maix_struct_return)) {
1305       Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
1306     } else {
1307       assert(O.matches(OPT_freg_struct_return) ||
1308              O.matches(OPT_msvr4_struct_return));
1309       Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
1310     }
1311   }
1312 
1313   Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
1314   Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
1315   bool NeedLocTracking = false;
1316 
1317   Opts.OptRecordFile = std::string(Args.getLastArgValue(OPT_opt_record_file));
1318   if (!Opts.OptRecordFile.empty())
1319     NeedLocTracking = true;
1320 
1321   if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
1322     Opts.OptRecordPasses = A->getValue();
1323     NeedLocTracking = true;
1324   }
1325 
1326   if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
1327     Opts.OptRecordFormat = A->getValue();
1328     NeedLocTracking = true;
1329   }
1330 
1331   if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
1332     Opts.OptimizationRemarkPattern =
1333         GenerateOptimizationRemarkRegex(Diags, Args, A);
1334     NeedLocTracking = true;
1335   }
1336 
1337   if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) {
1338     Opts.OptimizationRemarkMissedPattern =
1339         GenerateOptimizationRemarkRegex(Diags, Args, A);
1340     NeedLocTracking = true;
1341   }
1342 
1343   if (Arg *A = Args.getLastArg(OPT_Rpass_analysis_EQ)) {
1344     Opts.OptimizationRemarkAnalysisPattern =
1345         GenerateOptimizationRemarkRegex(Diags, Args, A);
1346     NeedLocTracking = true;
1347   }
1348 
1349   Opts.DiagnosticsWithHotness =
1350       Args.hasArg(options::OPT_fdiagnostics_show_hotness);
1351   bool UsingSampleProfile = !Opts.SampleProfileFile.empty();
1352   bool UsingProfile = UsingSampleProfile ||
1353       (Opts.getProfileUse() != CodeGenOptions::ProfileNone);
1354 
1355   if (Opts.DiagnosticsWithHotness && !UsingProfile &&
1356       // An IR file will contain PGO as metadata
1357       IK.getLanguage() != Language::LLVM_IR)
1358     Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1359         << "-fdiagnostics-show-hotness";
1360 
1361   Opts.DiagnosticsHotnessThreshold = getLastArgUInt64Value(
1362       Args, options::OPT_fdiagnostics_hotness_threshold_EQ, 0);
1363   if (Opts.DiagnosticsHotnessThreshold > 0 && !UsingProfile)
1364     Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1365         << "-fdiagnostics-hotness-threshold=";
1366 
1367   // If the user requested to use a sample profile for PGO, then the
1368   // backend will need to track source location information so the profile
1369   // can be incorporated into the IR.
1370   if (UsingSampleProfile)
1371     NeedLocTracking = true;
1372 
1373   // If the user requested a flag that requires source locations available in
1374   // the backend, make sure that the backend tracks source location information.
1375   if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo)
1376     Opts.setDebugInfo(codegenoptions::LocTrackingOnly);
1377 
1378   Opts.RewriteMapFiles = Args.getAllArgValues(OPT_frewrite_map_file);
1379 
1380   // Parse -fsanitize-recover= arguments.
1381   // FIXME: Report unrecoverable sanitizers incorrectly specified here.
1382   parseSanitizerKinds("-fsanitize-recover=",
1383                       Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
1384                       Opts.SanitizeRecover);
1385   parseSanitizerKinds("-fsanitize-trap=",
1386                       Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
1387                       Opts.SanitizeTrap);
1388 
1389   Opts.CudaGpuBinaryFileName =
1390       std::string(Args.getLastArgValue(OPT_fcuda_include_gpubinary));
1391 
1392   Opts.Backchain = Args.hasArg(OPT_mbackchain);
1393 
1394   Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
1395       Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
1396 
1397   Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);
1398 
1399   Opts.Addrsig = Args.hasArg(OPT_faddrsig);
1400 
1401   Opts.KeepStaticConsts = Args.hasArg(OPT_fkeep_static_consts);
1402 
1403   Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening);
1404 
1405   Opts.DefaultFunctionAttrs = Args.getAllArgValues(OPT_default_function_attr);
1406 
1407   Opts.PassPlugins = Args.getAllArgValues(OPT_fpass_plugin_EQ);
1408 
1409   Opts.SymbolPartition =
1410       std::string(Args.getLastArgValue(OPT_fsymbol_partition_EQ));
1411 
1412   Opts.ForceAAPCSBitfieldLoad = Args.hasArg(OPT_ForceAAPCSBitfieldLoad);
1413   return Success;
1414 }
1415 
1416 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
1417                                       ArgList &Args) {
1418   Opts.OutputFile = std::string(Args.getLastArgValue(OPT_dependency_file));
1419   Opts.Targets = Args.getAllArgValues(OPT_MT);
1420   Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
1421   Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
1422   Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
1423   Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
1424   Opts.HeaderIncludeOutputFile =
1425       std::string(Args.getLastArgValue(OPT_header_include_file));
1426   Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
1427   if (Args.hasArg(OPT_show_includes)) {
1428     // Writing both /showIncludes and preprocessor output to stdout
1429     // would produce interleaved output, so use stderr for /showIncludes.
1430     // This behaves the same as cl.exe, when /E, /EP or /P are passed.
1431     if (Args.hasArg(options::OPT_E) || Args.hasArg(options::OPT_P))
1432       Opts.ShowIncludesDest = ShowIncludesDestination::Stderr;
1433     else
1434       Opts.ShowIncludesDest = ShowIncludesDestination::Stdout;
1435   } else {
1436     Opts.ShowIncludesDest = ShowIncludesDestination::None;
1437   }
1438   Opts.DOTOutputFile = std::string(Args.getLastArgValue(OPT_dependency_dot));
1439   Opts.ModuleDependencyOutputDir =
1440       std::string(Args.getLastArgValue(OPT_module_dependency_dir));
1441   if (Args.hasArg(OPT_MV))
1442     Opts.OutputFormat = DependencyOutputFormat::NMake;
1443   // Add sanitizer blacklists as extra dependencies.
1444   // They won't be discovered by the regular preprocessor, so
1445   // we let make / ninja to know about this implicit dependency.
1446   if (!Args.hasArg(OPT_fno_sanitize_blacklist)) {
1447     for (const auto *A : Args.filtered(OPT_fsanitize_blacklist)) {
1448       StringRef Val = A->getValue();
1449       if (Val.find('=') == StringRef::npos)
1450         Opts.ExtraDeps.push_back(std::string(Val));
1451     }
1452     if (Opts.IncludeSystemHeaders) {
1453       for (const auto *A : Args.filtered(OPT_fsanitize_system_blacklist)) {
1454         StringRef Val = A->getValue();
1455         if (Val.find('=') == StringRef::npos)
1456           Opts.ExtraDeps.push_back(std::string(Val));
1457       }
1458     }
1459   }
1460 
1461   // Propagate the extra dependencies.
1462   for (const auto *A : Args.filtered(OPT_fdepfile_entry)) {
1463     Opts.ExtraDeps.push_back(A->getValue());
1464   }
1465 
1466   // Only the -fmodule-file=<file> form.
1467   for (const auto *A : Args.filtered(OPT_fmodule_file)) {
1468     StringRef Val = A->getValue();
1469     if (Val.find('=') == StringRef::npos)
1470       Opts.ExtraDeps.push_back(std::string(Val));
1471   }
1472 }
1473 
1474 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
1475   // Color diagnostics default to auto ("on" if terminal supports) in the driver
1476   // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
1477   // Support both clang's -f[no-]color-diagnostics and gcc's
1478   // -f[no-]diagnostics-colors[=never|always|auto].
1479   enum {
1480     Colors_On,
1481     Colors_Off,
1482     Colors_Auto
1483   } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
1484   for (auto *A : Args) {
1485     const Option &O = A->getOption();
1486     if (O.matches(options::OPT_fcolor_diagnostics) ||
1487         O.matches(options::OPT_fdiagnostics_color)) {
1488       ShowColors = Colors_On;
1489     } else if (O.matches(options::OPT_fno_color_diagnostics) ||
1490                O.matches(options::OPT_fno_diagnostics_color)) {
1491       ShowColors = Colors_Off;
1492     } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
1493       StringRef Value(A->getValue());
1494       if (Value == "always")
1495         ShowColors = Colors_On;
1496       else if (Value == "never")
1497         ShowColors = Colors_Off;
1498       else if (Value == "auto")
1499         ShowColors = Colors_Auto;
1500     }
1501   }
1502   return ShowColors == Colors_On ||
1503          (ShowColors == Colors_Auto &&
1504           llvm::sys::Process::StandardErrHasColors());
1505 }
1506 
1507 static bool checkVerifyPrefixes(const std::vector<std::string> &VerifyPrefixes,
1508                                 DiagnosticsEngine *Diags) {
1509   bool Success = true;
1510   for (const auto &Prefix : VerifyPrefixes) {
1511     // Every prefix must start with a letter and contain only alphanumeric
1512     // characters, hyphens, and underscores.
1513     auto BadChar = llvm::find_if(Prefix, [](char C) {
1514       return !isAlphanumeric(C) && C != '-' && C != '_';
1515     });
1516     if (BadChar != Prefix.end() || !isLetter(Prefix[0])) {
1517       Success = false;
1518       if (Diags) {
1519         Diags->Report(diag::err_drv_invalid_value) << "-verify=" << Prefix;
1520         Diags->Report(diag::note_drv_verify_prefix_spelling);
1521       }
1522     }
1523   }
1524   return Success;
1525 }
1526 
1527 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
1528                                 DiagnosticsEngine *Diags,
1529                                 bool DefaultDiagColor) {
1530   bool Success = true;
1531 
1532   Opts.DiagnosticLogFile =
1533       std::string(Args.getLastArgValue(OPT_diagnostic_log_file));
1534   if (Arg *A =
1535           Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
1536     Opts.DiagnosticSerializationFile = A->getValue();
1537   Opts.IgnoreWarnings = Args.hasArg(OPT_w);
1538   Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
1539   Opts.Pedantic = Args.hasArg(OPT_pedantic);
1540   Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
1541   Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
1542   Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
1543   Opts.ShowColumn = !Args.hasArg(OPT_fno_show_column);
1544   Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
1545   Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
1546   Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
1547   Opts.ShowOptionNames = !Args.hasArg(OPT_fno_diagnostics_show_option);
1548 
1549   llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
1550 
1551   // Default behavior is to not to show note include stacks.
1552   Opts.ShowNoteIncludeStack = false;
1553   if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
1554                                OPT_fno_diagnostics_show_note_include_stack))
1555     if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
1556       Opts.ShowNoteIncludeStack = true;
1557 
1558   StringRef ShowOverloads =
1559     Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
1560   if (ShowOverloads == "best")
1561     Opts.setShowOverloads(Ovl_Best);
1562   else if (ShowOverloads == "all")
1563     Opts.setShowOverloads(Ovl_All);
1564   else {
1565     Success = false;
1566     if (Diags)
1567       Diags->Report(diag::err_drv_invalid_value)
1568       << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1569       << ShowOverloads;
1570   }
1571 
1572   StringRef ShowCategory =
1573     Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
1574   if (ShowCategory == "none")
1575     Opts.ShowCategories = 0;
1576   else if (ShowCategory == "id")
1577     Opts.ShowCategories = 1;
1578   else if (ShowCategory == "name")
1579     Opts.ShowCategories = 2;
1580   else {
1581     Success = false;
1582     if (Diags)
1583       Diags->Report(diag::err_drv_invalid_value)
1584       << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1585       << ShowCategory;
1586   }
1587 
1588   StringRef Format =
1589     Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
1590   if (Format == "clang")
1591     Opts.setFormat(DiagnosticOptions::Clang);
1592   else if (Format == "msvc")
1593     Opts.setFormat(DiagnosticOptions::MSVC);
1594   else if (Format == "msvc-fallback") {
1595     Opts.setFormat(DiagnosticOptions::MSVC);
1596     Opts.CLFallbackMode = true;
1597   } else if (Format == "vi")
1598     Opts.setFormat(DiagnosticOptions::Vi);
1599   else {
1600     Success = false;
1601     if (Diags)
1602       Diags->Report(diag::err_drv_invalid_value)
1603       << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
1604       << Format;
1605   }
1606 
1607   Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
1608   Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
1609   Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
1610   Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
1611   Opts.VerifyPrefixes = Args.getAllArgValues(OPT_verify_EQ);
1612   if (Args.hasArg(OPT_verify))
1613     Opts.VerifyPrefixes.push_back("expected");
1614   // Keep VerifyPrefixes in its original order for the sake of diagnostics, and
1615   // then sort it to prepare for fast lookup using std::binary_search.
1616   if (!checkVerifyPrefixes(Opts.VerifyPrefixes, Diags)) {
1617     Opts.VerifyDiagnostics = false;
1618     Success = false;
1619   }
1620   else
1621     llvm::sort(Opts.VerifyPrefixes);
1622   DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None;
1623   Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
1624     Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
1625     Diags, DiagMask);
1626   if (Args.hasArg(OPT_verify_ignore_unexpected))
1627     DiagMask = DiagnosticLevelMask::All;
1628   Opts.setVerifyIgnoreUnexpected(DiagMask);
1629   Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
1630   Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
1631   Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
1632   Opts.MacroBacktraceLimit =
1633       getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
1634                          DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
1635   Opts.TemplateBacktraceLimit = getLastArgIntValue(
1636       Args, OPT_ftemplate_backtrace_limit,
1637       DiagnosticOptions::DefaultTemplateBacktraceLimit, Diags);
1638   Opts.ConstexprBacktraceLimit = getLastArgIntValue(
1639       Args, OPT_fconstexpr_backtrace_limit,
1640       DiagnosticOptions::DefaultConstexprBacktraceLimit, Diags);
1641   Opts.SpellCheckingLimit = getLastArgIntValue(
1642       Args, OPT_fspell_checking_limit,
1643       DiagnosticOptions::DefaultSpellCheckingLimit, Diags);
1644   Opts.SnippetLineLimit = getLastArgIntValue(
1645       Args, OPT_fcaret_diagnostics_max_lines,
1646       DiagnosticOptions::DefaultSnippetLineLimit, Diags);
1647   Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
1648                                     DiagnosticOptions::DefaultTabStop, Diags);
1649   if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
1650     Opts.TabStop = DiagnosticOptions::DefaultTabStop;
1651     if (Diags)
1652       Diags->Report(diag::warn_ignoring_ftabstop_value)
1653       << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
1654   }
1655   Opts.MessageLength =
1656       getLastArgIntValue(Args, OPT_fmessage_length_EQ, 0, Diags);
1657   addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
1658   addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
1659 
1660   return Success;
1661 }
1662 
1663 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1664   Opts.WorkingDir = std::string(Args.getLastArgValue(OPT_working_directory));
1665 }
1666 
1667 /// Parse the argument to the -ftest-module-file-extension
1668 /// command-line argument.
1669 ///
1670 /// \returns true on error, false on success.
1671 static bool parseTestModuleFileExtensionArg(StringRef Arg,
1672                                             std::string &BlockName,
1673                                             unsigned &MajorVersion,
1674                                             unsigned &MinorVersion,
1675                                             bool &Hashed,
1676                                             std::string &UserInfo) {
1677   SmallVector<StringRef, 5> Args;
1678   Arg.split(Args, ':', 5);
1679   if (Args.size() < 5)
1680     return true;
1681 
1682   BlockName = std::string(Args[0]);
1683   if (Args[1].getAsInteger(10, MajorVersion)) return true;
1684   if (Args[2].getAsInteger(10, MinorVersion)) return true;
1685   if (Args[3].getAsInteger(2, Hashed)) return true;
1686   if (Args.size() > 4)
1687     UserInfo = std::string(Args[4]);
1688   return false;
1689 }
1690 
1691 static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
1692                                    DiagnosticsEngine &Diags,
1693                                    bool &IsHeaderFile) {
1694   Opts.ProgramAction = frontend::ParseSyntaxOnly;
1695   if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1696     switch (A->getOption().getID()) {
1697     default:
1698       llvm_unreachable("Invalid option in group!");
1699     case OPT_ast_list:
1700       Opts.ProgramAction = frontend::ASTDeclList; break;
1701     case OPT_ast_dump_all_EQ:
1702     case OPT_ast_dump_EQ: {
1703       unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
1704                          .CaseLower("default", ADOF_Default)
1705                          .CaseLower("json", ADOF_JSON)
1706                          .Default(std::numeric_limits<unsigned>::max());
1707 
1708       if (Val != std::numeric_limits<unsigned>::max())
1709         Opts.ASTDumpFormat = static_cast<ASTDumpOutputFormat>(Val);
1710       else {
1711         Diags.Report(diag::err_drv_invalid_value)
1712             << A->getAsString(Args) << A->getValue();
1713         Opts.ASTDumpFormat = ADOF_Default;
1714       }
1715       LLVM_FALLTHROUGH;
1716     }
1717     case OPT_ast_dump:
1718     case OPT_ast_dump_all:
1719     case OPT_ast_dump_lookups:
1720       Opts.ProgramAction = frontend::ASTDump; break;
1721     case OPT_ast_print:
1722       Opts.ProgramAction = frontend::ASTPrint; break;
1723     case OPT_ast_view:
1724       Opts.ProgramAction = frontend::ASTView; break;
1725     case OPT_compiler_options_dump:
1726       Opts.ProgramAction = frontend::DumpCompilerOptions; break;
1727     case OPT_dump_raw_tokens:
1728       Opts.ProgramAction = frontend::DumpRawTokens; break;
1729     case OPT_dump_tokens:
1730       Opts.ProgramAction = frontend::DumpTokens; break;
1731     case OPT_S:
1732       Opts.ProgramAction = frontend::EmitAssembly; break;
1733     case OPT_emit_llvm_bc:
1734       Opts.ProgramAction = frontend::EmitBC; break;
1735     case OPT_emit_html:
1736       Opts.ProgramAction = frontend::EmitHTML; break;
1737     case OPT_emit_llvm:
1738       Opts.ProgramAction = frontend::EmitLLVM; break;
1739     case OPT_emit_llvm_only:
1740       Opts.ProgramAction = frontend::EmitLLVMOnly; break;
1741     case OPT_emit_codegen_only:
1742       Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
1743     case OPT_emit_obj:
1744       Opts.ProgramAction = frontend::EmitObj; break;
1745     case OPT_fixit_EQ:
1746       Opts.FixItSuffix = A->getValue();
1747       LLVM_FALLTHROUGH;
1748     case OPT_fixit:
1749       Opts.ProgramAction = frontend::FixIt; break;
1750     case OPT_emit_module:
1751       Opts.ProgramAction = frontend::GenerateModule; break;
1752     case OPT_emit_module_interface:
1753       Opts.ProgramAction = frontend::GenerateModuleInterface; break;
1754     case OPT_emit_header_module:
1755       Opts.ProgramAction = frontend::GenerateHeaderModule; break;
1756     case OPT_emit_pch:
1757       Opts.ProgramAction = frontend::GeneratePCH; break;
1758     case OPT_emit_interface_stubs: {
1759       StringRef ArgStr =
1760           Args.hasArg(OPT_interface_stub_version_EQ)
1761               ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
1762               : "experimental-ifs-v2";
1763       if (ArgStr == "experimental-yaml-elf-v1" ||
1764           ArgStr == "experimental-ifs-v1" ||
1765           ArgStr == "experimental-tapi-elf-v1") {
1766         std::string ErrorMessage =
1767             "Invalid interface stub format: " + ArgStr.str() +
1768             " is deprecated.";
1769         Diags.Report(diag::err_drv_invalid_value)
1770             << "Must specify a valid interface stub format type, ie: "
1771                "-interface-stub-version=experimental-ifs-v2"
1772             << ErrorMessage;
1773       } else if (!ArgStr.startswith("experimental-ifs-")) {
1774         std::string ErrorMessage =
1775             "Invalid interface stub format: " + ArgStr.str() + ".";
1776         Diags.Report(diag::err_drv_invalid_value)
1777             << "Must specify a valid interface stub format type, ie: "
1778                "-interface-stub-version=experimental-ifs-v2"
1779             << ErrorMessage;
1780       } else {
1781         Opts.ProgramAction = frontend::GenerateInterfaceStubs;
1782       }
1783       break;
1784     }
1785     case OPT_init_only:
1786       Opts.ProgramAction = frontend::InitOnly; break;
1787     case OPT_fsyntax_only:
1788       Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
1789     case OPT_module_file_info:
1790       Opts.ProgramAction = frontend::ModuleFileInfo; break;
1791     case OPT_verify_pch:
1792       Opts.ProgramAction = frontend::VerifyPCH; break;
1793     case OPT_print_preamble:
1794       Opts.ProgramAction = frontend::PrintPreamble; break;
1795     case OPT_E:
1796       Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
1797     case OPT_templight_dump:
1798       Opts.ProgramAction = frontend::TemplightDump; break;
1799     case OPT_rewrite_macros:
1800       Opts.ProgramAction = frontend::RewriteMacros; break;
1801     case OPT_rewrite_objc:
1802       Opts.ProgramAction = frontend::RewriteObjC; break;
1803     case OPT_rewrite_test:
1804       Opts.ProgramAction = frontend::RewriteTest; break;
1805     case OPT_analyze:
1806       Opts.ProgramAction = frontend::RunAnalysis; break;
1807     case OPT_migrate:
1808       Opts.ProgramAction = frontend::MigrateSource; break;
1809     case OPT_Eonly:
1810       Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
1811     case OPT_print_dependency_directives_minimized_source:
1812       Opts.ProgramAction =
1813           frontend::PrintDependencyDirectivesSourceMinimizerOutput;
1814       break;
1815     }
1816   }
1817 
1818   if (const Arg* A = Args.getLastArg(OPT_plugin)) {
1819     Opts.Plugins.emplace_back(A->getValue(0));
1820     Opts.ProgramAction = frontend::PluginAction;
1821     Opts.ActionName = A->getValue();
1822   }
1823   Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
1824   for (const auto *AA : Args.filtered(OPT_plugin_arg))
1825     Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
1826 
1827   for (const std::string &Arg :
1828          Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
1829     std::string BlockName;
1830     unsigned MajorVersion;
1831     unsigned MinorVersion;
1832     bool Hashed;
1833     std::string UserInfo;
1834     if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion,
1835                                         MinorVersion, Hashed, UserInfo)) {
1836       Diags.Report(diag::err_test_module_file_extension_format) << Arg;
1837 
1838       continue;
1839     }
1840 
1841     // Add the testing module file extension.
1842     Opts.ModuleFileExtensions.push_back(
1843         std::make_shared<TestModuleFileExtension>(
1844             BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
1845   }
1846 
1847   if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1848     Opts.CodeCompletionAt =
1849       ParsedSourceLocation::FromString(A->getValue());
1850     if (Opts.CodeCompletionAt.FileName.empty())
1851       Diags.Report(diag::err_drv_invalid_value)
1852         << A->getAsString(Args) << A->getValue();
1853   }
1854   Opts.DisableFree = Args.hasArg(OPT_disable_free);
1855 
1856   Opts.OutputFile = std::string(Args.getLastArgValue(OPT_o));
1857   Opts.Plugins = Args.getAllArgValues(OPT_load);
1858   Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
1859   Opts.ShowHelp = Args.hasArg(OPT_help);
1860   Opts.ShowStats = Args.hasArg(OPT_print_stats);
1861   Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
1862   Opts.PrintSupportedCPUs = Args.hasArg(OPT_print_supported_cpus);
1863   Opts.TimeTrace = Args.hasArg(OPT_ftime_trace);
1864   Opts.TimeTraceGranularity = getLastArgIntValue(
1865       Args, OPT_ftime_trace_granularity_EQ, Opts.TimeTraceGranularity, Diags);
1866   Opts.ShowVersion = Args.hasArg(OPT_version);
1867   Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1868   Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
1869   Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
1870   Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
1871   Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
1872   Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
1873   Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
1874   Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
1875   Opts.ASTDumpFilter = std::string(Args.getLastArgValue(OPT_ast_dump_filter));
1876   Opts.ASTDumpLookups = Args.hasArg(OPT_ast_dump_lookups);
1877   Opts.UseGlobalModuleIndex = !Args.hasArg(OPT_fno_modules_global_index);
1878   Opts.GenerateGlobalModuleIndex = Opts.UseGlobalModuleIndex;
1879   Opts.ModuleMapFiles = Args.getAllArgValues(OPT_fmodule_map_file);
1880   // Only the -fmodule-file=<file> form.
1881   for (const auto *A : Args.filtered(OPT_fmodule_file)) {
1882     StringRef Val = A->getValue();
1883     if (Val.find('=') == StringRef::npos)
1884       Opts.ModuleFiles.push_back(std::string(Val));
1885   }
1886   Opts.ModulesEmbedFiles = Args.getAllArgValues(OPT_fmodules_embed_file_EQ);
1887   Opts.ModulesEmbedAllFiles = Args.hasArg(OPT_fmodules_embed_all_files);
1888   Opts.IncludeTimestamps = !Args.hasArg(OPT_fno_pch_timestamp);
1889   Opts.UseTemporary = !Args.hasArg(OPT_fno_temp_file);
1890   Opts.IsSystemModule = Args.hasArg(OPT_fsystem_module);
1891 
1892   if (Opts.ProgramAction != frontend::GenerateModule && Opts.IsSystemModule)
1893     Diags.Report(diag::err_drv_argument_only_allowed_with) << "-fsystem-module"
1894                                                            << "-emit-module";
1895 
1896   Opts.CodeCompleteOpts.IncludeMacros
1897     = Args.hasArg(OPT_code_completion_macros);
1898   Opts.CodeCompleteOpts.IncludeCodePatterns
1899     = Args.hasArg(OPT_code_completion_patterns);
1900   Opts.CodeCompleteOpts.IncludeGlobals
1901     = !Args.hasArg(OPT_no_code_completion_globals);
1902   Opts.CodeCompleteOpts.IncludeNamespaceLevelDecls
1903     = !Args.hasArg(OPT_no_code_completion_ns_level_decls);
1904   Opts.CodeCompleteOpts.IncludeBriefComments
1905     = Args.hasArg(OPT_code_completion_brief_comments);
1906   Opts.CodeCompleteOpts.IncludeFixIts
1907     = Args.hasArg(OPT_code_completion_with_fixits);
1908 
1909   Opts.OverrideRecordLayoutsFile =
1910       std::string(Args.getLastArgValue(OPT_foverride_record_layout_EQ));
1911   Opts.AuxTriple = std::string(Args.getLastArgValue(OPT_aux_triple));
1912   if (Args.hasArg(OPT_aux_target_cpu))
1913     Opts.AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
1914   if (Args.hasArg(OPT_aux_target_feature))
1915     Opts.AuxTargetFeatures = Args.getAllArgValues(OPT_aux_target_feature);
1916   Opts.StatsFile = std::string(Args.getLastArgValue(OPT_stats_file));
1917 
1918   if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
1919                                      OPT_arcmt_modify,
1920                                      OPT_arcmt_migrate)) {
1921     switch (A->getOption().getID()) {
1922     default:
1923       llvm_unreachable("missed a case");
1924     case OPT_arcmt_check:
1925       Opts.ARCMTAction = FrontendOptions::ARCMT_Check;
1926       break;
1927     case OPT_arcmt_modify:
1928       Opts.ARCMTAction = FrontendOptions::ARCMT_Modify;
1929       break;
1930     case OPT_arcmt_migrate:
1931       Opts.ARCMTAction = FrontendOptions::ARCMT_Migrate;
1932       break;
1933     }
1934   }
1935   Opts.MTMigrateDir =
1936       std::string(Args.getLastArgValue(OPT_mt_migrate_directory));
1937   Opts.ARCMTMigrateReportOut =
1938       std::string(Args.getLastArgValue(OPT_arcmt_migrate_report_output));
1939   Opts.ARCMTMigrateEmitARCErrors
1940     = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
1941 
1942   if (Args.hasArg(OPT_objcmt_migrate_literals))
1943     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Literals;
1944   if (Args.hasArg(OPT_objcmt_migrate_subscripting))
1945     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Subscripting;
1946   if (Args.hasArg(OPT_objcmt_migrate_property_dot_syntax))
1947     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_PropertyDotSyntax;
1948   if (Args.hasArg(OPT_objcmt_migrate_property))
1949     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Property;
1950   if (Args.hasArg(OPT_objcmt_migrate_readonly_property))
1951     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReadonlyProperty;
1952   if (Args.hasArg(OPT_objcmt_migrate_readwrite_property))
1953     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReadwriteProperty;
1954   if (Args.hasArg(OPT_objcmt_migrate_annotation))
1955     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Annotation;
1956   if (Args.hasArg(OPT_objcmt_returns_innerpointer_property))
1957     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReturnsInnerPointerProperty;
1958   if (Args.hasArg(OPT_objcmt_migrate_instancetype))
1959     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Instancetype;
1960   if (Args.hasArg(OPT_objcmt_migrate_nsmacros))
1961     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_NsMacros;
1962   if (Args.hasArg(OPT_objcmt_migrate_protocol_conformance))
1963     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ProtocolConformance;
1964   if (Args.hasArg(OPT_objcmt_atomic_property))
1965     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_AtomicProperty;
1966   if (Args.hasArg(OPT_objcmt_ns_nonatomic_iosonly))
1967     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty;
1968   if (Args.hasArg(OPT_objcmt_migrate_designated_init))
1969     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_DesignatedInitializer;
1970   if (Args.hasArg(OPT_objcmt_migrate_all))
1971     Opts.ObjCMTAction |= FrontendOptions::ObjCMT_MigrateDecls;
1972 
1973   Opts.ObjCMTWhiteListPath =
1974       std::string(Args.getLastArgValue(OPT_objcmt_whitelist_dir_path));
1975 
1976   if (Opts.ARCMTAction != FrontendOptions::ARCMT_None &&
1977       Opts.ObjCMTAction != FrontendOptions::ObjCMT_None) {
1978     Diags.Report(diag::err_drv_argument_not_allowed_with)
1979       << "ARC migration" << "ObjC migration";
1980   }
1981 
1982   InputKind DashX(Language::Unknown);
1983   if (const Arg *A = Args.getLastArg(OPT_x)) {
1984     StringRef XValue = A->getValue();
1985 
1986     // Parse suffixes: '<lang>(-header|[-module-map][-cpp-output])'.
1987     // FIXME: Supporting '<lang>-header-cpp-output' would be useful.
1988     bool Preprocessed = XValue.consume_back("-cpp-output");
1989     bool ModuleMap = XValue.consume_back("-module-map");
1990     IsHeaderFile =
1991         !Preprocessed && !ModuleMap && XValue.consume_back("-header");
1992 
1993     // Principal languages.
1994     DashX = llvm::StringSwitch<InputKind>(XValue)
1995                 .Case("c", Language::C)
1996                 .Case("cl", Language::OpenCL)
1997                 .Case("cuda", Language::CUDA)
1998                 .Case("hip", Language::HIP)
1999                 .Case("c++", Language::CXX)
2000                 .Case("objective-c", Language::ObjC)
2001                 .Case("objective-c++", Language::ObjCXX)
2002                 .Case("renderscript", Language::RenderScript)
2003                 .Default(Language::Unknown);
2004 
2005     // "objc[++]-cpp-output" is an acceptable synonym for
2006     // "objective-c[++]-cpp-output".
2007     if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap)
2008       DashX = llvm::StringSwitch<InputKind>(XValue)
2009                   .Case("objc", Language::ObjC)
2010                   .Case("objc++", Language::ObjCXX)
2011                   .Default(Language::Unknown);
2012 
2013     // Some special cases cannot be combined with suffixes.
2014     if (DashX.isUnknown() && !Preprocessed && !ModuleMap && !IsHeaderFile)
2015       DashX = llvm::StringSwitch<InputKind>(XValue)
2016                   .Case("cpp-output", InputKind(Language::C).getPreprocessed())
2017                   .Case("assembler-with-cpp", Language::Asm)
2018                   .Cases("ast", "pcm",
2019                          InputKind(Language::Unknown, InputKind::Precompiled))
2020                   .Case("ir", Language::LLVM_IR)
2021                   .Default(Language::Unknown);
2022 
2023     if (DashX.isUnknown())
2024       Diags.Report(diag::err_drv_invalid_value)
2025         << A->getAsString(Args) << A->getValue();
2026 
2027     if (Preprocessed)
2028       DashX = DashX.getPreprocessed();
2029     if (ModuleMap)
2030       DashX = DashX.withFormat(InputKind::ModuleMap);
2031   }
2032 
2033   // '-' is the default input if none is given.
2034   std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
2035   Opts.Inputs.clear();
2036   if (Inputs.empty())
2037     Inputs.push_back("-");
2038   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
2039     InputKind IK = DashX;
2040     if (IK.isUnknown()) {
2041       IK = FrontendOptions::getInputKindForExtension(
2042         StringRef(Inputs[i]).rsplit('.').second);
2043       // FIXME: Warn on this?
2044       if (IK.isUnknown())
2045         IK = Language::C;
2046       // FIXME: Remove this hack.
2047       if (i == 0)
2048         DashX = IK;
2049     }
2050 
2051     bool IsSystem = false;
2052 
2053     // The -emit-module action implicitly takes a module map.
2054     if (Opts.ProgramAction == frontend::GenerateModule &&
2055         IK.getFormat() == InputKind::Source) {
2056       IK = IK.withFormat(InputKind::ModuleMap);
2057       IsSystem = Opts.IsSystemModule;
2058     }
2059 
2060     Opts.Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
2061   }
2062 
2063   return DashX;
2064 }
2065 
2066 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
2067                                                  void *MainAddr) {
2068   std::string ClangExecutable =
2069       llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
2070   return Driver::GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
2071 }
2072 
2073 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
2074                                   const std::string &WorkingDir) {
2075   Opts.Sysroot = std::string(Args.getLastArgValue(OPT_isysroot, "/"));
2076   Opts.Verbose = Args.hasArg(OPT_v);
2077   Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
2078   Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
2079   Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
2080   if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
2081     Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
2082   Opts.ResourceDir = std::string(Args.getLastArgValue(OPT_resource_dir));
2083 
2084   // Canonicalize -fmodules-cache-path before storing it.
2085   SmallString<128> P(Args.getLastArgValue(OPT_fmodules_cache_path));
2086   if (!(P.empty() || llvm::sys::path::is_absolute(P))) {
2087     if (WorkingDir.empty())
2088       llvm::sys::fs::make_absolute(P);
2089     else
2090       llvm::sys::fs::make_absolute(WorkingDir, P);
2091   }
2092   llvm::sys::path::remove_dots(P);
2093   Opts.ModuleCachePath = std::string(P.str());
2094 
2095   Opts.ModuleUserBuildPath =
2096       std::string(Args.getLastArgValue(OPT_fmodules_user_build_path));
2097   // Only the -fmodule-file=<name>=<file> form.
2098   for (const auto *A : Args.filtered(OPT_fmodule_file)) {
2099     StringRef Val = A->getValue();
2100     if (Val.find('=') != StringRef::npos){
2101       auto Split = Val.split('=');
2102       Opts.PrebuiltModuleFiles.insert(
2103           {std::string(Split.first), std::string(Split.second)});
2104     }
2105   }
2106   for (const auto *A : Args.filtered(OPT_fprebuilt_module_path))
2107     Opts.AddPrebuiltModulePath(A->getValue());
2108   Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
2109   Opts.ModulesHashContent = Args.hasArg(OPT_fmodules_hash_content);
2110   Opts.ModulesStrictContextHash = Args.hasArg(OPT_fmodules_strict_context_hash);
2111   Opts.ModulesValidateDiagnosticOptions =
2112       !Args.hasArg(OPT_fmodules_disable_diagnostic_validation);
2113   Opts.ImplicitModuleMaps = Args.hasArg(OPT_fimplicit_module_maps);
2114   Opts.ModuleMapFileHomeIsCwd = Args.hasArg(OPT_fmodule_map_file_home_is_cwd);
2115   Opts.ModuleCachePruneInterval =
2116       getLastArgIntValue(Args, OPT_fmodules_prune_interval, 7 * 24 * 60 * 60);
2117   Opts.ModuleCachePruneAfter =
2118       getLastArgIntValue(Args, OPT_fmodules_prune_after, 31 * 24 * 60 * 60);
2119   Opts.ModulesValidateOncePerBuildSession =
2120       Args.hasArg(OPT_fmodules_validate_once_per_build_session);
2121   Opts.BuildSessionTimestamp =
2122       getLastArgUInt64Value(Args, OPT_fbuild_session_timestamp, 0);
2123   Opts.ModulesValidateSystemHeaders =
2124       Args.hasArg(OPT_fmodules_validate_system_headers);
2125   Opts.ValidateASTInputFilesContent =
2126       Args.hasArg(OPT_fvalidate_ast_input_files_content);
2127   if (const Arg *A = Args.getLastArg(OPT_fmodule_format_EQ))
2128     Opts.ModuleFormat = A->getValue();
2129 
2130   for (const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
2131     StringRef MacroDef = A->getValue();
2132     Opts.ModulesIgnoreMacros.insert(
2133         llvm::CachedHashString(MacroDef.split('=').first));
2134   }
2135 
2136   // Add -I..., -F..., and -index-header-map options in order.
2137   bool IsIndexHeaderMap = false;
2138   bool IsSysrootSpecified =
2139       Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
2140   for (const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
2141     if (A->getOption().matches(OPT_index_header_map)) {
2142       // -index-header-map applies to the next -I or -F.
2143       IsIndexHeaderMap = true;
2144       continue;
2145     }
2146 
2147     frontend::IncludeDirGroup Group =
2148         IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled;
2149 
2150     bool IsFramework = A->getOption().matches(OPT_F);
2151     std::string Path = A->getValue();
2152 
2153     if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {
2154       SmallString<32> Buffer;
2155       llvm::sys::path::append(Buffer, Opts.Sysroot,
2156                               llvm::StringRef(A->getValue()).substr(1));
2157       Path = std::string(Buffer.str());
2158     }
2159 
2160     Opts.AddPath(Path, Group, IsFramework,
2161                  /*IgnoreSysroot*/ true);
2162     IsIndexHeaderMap = false;
2163   }
2164 
2165   // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
2166   StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
2167   for (const auto *A :
2168        Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
2169     if (A->getOption().matches(OPT_iprefix))
2170       Prefix = A->getValue();
2171     else if (A->getOption().matches(OPT_iwithprefix))
2172       Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
2173     else
2174       Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
2175   }
2176 
2177   for (const auto *A : Args.filtered(OPT_idirafter))
2178     Opts.AddPath(A->getValue(), frontend::After, false, true);
2179   for (const auto *A : Args.filtered(OPT_iquote))
2180     Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
2181   for (const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
2182     Opts.AddPath(A->getValue(), frontend::System, false,
2183                  !A->getOption().matches(OPT_iwithsysroot));
2184   for (const auto *A : Args.filtered(OPT_iframework))
2185     Opts.AddPath(A->getValue(), frontend::System, true, true);
2186   for (const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
2187     Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,
2188                  /*IgnoreSysRoot=*/false);
2189 
2190   // Add the paths for the various language specific isystem flags.
2191   for (const auto *A : Args.filtered(OPT_c_isystem))
2192     Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
2193   for (const auto *A : Args.filtered(OPT_cxx_isystem))
2194     Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
2195   for (const auto *A : Args.filtered(OPT_objc_isystem))
2196     Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
2197   for (const auto *A : Args.filtered(OPT_objcxx_isystem))
2198     Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
2199 
2200   // Add the internal paths from a driver that detects standard include paths.
2201   for (const auto *A :
2202        Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
2203     frontend::IncludeDirGroup Group = frontend::System;
2204     if (A->getOption().matches(OPT_internal_externc_isystem))
2205       Group = frontend::ExternCSystem;
2206     Opts.AddPath(A->getValue(), Group, false, true);
2207   }
2208 
2209   // Add the path prefixes which are implicitly treated as being system headers.
2210   for (const auto *A :
2211        Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
2212     Opts.AddSystemHeaderPrefix(
2213         A->getValue(), A->getOption().matches(OPT_system_header_prefix));
2214 
2215   for (const auto *A : Args.filtered(OPT_ivfsoverlay))
2216     Opts.AddVFSOverlayFile(A->getValue());
2217 }
2218 
2219 void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
2220                                          const llvm::Triple &T,
2221                                          PreprocessorOptions &PPOpts,
2222                                          LangStandard::Kind LangStd) {
2223   // Set some properties which depend solely on the input kind; it would be nice
2224   // to move these to the language standard, and have the driver resolve the
2225   // input kind + language standard.
2226   //
2227   // FIXME: Perhaps a better model would be for a single source file to have
2228   // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
2229   // simultaneously active?
2230   if (IK.getLanguage() == Language::Asm) {
2231     Opts.AsmPreprocessor = 1;
2232   } else if (IK.isObjectiveC()) {
2233     Opts.ObjC = 1;
2234   }
2235 
2236   if (LangStd == LangStandard::lang_unspecified) {
2237     // Based on the base language, pick one.
2238     switch (IK.getLanguage()) {
2239     case Language::Unknown:
2240     case Language::LLVM_IR:
2241       llvm_unreachable("Invalid input kind!");
2242     case Language::OpenCL:
2243       LangStd = LangStandard::lang_opencl10;
2244       break;
2245     case Language::CUDA:
2246       LangStd = LangStandard::lang_cuda;
2247       break;
2248     case Language::Asm:
2249     case Language::C:
2250 #if defined(CLANG_DEFAULT_STD_C)
2251       LangStd = CLANG_DEFAULT_STD_C;
2252 #else
2253       // The PS4 uses C99 as the default C standard.
2254       if (T.isPS4())
2255         LangStd = LangStandard::lang_gnu99;
2256       else
2257         LangStd = LangStandard::lang_gnu17;
2258 #endif
2259       break;
2260     case Language::ObjC:
2261 #if defined(CLANG_DEFAULT_STD_C)
2262       LangStd = CLANG_DEFAULT_STD_C;
2263 #else
2264       LangStd = LangStandard::lang_gnu11;
2265 #endif
2266       break;
2267     case Language::CXX:
2268     case Language::ObjCXX:
2269 #if defined(CLANG_DEFAULT_STD_CXX)
2270       LangStd = CLANG_DEFAULT_STD_CXX;
2271 #else
2272       LangStd = LangStandard::lang_gnucxx14;
2273 #endif
2274       break;
2275     case Language::RenderScript:
2276       LangStd = LangStandard::lang_c99;
2277       break;
2278     case Language::HIP:
2279       LangStd = LangStandard::lang_hip;
2280       break;
2281     }
2282   }
2283 
2284   const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
2285   Opts.LineComment = Std.hasLineComments();
2286   Opts.C99 = Std.isC99();
2287   Opts.C11 = Std.isC11();
2288   Opts.C17 = Std.isC17();
2289   Opts.C2x = Std.isC2x();
2290   Opts.CPlusPlus = Std.isCPlusPlus();
2291   Opts.CPlusPlus11 = Std.isCPlusPlus11();
2292   Opts.CPlusPlus14 = Std.isCPlusPlus14();
2293   Opts.CPlusPlus17 = Std.isCPlusPlus17();
2294   Opts.CPlusPlus20 = Std.isCPlusPlus20();
2295   Opts.Digraphs = Std.hasDigraphs();
2296   Opts.GNUMode = Std.isGNUMode();
2297   Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;
2298   Opts.GNUCVersion = 0;
2299   Opts.HexFloats = Std.hasHexFloats();
2300   Opts.ImplicitInt = Std.hasImplicitInt();
2301 
2302   // Set OpenCL Version.
2303   Opts.OpenCL = Std.isOpenCL();
2304   if (LangStd == LangStandard::lang_opencl10)
2305     Opts.OpenCLVersion = 100;
2306   else if (LangStd == LangStandard::lang_opencl11)
2307     Opts.OpenCLVersion = 110;
2308   else if (LangStd == LangStandard::lang_opencl12)
2309     Opts.OpenCLVersion = 120;
2310   else if (LangStd == LangStandard::lang_opencl20)
2311     Opts.OpenCLVersion = 200;
2312   else if (LangStd == LangStandard::lang_openclcpp)
2313     Opts.OpenCLCPlusPlusVersion = 100;
2314 
2315   // OpenCL has some additional defaults.
2316   if (Opts.OpenCL) {
2317     Opts.AltiVec = 0;
2318     Opts.ZVector = 0;
2319     Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::None);
2320     Opts.setDefaultFPContractMode(LangOptions::FPM_On);
2321     Opts.NativeHalfType = 1;
2322     Opts.NativeHalfArgsAndReturns = 1;
2323     Opts.OpenCLCPlusPlus = Opts.CPlusPlus;
2324 
2325     // Include default header file for OpenCL.
2326     if (Opts.IncludeDefaultHeader) {
2327       if (Opts.DeclareOpenCLBuiltins) {
2328         // Only include base header file for builtin types and constants.
2329         PPOpts.Includes.push_back("opencl-c-base.h");
2330       } else {
2331         PPOpts.Includes.push_back("opencl-c.h");
2332       }
2333     }
2334   }
2335 
2336   Opts.HIP = IK.getLanguage() == Language::HIP;
2337   Opts.CUDA = IK.getLanguage() == Language::CUDA || Opts.HIP;
2338   if (Opts.CUDA)
2339     // Set default FP_CONTRACT to FAST.
2340     Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
2341 
2342   Opts.RenderScript = IK.getLanguage() == Language::RenderScript;
2343   if (Opts.RenderScript) {
2344     Opts.NativeHalfType = 1;
2345     Opts.NativeHalfArgsAndReturns = 1;
2346   }
2347 
2348   // OpenCL and C++ both have bool, true, false keywords.
2349   Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
2350 
2351   // OpenCL has half keyword
2352   Opts.Half = Opts.OpenCL;
2353 
2354   // C++ has wchar_t keyword.
2355   Opts.WChar = Opts.CPlusPlus;
2356 
2357   Opts.GNUKeywords = Opts.GNUMode;
2358   Opts.CXXOperatorNames = Opts.CPlusPlus;
2359 
2360   Opts.AlignedAllocation = Opts.CPlusPlus17;
2361 
2362   Opts.DollarIdents = !Opts.AsmPreprocessor;
2363 
2364   // Enable [[]] attributes in C++11 and C2x by default.
2365   Opts.DoubleSquareBracketAttributes = Opts.CPlusPlus11 || Opts.C2x;
2366 }
2367 
2368 /// Attempt to parse a visibility value out of the given argument.
2369 static Visibility parseVisibility(Arg *arg, ArgList &args,
2370                                   DiagnosticsEngine &diags) {
2371   StringRef value = arg->getValue();
2372   if (value == "default") {
2373     return DefaultVisibility;
2374   } else if (value == "hidden" || value == "internal") {
2375     return HiddenVisibility;
2376   } else if (value == "protected") {
2377     // FIXME: diagnose if target does not support protected visibility
2378     return ProtectedVisibility;
2379   }
2380 
2381   diags.Report(diag::err_drv_invalid_value)
2382     << arg->getAsString(args) << value;
2383   return DefaultVisibility;
2384 }
2385 
2386 /// Check if input file kind and language standard are compatible.
2387 static bool IsInputCompatibleWithStandard(InputKind IK,
2388                                           const LangStandard &S) {
2389   switch (IK.getLanguage()) {
2390   case Language::Unknown:
2391   case Language::LLVM_IR:
2392     llvm_unreachable("should not parse language flags for this input");
2393 
2394   case Language::C:
2395   case Language::ObjC:
2396   case Language::RenderScript:
2397     return S.getLanguage() == Language::C;
2398 
2399   case Language::OpenCL:
2400     return S.getLanguage() == Language::OpenCL;
2401 
2402   case Language::CXX:
2403   case Language::ObjCXX:
2404     return S.getLanguage() == Language::CXX;
2405 
2406   case Language::CUDA:
2407     // FIXME: What -std= values should be permitted for CUDA compilations?
2408     return S.getLanguage() == Language::CUDA ||
2409            S.getLanguage() == Language::CXX;
2410 
2411   case Language::HIP:
2412     return S.getLanguage() == Language::CXX || S.getLanguage() == Language::HIP;
2413 
2414   case Language::Asm:
2415     // Accept (and ignore) all -std= values.
2416     // FIXME: The -std= value is not ignored; it affects the tokenization
2417     // and preprocessing rules if we're preprocessing this asm input.
2418     return true;
2419   }
2420 
2421   llvm_unreachable("unexpected input language");
2422 }
2423 
2424 /// Get language name for given input kind.
2425 static const StringRef GetInputKindName(InputKind IK) {
2426   switch (IK.getLanguage()) {
2427   case Language::C:
2428     return "C";
2429   case Language::ObjC:
2430     return "Objective-C";
2431   case Language::CXX:
2432     return "C++";
2433   case Language::ObjCXX:
2434     return "Objective-C++";
2435   case Language::OpenCL:
2436     return "OpenCL";
2437   case Language::CUDA:
2438     return "CUDA";
2439   case Language::RenderScript:
2440     return "RenderScript";
2441   case Language::HIP:
2442     return "HIP";
2443 
2444   case Language::Asm:
2445     return "Asm";
2446   case Language::LLVM_IR:
2447     return "LLVM IR";
2448 
2449   case Language::Unknown:
2450     break;
2451   }
2452   llvm_unreachable("unknown input language");
2453 }
2454 
2455 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
2456                           const TargetOptions &TargetOpts,
2457                           PreprocessorOptions &PPOpts, CodeGenOptions &CGOpts,
2458                           DiagnosticsEngine &Diags) {
2459   // FIXME: Cleanup per-file based stuff.
2460   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
2461   if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
2462     LangStd = LangStandard::getLangKind(A->getValue());
2463     if (LangStd == LangStandard::lang_unspecified) {
2464       Diags.Report(diag::err_drv_invalid_value)
2465         << A->getAsString(Args) << A->getValue();
2466       // Report supported standards with short description.
2467       for (unsigned KindValue = 0;
2468            KindValue != LangStandard::lang_unspecified;
2469            ++KindValue) {
2470         const LangStandard &Std = LangStandard::getLangStandardForKind(
2471           static_cast<LangStandard::Kind>(KindValue));
2472         if (IsInputCompatibleWithStandard(IK, Std)) {
2473           auto Diag = Diags.Report(diag::note_drv_use_standard);
2474           Diag << Std.getName() << Std.getDescription();
2475           unsigned NumAliases = 0;
2476 #define LANGSTANDARD(id, name, lang, desc, features)
2477 #define LANGSTANDARD_ALIAS(id, alias) \
2478           if (KindValue == LangStandard::lang_##id) ++NumAliases;
2479 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
2480 #include "clang/Basic/LangStandards.def"
2481           Diag << NumAliases;
2482 #define LANGSTANDARD(id, name, lang, desc, features)
2483 #define LANGSTANDARD_ALIAS(id, alias) \
2484           if (KindValue == LangStandard::lang_##id) Diag << alias;
2485 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
2486 #include "clang/Basic/LangStandards.def"
2487         }
2488       }
2489     } else {
2490       // Valid standard, check to make sure language and standard are
2491       // compatible.
2492       const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
2493       if (!IsInputCompatibleWithStandard(IK, Std)) {
2494         Diags.Report(diag::err_drv_argument_not_allowed_with)
2495           << A->getAsString(Args) << GetInputKindName(IK);
2496       }
2497     }
2498   }
2499 
2500   if (Args.hasArg(OPT_fno_dllexport_inlines))
2501     Opts.DllExportInlines = false;
2502 
2503   if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
2504     StringRef Name = A->getValue();
2505     if (Name == "full" || Name == "branch") {
2506       Opts.CFProtectionBranch = 1;
2507     }
2508   }
2509   // -cl-std only applies for OpenCL language standards.
2510   // Override the -std option in this case.
2511   if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
2512     LangStandard::Kind OpenCLLangStd
2513       = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
2514         .Cases("cl", "CL", LangStandard::lang_opencl10)
2515         .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
2516         .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
2517         .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
2518         .Cases("clc++", "CLC++", LangStandard::lang_openclcpp)
2519         .Default(LangStandard::lang_unspecified);
2520 
2521     if (OpenCLLangStd == LangStandard::lang_unspecified) {
2522       Diags.Report(diag::err_drv_invalid_value)
2523         << A->getAsString(Args) << A->getValue();
2524     }
2525     else
2526       LangStd = OpenCLLangStd;
2527   }
2528 
2529   Opts.SYCL = Args.hasArg(options::OPT_fsycl);
2530   Opts.SYCLIsDevice = Opts.SYCL && Args.hasArg(options::OPT_fsycl_is_device);
2531   if (Opts.SYCL) {
2532     // -sycl-std applies to any SYCL source, not only those containing kernels,
2533     // but also those using the SYCL API
2534     if (const Arg *A = Args.getLastArg(OPT_sycl_std_EQ)) {
2535       Opts.SYCLVersion = llvm::StringSwitch<unsigned>(A->getValue())
2536                              .Cases("2017", "1.2.1", "121", "sycl-1.2.1", 2017)
2537                              .Default(0U);
2538 
2539       if (Opts.SYCLVersion == 0U) {
2540         // User has passed an invalid value to the flag, this is an error
2541         Diags.Report(diag::err_drv_invalid_value)
2542             << A->getAsString(Args) << A->getValue();
2543       }
2544     }
2545   }
2546 
2547   Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
2548   Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
2549 
2550   llvm::Triple T(TargetOpts.Triple);
2551   CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
2552 
2553   // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
2554   // This option should be deprecated for CL > 1.0 because
2555   // this option was added for compatibility with OpenCL 1.0.
2556   if (Args.getLastArg(OPT_cl_strict_aliasing)
2557        && Opts.OpenCLVersion > 100) {
2558     Diags.Report(diag::warn_option_invalid_ocl_version)
2559         << Opts.getOpenCLVersionTuple().getAsString()
2560         << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
2561   }
2562 
2563   // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
2564   // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
2565   // while a subset (the non-C++ GNU keywords) is provided by GCC's
2566   // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
2567   // name, as it doesn't seem a useful distinction.
2568   Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
2569                                   Opts.GNUKeywords);
2570 
2571   Opts.Digraphs = Args.hasFlag(OPT_fdigraphs, OPT_fno_digraphs, Opts.Digraphs);
2572 
2573   if (Args.hasArg(OPT_fno_operator_names))
2574     Opts.CXXOperatorNames = 0;
2575 
2576   if (Args.hasArg(OPT_fcuda_is_device))
2577     Opts.CUDAIsDevice = 1;
2578 
2579   if (Args.hasArg(OPT_fcuda_allow_variadic_functions))
2580     Opts.CUDAAllowVariadicFunctions = 1;
2581 
2582   if (Args.hasArg(OPT_fno_cuda_host_device_constexpr))
2583     Opts.CUDAHostDeviceConstexpr = 0;
2584 
2585   if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals))
2586     Opts.CUDADeviceApproxTranscendentals = 1;
2587 
2588   Opts.GPURelocatableDeviceCode = Args.hasArg(OPT_fgpu_rdc);
2589   if (Args.hasArg(OPT_fgpu_allow_device_init)) {
2590     if (Opts.HIP)
2591       Opts.GPUAllowDeviceInit = 1;
2592     else
2593       Diags.Report(diag::warn_ignored_hip_only_option)
2594           << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
2595   }
2596   Opts.HIPUseNewLaunchAPI = Args.hasArg(OPT_fhip_new_launch_api);
2597   if (Opts.HIP)
2598     Opts.GPUMaxThreadsPerBlock = getLastArgIntValue(
2599         Args, OPT_gpu_max_threads_per_block_EQ, Opts.GPUMaxThreadsPerBlock);
2600   else if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ))
2601     Diags.Report(diag::warn_ignored_hip_only_option)
2602         << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
2603 
2604   if (Opts.ObjC) {
2605     if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
2606       StringRef value = arg->getValue();
2607       if (Opts.ObjCRuntime.tryParse(value))
2608         Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
2609     }
2610 
2611     if (Args.hasArg(OPT_fobjc_gc_only))
2612       Opts.setGC(LangOptions::GCOnly);
2613     else if (Args.hasArg(OPT_fobjc_gc))
2614       Opts.setGC(LangOptions::HybridGC);
2615     else if (Args.hasArg(OPT_fobjc_arc)) {
2616       Opts.ObjCAutoRefCount = 1;
2617       if (!Opts.ObjCRuntime.allowsARC())
2618         Diags.Report(diag::err_arc_unsupported_on_runtime);
2619     }
2620 
2621     // ObjCWeakRuntime tracks whether the runtime supports __weak, not
2622     // whether the feature is actually enabled.  This is predominantly
2623     // determined by -fobjc-runtime, but we allow it to be overridden
2624     // from the command line for testing purposes.
2625     if (Args.hasArg(OPT_fobjc_runtime_has_weak))
2626       Opts.ObjCWeakRuntime = 1;
2627     else
2628       Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak();
2629 
2630     // ObjCWeak determines whether __weak is actually enabled.
2631     // Note that we allow -fno-objc-weak to disable this even in ARC mode.
2632     if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
2633       if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
2634         assert(!Opts.ObjCWeak);
2635       } else if (Opts.getGC() != LangOptions::NonGC) {
2636         Diags.Report(diag::err_objc_weak_with_gc);
2637       } else if (!Opts.ObjCWeakRuntime) {
2638         Diags.Report(diag::err_objc_weak_unsupported);
2639       } else {
2640         Opts.ObjCWeak = 1;
2641       }
2642     } else if (Opts.ObjCAutoRefCount) {
2643       Opts.ObjCWeak = Opts.ObjCWeakRuntime;
2644     }
2645 
2646     if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
2647       Opts.ObjCInferRelatedResultType = 0;
2648 
2649     if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
2650       Opts.ObjCSubscriptingLegacyRuntime =
2651         (Opts.ObjCRuntime.getKind() == ObjCRuntime::FragileMacOSX);
2652   }
2653 
2654   if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
2655     // Check that the version has 1 to 3 components and the minor and patch
2656     // versions fit in two decimal digits.
2657     VersionTuple GNUCVer;
2658     bool Invalid = GNUCVer.tryParse(A->getValue());
2659     unsigned Major = GNUCVer.getMajor();
2660     unsigned Minor = GNUCVer.getMinor().getValueOr(0);
2661     unsigned Patch = GNUCVer.getSubminor().getValueOr(0);
2662     if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
2663       Diags.Report(diag::err_drv_invalid_value)
2664           << A->getAsString(Args) << A->getValue();
2665     }
2666     Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
2667   }
2668 
2669   if (Args.hasArg(OPT_fgnu89_inline)) {
2670     if (Opts.CPlusPlus)
2671       Diags.Report(diag::err_drv_argument_not_allowed_with)
2672         << "-fgnu89-inline" << GetInputKindName(IK);
2673     else
2674       Opts.GNUInline = 1;
2675   }
2676 
2677   if (Args.hasArg(OPT_fapple_kext)) {
2678     if (!Opts.CPlusPlus)
2679       Diags.Report(diag::warn_c_kext);
2680     else
2681       Opts.AppleKext = 1;
2682   }
2683 
2684   if (Args.hasArg(OPT_print_ivar_layout))
2685     Opts.ObjCGCBitmapPrint = 1;
2686 
2687   if (Args.hasArg(OPT_fno_constant_cfstrings))
2688     Opts.NoConstantCFStrings = 1;
2689   if (const auto *A = Args.getLastArg(OPT_fcf_runtime_abi_EQ))
2690     Opts.CFRuntime =
2691         llvm::StringSwitch<LangOptions::CoreFoundationABI>(A->getValue())
2692             .Cases("unspecified", "standalone", "objc",
2693                    LangOptions::CoreFoundationABI::ObjectiveC)
2694             .Cases("swift", "swift-5.0",
2695                    LangOptions::CoreFoundationABI::Swift5_0)
2696             .Case("swift-4.2", LangOptions::CoreFoundationABI::Swift4_2)
2697             .Case("swift-4.1", LangOptions::CoreFoundationABI::Swift4_1)
2698             .Default(LangOptions::CoreFoundationABI::ObjectiveC);
2699 
2700   if (Args.hasArg(OPT_fzvector))
2701     Opts.ZVector = 1;
2702 
2703   if (Args.hasArg(OPT_pthread))
2704     Opts.POSIXThreads = 1;
2705 
2706   // The value-visibility mode defaults to "default".
2707   if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
2708     Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
2709   } else {
2710     Opts.setValueVisibilityMode(DefaultVisibility);
2711   }
2712 
2713   // The type-visibility mode defaults to the value-visibility mode.
2714   if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) {
2715     Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags));
2716   } else {
2717     Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
2718   }
2719 
2720   if (Args.hasArg(OPT_fvisibility_inlines_hidden))
2721     Opts.InlineVisibilityHidden = 1;
2722 
2723   if (Args.hasArg(OPT_fvisibility_global_new_delete_hidden))
2724     Opts.GlobalAllocationFunctionVisibilityHidden = 1;
2725 
2726   if (Args.hasArg(OPT_fapply_global_visibility_to_externs))
2727     Opts.SetVisibilityForExternDecls = 1;
2728 
2729   if (Args.hasArg(OPT_ftrapv)) {
2730     Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
2731     // Set the handler, if one is specified.
2732     Opts.OverflowHandler =
2733         std::string(Args.getLastArgValue(OPT_ftrapv_handler));
2734   }
2735   else if (Args.hasArg(OPT_fwrapv))
2736     Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
2737 
2738   Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
2739   Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
2740   Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
2741   Opts.MSCompatibilityVersion = 0;
2742   if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
2743     VersionTuple VT;
2744     if (VT.tryParse(A->getValue()))
2745       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
2746                                                 << A->getValue();
2747     Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
2748                                   VT.getMinor().getValueOr(0) * 100000 +
2749                                   VT.getSubminor().getValueOr(0);
2750   }
2751 
2752   // Mimicking gcc's behavior, trigraphs are only enabled if -trigraphs
2753   // is specified, or -std is set to a conforming mode.
2754   // Trigraphs are disabled by default in c++1z onwards.
2755   Opts.Trigraphs = !Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17;
2756   Opts.Trigraphs =
2757       Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
2758 
2759   Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
2760                                    OPT_fno_dollars_in_identifiers,
2761                                    Opts.DollarIdents);
2762   Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
2763   Opts.setVtorDispMode(
2764       MSVtorDispMode(getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags)));
2765   Opts.Borland = Args.hasArg(OPT_fborland_extensions);
2766   Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
2767   Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
2768                                    Opts.ConstStrings);
2769   if (Arg *A = Args.getLastArg(OPT_flax_vector_conversions_EQ)) {
2770     using LaxKind = LangOptions::LaxVectorConversionKind;
2771     if (auto Kind = llvm::StringSwitch<Optional<LaxKind>>(A->getValue())
2772                         .Case("none", LaxKind::None)
2773                         .Case("integer", LaxKind::Integer)
2774                         .Case("all", LaxKind::All)
2775                         .Default(llvm::None))
2776       Opts.setLaxVectorConversions(*Kind);
2777     else
2778       Diags.Report(diag::err_drv_invalid_value)
2779           << A->getAsString(Args) << A->getValue();
2780   }
2781   if (Args.hasArg(OPT_fno_threadsafe_statics))
2782     Opts.ThreadsafeStatics = 0;
2783   Opts.Exceptions = Args.hasArg(OPT_fexceptions);
2784   Opts.IgnoreExceptions = Args.hasArg(OPT_fignore_exceptions);
2785   Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
2786   Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
2787 
2788   // -ffixed-point
2789   Opts.FixedPoint =
2790       Args.hasFlag(OPT_ffixed_point, OPT_fno_fixed_point, /*Default=*/false) &&
2791       !Opts.CPlusPlus;
2792   Opts.PaddingOnUnsignedFixedPoint =
2793       Args.hasFlag(OPT_fpadding_on_unsigned_fixed_point,
2794                    OPT_fno_padding_on_unsigned_fixed_point,
2795                    /*Default=*/false) &&
2796       Opts.FixedPoint;
2797 
2798   // Handle exception personalities
2799   Arg *A = Args.getLastArg(
2800       options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions,
2801       options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions);
2802   if (A) {
2803     const Option &Opt = A->getOption();
2804     llvm::Triple T(TargetOpts.Triple);
2805     if (T.isWindowsMSVCEnvironment())
2806       Diags.Report(diag::err_fe_invalid_exception_model)
2807           << Opt.getName() << T.str();
2808 
2809     Opts.SjLjExceptions = Opt.matches(options::OPT_fsjlj_exceptions);
2810     Opts.SEHExceptions = Opt.matches(options::OPT_fseh_exceptions);
2811     Opts.DWARFExceptions = Opt.matches(options::OPT_fdwarf_exceptions);
2812     Opts.WasmExceptions = Opt.matches(options::OPT_fwasm_exceptions);
2813   }
2814 
2815   Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
2816   Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
2817 
2818   Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
2819   Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
2820   Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
2821     && Opts.OpenCLVersion == 200);
2822   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
2823   Opts.Coroutines = Opts.CPlusPlus20 || Args.hasArg(OPT_fcoroutines_ts);
2824 
2825   Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
2826     Args.hasArg(OPT_fconvergent_functions);
2827 
2828   Opts.DoubleSquareBracketAttributes =
2829       Args.hasFlag(OPT_fdouble_square_bracket_attributes,
2830                    OPT_fno_double_square_bracket_attributes,
2831                    Opts.DoubleSquareBracketAttributes);
2832 
2833   Opts.CPlusPlusModules = Opts.CPlusPlus20;
2834   Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
2835   Opts.Modules =
2836       Args.hasArg(OPT_fmodules) || Opts.ModulesTS || Opts.CPlusPlusModules;
2837   Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
2838   Opts.ModulesDeclUse =
2839       Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
2840   // FIXME: We only need this in C++ modules / Modules TS if we might textually
2841   // enter a different module (eg, when building a header unit).
2842   Opts.ModulesLocalVisibility =
2843       Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS ||
2844       Opts.CPlusPlusModules;
2845   Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen);
2846   Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
2847   Opts.ModulesSearchAll = Opts.Modules &&
2848     !Args.hasArg(OPT_fno_modules_search_all) &&
2849     Args.hasArg(OPT_fmodules_search_all);
2850   Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
2851   Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
2852   Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
2853   Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
2854   Opts.Char8 = Args.hasFlag(OPT_fchar8__t, OPT_fno_char8__t, Opts.CPlusPlus20);
2855   if (const Arg *A = Args.getLastArg(OPT_fwchar_type_EQ)) {
2856     Opts.WCharSize = llvm::StringSwitch<unsigned>(A->getValue())
2857                          .Case("char", 1)
2858                          .Case("short", 2)
2859                          .Case("int", 4)
2860                          .Default(0);
2861     if (Opts.WCharSize == 0)
2862       Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue();
2863   }
2864   Opts.WCharIsSigned = Args.hasFlag(OPT_fsigned_wchar, OPT_fno_signed_wchar, true);
2865   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
2866   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
2867   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
2868   if (!Opts.NoBuiltin)
2869     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
2870   Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
2871   Opts.RelaxedTemplateTemplateArgs =
2872       Args.hasArg(OPT_frelaxed_template_template_args);
2873   Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
2874   Opts.AlignedAllocation =
2875       Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
2876                    Opts.AlignedAllocation);
2877   Opts.AlignedAllocationUnavailable =
2878       Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable);
2879   Opts.NewAlignOverride =
2880       getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
2881   if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
2882     Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
2883     Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
2884                                                  << A->getValue();
2885     Opts.NewAlignOverride = 0;
2886   }
2887   Opts.ConceptSatisfactionCaching =
2888       !Args.hasArg(OPT_fno_concept_satisfaction_caching);
2889   if (Args.hasArg(OPT_fconcepts_ts))
2890     Diags.Report(diag::warn_fe_concepts_ts_flag);
2891   Opts.RecoveryAST =
2892       Args.hasFlag(OPT_frecovery_ast, OPT_fno_recovery_ast, false);
2893   Opts.RecoveryASTType =
2894 +      Args.hasFlag(OPT_frecovery_ast_type, OPT_fno_recovery_ast_type, false);
2895   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
2896   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
2897   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
2898   Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
2899   Opts.InstantiationDepth =
2900       getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
2901   Opts.ArrowDepth =
2902       getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
2903   Opts.ConstexprCallDepth =
2904       getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
2905   Opts.ConstexprStepLimit =
2906       getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
2907   Opts.EnableNewConstInterp =
2908       Args.hasArg(OPT_fexperimental_new_constant_interpreter);
2909   Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
2910   Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
2911   Opts.NumLargeByValueCopy =
2912       getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
2913   Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
2914   Opts.ObjCConstantStringClass =
2915       std::string(Args.getLastArgValue(OPT_fconstant_string_class));
2916   Opts.ObjCDefaultSynthProperties =
2917     !Args.hasArg(OPT_disable_objc_default_synthesize_properties);
2918   Opts.EncodeExtendedBlockSig =
2919     Args.hasArg(OPT_fencode_extended_block_signature);
2920   Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
2921   Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
2922   Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
2923   Opts.AlignDouble = Args.hasArg(OPT_malign_double);
2924   Opts.DoubleSize = getLastArgIntValue(Args, OPT_mdouble_EQ, 0, Diags);
2925   Opts.LongDoubleSize = Args.hasArg(OPT_mlong_double_128)
2926                             ? 128
2927                             : Args.hasArg(OPT_mlong_double_64) ? 64 : 0;
2928   Opts.PPCIEEELongDouble = Args.hasArg(OPT_mabi_EQ_ieeelongdouble);
2929   Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
2930   Opts.ROPI = Args.hasArg(OPT_fropi);
2931   Opts.RWPI = Args.hasArg(OPT_frwpi);
2932   Opts.PIE = Args.hasArg(OPT_pic_is_pie);
2933   Opts.Static = Args.hasArg(OPT_static_define);
2934   Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
2935   Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
2936                         || Args.hasArg(OPT_fdump_record_layouts);
2937   Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
2938   Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
2939   Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
2940   Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
2941   Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
2942   Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
2943   Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
2944   Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
2945   Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
2946   Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
2947   Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
2948   Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
2949   Opts.ModuleName = std::string(Args.getLastArgValue(OPT_fmodule_name_EQ));
2950   Opts.CurrentModule = Opts.ModuleName;
2951   Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
2952   Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
2953   llvm::sort(Opts.ModuleFeatures);
2954   Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
2955   Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns);
2956   // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns
2957   // is enabled.
2958   Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
2959                             | Opts.NativeHalfArgsAndReturns;
2960   Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
2961   Opts.Cmse = Args.hasArg(OPT_mcmse); // Armv8-M Security Extensions
2962 
2963   // __declspec is enabled by default for the PS4 by the driver, and also
2964   // enabled for Microsoft Extensions or Borland Extensions, here.
2965   //
2966   // FIXME: __declspec is also currently enabled for CUDA, but isn't really a
2967   // CUDA extension. However, it is required for supporting
2968   // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
2969   // been rewritten in terms of something more generic, remove the Opts.CUDA
2970   // term here.
2971   Opts.DeclSpecKeyword =
2972       Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec,
2973                    (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA));
2974 
2975   if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) {
2976     switch (llvm::StringSwitch<unsigned>(A->getValue())
2977       .Case("target", LangOptions::ASMM_Target)
2978       .Case("no", LangOptions::ASMM_Off)
2979       .Case("yes", LangOptions::ASMM_On)
2980       .Default(255)) {
2981     default:
2982       Diags.Report(diag::err_drv_invalid_value)
2983         << "-faddress-space-map-mangling=" << A->getValue();
2984       break;
2985     case LangOptions::ASMM_Target:
2986       Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Target);
2987       break;
2988     case LangOptions::ASMM_On:
2989       Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On);
2990       break;
2991     case LangOptions::ASMM_Off:
2992       Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off);
2993       break;
2994     }
2995   }
2996 
2997   if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
2998     LangOptions::PragmaMSPointersToMembersKind InheritanceModel =
2999         llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
3000             A->getValue())
3001             .Case("single",
3002                   LangOptions::PPTMK_FullGeneralitySingleInheritance)
3003             .Case("multiple",
3004                   LangOptions::PPTMK_FullGeneralityMultipleInheritance)
3005             .Case("virtual",
3006                   LangOptions::PPTMK_FullGeneralityVirtualInheritance)
3007             .Default(LangOptions::PPTMK_BestCase);
3008     if (InheritanceModel == LangOptions::PPTMK_BestCase)
3009       Diags.Report(diag::err_drv_invalid_value)
3010           << "-fms-memptr-rep=" << A->getValue();
3011 
3012     Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
3013   }
3014 
3015   // Check for MS default calling conventions being specified.
3016   if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
3017     LangOptions::DefaultCallingConvention DefaultCC =
3018         llvm::StringSwitch<LangOptions::DefaultCallingConvention>(A->getValue())
3019             .Case("cdecl", LangOptions::DCC_CDecl)
3020             .Case("fastcall", LangOptions::DCC_FastCall)
3021             .Case("stdcall", LangOptions::DCC_StdCall)
3022             .Case("vectorcall", LangOptions::DCC_VectorCall)
3023             .Case("regcall", LangOptions::DCC_RegCall)
3024             .Default(LangOptions::DCC_None);
3025     if (DefaultCC == LangOptions::DCC_None)
3026       Diags.Report(diag::err_drv_invalid_value)
3027           << "-fdefault-calling-conv=" << A->getValue();
3028 
3029     llvm::Triple T(TargetOpts.Triple);
3030     llvm::Triple::ArchType Arch = T.getArch();
3031     bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||
3032                       DefaultCC == LangOptions::DCC_StdCall) &&
3033                      Arch != llvm::Triple::x86;
3034     emitError |= (DefaultCC == LangOptions::DCC_VectorCall ||
3035                   DefaultCC == LangOptions::DCC_RegCall) &&
3036                  !T.isX86();
3037     if (emitError)
3038       Diags.Report(diag::err_drv_argument_not_allowed_with)
3039           << A->getSpelling() << T.getTriple();
3040     else
3041       Opts.setDefaultCallingConv(DefaultCC);
3042   }
3043 
3044   Opts.SemanticInterposition = Args.hasArg(OPT_fsemantic_interposition);
3045 
3046   // -mrtd option
3047   if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3048     if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
3049       Diags.Report(diag::err_drv_argument_not_allowed_with)
3050           << A->getSpelling() << "-fdefault-calling-conv";
3051     else {
3052       llvm::Triple T(TargetOpts.Triple);
3053       if (T.getArch() != llvm::Triple::x86)
3054         Diags.Report(diag::err_drv_argument_not_allowed_with)
3055             << A->getSpelling() << T.getTriple();
3056       else
3057         Opts.setDefaultCallingConv(LangOptions::DCC_StdCall);
3058     }
3059   }
3060 
3061   // Check if -fopenmp is specified and set default version to 4.5.
3062   Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 45 : 0;
3063   // Check if -fopenmp-simd is specified.
3064   bool IsSimdSpecified =
3065       Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
3066                    /*Default=*/false);
3067   Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
3068   Opts.OpenMPUseTLS =
3069       Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
3070   Opts.OpenMPIsDevice =
3071       Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
3072   Opts.OpenMPIRBuilder =
3073       Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
3074   bool IsTargetSpecified =
3075       Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
3076 
3077   if (Opts.OpenMP || Opts.OpenMPSimd) {
3078     if (int Version = getLastArgIntValue(
3079             Args, OPT_fopenmp_version_EQ,
3080             (IsSimdSpecified || IsTargetSpecified) ? 45 : Opts.OpenMP, Diags))
3081       Opts.OpenMP = Version;
3082     else if (IsSimdSpecified || IsTargetSpecified)
3083       Opts.OpenMP = 45;
3084     // Provide diagnostic when a given target is not expected to be an OpenMP
3085     // device or host.
3086     if (!Opts.OpenMPIsDevice) {
3087       switch (T.getArch()) {
3088       default:
3089         break;
3090       // Add unsupported host targets here:
3091       case llvm::Triple::nvptx:
3092       case llvm::Triple::nvptx64:
3093         Diags.Report(diag::err_drv_omp_host_target_not_supported)
3094             << TargetOpts.Triple;
3095         break;
3096       }
3097     }
3098   }
3099 
3100   // Set the flag to prevent the implementation from emitting device exception
3101   // handling code for those requiring so.
3102   if ((Opts.OpenMPIsDevice && T.isNVPTX()) || Opts.OpenCLCPlusPlus) {
3103     Opts.Exceptions = 0;
3104     Opts.CXXExceptions = 0;
3105   }
3106   if (Opts.OpenMPIsDevice && T.isNVPTX()) {
3107     Opts.OpenMPCUDANumSMs =
3108         getLastArgIntValue(Args, options::OPT_fopenmp_cuda_number_of_sm_EQ,
3109                            Opts.OpenMPCUDANumSMs, Diags);
3110     Opts.OpenMPCUDABlocksPerSM =
3111         getLastArgIntValue(Args, options::OPT_fopenmp_cuda_blocks_per_sm_EQ,
3112                            Opts.OpenMPCUDABlocksPerSM, Diags);
3113     Opts.OpenMPCUDAReductionBufNum = getLastArgIntValue(
3114         Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3115         Opts.OpenMPCUDAReductionBufNum, Diags);
3116   }
3117 
3118   // Prevent auto-widening the representation of loop counters during an
3119   // OpenMP collapse clause.
3120   Opts.OpenMPOptimisticCollapse =
3121       Args.hasArg(options::OPT_fopenmp_optimistic_collapse) ? 1 : 0;
3122 
3123   // Get the OpenMP target triples if any.
3124   if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
3125 
3126     for (unsigned i = 0; i < A->getNumValues(); ++i) {
3127       llvm::Triple TT(A->getValue(i));
3128 
3129       if (TT.getArch() == llvm::Triple::UnknownArch ||
3130           !(TT.getArch() == llvm::Triple::aarch64 ||
3131             TT.getArch() == llvm::Triple::ppc ||
3132             TT.getArch() == llvm::Triple::ppc64 ||
3133             TT.getArch() == llvm::Triple::ppc64le ||
3134             TT.getArch() == llvm::Triple::nvptx ||
3135             TT.getArch() == llvm::Triple::nvptx64 ||
3136             TT.getArch() == llvm::Triple::x86 ||
3137             TT.getArch() == llvm::Triple::x86_64))
3138         Diags.Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
3139       else
3140         Opts.OMPTargetTriples.push_back(TT);
3141     }
3142   }
3143 
3144   // Get OpenMP host file path if any and report if a non existent file is
3145   // found
3146   if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
3147     Opts.OMPHostIRFile = A->getValue();
3148     if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
3149       Diags.Report(diag::err_drv_omp_host_ir_file_not_found)
3150           << Opts.OMPHostIRFile;
3151   }
3152 
3153   // Set CUDA mode for OpenMP target NVPTX if specified in options
3154   Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && T.isNVPTX() &&
3155                         Args.hasArg(options::OPT_fopenmp_cuda_mode);
3156 
3157   // Set CUDA mode for OpenMP target NVPTX if specified in options
3158   Opts.OpenMPCUDAForceFullRuntime =
3159       Opts.OpenMPIsDevice && T.isNVPTX() &&
3160       Args.hasArg(options::OPT_fopenmp_cuda_force_full_runtime);
3161 
3162   // Record whether the __DEPRECATED define was requested.
3163   Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
3164                                  OPT_fno_deprecated_macro,
3165                                  Opts.Deprecated);
3166 
3167   // FIXME: Eliminate this dependency.
3168   unsigned Opt = getOptimizationLevel(Args, IK, Diags),
3169        OptSize = getOptimizationLevelSize(Args);
3170   Opts.Optimize = Opt != 0;
3171   Opts.OptimizeSize = OptSize != 0;
3172 
3173   // This is the __NO_INLINE__ define, which just depends on things like the
3174   // optimization level and -fno-inline, not actually whether the backend has
3175   // inlining enabled.
3176   Opts.NoInlineDefine = !Opts.Optimize;
3177   if (Arg *InlineArg = Args.getLastArg(
3178           options::OPT_finline_functions, options::OPT_finline_hint_functions,
3179           options::OPT_fno_inline_functions, options::OPT_fno_inline))
3180     if (InlineArg->getOption().matches(options::OPT_fno_inline))
3181       Opts.NoInlineDefine = true;
3182 
3183   Opts.FastMath = Args.hasArg(OPT_ffast_math) ||
3184       Args.hasArg(OPT_cl_fast_relaxed_math);
3185   Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
3186       Args.hasArg(OPT_cl_finite_math_only) ||
3187       Args.hasArg(OPT_cl_fast_relaxed_math);
3188   Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
3189                       Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
3190                       Args.hasArg(OPT_cl_fast_relaxed_math);
3191   Opts.AllowFPReassoc = Opts.FastMath || CGOpts.Reassociate;
3192   Opts.NoHonorNaNs =
3193       Opts.FastMath || CGOpts.NoNaNsFPMath || Opts.FiniteMathOnly;
3194   Opts.NoHonorInfs =
3195       Opts.FastMath || CGOpts.NoInfsFPMath || Opts.FiniteMathOnly;
3196   Opts.NoSignedZero = Opts.FastMath || CGOpts.NoSignedZeros;
3197   Opts.AllowRecip = Opts.FastMath || CGOpts.ReciprocalMath;
3198   // Currently there's no clang option to enable this individually
3199   Opts.ApproxFunc = Opts.FastMath;
3200 
3201   if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
3202     StringRef Val = A->getValue();
3203     if (Val == "fast")
3204       Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
3205     else if (Val == "on")
3206       Opts.setDefaultFPContractMode(LangOptions::FPM_On);
3207     else if (Val == "off")
3208       Opts.setDefaultFPContractMode(LangOptions::FPM_Off);
3209     else
3210       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
3211   }
3212 
3213   auto FPRM = llvm::RoundingMode::NearestTiesToEven;
3214   if (Args.hasArg(OPT_frounding_math)) {
3215     FPRM = llvm::RoundingMode::Dynamic;
3216   }
3217   Opts.setFPRoundingMode(FPRM);
3218 
3219   if (Args.hasArg(OPT_ftrapping_math)) {
3220     Opts.setFPExceptionMode(LangOptions::FPE_Strict);
3221   }
3222 
3223   if (Args.hasArg(OPT_fno_trapping_math)) {
3224     Opts.setFPExceptionMode(LangOptions::FPE_Ignore);
3225   }
3226 
3227   LangOptions::FPExceptionModeKind FPEB = LangOptions::FPE_Ignore;
3228   if (Arg *A = Args.getLastArg(OPT_ffp_exception_behavior_EQ)) {
3229     StringRef Val = A->getValue();
3230     if (Val.equals("ignore"))
3231       FPEB = LangOptions::FPE_Ignore;
3232     else if (Val.equals("maytrap"))
3233       FPEB = LangOptions::FPE_MayTrap;
3234     else if (Val.equals("strict"))
3235       FPEB = LangOptions::FPE_Strict;
3236     else
3237       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
3238   }
3239   Opts.setFPExceptionMode(FPEB);
3240 
3241   Opts.RetainCommentsFromSystemHeaders =
3242       Args.hasArg(OPT_fretain_comments_from_system_headers);
3243 
3244   unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
3245   switch (SSP) {
3246   default:
3247     Diags.Report(diag::err_drv_invalid_value)
3248       << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
3249     break;
3250   case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
3251   case 1: Opts.setStackProtector(LangOptions::SSPOn);  break;
3252   case 2: Opts.setStackProtector(LangOptions::SSPStrong); break;
3253   case 3: Opts.setStackProtector(LangOptions::SSPReq); break;
3254   }
3255 
3256   if (Arg *A = Args.getLastArg(OPT_ftrivial_auto_var_init)) {
3257     StringRef Val = A->getValue();
3258     if (Val == "uninitialized")
3259       Opts.setTrivialAutoVarInit(
3260           LangOptions::TrivialAutoVarInitKind::Uninitialized);
3261     else if (Val == "zero")
3262       Opts.setTrivialAutoVarInit(LangOptions::TrivialAutoVarInitKind::Zero);
3263     else if (Val == "pattern")
3264       Opts.setTrivialAutoVarInit(LangOptions::TrivialAutoVarInitKind::Pattern);
3265     else
3266       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
3267   }
3268 
3269   // Parse -fsanitize= arguments.
3270   parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
3271                       Diags, Opts.Sanitize);
3272   // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
3273   Opts.SanitizeAddressFieldPadding =
3274       getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
3275   Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
3276   std::vector<std::string> systemBlacklists =
3277       Args.getAllArgValues(OPT_fsanitize_system_blacklist);
3278   Opts.SanitizerBlacklistFiles.insert(Opts.SanitizerBlacklistFiles.end(),
3279                                       systemBlacklists.begin(),
3280                                       systemBlacklists.end());
3281 
3282   // -fxray-instrument
3283   Opts.XRayInstrument = Args.hasArg(OPT_fxray_instrument);
3284   Opts.XRayAlwaysEmitCustomEvents =
3285       Args.hasArg(OPT_fxray_always_emit_customevents);
3286   Opts.XRayAlwaysEmitTypedEvents =
3287       Args.hasArg(OPT_fxray_always_emit_typedevents);
3288 
3289   // -fxray-{always,never}-instrument= filenames.
3290   Opts.XRayAlwaysInstrumentFiles =
3291       Args.getAllArgValues(OPT_fxray_always_instrument);
3292   Opts.XRayNeverInstrumentFiles =
3293       Args.getAllArgValues(OPT_fxray_never_instrument);
3294   Opts.XRayAttrListFiles = Args.getAllArgValues(OPT_fxray_attr_list);
3295 
3296   // -fforce-emit-vtables
3297   Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables);
3298 
3299   // -fallow-editor-placeholders
3300   Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders);
3301 
3302   Opts.RegisterStaticDestructors = !Args.hasArg(OPT_fno_cxx_static_destructors);
3303 
3304   if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
3305     Opts.setClangABICompat(LangOptions::ClangABI::Latest);
3306 
3307     StringRef Ver = A->getValue();
3308     std::pair<StringRef, StringRef> VerParts = Ver.split('.');
3309     unsigned Major, Minor = 0;
3310 
3311     // Check the version number is valid: either 3.x (0 <= x <= 9) or
3312     // y or y.0 (4 <= y <= current version).
3313     if (!VerParts.first.startswith("0") &&
3314         !VerParts.first.getAsInteger(10, Major) &&
3315         3 <= Major && Major <= CLANG_VERSION_MAJOR &&
3316         (Major == 3 ? VerParts.second.size() == 1 &&
3317                       !VerParts.second.getAsInteger(10, Minor)
3318                     : VerParts.first.size() == Ver.size() ||
3319                       VerParts.second == "0")) {
3320       // Got a valid version number.
3321       if (Major == 3 && Minor <= 8)
3322         Opts.setClangABICompat(LangOptions::ClangABI::Ver3_8);
3323       else if (Major <= 4)
3324         Opts.setClangABICompat(LangOptions::ClangABI::Ver4);
3325       else if (Major <= 6)
3326         Opts.setClangABICompat(LangOptions::ClangABI::Ver6);
3327       else if (Major <= 7)
3328         Opts.setClangABICompat(LangOptions::ClangABI::Ver7);
3329       else if (Major <= 9)
3330         Opts.setClangABICompat(LangOptions::ClangABI::Ver9);
3331     } else if (Ver != "latest") {
3332       Diags.Report(diag::err_drv_invalid_value)
3333           << A->getAsString(Args) << A->getValue();
3334     }
3335   }
3336 
3337   Opts.CompleteMemberPointers = Args.hasArg(OPT_fcomplete_member_pointers);
3338   Opts.BuildingPCHWithObjectFile = Args.hasArg(OPT_building_pch_with_obj);
3339 
3340   Opts.MatrixTypes = Args.hasArg(OPT_fenable_matrix);
3341 
3342   Opts.MaxTokens = getLastArgIntValue(Args, OPT_fmax_tokens_EQ, 0, Diags);
3343 
3344   if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
3345     StringRef SignScope = A->getValue();
3346 
3347     if (SignScope.equals_lower("none"))
3348       Opts.setSignReturnAddressScope(
3349           LangOptions::SignReturnAddressScopeKind::None);
3350     else if (SignScope.equals_lower("all"))
3351       Opts.setSignReturnAddressScope(
3352           LangOptions::SignReturnAddressScopeKind::All);
3353     else if (SignScope.equals_lower("non-leaf"))
3354       Opts.setSignReturnAddressScope(
3355           LangOptions::SignReturnAddressScopeKind::NonLeaf);
3356     else
3357       Diags.Report(diag::err_drv_invalid_value)
3358           << A->getAsString(Args) << SignScope;
3359 
3360     if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
3361       StringRef SignKey = A->getValue();
3362       if (!SignScope.empty() && !SignKey.empty()) {
3363         if (SignKey.equals_lower("a_key"))
3364           Opts.setSignReturnAddressKey(
3365               LangOptions::SignReturnAddressKeyKind::AKey);
3366         else if (SignKey.equals_lower("b_key"))
3367           Opts.setSignReturnAddressKey(
3368               LangOptions::SignReturnAddressKeyKind::BKey);
3369         else
3370           Diags.Report(diag::err_drv_invalid_value)
3371               << A->getAsString(Args) << SignKey;
3372       }
3373     }
3374   }
3375 
3376   Opts.BranchTargetEnforcement = Args.hasArg(OPT_mbranch_target_enforce);
3377 }
3378 
3379 static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
3380   switch (Action) {
3381   case frontend::ASTDeclList:
3382   case frontend::ASTDump:
3383   case frontend::ASTPrint:
3384   case frontend::ASTView:
3385   case frontend::EmitAssembly:
3386   case frontend::EmitBC:
3387   case frontend::EmitHTML:
3388   case frontend::EmitLLVM:
3389   case frontend::EmitLLVMOnly:
3390   case frontend::EmitCodeGenOnly:
3391   case frontend::EmitObj:
3392   case frontend::FixIt:
3393   case frontend::GenerateModule:
3394   case frontend::GenerateModuleInterface:
3395   case frontend::GenerateHeaderModule:
3396   case frontend::GeneratePCH:
3397   case frontend::GenerateInterfaceStubs:
3398   case frontend::ParseSyntaxOnly:
3399   case frontend::ModuleFileInfo:
3400   case frontend::VerifyPCH:
3401   case frontend::PluginAction:
3402   case frontend::RewriteObjC:
3403   case frontend::RewriteTest:
3404   case frontend::RunAnalysis:
3405   case frontend::TemplightDump:
3406   case frontend::MigrateSource:
3407     return false;
3408 
3409   case frontend::DumpCompilerOptions:
3410   case frontend::DumpRawTokens:
3411   case frontend::DumpTokens:
3412   case frontend::InitOnly:
3413   case frontend::PrintPreamble:
3414   case frontend::PrintPreprocessedInput:
3415   case frontend::RewriteMacros:
3416   case frontend::RunPreprocessorOnly:
3417   case frontend::PrintDependencyDirectivesSourceMinimizerOutput:
3418     return true;
3419   }
3420   llvm_unreachable("invalid frontend action");
3421 }
3422 
3423 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
3424                                   DiagnosticsEngine &Diags,
3425                                   frontend::ActionKind Action) {
3426   Opts.ImplicitPCHInclude = std::string(Args.getLastArgValue(OPT_include_pch));
3427   Opts.PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
3428                         Args.hasArg(OPT_pch_through_hdrstop_use);
3429   Opts.PCHWithHdrStopCreate = Args.hasArg(OPT_pch_through_hdrstop_create);
3430   Opts.PCHThroughHeader =
3431       std::string(Args.getLastArgValue(OPT_pch_through_header_EQ));
3432   Opts.UsePredefines = !Args.hasArg(OPT_undef);
3433   Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
3434   Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
3435   Opts.AllowPCHWithCompilerErrors = Args.hasArg(OPT_fallow_pch_with_errors);
3436 
3437   Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
3438   for (const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
3439     Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue());
3440 
3441   for (const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
3442     auto Split = StringRef(A).split('=');
3443     Opts.MacroPrefixMap.insert(
3444         {std::string(Split.first), std::string(Split.second)});
3445   }
3446 
3447   if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
3448     StringRef Value(A->getValue());
3449     size_t Comma = Value.find(',');
3450     unsigned Bytes = 0;
3451     unsigned EndOfLine = 0;
3452 
3453     if (Comma == StringRef::npos ||
3454         Value.substr(0, Comma).getAsInteger(10, Bytes) ||
3455         Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
3456       Diags.Report(diag::err_drv_preamble_format);
3457     else {
3458       Opts.PrecompiledPreambleBytes.first = Bytes;
3459       Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
3460     }
3461   }
3462 
3463   // Add the __CET__ macro if a CFProtection option is set.
3464   if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3465     StringRef Name = A->getValue();
3466     if (Name == "branch")
3467       Opts.addMacroDef("__CET__=1");
3468     else if (Name == "return")
3469       Opts.addMacroDef("__CET__=2");
3470     else if (Name == "full")
3471       Opts.addMacroDef("__CET__=3");
3472   }
3473 
3474   // Add macros from the command line.
3475   for (const auto *A : Args.filtered(OPT_D, OPT_U)) {
3476     if (A->getOption().matches(OPT_D))
3477       Opts.addMacroDef(A->getValue());
3478     else
3479       Opts.addMacroUndef(A->getValue());
3480   }
3481 
3482   Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
3483 
3484   // Add the ordered list of -includes.
3485   for (const auto *A : Args.filtered(OPT_include))
3486     Opts.Includes.emplace_back(A->getValue());
3487 
3488   for (const auto *A : Args.filtered(OPT_chain_include))
3489     Opts.ChainedIncludes.emplace_back(A->getValue());
3490 
3491   for (const auto *A : Args.filtered(OPT_remap_file)) {
3492     std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');
3493 
3494     if (Split.second.empty()) {
3495       Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
3496       continue;
3497     }
3498 
3499     Opts.addRemappedFile(Split.first, Split.second);
3500   }
3501 
3502   if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
3503     StringRef Name = A->getValue();
3504     unsigned Library = llvm::StringSwitch<unsigned>(Name)
3505       .Case("libc++", ARCXX_libcxx)
3506       .Case("libstdc++", ARCXX_libstdcxx)
3507       .Case("none", ARCXX_nolib)
3508       .Default(~0U);
3509     if (Library == ~0U)
3510       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
3511     else
3512       Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
3513   }
3514 
3515   // Always avoid lexing editor placeholders when we're just running the
3516   // preprocessor as we never want to emit the
3517   // "editor placeholder in source file" error in PP only mode.
3518   if (isStrictlyPreprocessorAction(Action))
3519     Opts.LexEditorPlaceholders = false;
3520 
3521   Opts.SetUpStaticAnalyzer = Args.hasArg(OPT_setup_static_analyzer);
3522   Opts.DisablePragmaDebugCrash = Args.hasArg(OPT_disable_pragma_debug_crash);
3523 }
3524 
3525 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
3526                                         ArgList &Args,
3527                                         frontend::ActionKind Action) {
3528   if (isStrictlyPreprocessorAction(Action))
3529     Opts.ShowCPP = !Args.hasArg(OPT_dM);
3530   else
3531     Opts.ShowCPP = 0;
3532 
3533   Opts.ShowComments = Args.hasArg(OPT_C);
3534   Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
3535   Opts.ShowMacroComments = Args.hasArg(OPT_CC);
3536   Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
3537   Opts.ShowIncludeDirectives = Args.hasArg(OPT_dI);
3538   Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
3539   Opts.RewriteImports = Args.hasArg(OPT_frewrite_imports);
3540   Opts.UseLineDirectives = Args.hasArg(OPT_fuse_line_directives);
3541 }
3542 
3543 static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
3544                             DiagnosticsEngine &Diags) {
3545   Opts.CodeModel = std::string(Args.getLastArgValue(OPT_mcmodel_EQ, "default"));
3546   Opts.ABI = std::string(Args.getLastArgValue(OPT_target_abi));
3547   if (Arg *A = Args.getLastArg(OPT_meabi)) {
3548     StringRef Value = A->getValue();
3549     llvm::EABI EABIVersion = llvm::StringSwitch<llvm::EABI>(Value)
3550                                  .Case("default", llvm::EABI::Default)
3551                                  .Case("4", llvm::EABI::EABI4)
3552                                  .Case("5", llvm::EABI::EABI5)
3553                                  .Case("gnu", llvm::EABI::GNU)
3554                                  .Default(llvm::EABI::Unknown);
3555     if (EABIVersion == llvm::EABI::Unknown)
3556       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3557                                                 << Value;
3558     else
3559       Opts.EABIVersion = EABIVersion;
3560   }
3561   Opts.CPU = std::string(Args.getLastArgValue(OPT_target_cpu));
3562   Opts.FPMath = std::string(Args.getLastArgValue(OPT_mfpmath));
3563   Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
3564   Opts.LinkerVersion =
3565       std::string(Args.getLastArgValue(OPT_target_linker_version));
3566   Opts.Triple = std::string(Args.getLastArgValue(OPT_triple));
3567   // Use the default target triple if unspecified.
3568   if (Opts.Triple.empty())
3569     Opts.Triple = llvm::sys::getDefaultTargetTriple();
3570   Opts.Triple = llvm::Triple::normalize(Opts.Triple);
3571   Opts.OpenCLExtensionsAsWritten = Args.getAllArgValues(OPT_cl_ext_EQ);
3572   Opts.ForceEnableInt128 = Args.hasArg(OPT_fforce_enable_int128);
3573   Opts.NVPTXUseShortPointers = Args.hasFlag(
3574       options::OPT_fcuda_short_ptr, options::OPT_fno_cuda_short_ptr, false);
3575   if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
3576     llvm::VersionTuple Version;
3577     if (Version.tryParse(A->getValue()))
3578       Diags.Report(diag::err_drv_invalid_value)
3579           << A->getAsString(Args) << A->getValue();
3580     else
3581       Opts.SDKVersion = Version;
3582   }
3583 }
3584 
3585 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
3586                                         ArrayRef<const char *> CommandLineArgs,
3587                                         DiagnosticsEngine &Diags) {
3588   bool Success = true;
3589 
3590   // Parse the arguments.
3591   const OptTable &Opts = getDriverOptTable();
3592   const unsigned IncludedFlagsBitmask = options::CC1Option;
3593   unsigned MissingArgIndex, MissingArgCount;
3594   InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
3595                                      MissingArgCount, IncludedFlagsBitmask);
3596   LangOptions &LangOpts = *Res.getLangOpts();
3597 
3598   // Check for missing argument error.
3599   if (MissingArgCount) {
3600     Diags.Report(diag::err_drv_missing_argument)
3601         << Args.getArgString(MissingArgIndex) << MissingArgCount;
3602     Success = false;
3603   }
3604 
3605   // Issue errors on unknown arguments.
3606   for (const auto *A : Args.filtered(OPT_UNKNOWN)) {
3607     auto ArgString = A->getAsString(Args);
3608     std::string Nearest;
3609     if (Opts.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
3610       Diags.Report(diag::err_drv_unknown_argument) << ArgString;
3611     else
3612       Diags.Report(diag::err_drv_unknown_argument_with_suggestion)
3613           << ArgString << Nearest;
3614     Success = false;
3615   }
3616 
3617   Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
3618   Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args);
3619   ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args);
3620   if (!Res.getDependencyOutputOpts().OutputFile.empty() &&
3621       Res.getDependencyOutputOpts().Targets.empty()) {
3622     Diags.Report(diag::err_fe_dependency_file_requires_MT);
3623     Success = false;
3624   }
3625   Success &= ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
3626                                  /*DefaultDiagColor=*/false);
3627   ParseCommentArgs(LangOpts.CommentOpts, Args);
3628   ParseFileSystemArgs(Res.getFileSystemOpts(), Args);
3629   // FIXME: We shouldn't have to pass the DashX option around here
3630   InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
3631                                       LangOpts.IsHeaderFile);
3632   ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
3633   Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags,
3634                               Res.getTargetOpts(), Res.getFrontendOpts());
3635   ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args,
3636                         Res.getFileSystemOpts().WorkingDir);
3637   llvm::Triple T(Res.getTargetOpts().Triple);
3638   if (DashX.getFormat() == InputKind::Precompiled ||
3639       DashX.getLanguage() == Language::LLVM_IR) {
3640     // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
3641     // PassManager in BackendUtil.cpp. They need to be initializd no matter
3642     // what the input type is.
3643     if (Args.hasArg(OPT_fobjc_arc))
3644       LangOpts.ObjCAutoRefCount = 1;
3645     // PIClevel and PIELevel are needed during code generation and this should be
3646     // set regardless of the input type.
3647     LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
3648     LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
3649     parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
3650                         Diags, LangOpts.Sanitize);
3651   } else {
3652     // Other LangOpts are only initialized when the input is not AST or LLVM IR.
3653     // FIXME: Should we really be calling this for an Language::Asm input?
3654     ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
3655                   Res.getPreprocessorOpts(), Res.getCodeGenOpts(), Diags);
3656     if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
3657       LangOpts.ObjCExceptions = 1;
3658     if (T.isOSDarwin() && DashX.isPreprocessed()) {
3659       // Supress the darwin-specific 'stdlibcxx-not-found' diagnostic for
3660       // preprocessed input as we don't expect it to be used with -std=libc++
3661       // anyway.
3662       Res.getDiagnosticOpts().Warnings.push_back("no-stdlibcxx-not-found");
3663     }
3664   }
3665 
3666   if (Diags.isIgnored(diag::warn_profile_data_misexpect, SourceLocation()))
3667     Res.FrontendOpts.LLVMArgs.push_back("-pgo-warn-misexpect");
3668 
3669   LangOpts.FunctionAlignment =
3670       getLastArgIntValue(Args, OPT_function_alignment, 0, Diags);
3671 
3672   if (LangOpts.CUDA) {
3673     // During CUDA device-side compilation, the aux triple is the
3674     // triple used for host compilation.
3675     if (LangOpts.CUDAIsDevice)
3676       Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
3677   }
3678 
3679   // Set the triple of the host for OpenMP device compile.
3680   if (LangOpts.OpenMPIsDevice)
3681     Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
3682 
3683   // FIXME: Override value name discarding when asan or msan is used because the
3684   // backend passes depend on the name of the alloca in order to print out
3685   // names.
3686   Res.getCodeGenOpts().DiscardValueNames &=
3687       !LangOpts.Sanitize.has(SanitizerKind::Address) &&
3688       !LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
3689       !LangOpts.Sanitize.has(SanitizerKind::Memory) &&
3690       !LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
3691 
3692   ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, Diags,
3693                         Res.getFrontendOpts().ProgramAction);
3694   ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args,
3695                               Res.getFrontendOpts().ProgramAction);
3696 
3697   // Turn on -Wspir-compat for SPIR target.
3698   if (T.isSPIR())
3699     Res.getDiagnosticOpts().Warnings.push_back("spir-compat");
3700 
3701   // If sanitizer is enabled, disable OPT_ffine_grained_bitfield_accesses.
3702   if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&
3703       !Res.getLangOpts()->Sanitize.empty()) {
3704     Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;
3705     Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
3706   }
3707   return Success;
3708 }
3709 
3710 std::string CompilerInvocation::getModuleHash() const {
3711   // Note: For QoI reasons, the things we use as a hash here should all be
3712   // dumped via the -module-info flag.
3713   using llvm::hash_code;
3714   using llvm::hash_value;
3715   using llvm::hash_combine;
3716   using llvm::hash_combine_range;
3717 
3718   // Start the signature with the compiler version.
3719   // FIXME: We'd rather use something more cryptographically sound than
3720   // CityHash, but this will do for now.
3721   hash_code code = hash_value(getClangFullRepositoryVersion());
3722 
3723   // Also include the serialization version, in case LLVM_APPEND_VC_REV is off
3724   // and getClangFullRepositoryVersion() doesn't include git revision.
3725   code = hash_combine(code, serialization::VERSION_MAJOR,
3726                       serialization::VERSION_MINOR);
3727 
3728   // Extend the signature with the language options
3729 #define LANGOPT(Name, Bits, Default, Description) \
3730    code = hash_combine(code, LangOpts->Name);
3731 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
3732   code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
3733 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
3734 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
3735 #include "clang/Basic/LangOptions.def"
3736 
3737   for (StringRef Feature : LangOpts->ModuleFeatures)
3738     code = hash_combine(code, Feature);
3739 
3740   // Extend the signature with the target options.
3741   code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
3742                       TargetOpts->ABI);
3743   for (const auto &FeatureAsWritten : TargetOpts->FeaturesAsWritten)
3744     code = hash_combine(code, FeatureAsWritten);
3745 
3746   // Extend the signature with preprocessor options.
3747   const PreprocessorOptions &ppOpts = getPreprocessorOpts();
3748   const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
3749   code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord);
3750 
3751   for (const auto &I : getPreprocessorOpts().Macros) {
3752     // If we're supposed to ignore this macro for the purposes of modules,
3753     // don't put it into the hash.
3754     if (!hsOpts.ModulesIgnoreMacros.empty()) {
3755       // Check whether we're ignoring this macro.
3756       StringRef MacroDef = I.first;
3757       if (hsOpts.ModulesIgnoreMacros.count(
3758               llvm::CachedHashString(MacroDef.split('=').first)))
3759         continue;
3760     }
3761 
3762     code = hash_combine(code, I.first, I.second);
3763   }
3764 
3765   // Extend the signature with the sysroot and other header search options.
3766   code = hash_combine(code, hsOpts.Sysroot,
3767                       hsOpts.ModuleFormat,
3768                       hsOpts.UseDebugInfo,
3769                       hsOpts.UseBuiltinIncludes,
3770                       hsOpts.UseStandardSystemIncludes,
3771                       hsOpts.UseStandardCXXIncludes,
3772                       hsOpts.UseLibcxx,
3773                       hsOpts.ModulesValidateDiagnosticOptions);
3774   code = hash_combine(code, hsOpts.ResourceDir);
3775 
3776   if (hsOpts.ModulesStrictContextHash) {
3777     hash_code SHPC = hash_combine_range(hsOpts.SystemHeaderPrefixes.begin(),
3778                                         hsOpts.SystemHeaderPrefixes.end());
3779     hash_code UEC = hash_combine_range(hsOpts.UserEntries.begin(),
3780                                        hsOpts.UserEntries.end());
3781     code = hash_combine(code, hsOpts.SystemHeaderPrefixes.size(), SHPC,
3782                         hsOpts.UserEntries.size(), UEC);
3783 
3784     const DiagnosticOptions &diagOpts = getDiagnosticOpts();
3785     #define DIAGOPT(Name, Bits, Default) \
3786       code = hash_combine(code, diagOpts.Name);
3787     #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
3788       code = hash_combine(code, diagOpts.get##Name());
3789     #include "clang/Basic/DiagnosticOptions.def"
3790     #undef DIAGOPT
3791     #undef ENUM_DIAGOPT
3792   }
3793 
3794   // Extend the signature with the user build path.
3795   code = hash_combine(code, hsOpts.ModuleUserBuildPath);
3796 
3797   // Extend the signature with the module file extensions.
3798   const FrontendOptions &frontendOpts = getFrontendOpts();
3799   for (const auto &ext : frontendOpts.ModuleFileExtensions) {
3800     code = ext->hashExtension(code);
3801   }
3802 
3803   // When compiling with -gmodules, also hash -fdebug-prefix-map as it
3804   // affects the debug info in the PCM.
3805   if (getCodeGenOpts().DebugTypeExtRefs)
3806     for (const auto &KeyValue : getCodeGenOpts().DebugPrefixMap)
3807       code = hash_combine(code, KeyValue.first, KeyValue.second);
3808 
3809   // Extend the signature with the enabled sanitizers, if at least one is
3810   // enabled. Sanitizers which cannot affect AST generation aren't hashed.
3811   SanitizerSet SanHash = LangOpts->Sanitize;
3812   SanHash.clear(getPPTransparentSanitizers());
3813   if (!SanHash.empty())
3814     code = hash_combine(code, SanHash.Mask);
3815 
3816   return llvm::APInt(64, code).toString(36, /*Signed=*/false);
3817 }
3818 
3819 namespace clang {
3820 
3821 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
3822 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
3823                                 DiagnosticsEngine &Diags) {
3824   return createVFSFromCompilerInvocation(CI, Diags,
3825                                          llvm::vfs::getRealFileSystem());
3826 }
3827 
3828 IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
3829     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
3830     IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
3831   if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
3832     return BaseFS;
3833 
3834   IntrusiveRefCntPtr<llvm::vfs::FileSystem> Result = BaseFS;
3835   // earlier vfs files are on the bottom
3836   for (const auto &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
3837     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
3838         Result->getBufferForFile(File);
3839     if (!Buffer) {
3840       Diags.Report(diag::err_missing_vfs_overlay_file) << File;
3841       continue;
3842     }
3843 
3844     IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = llvm::vfs::getVFSFromYAML(
3845         std::move(Buffer.get()), /*DiagHandler*/ nullptr, File,
3846         /*DiagContext*/ nullptr, Result);
3847     if (!FS) {
3848       Diags.Report(diag::err_invalid_vfs_overlay) << File;
3849       continue;
3850     }
3851 
3852     Result = FS;
3853   }
3854   return Result;
3855 }
3856 
3857 } // namespace clang
3858