xref: /llvm-project/clang/lib/Frontend/CompilerInvocation.cpp (revision 29a500b346bdd998cac237f8570c6957730e086a)
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/DiagnosticDriver.h"
18 #include "clang/Basic/DiagnosticOptions.h"
19 #include "clang/Basic/FileSystemOptions.h"
20 #include "clang/Basic/LLVM.h"
21 #include "clang/Basic/LangOptions.h"
22 #include "clang/Basic/LangStandard.h"
23 #include "clang/Basic/ObjCRuntime.h"
24 #include "clang/Basic/Sanitizers.h"
25 #include "clang/Basic/SourceLocation.h"
26 #include "clang/Basic/TargetOptions.h"
27 #include "clang/Basic/Version.h"
28 #include "clang/Basic/Visibility.h"
29 #include "clang/Basic/XRayInstr.h"
30 #include "clang/Config/config.h"
31 #include "clang/Driver/Driver.h"
32 #include "clang/Driver/DriverDiagnostic.h"
33 #include "clang/Driver/Options.h"
34 #include "clang/Frontend/CommandLineSourceLoc.h"
35 #include "clang/Frontend/DependencyOutputOptions.h"
36 #include "clang/Frontend/FrontendDiagnostic.h"
37 #include "clang/Frontend/FrontendOptions.h"
38 #include "clang/Frontend/FrontendPluginRegistry.h"
39 #include "clang/Frontend/MigratorOptions.h"
40 #include "clang/Frontend/PreprocessorOutputOptions.h"
41 #include "clang/Frontend/TextDiagnosticBuffer.h"
42 #include "clang/Frontend/Utils.h"
43 #include "clang/Lex/HeaderSearchOptions.h"
44 #include "clang/Lex/PreprocessorOptions.h"
45 #include "clang/Sema/CodeCompleteOptions.h"
46 #include "clang/Serialization/ASTBitCodes.h"
47 #include "clang/Serialization/ModuleFileExtension.h"
48 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
49 #include "llvm/ADT/APInt.h"
50 #include "llvm/ADT/ArrayRef.h"
51 #include "llvm/ADT/CachedHashString.h"
52 #include "llvm/ADT/DenseSet.h"
53 #include "llvm/ADT/FloatingPointMode.h"
54 #include "llvm/ADT/Hashing.h"
55 #include "llvm/ADT/None.h"
56 #include "llvm/ADT/Optional.h"
57 #include "llvm/ADT/STLExtras.h"
58 #include "llvm/ADT/SmallString.h"
59 #include "llvm/ADT/SmallVector.h"
60 #include "llvm/ADT/StringRef.h"
61 #include "llvm/ADT/StringSwitch.h"
62 #include "llvm/ADT/Triple.h"
63 #include "llvm/ADT/Twine.h"
64 #include "llvm/Config/llvm-config.h"
65 #include "llvm/IR/DebugInfoMetadata.h"
66 #include "llvm/Linker/Linker.h"
67 #include "llvm/MC/MCTargetOptions.h"
68 #include "llvm/Option/Arg.h"
69 #include "llvm/Option/ArgList.h"
70 #include "llvm/Option/OptSpecifier.h"
71 #include "llvm/Option/OptTable.h"
72 #include "llvm/Option/Option.h"
73 #include "llvm/ProfileData/InstrProfReader.h"
74 #include "llvm/Remarks/HotnessThresholdParser.h"
75 #include "llvm/Support/CodeGen.h"
76 #include "llvm/Support/Compiler.h"
77 #include "llvm/Support/Error.h"
78 #include "llvm/Support/ErrorHandling.h"
79 #include "llvm/Support/ErrorOr.h"
80 #include "llvm/Support/FileSystem.h"
81 #include "llvm/Support/HashBuilder.h"
82 #include "llvm/Support/Host.h"
83 #include "llvm/Support/MathExtras.h"
84 #include "llvm/Support/MemoryBuffer.h"
85 #include "llvm/Support/Path.h"
86 #include "llvm/Support/Process.h"
87 #include "llvm/Support/Regex.h"
88 #include "llvm/Support/VersionTuple.h"
89 #include "llvm/Support/VirtualFileSystem.h"
90 #include "llvm/Support/raw_ostream.h"
91 #include "llvm/Target/TargetOptions.h"
92 #include <algorithm>
93 #include <atomic>
94 #include <cassert>
95 #include <cstddef>
96 #include <cstring>
97 #include <ctime>
98 #include <fstream>
99 #include <limits>
100 #include <memory>
101 #include <string>
102 #include <tuple>
103 #include <type_traits>
104 #include <utility>
105 #include <vector>
106 
107 using namespace clang;
108 using namespace driver;
109 using namespace options;
110 using namespace llvm::opt;
111 
112 //===----------------------------------------------------------------------===//
113 // Helpers.
114 //===----------------------------------------------------------------------===//
115 
116 // Parse misexpect tolerance argument value.
117 // Valid option values are integers in the range [0, 100)
118 inline Expected<Optional<uint32_t>> parseToleranceOption(StringRef Arg) {
119   uint32_t Val;
120   if (Arg.getAsInteger(10, Val))
121     return llvm::createStringError(llvm::inconvertibleErrorCode(),
122                                    "Not an integer: %s", Arg.data());
123   return Val;
124 }
125 
126 //===----------------------------------------------------------------------===//
127 // Initialization.
128 //===----------------------------------------------------------------------===//
129 
130 CompilerInvocationRefBase::CompilerInvocationRefBase()
131     : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
132       DiagnosticOpts(new DiagnosticOptions()),
133       HeaderSearchOpts(new HeaderSearchOptions()),
134       PreprocessorOpts(new PreprocessorOptions()),
135       AnalyzerOpts(new AnalyzerOptions()) {}
136 
137 CompilerInvocationRefBase::CompilerInvocationRefBase(
138     const CompilerInvocationRefBase &X)
139     : LangOpts(new LangOptions(*X.getLangOpts())),
140       TargetOpts(new TargetOptions(X.getTargetOpts())),
141       DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
142       HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
143       PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())),
144       AnalyzerOpts(new AnalyzerOptions(*X.getAnalyzerOpts())) {}
145 
146 CompilerInvocationRefBase::CompilerInvocationRefBase(
147     CompilerInvocationRefBase &&X) = default;
148 
149 CompilerInvocationRefBase &
150 CompilerInvocationRefBase::operator=(CompilerInvocationRefBase X) {
151   LangOpts.swap(X.LangOpts);
152   TargetOpts.swap(X.TargetOpts);
153   DiagnosticOpts.swap(X.DiagnosticOpts);
154   HeaderSearchOpts.swap(X.HeaderSearchOpts);
155   PreprocessorOpts.swap(X.PreprocessorOpts);
156   AnalyzerOpts.swap(X.AnalyzerOpts);
157   return *this;
158 }
159 
160 CompilerInvocationRefBase &
161 CompilerInvocationRefBase::operator=(CompilerInvocationRefBase &&X) = default;
162 
163 CompilerInvocationRefBase::~CompilerInvocationRefBase() = default;
164 
165 //===----------------------------------------------------------------------===//
166 // Normalizers
167 //===----------------------------------------------------------------------===//
168 
169 #define SIMPLE_ENUM_VALUE_TABLE
170 #include "clang/Driver/Options.inc"
171 #undef SIMPLE_ENUM_VALUE_TABLE
172 
173 static llvm::Optional<bool> normalizeSimpleFlag(OptSpecifier Opt,
174                                                 unsigned TableIndex,
175                                                 const ArgList &Args,
176                                                 DiagnosticsEngine &Diags) {
177   if (Args.hasArg(Opt))
178     return true;
179   return None;
180 }
181 
182 static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned,
183                                                   const ArgList &Args,
184                                                   DiagnosticsEngine &) {
185   if (Args.hasArg(Opt))
186     return false;
187   return None;
188 }
189 
190 /// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but
191 /// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with
192 /// unnecessary template instantiations and just ignore it with a variadic
193 /// argument.
194 static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
195                                   const char *Spelling,
196                                   CompilerInvocation::StringAllocator,
197                                   Option::OptionClass, unsigned, /*T*/...) {
198   Args.push_back(Spelling);
199 }
200 
201 template <typename T> static constexpr bool is_uint64_t_convertible() {
202   return !std::is_same<T, uint64_t>::value &&
203          llvm::is_integral_or_enum<T>::value;
204 }
205 
206 template <typename T,
207           std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
208 static auto makeFlagToValueNormalizer(T Value) {
209   return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
210                  DiagnosticsEngine &) -> Optional<T> {
211     if (Args.hasArg(Opt))
212       return Value;
213     return None;
214   };
215 }
216 
217 template <typename T,
218           std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>
219 static auto makeFlagToValueNormalizer(T Value) {
220   return makeFlagToValueNormalizer(uint64_t(Value));
221 }
222 
223 static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,
224                                         OptSpecifier OtherOpt) {
225   return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned,
226                                        const ArgList &Args,
227                                        DiagnosticsEngine &) -> Optional<bool> {
228     if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
229       return A->getOption().matches(Opt) ? Value : OtherValue;
230     }
231     return None;
232   };
233 }
234 
235 static auto makeBooleanOptionDenormalizer(bool Value) {
236   return [Value](SmallVectorImpl<const char *> &Args, const char *Spelling,
237                  CompilerInvocation::StringAllocator, Option::OptionClass,
238                  unsigned, bool KeyPath) {
239     if (KeyPath == Value)
240       Args.push_back(Spelling);
241   };
242 }
243 
244 static void denormalizeStringImpl(SmallVectorImpl<const char *> &Args,
245                                   const char *Spelling,
246                                   CompilerInvocation::StringAllocator SA,
247                                   Option::OptionClass OptClass, unsigned,
248                                   const Twine &Value) {
249   switch (OptClass) {
250   case Option::SeparateClass:
251   case Option::JoinedOrSeparateClass:
252   case Option::JoinedAndSeparateClass:
253     Args.push_back(Spelling);
254     Args.push_back(SA(Value));
255     break;
256   case Option::JoinedClass:
257   case Option::CommaJoinedClass:
258     Args.push_back(SA(Twine(Spelling) + Value));
259     break;
260   default:
261     llvm_unreachable("Cannot denormalize an option with option class "
262                      "incompatible with string denormalization.");
263   }
264 }
265 
266 template <typename T>
267 static void
268 denormalizeString(SmallVectorImpl<const char *> &Args, const char *Spelling,
269                   CompilerInvocation::StringAllocator SA,
270                   Option::OptionClass OptClass, unsigned TableIndex, T Value) {
271   denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
272 }
273 
274 static Optional<SimpleEnumValue>
275 findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) {
276   for (int I = 0, E = Table.Size; I != E; ++I)
277     if (Name == Table.Table[I].Name)
278       return Table.Table[I];
279 
280   return None;
281 }
282 
283 static Optional<SimpleEnumValue>
284 findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) {
285   for (int I = 0, E = Table.Size; I != E; ++I)
286     if (Value == Table.Table[I].Value)
287       return Table.Table[I];
288 
289   return None;
290 }
291 
292 static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,
293                                                     unsigned TableIndex,
294                                                     const ArgList &Args,
295                                                     DiagnosticsEngine &Diags) {
296   assert(TableIndex < SimpleEnumValueTablesSize);
297   const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
298 
299   auto *Arg = Args.getLastArg(Opt);
300   if (!Arg)
301     return None;
302 
303   StringRef ArgValue = Arg->getValue();
304   if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue))
305     return MaybeEnumVal->Value;
306 
307   Diags.Report(diag::err_drv_invalid_value)
308       << Arg->getAsString(Args) << ArgValue;
309   return None;
310 }
311 
312 static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args,
313                                       const char *Spelling,
314                                       CompilerInvocation::StringAllocator SA,
315                                       Option::OptionClass OptClass,
316                                       unsigned TableIndex, unsigned Value) {
317   assert(TableIndex < SimpleEnumValueTablesSize);
318   const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
319   if (auto MaybeEnumVal = findValueTableByValue(Table, Value)) {
320     denormalizeString(Args, Spelling, SA, OptClass, TableIndex,
321                       MaybeEnumVal->Name);
322   } else {
323     llvm_unreachable("The simple enum value was not correctly defined in "
324                      "the tablegen option description");
325   }
326 }
327 
328 template <typename T>
329 static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args,
330                                   const char *Spelling,
331                                   CompilerInvocation::StringAllocator SA,
332                                   Option::OptionClass OptClass,
333                                   unsigned TableIndex, T Value) {
334   return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
335                                    static_cast<unsigned>(Value));
336 }
337 
338 static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex,
339                                              const ArgList &Args,
340                                              DiagnosticsEngine &Diags) {
341   auto *Arg = Args.getLastArg(Opt);
342   if (!Arg)
343     return None;
344   return std::string(Arg->getValue());
345 }
346 
347 template <typename IntTy>
348 static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int,
349                                                const ArgList &Args,
350                                                DiagnosticsEngine &Diags) {
351   auto *Arg = Args.getLastArg(Opt);
352   if (!Arg)
353     return None;
354   IntTy Res;
355   if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
356     Diags.Report(diag::err_drv_invalid_int_value)
357         << Arg->getAsString(Args) << Arg->getValue();
358     return None;
359   }
360   return Res;
361 }
362 
363 static Optional<std::vector<std::string>>
364 normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args,
365                       DiagnosticsEngine &) {
366   return Args.getAllArgValues(Opt);
367 }
368 
369 static void denormalizeStringVector(SmallVectorImpl<const char *> &Args,
370                                     const char *Spelling,
371                                     CompilerInvocation::StringAllocator SA,
372                                     Option::OptionClass OptClass,
373                                     unsigned TableIndex,
374                                     const std::vector<std::string> &Values) {
375   switch (OptClass) {
376   case Option::CommaJoinedClass: {
377     std::string CommaJoinedValue;
378     if (!Values.empty()) {
379       CommaJoinedValue.append(Values.front());
380       for (const std::string &Value : llvm::drop_begin(Values, 1)) {
381         CommaJoinedValue.append(",");
382         CommaJoinedValue.append(Value);
383       }
384     }
385     denormalizeString(Args, Spelling, SA, Option::OptionClass::JoinedClass,
386                       TableIndex, CommaJoinedValue);
387     break;
388   }
389   case Option::JoinedClass:
390   case Option::SeparateClass:
391   case Option::JoinedOrSeparateClass:
392     for (const std::string &Value : Values)
393       denormalizeString(Args, Spelling, SA, OptClass, TableIndex, Value);
394     break;
395   default:
396     llvm_unreachable("Cannot denormalize an option with option class "
397                      "incompatible with string vector denormalization.");
398   }
399 }
400 
401 static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
402                                              const ArgList &Args,
403                                              DiagnosticsEngine &Diags) {
404   auto *Arg = Args.getLastArg(Opt);
405   if (!Arg)
406     return None;
407   return llvm::Triple::normalize(Arg->getValue());
408 }
409 
410 template <typename T, typename U>
411 static T mergeForwardValue(T KeyPath, U Value) {
412   return static_cast<T>(Value);
413 }
414 
415 template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {
416   return KeyPath | Value;
417 }
418 
419 template <typename T> static T extractForwardValue(T KeyPath) {
420   return KeyPath;
421 }
422 
423 template <typename T, typename U, U Value>
424 static T extractMaskValue(T KeyPath) {
425   return ((KeyPath & Value) == Value) ? static_cast<T>(Value) : T();
426 }
427 
428 #define PARSE_OPTION_WITH_MARSHALLING(                                         \
429     ARGS, DIAGS, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,       \
430     IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)             \
431   if ((FLAGS)&options::CC1Option) {                                            \
432     KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE);                                  \
433     if (IMPLIED_CHECK)                                                         \
434       KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE);                                \
435     if (SHOULD_PARSE)                                                          \
436       if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS))    \
437         KEYPATH =                                                              \
438             MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue));      \
439   }
440 
441 // Capture the extracted value as a lambda argument to avoid potential issues
442 // with lifetime extension of the reference.
443 #define GENERATE_OPTION_WITH_MARSHALLING(                                      \
444     ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH,       \
445     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR,      \
446     TABLE_INDEX)                                                               \
447   if ((FLAGS)&options::CC1Option) {                                            \
448     [&](const auto &Extracted) {                                               \
449       if (ALWAYS_EMIT ||                                                       \
450           (Extracted !=                                                        \
451            static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE)    \
452                                                           : (DEFAULT_VALUE)))) \
453         DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
454                      TABLE_INDEX, Extracted);                                  \
455     }(EXTRACTOR(KEYPATH));                                                     \
456   }
457 
458 static StringRef GetInputKindName(InputKind IK);
459 
460 static bool FixupInvocation(CompilerInvocation &Invocation,
461                             DiagnosticsEngine &Diags, const ArgList &Args,
462                             InputKind IK) {
463   unsigned NumErrorsBefore = Diags.getNumErrors();
464 
465   LangOptions &LangOpts = *Invocation.getLangOpts();
466   CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts();
467   TargetOptions &TargetOpts = Invocation.getTargetOpts();
468   FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
469   CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
470   CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
471   CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
472   CodeGenOpts.DisableFree = FrontendOpts.DisableFree;
473   FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex;
474   if (FrontendOpts.ShowStats)
475     CodeGenOpts.ClearASTBeforeBackend = false;
476   LangOpts.SanitizeCoverage = CodeGenOpts.hasSanitizeCoverage();
477   LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
478   LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
479   LangOpts.CurrentModule = LangOpts.ModuleName;
480 
481   llvm::Triple T(TargetOpts.Triple);
482   llvm::Triple::ArchType Arch = T.getArch();
483 
484   CodeGenOpts.CodeModel = TargetOpts.CodeModel;
485 
486   if (LangOpts.getExceptionHandling() !=
487           LangOptions::ExceptionHandlingKind::None &&
488       T.isWindowsMSVCEnvironment())
489     Diags.Report(diag::err_fe_invalid_exception_model)
490         << static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str();
491 
492   if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
493     Diags.Report(diag::warn_c_kext);
494 
495   if (Args.hasArg(OPT_fconcepts_ts))
496     Diags.Report(diag::warn_fe_concepts_ts_flag);
497 
498   if (LangOpts.NewAlignOverride &&
499       !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
500     Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
501     Diags.Report(diag::err_fe_invalid_alignment)
502         << A->getAsString(Args) << A->getValue();
503     LangOpts.NewAlignOverride = 0;
504   }
505 
506   // Prevent the user from specifying both -fsycl-is-device and -fsycl-is-host.
507   if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
508     Diags.Report(diag::err_drv_argument_not_allowed_with) << "-fsycl-is-device"
509                                                           << "-fsycl-is-host";
510 
511   if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
512     Diags.Report(diag::err_drv_argument_not_allowed_with)
513         << "-fgnu89-inline" << GetInputKindName(IK);
514 
515   if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
516     Diags.Report(diag::err_drv_argument_not_allowed_with)
517         << "-hlsl-entry" << GetInputKindName(IK);
518 
519   if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
520     Diags.Report(diag::warn_ignored_hip_only_option)
521         << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
522 
523   if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
524     Diags.Report(diag::warn_ignored_hip_only_option)
525         << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
526 
527   // When these options are used, the compiler is allowed to apply
528   // optimizations that may affect the final result. For example
529   // (x+y)+z is transformed to x+(y+z) but may not give the same
530   // final result; it's not value safe.
531   // Another example can be to simplify x/x to 1.0 but x could be 0.0, INF
532   // or NaN. Final result may then differ. An error is issued when the eval
533   // method is set with one of these options.
534   if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
535     if (LangOpts.ApproxFunc)
536       Diags.Report(diag::err_incompatible_fp_eval_method_options) << 0;
537     if (LangOpts.AllowFPReassoc)
538       Diags.Report(diag::err_incompatible_fp_eval_method_options) << 1;
539     if (LangOpts.AllowRecip)
540       Diags.Report(diag::err_incompatible_fp_eval_method_options) << 2;
541   }
542 
543   // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
544   // This option should be deprecated for CL > 1.0 because
545   // this option was added for compatibility with OpenCL 1.0.
546   if (Args.getLastArg(OPT_cl_strict_aliasing) &&
547       (LangOpts.getOpenCLCompatibleVersion() > 100))
548     Diags.Report(diag::warn_option_invalid_ocl_version)
549         << LangOpts.getOpenCLVersionString()
550         << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
551 
552   if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
553     auto DefaultCC = LangOpts.getDefaultCallingConv();
554 
555     bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||
556                       DefaultCC == LangOptions::DCC_StdCall) &&
557                      Arch != llvm::Triple::x86;
558     emitError |= (DefaultCC == LangOptions::DCC_VectorCall ||
559                   DefaultCC == LangOptions::DCC_RegCall) &&
560                  !T.isX86();
561     if (emitError)
562       Diags.Report(diag::err_drv_argument_not_allowed_with)
563           << A->getSpelling() << T.getTriple();
564   }
565 
566   return Diags.getNumErrors() == NumErrorsBefore;
567 }
568 
569 //===----------------------------------------------------------------------===//
570 // Deserialization (from args)
571 //===----------------------------------------------------------------------===//
572 
573 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
574                                      DiagnosticsEngine &Diags) {
575   unsigned DefaultOpt = llvm::CodeGenOpt::None;
576   if ((IK.getLanguage() == Language::OpenCL ||
577        IK.getLanguage() == Language::OpenCLCXX) &&
578       !Args.hasArg(OPT_cl_opt_disable))
579     DefaultOpt = llvm::CodeGenOpt::Default;
580 
581   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
582     if (A->getOption().matches(options::OPT_O0))
583       return llvm::CodeGenOpt::None;
584 
585     if (A->getOption().matches(options::OPT_Ofast))
586       return llvm::CodeGenOpt::Aggressive;
587 
588     assert(A->getOption().matches(options::OPT_O));
589 
590     StringRef S(A->getValue());
591     if (S == "s" || S == "z")
592       return llvm::CodeGenOpt::Default;
593 
594     if (S == "g")
595       return llvm::CodeGenOpt::Less;
596 
597     return getLastArgIntValue(Args, OPT_O, DefaultOpt, Diags);
598   }
599 
600   return DefaultOpt;
601 }
602 
603 static unsigned getOptimizationLevelSize(ArgList &Args) {
604   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
605     if (A->getOption().matches(options::OPT_O)) {
606       switch (A->getValue()[0]) {
607       default:
608         return 0;
609       case 's':
610         return 1;
611       case 'z':
612         return 2;
613       }
614     }
615   }
616   return 0;
617 }
618 
619 static void GenerateArg(SmallVectorImpl<const char *> &Args,
620                         llvm::opt::OptSpecifier OptSpecifier,
621                         CompilerInvocation::StringAllocator SA) {
622   Option Opt = getDriverOptTable().getOption(OptSpecifier);
623   denormalizeSimpleFlag(Args, SA(Opt.getPrefix() + Opt.getName()), SA,
624                         Option::OptionClass::FlagClass, 0);
625 }
626 
627 static void GenerateArg(SmallVectorImpl<const char *> &Args,
628                         llvm::opt::OptSpecifier OptSpecifier,
629                         const Twine &Value,
630                         CompilerInvocation::StringAllocator SA) {
631   Option Opt = getDriverOptTable().getOption(OptSpecifier);
632   denormalizeString(Args, SA(Opt.getPrefix() + Opt.getName()), SA,
633                     Opt.getKind(), 0, Value);
634 }
635 
636 // Parse command line arguments into CompilerInvocation.
637 using ParseFn =
638     llvm::function_ref<bool(CompilerInvocation &, ArrayRef<const char *>,
639                             DiagnosticsEngine &, const char *)>;
640 
641 // Generate command line arguments from CompilerInvocation.
642 using GenerateFn = llvm::function_ref<void(
643     CompilerInvocation &, SmallVectorImpl<const char *> &,
644     CompilerInvocation::StringAllocator)>;
645 
646 // May perform round-trip of command line arguments. By default, the round-trip
647 // is enabled in assert builds. This can be overwritten at run-time via the
648 // "-round-trip-args" and "-no-round-trip-args" command line flags.
649 // During round-trip, the command line arguments are parsed into a dummy
650 // instance of CompilerInvocation which is used to generate the command line
651 // arguments again. The real CompilerInvocation instance is then created by
652 // parsing the generated arguments, not the original ones.
653 static bool RoundTrip(ParseFn Parse, GenerateFn Generate,
654                       CompilerInvocation &RealInvocation,
655                       CompilerInvocation &DummyInvocation,
656                       ArrayRef<const char *> CommandLineArgs,
657                       DiagnosticsEngine &Diags, const char *Argv0) {
658 #ifndef NDEBUG
659   bool DoRoundTripDefault = true;
660 #else
661   bool DoRoundTripDefault = false;
662 #endif
663 
664   bool DoRoundTrip = DoRoundTripDefault;
665   for (const auto *Arg : CommandLineArgs) {
666     if (Arg == StringRef("-round-trip-args"))
667       DoRoundTrip = true;
668     if (Arg == StringRef("-no-round-trip-args"))
669       DoRoundTrip = false;
670   }
671 
672   // If round-trip was not requested, simply run the parser with the real
673   // invocation diagnostics.
674   if (!DoRoundTrip)
675     return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
676 
677   // Serializes quoted (and potentially escaped) arguments.
678   auto SerializeArgs = [](ArrayRef<const char *> Args) {
679     std::string Buffer;
680     llvm::raw_string_ostream OS(Buffer);
681     for (const char *Arg : Args) {
682       llvm::sys::printArg(OS, Arg, /*Quote=*/true);
683       OS << ' ';
684     }
685     OS.flush();
686     return Buffer;
687   };
688 
689   // Setup a dummy DiagnosticsEngine.
690   DiagnosticsEngine DummyDiags(new DiagnosticIDs(), new DiagnosticOptions());
691   DummyDiags.setClient(new TextDiagnosticBuffer());
692 
693   // Run the first parse on the original arguments with the dummy invocation and
694   // diagnostics.
695   if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
696       DummyDiags.getNumWarnings() != 0) {
697     // If the first parse did not succeed, it must be user mistake (invalid
698     // command line arguments). We won't be able to generate arguments that
699     // would reproduce the same result. Let's fail again with the real
700     // invocation and diagnostics, so all side-effects of parsing are visible.
701     unsigned NumWarningsBefore = Diags.getNumWarnings();
702     auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
703     if (!Success || Diags.getNumWarnings() != NumWarningsBefore)
704       return Success;
705 
706     // Parse with original options and diagnostics succeeded even though it
707     // shouldn't have. Something is off.
708     Diags.Report(diag::err_cc1_round_trip_fail_then_ok);
709     Diags.Report(diag::note_cc1_round_trip_original)
710         << SerializeArgs(CommandLineArgs);
711     return false;
712   }
713 
714   // Setup string allocator.
715   llvm::BumpPtrAllocator Alloc;
716   llvm::StringSaver StringPool(Alloc);
717   auto SA = [&StringPool](const Twine &Arg) {
718     return StringPool.save(Arg).data();
719   };
720 
721   // Generate arguments from the dummy invocation. If Generate is the
722   // inverse of Parse, the newly generated arguments must have the same
723   // semantics as the original.
724   SmallVector<const char *> GeneratedArgs1;
725   Generate(DummyInvocation, GeneratedArgs1, SA);
726 
727   // Run the second parse, now on the generated arguments, and with the real
728   // invocation and diagnostics. The result is what we will end up using for the
729   // rest of compilation, so if Generate is not inverse of Parse, something down
730   // the line will break.
731   bool Success2 = Parse(RealInvocation, GeneratedArgs1, Diags, Argv0);
732 
733   // The first parse on original arguments succeeded, but second parse of
734   // generated arguments failed. Something must be wrong with the generator.
735   if (!Success2) {
736     Diags.Report(diag::err_cc1_round_trip_ok_then_fail);
737     Diags.Report(diag::note_cc1_round_trip_generated)
738         << 1 << SerializeArgs(GeneratedArgs1);
739     return false;
740   }
741 
742   // Generate arguments again, this time from the options we will end up using
743   // for the rest of the compilation.
744   SmallVector<const char *> GeneratedArgs2;
745   Generate(RealInvocation, GeneratedArgs2, SA);
746 
747   // Compares two lists of generated arguments.
748   auto Equal = [](const ArrayRef<const char *> A,
749                   const ArrayRef<const char *> B) {
750     return std::equal(A.begin(), A.end(), B.begin(), B.end(),
751                       [](const char *AElem, const char *BElem) {
752                         return StringRef(AElem) == StringRef(BElem);
753                       });
754   };
755 
756   // If we generated different arguments from what we assume are two
757   // semantically equivalent CompilerInvocations, the Generate function may
758   // be non-deterministic.
759   if (!Equal(GeneratedArgs1, GeneratedArgs2)) {
760     Diags.Report(diag::err_cc1_round_trip_mismatch);
761     Diags.Report(diag::note_cc1_round_trip_generated)
762         << 1 << SerializeArgs(GeneratedArgs1);
763     Diags.Report(diag::note_cc1_round_trip_generated)
764         << 2 << SerializeArgs(GeneratedArgs2);
765     return false;
766   }
767 
768   Diags.Report(diag::remark_cc1_round_trip_generated)
769       << 1 << SerializeArgs(GeneratedArgs1);
770   Diags.Report(diag::remark_cc1_round_trip_generated)
771       << 2 << SerializeArgs(GeneratedArgs2);
772 
773   return Success2;
774 }
775 
776 static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
777                               OptSpecifier GroupWithValue,
778                               std::vector<std::string> &Diagnostics) {
779   for (auto *A : Args.filtered(Group)) {
780     if (A->getOption().getKind() == Option::FlagClass) {
781       // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
782       // its name (minus the "W" or "R" at the beginning) to the diagnostics.
783       Diagnostics.push_back(
784           std::string(A->getOption().getName().drop_front(1)));
785     } else if (A->getOption().matches(GroupWithValue)) {
786       // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic
787       // group. Add only the group name to the diagnostics.
788       Diagnostics.push_back(
789           std::string(A->getOption().getName().drop_front(1).rtrim("=-")));
790     } else {
791       // Otherwise, add its value (for OPT_W_Joined and similar).
792       Diagnostics.push_back(A->getValue());
793     }
794   }
795 }
796 
797 // Parse the Static Analyzer configuration. If \p Diags is set to nullptr,
798 // it won't verify the input.
799 static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,
800                                  DiagnosticsEngine *Diags);
801 
802 static void getAllNoBuiltinFuncValues(ArgList &Args,
803                                       std::vector<std::string> &Funcs) {
804   std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
805   auto BuiltinEnd = llvm::partition(Values, Builtin::Context::isBuiltinFunc);
806   Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
807 }
808 
809 static void GenerateAnalyzerArgs(AnalyzerOptions &Opts,
810                                  SmallVectorImpl<const char *> &Args,
811                                  CompilerInvocation::StringAllocator SA) {
812   const AnalyzerOptions *AnalyzerOpts = &Opts;
813 
814 #define ANALYZER_OPTION_WITH_MARSHALLING(                                      \
815     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
816     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
817     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
818     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
819   GENERATE_OPTION_WITH_MARSHALLING(                                            \
820       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
821       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
822 #include "clang/Driver/Options.inc"
823 #undef ANALYZER_OPTION_WITH_MARSHALLING
824 
825   if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) {
826     switch (Opts.AnalysisConstraintsOpt) {
827 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN)                     \
828   case NAME##Model:                                                            \
829     GenerateArg(Args, OPT_analyzer_constraints, CMDFLAG, SA);                  \
830     break;
831 #include "clang/StaticAnalyzer/Core/Analyses.def"
832     default:
833       llvm_unreachable("Tried to generate unknown analysis constraint.");
834     }
835   }
836 
837   if (Opts.AnalysisDiagOpt != PD_HTML) {
838     switch (Opts.AnalysisDiagOpt) {
839 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN)                     \
840   case PD_##NAME:                                                              \
841     GenerateArg(Args, OPT_analyzer_output, CMDFLAG, SA);                       \
842     break;
843 #include "clang/StaticAnalyzer/Core/Analyses.def"
844     default:
845       llvm_unreachable("Tried to generate unknown analysis diagnostic client.");
846     }
847   }
848 
849   if (Opts.AnalysisPurgeOpt != PurgeStmt) {
850     switch (Opts.AnalysisPurgeOpt) {
851 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC)                                    \
852   case NAME:                                                                   \
853     GenerateArg(Args, OPT_analyzer_purge, CMDFLAG, SA);                        \
854     break;
855 #include "clang/StaticAnalyzer/Core/Analyses.def"
856     default:
857       llvm_unreachable("Tried to generate unknown analysis purge mode.");
858     }
859   }
860 
861   if (Opts.InliningMode != NoRedundancy) {
862     switch (Opts.InliningMode) {
863 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC)                            \
864   case NAME:                                                                   \
865     GenerateArg(Args, OPT_analyzer_inlining_mode, CMDFLAG, SA);                \
866     break;
867 #include "clang/StaticAnalyzer/Core/Analyses.def"
868     default:
869       llvm_unreachable("Tried to generate unknown analysis inlining mode.");
870     }
871   }
872 
873   for (const auto &CP : Opts.CheckersAndPackages) {
874     OptSpecifier Opt =
875         CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
876     GenerateArg(Args, Opt, CP.first, SA);
877   }
878 
879   AnalyzerOptions ConfigOpts;
880   parseAnalyzerConfigs(ConfigOpts, nullptr);
881 
882   for (const auto &C : Opts.Config) {
883     // Don't generate anything that came from parseAnalyzerConfigs. It would be
884     // redundant and may not be valid on the command line.
885     auto Entry = ConfigOpts.Config.find(C.getKey());
886     if (Entry != ConfigOpts.Config.end() && Entry->getValue() == C.getValue())
887       continue;
888 
889     GenerateArg(Args, OPT_analyzer_config, C.getKey() + "=" + C.getValue(), SA);
890   }
891 
892   // Nothing to generate for FullCompilerInvocation.
893 }
894 
895 static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
896                               DiagnosticsEngine &Diags) {
897   unsigned NumErrorsBefore = Diags.getNumErrors();
898 
899   AnalyzerOptions *AnalyzerOpts = &Opts;
900 
901 #define ANALYZER_OPTION_WITH_MARSHALLING(                                      \
902     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
903     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
904     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
905     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
906   PARSE_OPTION_WITH_MARSHALLING(                                               \
907       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
908       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
909 #include "clang/Driver/Options.inc"
910 #undef ANALYZER_OPTION_WITH_MARSHALLING
911 
912   if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
913     StringRef Name = A->getValue();
914     AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
915 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
916       .Case(CMDFLAG, NAME##Model)
917 #include "clang/StaticAnalyzer/Core/Analyses.def"
918       .Default(NumConstraints);
919     if (Value == NumConstraints) {
920       Diags.Report(diag::err_drv_invalid_value)
921         << A->getAsString(Args) << Name;
922     } else {
923 #ifndef LLVM_WITH_Z3
924       if (Value == AnalysisConstraints::Z3ConstraintsModel) {
925         Diags.Report(diag::err_analyzer_not_built_with_z3);
926       }
927 #endif // LLVM_WITH_Z3
928       Opts.AnalysisConstraintsOpt = Value;
929     }
930   }
931 
932   if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
933     StringRef Name = A->getValue();
934     AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
935 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
936       .Case(CMDFLAG, PD_##NAME)
937 #include "clang/StaticAnalyzer/Core/Analyses.def"
938       .Default(NUM_ANALYSIS_DIAG_CLIENTS);
939     if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
940       Diags.Report(diag::err_drv_invalid_value)
941         << A->getAsString(Args) << Name;
942     } else {
943       Opts.AnalysisDiagOpt = Value;
944     }
945   }
946 
947   if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
948     StringRef Name = A->getValue();
949     AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
950 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
951       .Case(CMDFLAG, NAME)
952 #include "clang/StaticAnalyzer/Core/Analyses.def"
953       .Default(NumPurgeModes);
954     if (Value == NumPurgeModes) {
955       Diags.Report(diag::err_drv_invalid_value)
956         << A->getAsString(Args) << Name;
957     } else {
958       Opts.AnalysisPurgeOpt = Value;
959     }
960   }
961 
962   if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
963     StringRef Name = A->getValue();
964     AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name)
965 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
966       .Case(CMDFLAG, NAME)
967 #include "clang/StaticAnalyzer/Core/Analyses.def"
968       .Default(NumInliningModes);
969     if (Value == NumInliningModes) {
970       Diags.Report(diag::err_drv_invalid_value)
971         << A->getAsString(Args) << Name;
972     } else {
973       Opts.InliningMode = Value;
974     }
975   }
976 
977   Opts.CheckersAndPackages.clear();
978   for (const Arg *A :
979        Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
980     A->claim();
981     bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
982     // We can have a list of comma separated checker names, e.g:
983     // '-analyzer-checker=cocoa,unix'
984     StringRef CheckerAndPackageList = A->getValue();
985     SmallVector<StringRef, 16> CheckersAndPackages;
986     CheckerAndPackageList.split(CheckersAndPackages, ",");
987     for (const StringRef &CheckerOrPackage : CheckersAndPackages)
988       Opts.CheckersAndPackages.emplace_back(std::string(CheckerOrPackage),
989                                             IsEnabled);
990   }
991 
992   // Go through the analyzer configuration options.
993   for (const auto *A : Args.filtered(OPT_analyzer_config)) {
994 
995     // We can have a list of comma separated config names, e.g:
996     // '-analyzer-config key1=val1,key2=val2'
997     StringRef configList = A->getValue();
998     SmallVector<StringRef, 4> configVals;
999     configList.split(configVals, ",");
1000     for (const auto &configVal : configVals) {
1001       StringRef key, val;
1002       std::tie(key, val) = configVal.split("=");
1003       if (val.empty()) {
1004         Diags.Report(SourceLocation(),
1005                      diag::err_analyzer_config_no_value) << configVal;
1006         break;
1007       }
1008       if (val.contains('=')) {
1009         Diags.Report(SourceLocation(),
1010                      diag::err_analyzer_config_multiple_values)
1011           << configVal;
1012         break;
1013       }
1014 
1015       // TODO: Check checker options too, possibly in CheckerRegistry.
1016       // Leave unknown non-checker configs unclaimed.
1017       if (!key.contains(":") && Opts.isUnknownAnalyzerConfig(key)) {
1018         if (Opts.ShouldEmitErrorsOnInvalidConfigValue)
1019           Diags.Report(diag::err_analyzer_config_unknown) << key;
1020         continue;
1021       }
1022 
1023       A->claim();
1024       Opts.Config[key] = std::string(val);
1025     }
1026   }
1027 
1028   if (Opts.ShouldEmitErrorsOnInvalidConfigValue)
1029     parseAnalyzerConfigs(Opts, &Diags);
1030   else
1031     parseAnalyzerConfigs(Opts, nullptr);
1032 
1033   llvm::raw_string_ostream os(Opts.FullCompilerInvocation);
1034   for (unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1035     if (i != 0)
1036       os << " ";
1037     os << Args.getArgString(i);
1038   }
1039   os.flush();
1040 
1041   return Diags.getNumErrors() == NumErrorsBefore;
1042 }
1043 
1044 static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config,
1045                                  StringRef OptionName, StringRef DefaultVal) {
1046   return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1047 }
1048 
1049 static void initOption(AnalyzerOptions::ConfigTable &Config,
1050                        DiagnosticsEngine *Diags,
1051                        StringRef &OptionField, StringRef Name,
1052                        StringRef DefaultVal) {
1053   // String options may be known to invalid (e.g. if the expected string is a
1054   // file name, but the file does not exist), those will have to be checked in
1055   // parseConfigs.
1056   OptionField = getStringOption(Config, Name, DefaultVal);
1057 }
1058 
1059 static void initOption(AnalyzerOptions::ConfigTable &Config,
1060                        DiagnosticsEngine *Diags,
1061                        bool &OptionField, StringRef Name, bool DefaultVal) {
1062   auto PossiblyInvalidVal = llvm::StringSwitch<Optional<bool>>(
1063                  getStringOption(Config, Name, (DefaultVal ? "true" : "false")))
1064       .Case("true", true)
1065       .Case("false", false)
1066       .Default(None);
1067 
1068   if (!PossiblyInvalidVal) {
1069     if (Diags)
1070       Diags->Report(diag::err_analyzer_config_invalid_input)
1071         << Name << "a boolean";
1072     else
1073       OptionField = DefaultVal;
1074   } else
1075     OptionField = *PossiblyInvalidVal;
1076 }
1077 
1078 static void initOption(AnalyzerOptions::ConfigTable &Config,
1079                        DiagnosticsEngine *Diags,
1080                        unsigned &OptionField, StringRef Name,
1081                        unsigned DefaultVal) {
1082 
1083   OptionField = DefaultVal;
1084   bool HasFailed = getStringOption(Config, Name, std::to_string(DefaultVal))
1085                      .getAsInteger(0, OptionField);
1086   if (Diags && HasFailed)
1087     Diags->Report(diag::err_analyzer_config_invalid_input)
1088       << Name << "an unsigned";
1089 }
1090 
1091 static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,
1092                                  DiagnosticsEngine *Diags) {
1093   // TODO: There's no need to store the entire configtable, it'd be plenty
1094   // enough to store checker options.
1095 
1096 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)                \
1097   initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1098 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1099 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1100 
1101   assert(AnOpts.UserMode == "shallow" || AnOpts.UserMode == "deep");
1102   const bool InShallowMode = AnOpts.UserMode == "shallow";
1103 
1104 #define ANALYZER_OPTION(...)
1105 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC,        \
1106                                              SHALLOW_VAL, DEEP_VAL)            \
1107   initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG,                       \
1108              InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1109 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1110 
1111   // At this point, AnalyzerOptions is configured. Let's validate some options.
1112 
1113   // FIXME: Here we try to validate the silenced checkers or packages are valid.
1114   // The current approach only validates the registered checkers which does not
1115   // contain the runtime enabled checkers and optimally we would validate both.
1116   if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1117     std::vector<StringRef> Checkers =
1118         AnOpts.getRegisteredCheckers(/*IncludeExperimental=*/true);
1119     std::vector<StringRef> Packages =
1120         AnOpts.getRegisteredPackages(/*IncludeExperimental=*/true);
1121 
1122     SmallVector<StringRef, 16> CheckersAndPackages;
1123     AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages, ";");
1124 
1125     for (const StringRef &CheckerOrPackage : CheckersAndPackages) {
1126       if (Diags) {
1127         bool IsChecker = CheckerOrPackage.contains('.');
1128         bool IsValidName = IsChecker
1129                                ? llvm::is_contained(Checkers, CheckerOrPackage)
1130                                : llvm::is_contained(Packages, CheckerOrPackage);
1131 
1132         if (!IsValidName)
1133           Diags->Report(diag::err_unknown_analyzer_checker_or_package)
1134               << CheckerOrPackage;
1135       }
1136 
1137       AnOpts.SilencedCheckersAndPackages.emplace_back(CheckerOrPackage);
1138     }
1139   }
1140 
1141   if (!Diags)
1142     return;
1143 
1144   if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1145     Diags->Report(diag::err_analyzer_config_invalid_input)
1146         << "track-conditions-debug" << "'track-conditions' to also be enabled";
1147 
1148   if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1149     Diags->Report(diag::err_analyzer_config_invalid_input) << "ctu-dir"
1150                                                            << "a filename";
1151 
1152   if (!AnOpts.ModelPath.empty() &&
1153       !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1154     Diags->Report(diag::err_analyzer_config_invalid_input) << "model-path"
1155                                                            << "a filename";
1156 }
1157 
1158 /// Generate a remark argument. This is an inverse of `ParseOptimizationRemark`.
1159 static void
1160 GenerateOptimizationRemark(SmallVectorImpl<const char *> &Args,
1161                            CompilerInvocation::StringAllocator SA,
1162                            OptSpecifier OptEQ, StringRef Name,
1163                            const CodeGenOptions::OptRemark &Remark) {
1164   if (Remark.hasValidPattern()) {
1165     GenerateArg(Args, OptEQ, Remark.Pattern, SA);
1166   } else if (Remark.Kind == CodeGenOptions::RK_Enabled) {
1167     GenerateArg(Args, OPT_R_Joined, Name, SA);
1168   } else if (Remark.Kind == CodeGenOptions::RK_Disabled) {
1169     GenerateArg(Args, OPT_R_Joined, StringRef("no-") + Name, SA);
1170   }
1171 }
1172 
1173 /// Parse a remark command line argument. It may be missing, disabled/enabled by
1174 /// '-R[no-]group' or specified with a regular expression by '-Rgroup=regexp'.
1175 /// On top of that, it can be disabled/enabled globally by '-R[no-]everything'.
1176 static CodeGenOptions::OptRemark
1177 ParseOptimizationRemark(DiagnosticsEngine &Diags, ArgList &Args,
1178                         OptSpecifier OptEQ, StringRef Name) {
1179   CodeGenOptions::OptRemark Result;
1180 
1181   auto InitializeResultPattern = [&Diags, &Args, &Result](const Arg *A,
1182                                                           StringRef Pattern) {
1183     Result.Pattern = Pattern.str();
1184 
1185     std::string RegexError;
1186     Result.Regex = std::make_shared<llvm::Regex>(Result.Pattern);
1187     if (!Result.Regex->isValid(RegexError)) {
1188       Diags.Report(diag::err_drv_optimization_remark_pattern)
1189           << RegexError << A->getAsString(Args);
1190       return false;
1191     }
1192 
1193     return true;
1194   };
1195 
1196   for (Arg *A : Args) {
1197     if (A->getOption().matches(OPT_R_Joined)) {
1198       StringRef Value = A->getValue();
1199 
1200       if (Value == Name)
1201         Result.Kind = CodeGenOptions::RK_Enabled;
1202       else if (Value == "everything")
1203         Result.Kind = CodeGenOptions::RK_EnabledEverything;
1204       else if (Value.split('-') == std::make_pair(StringRef("no"), Name))
1205         Result.Kind = CodeGenOptions::RK_Disabled;
1206       else if (Value == "no-everything")
1207         Result.Kind = CodeGenOptions::RK_DisabledEverything;
1208       else
1209         continue;
1210 
1211       if (Result.Kind == CodeGenOptions::RK_Disabled ||
1212           Result.Kind == CodeGenOptions::RK_DisabledEverything) {
1213         Result.Pattern = "";
1214         Result.Regex = nullptr;
1215       } else {
1216         InitializeResultPattern(A, ".*");
1217       }
1218     } else if (A->getOption().matches(OptEQ)) {
1219       Result.Kind = CodeGenOptions::RK_WithPattern;
1220       if (!InitializeResultPattern(A, A->getValue()))
1221         return CodeGenOptions::OptRemark();
1222     }
1223   }
1224 
1225   return Result;
1226 }
1227 
1228 static bool parseDiagnosticLevelMask(StringRef FlagName,
1229                                      const std::vector<std::string> &Levels,
1230                                      DiagnosticsEngine &Diags,
1231                                      DiagnosticLevelMask &M) {
1232   bool Success = true;
1233   for (const auto &Level : Levels) {
1234     DiagnosticLevelMask const PM =
1235       llvm::StringSwitch<DiagnosticLevelMask>(Level)
1236         .Case("note",    DiagnosticLevelMask::Note)
1237         .Case("remark",  DiagnosticLevelMask::Remark)
1238         .Case("warning", DiagnosticLevelMask::Warning)
1239         .Case("error",   DiagnosticLevelMask::Error)
1240         .Default(DiagnosticLevelMask::None);
1241     if (PM == DiagnosticLevelMask::None) {
1242       Success = false;
1243       Diags.Report(diag::err_drv_invalid_value) << FlagName << Level;
1244     }
1245     M = M | PM;
1246   }
1247   return Success;
1248 }
1249 
1250 static void parseSanitizerKinds(StringRef FlagName,
1251                                 const std::vector<std::string> &Sanitizers,
1252                                 DiagnosticsEngine &Diags, SanitizerSet &S) {
1253   for (const auto &Sanitizer : Sanitizers) {
1254     SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
1255     if (K == SanitizerMask())
1256       Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1257     else
1258       S.set(K, true);
1259   }
1260 }
1261 
1262 static SmallVector<StringRef, 4> serializeSanitizerKinds(SanitizerSet S) {
1263   SmallVector<StringRef, 4> Values;
1264   serializeSanitizerSet(S, Values);
1265   return Values;
1266 }
1267 
1268 static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle,
1269                                            ArgList &Args, DiagnosticsEngine &D,
1270                                            XRayInstrSet &S) {
1271   llvm::SmallVector<StringRef, 2> BundleParts;
1272   llvm::SplitString(Bundle, BundleParts, ",");
1273   for (const auto &B : BundleParts) {
1274     auto Mask = parseXRayInstrValue(B);
1275     if (Mask == XRayInstrKind::None)
1276       if (B != "none")
1277         D.Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1278       else
1279         S.Mask = Mask;
1280     else if (Mask == XRayInstrKind::All)
1281       S.Mask = Mask;
1282     else
1283       S.set(Mask, true);
1284   }
1285 }
1286 
1287 static std::string serializeXRayInstrumentationBundle(const XRayInstrSet &S) {
1288   llvm::SmallVector<StringRef, 2> BundleParts;
1289   serializeXRayInstrValue(S, BundleParts);
1290   std::string Buffer;
1291   llvm::raw_string_ostream OS(Buffer);
1292   llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; }, ",");
1293   return Buffer;
1294 }
1295 
1296 // Set the profile kind using fprofile-instrument-use-path.
1297 static void setPGOUseInstrumentor(CodeGenOptions &Opts,
1298                                   const Twine &ProfileName,
1299                                   DiagnosticsEngine &Diags) {
1300   auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName);
1301   if (auto E = ReaderOrErr.takeError()) {
1302     unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1303                                             "Error in reading profile %0: %1");
1304     llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
1305       Diags.Report(DiagID) << ProfileName.str() << EI.message();
1306     });
1307     return;
1308   }
1309   std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1310     std::move(ReaderOrErr.get());
1311   // Currently memprof profiles are only added at the IR level. Mark the profile
1312   // type as IR in that case as well and the subsequent matching needs to detect
1313   // which is available (might be one or both).
1314   if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1315     if (PGOReader->hasCSIRLevelProfile())
1316       Opts.setProfileUse(CodeGenOptions::ProfileCSIRInstr);
1317     else
1318       Opts.setProfileUse(CodeGenOptions::ProfileIRInstr);
1319   } else
1320     Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
1321 }
1322 
1323 void CompilerInvocation::GenerateCodeGenArgs(
1324     const CodeGenOptions &Opts, SmallVectorImpl<const char *> &Args,
1325     StringAllocator SA, const llvm::Triple &T, const std::string &OutputFile,
1326     const LangOptions *LangOpts) {
1327   const CodeGenOptions &CodeGenOpts = Opts;
1328 
1329   if (Opts.OptimizationLevel == 0)
1330     GenerateArg(Args, OPT_O0, SA);
1331   else
1332     GenerateArg(Args, OPT_O, Twine(Opts.OptimizationLevel), SA);
1333 
1334 #define CODEGEN_OPTION_WITH_MARSHALLING(                                       \
1335     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
1336     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
1337     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
1338     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
1339   GENERATE_OPTION_WITH_MARSHALLING(                                            \
1340       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
1341       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
1342 #include "clang/Driver/Options.inc"
1343 #undef CODEGEN_OPTION_WITH_MARSHALLING
1344 
1345   if (Opts.OptimizationLevel > 0) {
1346     if (Opts.Inlining == CodeGenOptions::NormalInlining)
1347       GenerateArg(Args, OPT_finline_functions, SA);
1348     else if (Opts.Inlining == CodeGenOptions::OnlyHintInlining)
1349       GenerateArg(Args, OPT_finline_hint_functions, SA);
1350     else if (Opts.Inlining == CodeGenOptions::OnlyAlwaysInlining)
1351       GenerateArg(Args, OPT_fno_inline, SA);
1352   }
1353 
1354   if (Opts.DirectAccessExternalData && LangOpts->PICLevel != 0)
1355     GenerateArg(Args, OPT_fdirect_access_external_data, SA);
1356   else if (!Opts.DirectAccessExternalData && LangOpts->PICLevel == 0)
1357     GenerateArg(Args, OPT_fno_direct_access_external_data, SA);
1358 
1359   Optional<StringRef> DebugInfoVal;
1360   switch (Opts.DebugInfo) {
1361   case codegenoptions::DebugLineTablesOnly:
1362     DebugInfoVal = "line-tables-only";
1363     break;
1364   case codegenoptions::DebugDirectivesOnly:
1365     DebugInfoVal = "line-directives-only";
1366     break;
1367   case codegenoptions::DebugInfoConstructor:
1368     DebugInfoVal = "constructor";
1369     break;
1370   case codegenoptions::LimitedDebugInfo:
1371     DebugInfoVal = "limited";
1372     break;
1373   case codegenoptions::FullDebugInfo:
1374     DebugInfoVal = "standalone";
1375     break;
1376   case codegenoptions::UnusedTypeInfo:
1377     DebugInfoVal = "unused-types";
1378     break;
1379   case codegenoptions::NoDebugInfo: // default value
1380     DebugInfoVal = None;
1381     break;
1382   case codegenoptions::LocTrackingOnly: // implied value
1383     DebugInfoVal = None;
1384     break;
1385   }
1386   if (DebugInfoVal)
1387     GenerateArg(Args, OPT_debug_info_kind_EQ, *DebugInfoVal, SA);
1388 
1389   for (const auto &Prefix : Opts.DebugPrefixMap)
1390     GenerateArg(Args, OPT_fdebug_prefix_map_EQ,
1391                 Prefix.first + "=" + Prefix.second, SA);
1392 
1393   for (const auto &Prefix : Opts.CoveragePrefixMap)
1394     GenerateArg(Args, OPT_fcoverage_prefix_map_EQ,
1395                 Prefix.first + "=" + Prefix.second, SA);
1396 
1397   if (Opts.NewStructPathTBAA)
1398     GenerateArg(Args, OPT_new_struct_path_tbaa, SA);
1399 
1400   if (Opts.OptimizeSize == 1)
1401     GenerateArg(Args, OPT_O, "s", SA);
1402   else if (Opts.OptimizeSize == 2)
1403     GenerateArg(Args, OPT_O, "z", SA);
1404 
1405   // SimplifyLibCalls is set only in the absence of -fno-builtin and
1406   // -ffreestanding. We'll consider that when generating them.
1407 
1408   // NoBuiltinFuncs are generated by LangOptions.
1409 
1410   if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1411     GenerateArg(Args, OPT_funroll_loops, SA);
1412   else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1413     GenerateArg(Args, OPT_fno_unroll_loops, SA);
1414 
1415   if (!Opts.BinutilsVersion.empty())
1416     GenerateArg(Args, OPT_fbinutils_version_EQ, Opts.BinutilsVersion, SA);
1417 
1418   if (Opts.DebugNameTable ==
1419       static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1420     GenerateArg(Args, OPT_ggnu_pubnames, SA);
1421   else if (Opts.DebugNameTable ==
1422            static_cast<unsigned>(
1423                llvm::DICompileUnit::DebugNameTableKind::Default))
1424     GenerateArg(Args, OPT_gpubnames, SA);
1425 
1426   auto TNK = Opts.getDebugSimpleTemplateNames();
1427   if (TNK != codegenoptions::DebugTemplateNamesKind::Full) {
1428     if (TNK == codegenoptions::DebugTemplateNamesKind::Simple)
1429       GenerateArg(Args, OPT_gsimple_template_names_EQ, "simple", SA);
1430     else if (TNK == codegenoptions::DebugTemplateNamesKind::Mangled)
1431       GenerateArg(Args, OPT_gsimple_template_names_EQ, "mangled", SA);
1432   }
1433   // ProfileInstrumentUsePath is marshalled automatically, no need to generate
1434   // it or PGOUseInstrumentor.
1435 
1436   if (Opts.TimePasses) {
1437     if (Opts.TimePassesPerRun)
1438       GenerateArg(Args, OPT_ftime_report_EQ, "per-pass-run", SA);
1439     else
1440       GenerateArg(Args, OPT_ftime_report, SA);
1441   }
1442 
1443   if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1444     GenerateArg(Args, OPT_flto_EQ, "full", SA);
1445 
1446   if (Opts.PrepareForThinLTO)
1447     GenerateArg(Args, OPT_flto_EQ, "thin", SA);
1448 
1449   if (!Opts.ThinLTOIndexFile.empty())
1450     GenerateArg(Args, OPT_fthinlto_index_EQ, Opts.ThinLTOIndexFile, SA);
1451 
1452   if (Opts.SaveTempsFilePrefix == OutputFile)
1453     GenerateArg(Args, OPT_save_temps_EQ, "obj", SA);
1454 
1455   StringRef MemProfileBasename("memprof.profraw");
1456   if (!Opts.MemoryProfileOutput.empty()) {
1457     if (Opts.MemoryProfileOutput == MemProfileBasename) {
1458       GenerateArg(Args, OPT_fmemory_profile, SA);
1459     } else {
1460       size_t ArgLength =
1461           Opts.MemoryProfileOutput.size() - MemProfileBasename.size();
1462       GenerateArg(Args, OPT_fmemory_profile_EQ,
1463                   Opts.MemoryProfileOutput.substr(0, ArgLength), SA);
1464     }
1465   }
1466 
1467   if (memcmp(Opts.CoverageVersion, "408*", 4) != 0)
1468     GenerateArg(Args, OPT_coverage_version_EQ,
1469                 StringRef(Opts.CoverageVersion, 4), SA);
1470 
1471   // TODO: Check if we need to generate arguments stored in CmdArgs. (Namely
1472   //  '-fembed_bitcode', which does not map to any CompilerInvocation field and
1473   //  won't be generated.)
1474 
1475   if (Opts.XRayInstrumentationBundle.Mask != XRayInstrKind::All) {
1476     std::string InstrBundle =
1477         serializeXRayInstrumentationBundle(Opts.XRayInstrumentationBundle);
1478     if (!InstrBundle.empty())
1479       GenerateArg(Args, OPT_fxray_instrumentation_bundle, InstrBundle, SA);
1480   }
1481 
1482   if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1483     GenerateArg(Args, OPT_fcf_protection_EQ, "full", SA);
1484   else if (Opts.CFProtectionReturn)
1485     GenerateArg(Args, OPT_fcf_protection_EQ, "return", SA);
1486   else if (Opts.CFProtectionBranch)
1487     GenerateArg(Args, OPT_fcf_protection_EQ, "branch", SA);
1488 
1489   if (Opts.IBTSeal)
1490     GenerateArg(Args, OPT_mibt_seal, SA);
1491 
1492   if (Opts.FunctionReturnThunks)
1493     GenerateArg(Args, OPT_mfunction_return_EQ, "thunk-extern", SA);
1494 
1495   for (const auto &F : Opts.LinkBitcodeFiles) {
1496     bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1497                     F.PropagateAttrs && F.Internalize;
1498     GenerateArg(Args,
1499                 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1500                 F.Filename, SA);
1501   }
1502 
1503   GenerateArg(
1504       Args, Opts.EmulatedTLS ? OPT_femulated_tls : OPT_fno_emulated_tls, SA);
1505 
1506   if (Opts.FPDenormalMode != llvm::DenormalMode::getIEEE())
1507     GenerateArg(Args, OPT_fdenormal_fp_math_EQ, Opts.FPDenormalMode.str(), SA);
1508 
1509   if ((Opts.FPDenormalMode != Opts.FP32DenormalMode) ||
1510       (Opts.FP32DenormalMode != llvm::DenormalMode::getIEEE()))
1511     GenerateArg(Args, OPT_fdenormal_fp_math_f32_EQ, Opts.FP32DenormalMode.str(),
1512                 SA);
1513 
1514   if (Opts.StructReturnConvention == CodeGenOptions::SRCK_OnStack) {
1515     OptSpecifier Opt =
1516         T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1517     GenerateArg(Args, Opt, SA);
1518   } else if (Opts.StructReturnConvention == CodeGenOptions::SRCK_InRegs) {
1519     OptSpecifier Opt =
1520         T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1521     GenerateArg(Args, Opt, SA);
1522   }
1523 
1524   if (Opts.EnableAIXExtendedAltivecABI)
1525     GenerateArg(Args, OPT_mabi_EQ_vec_extabi, SA);
1526 
1527   if (!Opts.OptRecordPasses.empty())
1528     GenerateArg(Args, OPT_opt_record_passes, Opts.OptRecordPasses, SA);
1529 
1530   if (!Opts.OptRecordFormat.empty())
1531     GenerateArg(Args, OPT_opt_record_format, Opts.OptRecordFormat, SA);
1532 
1533   GenerateOptimizationRemark(Args, SA, OPT_Rpass_EQ, "pass",
1534                              Opts.OptimizationRemark);
1535 
1536   GenerateOptimizationRemark(Args, SA, OPT_Rpass_missed_EQ, "pass-missed",
1537                              Opts.OptimizationRemarkMissed);
1538 
1539   GenerateOptimizationRemark(Args, SA, OPT_Rpass_analysis_EQ, "pass-analysis",
1540                              Opts.OptimizationRemarkAnalysis);
1541 
1542   GenerateArg(Args, OPT_fdiagnostics_hotness_threshold_EQ,
1543               Opts.DiagnosticsHotnessThreshold
1544                   ? Twine(*Opts.DiagnosticsHotnessThreshold)
1545                   : "auto",
1546               SA);
1547 
1548   GenerateArg(Args, OPT_fdiagnostics_misexpect_tolerance_EQ,
1549               Twine(*Opts.DiagnosticsMisExpectTolerance), SA);
1550 
1551   for (StringRef Sanitizer : serializeSanitizerKinds(Opts.SanitizeRecover))
1552     GenerateArg(Args, OPT_fsanitize_recover_EQ, Sanitizer, SA);
1553 
1554   for (StringRef Sanitizer : serializeSanitizerKinds(Opts.SanitizeTrap))
1555     GenerateArg(Args, OPT_fsanitize_trap_EQ, Sanitizer, SA);
1556 
1557   if (!Opts.EmitVersionIdentMetadata)
1558     GenerateArg(Args, OPT_Qn, SA);
1559 
1560   switch (Opts.FiniteLoops) {
1561   case CodeGenOptions::FiniteLoopsKind::Language:
1562     break;
1563   case CodeGenOptions::FiniteLoopsKind::Always:
1564     GenerateArg(Args, OPT_ffinite_loops, SA);
1565     break;
1566   case CodeGenOptions::FiniteLoopsKind::Never:
1567     GenerateArg(Args, OPT_fno_finite_loops, SA);
1568     break;
1569   }
1570 }
1571 
1572 bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
1573                                           InputKind IK,
1574                                           DiagnosticsEngine &Diags,
1575                                           const llvm::Triple &T,
1576                                           const std::string &OutputFile,
1577                                           const LangOptions &LangOptsRef) {
1578   unsigned NumErrorsBefore = Diags.getNumErrors();
1579 
1580   unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
1581   // TODO: This could be done in Driver
1582   unsigned MaxOptLevel = 3;
1583   if (OptimizationLevel > MaxOptLevel) {
1584     // If the optimization level is not supported, fall back on the default
1585     // optimization
1586     Diags.Report(diag::warn_drv_optimization_value)
1587         << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel;
1588     OptimizationLevel = MaxOptLevel;
1589   }
1590   Opts.OptimizationLevel = OptimizationLevel;
1591 
1592   // The key paths of codegen options defined in Options.td start with
1593   // "CodeGenOpts.". Let's provide the expected variable name and type.
1594   CodeGenOptions &CodeGenOpts = Opts;
1595   // Some codegen options depend on language options. Let's provide the expected
1596   // variable name and type.
1597   const LangOptions *LangOpts = &LangOptsRef;
1598 
1599 #define CODEGEN_OPTION_WITH_MARSHALLING(                                       \
1600     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
1601     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
1602     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
1603     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
1604   PARSE_OPTION_WITH_MARSHALLING(                                               \
1605       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
1606       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
1607 #include "clang/Driver/Options.inc"
1608 #undef CODEGEN_OPTION_WITH_MARSHALLING
1609 
1610   // At O0 we want to fully disable inlining outside of cases marked with
1611   // 'alwaysinline' that are required for correctness.
1612   if (Opts.OptimizationLevel == 0) {
1613     Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
1614   } else if (const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1615                                             options::OPT_finline_hint_functions,
1616                                             options::OPT_fno_inline_functions,
1617                                             options::OPT_fno_inline)) {
1618     // Explicit inlining flags can disable some or all inlining even at
1619     // optimization levels above zero.
1620     if (A->getOption().matches(options::OPT_finline_functions))
1621       Opts.setInlining(CodeGenOptions::NormalInlining);
1622     else if (A->getOption().matches(options::OPT_finline_hint_functions))
1623       Opts.setInlining(CodeGenOptions::OnlyHintInlining);
1624     else
1625       Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
1626   } else {
1627     Opts.setInlining(CodeGenOptions::NormalInlining);
1628   }
1629 
1630   // PIC defaults to -fno-direct-access-external-data while non-PIC defaults to
1631   // -fdirect-access-external-data.
1632   Opts.DirectAccessExternalData =
1633       Args.hasArg(OPT_fdirect_access_external_data) ||
1634       (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1635        LangOpts->PICLevel == 0);
1636 
1637   if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1638     unsigned Val =
1639         llvm::StringSwitch<unsigned>(A->getValue())
1640             .Case("line-tables-only", codegenoptions::DebugLineTablesOnly)
1641             .Case("line-directives-only", codegenoptions::DebugDirectivesOnly)
1642             .Case("constructor", codegenoptions::DebugInfoConstructor)
1643             .Case("limited", codegenoptions::LimitedDebugInfo)
1644             .Case("standalone", codegenoptions::FullDebugInfo)
1645             .Case("unused-types", codegenoptions::UnusedTypeInfo)
1646             .Default(~0U);
1647     if (Val == ~0U)
1648       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1649                                                 << A->getValue();
1650     else
1651       Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val));
1652   }
1653 
1654   // If -fuse-ctor-homing is set and limited debug info is already on, then use
1655   // constructor homing, and vice versa for -fno-use-ctor-homing.
1656   if (const Arg *A =
1657           Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1658     if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1659         Opts.getDebugInfo() == codegenoptions::LimitedDebugInfo)
1660       Opts.setDebugInfo(codegenoptions::DebugInfoConstructor);
1661     if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1662         Opts.getDebugInfo() == codegenoptions::DebugInfoConstructor)
1663       Opts.setDebugInfo(codegenoptions::LimitedDebugInfo);
1664   }
1665 
1666   for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1667     auto Split = StringRef(Arg).split('=');
1668     Opts.DebugPrefixMap.insert(
1669         {std::string(Split.first), std::string(Split.second)});
1670   }
1671 
1672   for (const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1673     auto Split = StringRef(Arg).split('=');
1674     Opts.CoveragePrefixMap.insert(
1675         {std::string(Split.first), std::string(Split.second)});
1676   }
1677 
1678   const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1679       llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1680       llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1681       llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1682 
1683   if (Opts.OptimizationLevel > 0 && Opts.hasReducedDebugInfo() &&
1684       llvm::is_contained(DebugEntryValueArchs, T.getArch()))
1685     Opts.EmitCallSiteInfo = true;
1686 
1687   if (!Opts.EnableDIPreservationVerify && Opts.DIBugsReportFilePath.size()) {
1688     Diags.Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1689         << Opts.DIBugsReportFilePath;
1690     Opts.DIBugsReportFilePath = "";
1691   }
1692 
1693   Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1694                            Args.hasArg(OPT_new_struct_path_tbaa);
1695   Opts.OptimizeSize = getOptimizationLevelSize(Args);
1696   Opts.SimplifyLibCalls = !LangOpts->NoBuiltin;
1697   if (Opts.SimplifyLibCalls)
1698     Opts.NoBuiltinFuncs = LangOpts->NoBuiltinFuncs;
1699   Opts.UnrollLoops =
1700       Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1701                    (Opts.OptimizationLevel > 1));
1702   Opts.BinutilsVersion =
1703       std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1704 
1705   Opts.DebugNameTable = static_cast<unsigned>(
1706       Args.hasArg(OPT_ggnu_pubnames)
1707           ? llvm::DICompileUnit::DebugNameTableKind::GNU
1708           : Args.hasArg(OPT_gpubnames)
1709                 ? llvm::DICompileUnit::DebugNameTableKind::Default
1710                 : llvm::DICompileUnit::DebugNameTableKind::None);
1711   if (const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1712     StringRef Value = A->getValue();
1713     if (Value != "simple" && Value != "mangled")
1714       Diags.Report(diag::err_drv_unsupported_option_argument)
1715           << A->getOption().getName() << A->getValue();
1716     Opts.setDebugSimpleTemplateNames(
1717         StringRef(A->getValue()) == "simple"
1718             ? codegenoptions::DebugTemplateNamesKind::Simple
1719             : codegenoptions::DebugTemplateNamesKind::Mangled);
1720   }
1721 
1722   if (!Opts.ProfileInstrumentUsePath.empty())
1723     setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath, Diags);
1724 
1725   if (const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1726     Opts.TimePasses = true;
1727 
1728     // -ftime-report= is only for new pass manager.
1729     if (A->getOption().getID() == OPT_ftime_report_EQ) {
1730       StringRef Val = A->getValue();
1731       if (Val == "per-pass")
1732         Opts.TimePassesPerRun = false;
1733       else if (Val == "per-pass-run")
1734         Opts.TimePassesPerRun = true;
1735       else
1736         Diags.Report(diag::err_drv_invalid_value)
1737             << A->getAsString(Args) << A->getValue();
1738     }
1739   }
1740 
1741   Opts.PrepareForLTO = false;
1742   Opts.PrepareForThinLTO = false;
1743   if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1744     Opts.PrepareForLTO = true;
1745     StringRef S = A->getValue();
1746     if (S == "thin")
1747       Opts.PrepareForThinLTO = true;
1748     else if (S != "full")
1749       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1750   }
1751   if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1752     if (IK.getLanguage() != Language::LLVM_IR)
1753       Diags.Report(diag::err_drv_argument_only_allowed_with)
1754           << A->getAsString(Args) << "-x ir";
1755     Opts.ThinLTOIndexFile =
1756         std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1757   }
1758   if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1759     Opts.SaveTempsFilePrefix =
1760         llvm::StringSwitch<std::string>(A->getValue())
1761             .Case("obj", OutputFile)
1762             .Default(llvm::sys::path::filename(OutputFile).str());
1763 
1764   // The memory profile runtime appends the pid to make this name more unique.
1765   const char *MemProfileBasename = "memprof.profraw";
1766   if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1767     SmallString<128> Path(
1768         std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1769     llvm::sys::path::append(Path, MemProfileBasename);
1770     Opts.MemoryProfileOutput = std::string(Path);
1771   } else if (Args.hasArg(OPT_fmemory_profile))
1772     Opts.MemoryProfileOutput = MemProfileBasename;
1773 
1774   memcpy(Opts.CoverageVersion, "408*", 4);
1775   if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
1776     if (Args.hasArg(OPT_coverage_version_EQ)) {
1777       StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1778       if (CoverageVersion.size() != 4) {
1779         Diags.Report(diag::err_drv_invalid_value)
1780             << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1781             << CoverageVersion;
1782       } else {
1783         memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
1784       }
1785     }
1786   }
1787   // FIXME: For backend options that are not yet recorded as function
1788   // attributes in the IR, keep track of them so we can embed them in a
1789   // separate data section and use them when building the bitcode.
1790   for (const auto &A : Args) {
1791     // Do not encode output and input.
1792     if (A->getOption().getID() == options::OPT_o ||
1793         A->getOption().getID() == options::OPT_INPUT ||
1794         A->getOption().getID() == options::OPT_x ||
1795         A->getOption().getID() == options::OPT_fembed_bitcode ||
1796         A->getOption().matches(options::OPT_W_Group))
1797       continue;
1798     ArgStringList ASL;
1799     A->render(Args, ASL);
1800     for (const auto &arg : ASL) {
1801       StringRef ArgStr(arg);
1802       Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1803       // using \00 to separate each commandline options.
1804       Opts.CmdArgs.push_back('\0');
1805     }
1806   }
1807 
1808   auto XRayInstrBundles =
1809       Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1810   if (XRayInstrBundles.empty())
1811     Opts.XRayInstrumentationBundle.Mask = XRayInstrKind::All;
1812   else
1813     for (const auto &A : XRayInstrBundles)
1814       parseXRayInstrumentationBundle("-fxray-instrumentation-bundle=", A, Args,
1815                                      Diags, Opts.XRayInstrumentationBundle);
1816 
1817   if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1818     StringRef Name = A->getValue();
1819     if (Name == "full") {
1820       Opts.CFProtectionReturn = 1;
1821       Opts.CFProtectionBranch = 1;
1822     } else if (Name == "return")
1823       Opts.CFProtectionReturn = 1;
1824     else if (Name == "branch")
1825       Opts.CFProtectionBranch = 1;
1826     else if (Name != "none")
1827       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1828   }
1829 
1830   if (const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
1831     auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
1832                    .Case("keep", llvm::FunctionReturnThunksKind::Keep)
1833                    .Case("thunk-extern", llvm::FunctionReturnThunksKind::Extern)
1834                    .Default(llvm::FunctionReturnThunksKind::Invalid);
1835     // SystemZ might want to add support for "expolines."
1836     if (!T.isX86())
1837       Diags.Report(diag::err_drv_argument_not_allowed_with)
1838           << A->getSpelling() << T.getTriple();
1839     else if (Val == llvm::FunctionReturnThunksKind::Invalid)
1840       Diags.Report(diag::err_drv_invalid_value)
1841           << A->getAsString(Args) << A->getValue();
1842     else if (Val == llvm::FunctionReturnThunksKind::Extern &&
1843              Args.getLastArgValue(OPT_mcmodel_EQ).equals("large"))
1844       Diags.Report(diag::err_drv_argument_not_allowed_with)
1845           << A->getAsString(Args)
1846           << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
1847     else
1848       Opts.FunctionReturnThunks = static_cast<unsigned>(Val);
1849   }
1850 
1851   if (Opts.PrepareForLTO && Args.hasArg(OPT_mibt_seal))
1852     Opts.IBTSeal = 1;
1853 
1854   for (auto *A :
1855        Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1856     CodeGenOptions::BitcodeFileToLink F;
1857     F.Filename = A->getValue();
1858     if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1859       F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1860       // When linking CUDA bitcode, propagate function attributes so that
1861       // e.g. libdevice gets fast-math attrs if we're building with fast-math.
1862       F.PropagateAttrs = true;
1863       F.Internalize = true;
1864     }
1865     Opts.LinkBitcodeFiles.push_back(F);
1866   }
1867 
1868   if (!Args.getLastArg(OPT_femulated_tls) &&
1869       !Args.getLastArg(OPT_fno_emulated_tls)) {
1870     Opts.EmulatedTLS = T.hasDefaultEmulatedTLS();
1871   }
1872 
1873   if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
1874     if (T.isOSAIX()) {
1875       StringRef Name = A->getValue();
1876       if (Name != "global-dynamic")
1877         Diags.Report(diag::err_aix_unsupported_tls_model) << Name;
1878     }
1879   }
1880 
1881   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1882     StringRef Val = A->getValue();
1883     Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val);
1884     Opts.FP32DenormalMode = Opts.FPDenormalMode;
1885     if (!Opts.FPDenormalMode.isValid())
1886       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1887   }
1888 
1889   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
1890     StringRef Val = A->getValue();
1891     Opts.FP32DenormalMode = llvm::parseDenormalFPAttribute(Val);
1892     if (!Opts.FP32DenormalMode.isValid())
1893       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
1894   }
1895 
1896   // X86_32 has -fppc-struct-return and -freg-struct-return.
1897   // PPC32 has -maix-struct-return and -msvr4-struct-return.
1898   if (Arg *A =
1899           Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
1900                           OPT_maix_struct_return, OPT_msvr4_struct_return)) {
1901     // TODO: We might want to consider enabling these options on AIX in the
1902     // future.
1903     if (T.isOSAIX())
1904       Diags.Report(diag::err_drv_unsupported_opt_for_target)
1905           << A->getSpelling() << T.str();
1906 
1907     const Option &O = A->getOption();
1908     if (O.matches(OPT_fpcc_struct_return) ||
1909         O.matches(OPT_maix_struct_return)) {
1910       Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
1911     } else {
1912       assert(O.matches(OPT_freg_struct_return) ||
1913              O.matches(OPT_msvr4_struct_return));
1914       Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
1915     }
1916   }
1917 
1918   if (Arg *A =
1919           Args.getLastArg(OPT_mabi_EQ_vec_default, OPT_mabi_EQ_vec_extabi)) {
1920     if (!T.isOSAIX())
1921       Diags.Report(diag::err_drv_unsupported_opt_for_target)
1922           << A->getSpelling() << T.str();
1923 
1924     const Option &O = A->getOption();
1925     Opts.EnableAIXExtendedAltivecABI = O.matches(OPT_mabi_EQ_vec_extabi);
1926   }
1927 
1928   if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
1929     if (!T.isOSAIX() || T.isPPC32())
1930       Diags.Report(diag::err_drv_unsupported_opt_for_target)
1931         << A->getSpelling() << T.str();
1932   }
1933 
1934   bool NeedLocTracking = false;
1935 
1936   if (!Opts.OptRecordFile.empty())
1937     NeedLocTracking = true;
1938 
1939   if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
1940     Opts.OptRecordPasses = A->getValue();
1941     NeedLocTracking = true;
1942   }
1943 
1944   if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
1945     Opts.OptRecordFormat = A->getValue();
1946     NeedLocTracking = true;
1947   }
1948 
1949   Opts.OptimizationRemark =
1950       ParseOptimizationRemark(Diags, Args, OPT_Rpass_EQ, "pass");
1951 
1952   Opts.OptimizationRemarkMissed =
1953       ParseOptimizationRemark(Diags, Args, OPT_Rpass_missed_EQ, "pass-missed");
1954 
1955   Opts.OptimizationRemarkAnalysis = ParseOptimizationRemark(
1956       Diags, Args, OPT_Rpass_analysis_EQ, "pass-analysis");
1957 
1958   NeedLocTracking |= Opts.OptimizationRemark.hasValidPattern() ||
1959                      Opts.OptimizationRemarkMissed.hasValidPattern() ||
1960                      Opts.OptimizationRemarkAnalysis.hasValidPattern();
1961 
1962   bool UsingSampleProfile = !Opts.SampleProfileFile.empty();
1963   bool UsingProfile = UsingSampleProfile ||
1964       (Opts.getProfileUse() != CodeGenOptions::ProfileNone);
1965 
1966   if (Opts.DiagnosticsWithHotness && !UsingProfile &&
1967       // An IR file will contain PGO as metadata
1968       IK.getLanguage() != Language::LLVM_IR)
1969     Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1970         << "-fdiagnostics-show-hotness";
1971 
1972   // Parse remarks hotness threshold. Valid value is either integer or 'auto'.
1973   if (auto *arg =
1974           Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
1975     auto ResultOrErr =
1976         llvm::remarks::parseHotnessThresholdOption(arg->getValue());
1977 
1978     if (!ResultOrErr) {
1979       Diags.Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
1980           << "-fdiagnostics-hotness-threshold=";
1981     } else {
1982       Opts.DiagnosticsHotnessThreshold = *ResultOrErr;
1983       if ((!Opts.DiagnosticsHotnessThreshold ||
1984            Opts.DiagnosticsHotnessThreshold.value() > 0) &&
1985           !UsingProfile)
1986         Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
1987             << "-fdiagnostics-hotness-threshold=";
1988     }
1989   }
1990 
1991   if (auto *arg =
1992           Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
1993     auto ResultOrErr = parseToleranceOption(arg->getValue());
1994 
1995     if (!ResultOrErr) {
1996       Diags.Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
1997           << "-fdiagnostics-misexpect-tolerance=";
1998     } else {
1999       Opts.DiagnosticsMisExpectTolerance = *ResultOrErr;
2000       if ((!Opts.DiagnosticsMisExpectTolerance ||
2001            Opts.DiagnosticsMisExpectTolerance.value() > 0) &&
2002           !UsingProfile)
2003         Diags.Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2004             << "-fdiagnostics-misexpect-tolerance=";
2005     }
2006   }
2007 
2008   // If the user requested to use a sample profile for PGO, then the
2009   // backend will need to track source location information so the profile
2010   // can be incorporated into the IR.
2011   if (UsingSampleProfile)
2012     NeedLocTracking = true;
2013 
2014   if (!Opts.StackUsageOutput.empty())
2015     NeedLocTracking = true;
2016 
2017   // If the user requested a flag that requires source locations available in
2018   // the backend, make sure that the backend tracks source location information.
2019   if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo)
2020     Opts.setDebugInfo(codegenoptions::LocTrackingOnly);
2021 
2022   // Parse -fsanitize-recover= arguments.
2023   // FIXME: Report unrecoverable sanitizers incorrectly specified here.
2024   parseSanitizerKinds("-fsanitize-recover=",
2025                       Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2026                       Opts.SanitizeRecover);
2027   parseSanitizerKinds("-fsanitize-trap=",
2028                       Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2029                       Opts.SanitizeTrap);
2030 
2031   Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);
2032 
2033   if (Args.hasArg(options::OPT_ffinite_loops))
2034     Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Always;
2035   else if (Args.hasArg(options::OPT_fno_finite_loops))
2036     Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Never;
2037 
2038   Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2039       options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee, true);
2040   if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2041     Diags.Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2042 
2043   return Diags.getNumErrors() == NumErrorsBefore;
2044 }
2045 
2046 static void
2047 GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts,
2048                              SmallVectorImpl<const char *> &Args,
2049                              CompilerInvocation::StringAllocator SA) {
2050   const DependencyOutputOptions &DependencyOutputOpts = Opts;
2051 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(                             \
2052     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2053     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2054     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2055     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2056   GENERATE_OPTION_WITH_MARSHALLING(                                            \
2057       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
2058       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2059 #include "clang/Driver/Options.inc"
2060 #undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2061 
2062   if (Opts.ShowIncludesDest != ShowIncludesDestination::None)
2063     GenerateArg(Args, OPT_show_includes, SA);
2064 
2065   for (const auto &Dep : Opts.ExtraDeps) {
2066     switch (Dep.second) {
2067     case EDK_SanitizeIgnorelist:
2068       // Sanitizer ignorelist arguments are generated from LanguageOptions.
2069       continue;
2070     case EDK_ModuleFile:
2071       // Module file arguments are generated from FrontendOptions and
2072       // HeaderSearchOptions.
2073       continue;
2074     case EDK_ProfileList:
2075       // Profile list arguments are generated from LanguageOptions via the
2076       // marshalling infrastructure.
2077       continue;
2078     case EDK_DepFileEntry:
2079       GenerateArg(Args, OPT_fdepfile_entry, Dep.first, SA);
2080       break;
2081     }
2082   }
2083 }
2084 
2085 static bool ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
2086                                       ArgList &Args, DiagnosticsEngine &Diags,
2087                                       frontend::ActionKind Action,
2088                                       bool ShowLineMarkers) {
2089   unsigned NumErrorsBefore = Diags.getNumErrors();
2090 
2091   DependencyOutputOptions &DependencyOutputOpts = Opts;
2092 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(                             \
2093     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2094     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2095     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2096     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2097   PARSE_OPTION_WITH_MARSHALLING(                                               \
2098       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
2099       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2100 #include "clang/Driver/Options.inc"
2101 #undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2102 
2103   if (Args.hasArg(OPT_show_includes)) {
2104     // Writing both /showIncludes and preprocessor output to stdout
2105     // would produce interleaved output, so use stderr for /showIncludes.
2106     // This behaves the same as cl.exe, when /E, /EP or /P are passed.
2107     if (Action == frontend::PrintPreprocessedInput || !ShowLineMarkers)
2108       Opts.ShowIncludesDest = ShowIncludesDestination::Stderr;
2109     else
2110       Opts.ShowIncludesDest = ShowIncludesDestination::Stdout;
2111   } else {
2112     Opts.ShowIncludesDest = ShowIncludesDestination::None;
2113   }
2114 
2115   // Add sanitizer ignorelists as extra dependencies.
2116   // They won't be discovered by the regular preprocessor, so
2117   // we let make / ninja to know about this implicit dependency.
2118   if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2119     for (const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2120       StringRef Val = A->getValue();
2121       if (!Val.contains('='))
2122         Opts.ExtraDeps.emplace_back(std::string(Val), EDK_SanitizeIgnorelist);
2123     }
2124     if (Opts.IncludeSystemHeaders) {
2125       for (const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2126         StringRef Val = A->getValue();
2127         if (!Val.contains('='))
2128           Opts.ExtraDeps.emplace_back(std::string(Val), EDK_SanitizeIgnorelist);
2129       }
2130     }
2131   }
2132 
2133   // -fprofile-list= dependencies.
2134   for (const auto &Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2135     Opts.ExtraDeps.emplace_back(Filename, EDK_ProfileList);
2136 
2137   // Propagate the extra dependencies.
2138   for (const auto *A : Args.filtered(OPT_fdepfile_entry))
2139     Opts.ExtraDeps.emplace_back(A->getValue(), EDK_DepFileEntry);
2140 
2141   // Only the -fmodule-file=<file> form.
2142   for (const auto *A : Args.filtered(OPT_fmodule_file)) {
2143     StringRef Val = A->getValue();
2144     if (!Val.contains('='))
2145       Opts.ExtraDeps.emplace_back(std::string(Val), EDK_ModuleFile);
2146   }
2147 
2148   return Diags.getNumErrors() == NumErrorsBefore;
2149 }
2150 
2151 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
2152   // Color diagnostics default to auto ("on" if terminal supports) in the driver
2153   // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
2154   // Support both clang's -f[no-]color-diagnostics and gcc's
2155   // -f[no-]diagnostics-colors[=never|always|auto].
2156   enum {
2157     Colors_On,
2158     Colors_Off,
2159     Colors_Auto
2160   } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2161   for (auto *A : Args) {
2162     const Option &O = A->getOption();
2163     if (O.matches(options::OPT_fcolor_diagnostics)) {
2164       ShowColors = Colors_On;
2165     } else if (O.matches(options::OPT_fno_color_diagnostics)) {
2166       ShowColors = Colors_Off;
2167     } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2168       StringRef Value(A->getValue());
2169       if (Value == "always")
2170         ShowColors = Colors_On;
2171       else if (Value == "never")
2172         ShowColors = Colors_Off;
2173       else if (Value == "auto")
2174         ShowColors = Colors_Auto;
2175     }
2176   }
2177   return ShowColors == Colors_On ||
2178          (ShowColors == Colors_Auto &&
2179           llvm::sys::Process::StandardErrHasColors());
2180 }
2181 
2182 static bool checkVerifyPrefixes(const std::vector<std::string> &VerifyPrefixes,
2183                                 DiagnosticsEngine &Diags) {
2184   bool Success = true;
2185   for (const auto &Prefix : VerifyPrefixes) {
2186     // Every prefix must start with a letter and contain only alphanumeric
2187     // characters, hyphens, and underscores.
2188     auto BadChar = llvm::find_if(Prefix, [](char C) {
2189       return !isAlphanumeric(C) && C != '-' && C != '_';
2190     });
2191     if (BadChar != Prefix.end() || !isLetter(Prefix[0])) {
2192       Success = false;
2193       Diags.Report(diag::err_drv_invalid_value) << "-verify=" << Prefix;
2194       Diags.Report(diag::note_drv_verify_prefix_spelling);
2195     }
2196   }
2197   return Success;
2198 }
2199 
2200 static void GenerateFileSystemArgs(const FileSystemOptions &Opts,
2201                                    SmallVectorImpl<const char *> &Args,
2202                                    CompilerInvocation::StringAllocator SA) {
2203   const FileSystemOptions &FileSystemOpts = Opts;
2204 
2205 #define FILE_SYSTEM_OPTION_WITH_MARSHALLING(                                   \
2206     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2207     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2208     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2209     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2210   GENERATE_OPTION_WITH_MARSHALLING(                                            \
2211       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
2212       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2213 #include "clang/Driver/Options.inc"
2214 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2215 }
2216 
2217 static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args,
2218                                 DiagnosticsEngine &Diags) {
2219   unsigned NumErrorsBefore = Diags.getNumErrors();
2220 
2221   FileSystemOptions &FileSystemOpts = Opts;
2222 
2223 #define FILE_SYSTEM_OPTION_WITH_MARSHALLING(                                   \
2224     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2225     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2226     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2227     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2228   PARSE_OPTION_WITH_MARSHALLING(                                               \
2229       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
2230       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2231 #include "clang/Driver/Options.inc"
2232 #undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2233 
2234   return Diags.getNumErrors() == NumErrorsBefore;
2235 }
2236 
2237 static void GenerateMigratorArgs(const MigratorOptions &Opts,
2238                                  SmallVectorImpl<const char *> &Args,
2239                                  CompilerInvocation::StringAllocator SA) {
2240   const MigratorOptions &MigratorOpts = Opts;
2241 #define MIGRATOR_OPTION_WITH_MARSHALLING(                                      \
2242     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2243     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2244     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2245     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2246   GENERATE_OPTION_WITH_MARSHALLING(                                            \
2247       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
2248       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2249 #include "clang/Driver/Options.inc"
2250 #undef MIGRATOR_OPTION_WITH_MARSHALLING
2251 }
2252 
2253 static bool ParseMigratorArgs(MigratorOptions &Opts, const ArgList &Args,
2254                               DiagnosticsEngine &Diags) {
2255   unsigned NumErrorsBefore = Diags.getNumErrors();
2256 
2257   MigratorOptions &MigratorOpts = Opts;
2258 
2259 #define MIGRATOR_OPTION_WITH_MARSHALLING(                                      \
2260     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2261     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2262     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2263     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2264   PARSE_OPTION_WITH_MARSHALLING(                                               \
2265       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
2266       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2267 #include "clang/Driver/Options.inc"
2268 #undef MIGRATOR_OPTION_WITH_MARSHALLING
2269 
2270   return Diags.getNumErrors() == NumErrorsBefore;
2271 }
2272 
2273 void CompilerInvocation::GenerateDiagnosticArgs(
2274     const DiagnosticOptions &Opts, SmallVectorImpl<const char *> &Args,
2275     StringAllocator SA, bool DefaultDiagColor) {
2276   const DiagnosticOptions *DiagnosticOpts = &Opts;
2277 #define DIAG_OPTION_WITH_MARSHALLING(                                          \
2278     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2279     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2280     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2281     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2282   GENERATE_OPTION_WITH_MARSHALLING(                                            \
2283       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
2284       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2285 #include "clang/Driver/Options.inc"
2286 #undef DIAG_OPTION_WITH_MARSHALLING
2287 
2288   if (!Opts.DiagnosticSerializationFile.empty())
2289     GenerateArg(Args, OPT_diagnostic_serialized_file,
2290                 Opts.DiagnosticSerializationFile, SA);
2291 
2292   if (Opts.ShowColors)
2293     GenerateArg(Args, OPT_fcolor_diagnostics, SA);
2294 
2295   if (Opts.VerifyDiagnostics &&
2296       llvm::is_contained(Opts.VerifyPrefixes, "expected"))
2297     GenerateArg(Args, OPT_verify, SA);
2298 
2299   for (const auto &Prefix : Opts.VerifyPrefixes)
2300     if (Prefix != "expected")
2301       GenerateArg(Args, OPT_verify_EQ, Prefix, SA);
2302 
2303   DiagnosticLevelMask VIU = Opts.getVerifyIgnoreUnexpected();
2304   if (VIU == DiagnosticLevelMask::None) {
2305     // This is the default, don't generate anything.
2306   } else if (VIU == DiagnosticLevelMask::All) {
2307     GenerateArg(Args, OPT_verify_ignore_unexpected, SA);
2308   } else {
2309     if (static_cast<unsigned>(VIU & DiagnosticLevelMask::Note) != 0)
2310       GenerateArg(Args, OPT_verify_ignore_unexpected_EQ, "note", SA);
2311     if (static_cast<unsigned>(VIU & DiagnosticLevelMask::Remark) != 0)
2312       GenerateArg(Args, OPT_verify_ignore_unexpected_EQ, "remark", SA);
2313     if (static_cast<unsigned>(VIU & DiagnosticLevelMask::Warning) != 0)
2314       GenerateArg(Args, OPT_verify_ignore_unexpected_EQ, "warning", SA);
2315     if (static_cast<unsigned>(VIU & DiagnosticLevelMask::Error) != 0)
2316       GenerateArg(Args, OPT_verify_ignore_unexpected_EQ, "error", SA);
2317   }
2318 
2319   for (const auto &Warning : Opts.Warnings) {
2320     // This option is automatically generated from UndefPrefixes.
2321     if (Warning == "undef-prefix")
2322       continue;
2323     Args.push_back(SA(StringRef("-W") + Warning));
2324   }
2325 
2326   for (const auto &Remark : Opts.Remarks) {
2327     // These arguments are generated from OptimizationRemark fields of
2328     // CodeGenOptions.
2329     StringRef IgnoredRemarks[] = {"pass",          "no-pass",
2330                                   "pass-analysis", "no-pass-analysis",
2331                                   "pass-missed",   "no-pass-missed"};
2332     if (llvm::is_contained(IgnoredRemarks, Remark))
2333       continue;
2334 
2335     Args.push_back(SA(StringRef("-R") + Remark));
2336   }
2337 }
2338 
2339 std::unique_ptr<DiagnosticOptions>
2340 clang::CreateAndPopulateDiagOpts(ArrayRef<const char *> Argv) {
2341   auto DiagOpts = std::make_unique<DiagnosticOptions>();
2342   unsigned MissingArgIndex, MissingArgCount;
2343   InputArgList Args = getDriverOptTable().ParseArgs(
2344       Argv.slice(1), MissingArgIndex, MissingArgCount);
2345   // We ignore MissingArgCount and the return value of ParseDiagnosticArgs.
2346   // Any errors that would be diagnosed here will also be diagnosed later,
2347   // when the DiagnosticsEngine actually exists.
2348   (void)ParseDiagnosticArgs(*DiagOpts, Args);
2349   return DiagOpts;
2350 }
2351 
2352 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
2353                                 DiagnosticsEngine *Diags,
2354                                 bool DefaultDiagColor) {
2355   Optional<DiagnosticsEngine> IgnoringDiags;
2356   if (!Diags) {
2357     IgnoringDiags.emplace(new DiagnosticIDs(), new DiagnosticOptions(),
2358                           new IgnoringDiagConsumer());
2359     Diags = &*IgnoringDiags;
2360   }
2361 
2362   unsigned NumErrorsBefore = Diags->getNumErrors();
2363 
2364   // The key paths of diagnostic options defined in Options.td start with
2365   // "DiagnosticOpts->". Let's provide the expected variable name and type.
2366   DiagnosticOptions *DiagnosticOpts = &Opts;
2367 
2368 #define DIAG_OPTION_WITH_MARSHALLING(                                          \
2369     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2370     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2371     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2372     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2373   PARSE_OPTION_WITH_MARSHALLING(                                               \
2374       Args, *Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,    \
2375       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2376 #include "clang/Driver/Options.inc"
2377 #undef DIAG_OPTION_WITH_MARSHALLING
2378 
2379   llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2380 
2381   if (Arg *A =
2382           Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2383     Opts.DiagnosticSerializationFile = A->getValue();
2384   Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
2385 
2386   Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2387   Opts.VerifyPrefixes = Args.getAllArgValues(OPT_verify_EQ);
2388   if (Args.hasArg(OPT_verify))
2389     Opts.VerifyPrefixes.push_back("expected");
2390   // Keep VerifyPrefixes in its original order for the sake of diagnostics, and
2391   // then sort it to prepare for fast lookup using std::binary_search.
2392   if (!checkVerifyPrefixes(Opts.VerifyPrefixes, *Diags))
2393     Opts.VerifyDiagnostics = false;
2394   else
2395     llvm::sort(Opts.VerifyPrefixes);
2396   DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None;
2397   parseDiagnosticLevelMask(
2398       "-verify-ignore-unexpected=",
2399       Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2400   if (Args.hasArg(OPT_verify_ignore_unexpected))
2401     DiagMask = DiagnosticLevelMask::All;
2402   Opts.setVerifyIgnoreUnexpected(DiagMask);
2403   if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
2404     Opts.TabStop = DiagnosticOptions::DefaultTabStop;
2405     Diags->Report(diag::warn_ignoring_ftabstop_value)
2406         << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
2407   }
2408 
2409   addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
2410   addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
2411 
2412   return Diags->getNumErrors() == NumErrorsBefore;
2413 }
2414 
2415 /// Parse the argument to the -ftest-module-file-extension
2416 /// command-line argument.
2417 ///
2418 /// \returns true on error, false on success.
2419 static bool parseTestModuleFileExtensionArg(StringRef Arg,
2420                                             std::string &BlockName,
2421                                             unsigned &MajorVersion,
2422                                             unsigned &MinorVersion,
2423                                             bool &Hashed,
2424                                             std::string &UserInfo) {
2425   SmallVector<StringRef, 5> Args;
2426   Arg.split(Args, ':', 5);
2427   if (Args.size() < 5)
2428     return true;
2429 
2430   BlockName = std::string(Args[0]);
2431   if (Args[1].getAsInteger(10, MajorVersion)) return true;
2432   if (Args[2].getAsInteger(10, MinorVersion)) return true;
2433   if (Args[3].getAsInteger(2, Hashed)) return true;
2434   if (Args.size() > 4)
2435     UserInfo = std::string(Args[4]);
2436   return false;
2437 }
2438 
2439 /// Return a table that associates command line option specifiers with the
2440 /// frontend action. Note: The pair {frontend::PluginAction, OPT_plugin} is
2441 /// intentionally missing, as this case is handled separately from other
2442 /// frontend options.
2443 static const auto &getFrontendActionTable() {
2444   static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2445       {frontend::ASTDeclList, OPT_ast_list},
2446 
2447       {frontend::ASTDump, OPT_ast_dump_all_EQ},
2448       {frontend::ASTDump, OPT_ast_dump_all},
2449       {frontend::ASTDump, OPT_ast_dump_EQ},
2450       {frontend::ASTDump, OPT_ast_dump},
2451       {frontend::ASTDump, OPT_ast_dump_lookups},
2452       {frontend::ASTDump, OPT_ast_dump_decl_types},
2453 
2454       {frontend::ASTPrint, OPT_ast_print},
2455       {frontend::ASTView, OPT_ast_view},
2456       {frontend::DumpCompilerOptions, OPT_compiler_options_dump},
2457       {frontend::DumpRawTokens, OPT_dump_raw_tokens},
2458       {frontend::DumpTokens, OPT_dump_tokens},
2459       {frontend::EmitAssembly, OPT_S},
2460       {frontend::EmitBC, OPT_emit_llvm_bc},
2461       {frontend::EmitHTML, OPT_emit_html},
2462       {frontend::EmitLLVM, OPT_emit_llvm},
2463       {frontend::EmitLLVMOnly, OPT_emit_llvm_only},
2464       {frontend::EmitCodeGenOnly, OPT_emit_codegen_only},
2465       {frontend::EmitObj, OPT_emit_obj},
2466       {frontend::ExtractAPI, OPT_extract_api},
2467 
2468       {frontend::FixIt, OPT_fixit_EQ},
2469       {frontend::FixIt, OPT_fixit},
2470 
2471       {frontend::GenerateModule, OPT_emit_module},
2472       {frontend::GenerateModuleInterface, OPT_emit_module_interface},
2473       {frontend::GenerateHeaderModule, OPT_emit_header_module},
2474       {frontend::GenerateHeaderUnit, OPT_emit_header_unit},
2475       {frontend::GeneratePCH, OPT_emit_pch},
2476       {frontend::GenerateInterfaceStubs, OPT_emit_interface_stubs},
2477       {frontend::InitOnly, OPT_init_only},
2478       {frontend::ParseSyntaxOnly, OPT_fsyntax_only},
2479       {frontend::ModuleFileInfo, OPT_module_file_info},
2480       {frontend::VerifyPCH, OPT_verify_pch},
2481       {frontend::PrintPreamble, OPT_print_preamble},
2482       {frontend::PrintPreprocessedInput, OPT_E},
2483       {frontend::TemplightDump, OPT_templight_dump},
2484       {frontend::RewriteMacros, OPT_rewrite_macros},
2485       {frontend::RewriteObjC, OPT_rewrite_objc},
2486       {frontend::RewriteTest, OPT_rewrite_test},
2487       {frontend::RunAnalysis, OPT_analyze},
2488       {frontend::MigrateSource, OPT_migrate},
2489       {frontend::RunPreprocessorOnly, OPT_Eonly},
2490       {frontend::PrintDependencyDirectivesSourceMinimizerOutput,
2491        OPT_print_dependency_directives_minimized_source},
2492   };
2493 
2494   return Table;
2495 }
2496 
2497 /// Maps command line option to frontend action.
2498 static Optional<frontend::ActionKind> getFrontendAction(OptSpecifier &Opt) {
2499   for (const auto &ActionOpt : getFrontendActionTable())
2500     if (ActionOpt.second == Opt.getID())
2501       return ActionOpt.first;
2502 
2503   return None;
2504 }
2505 
2506 /// Maps frontend action to command line option.
2507 static Optional<OptSpecifier>
2508 getProgramActionOpt(frontend::ActionKind ProgramAction) {
2509   for (const auto &ActionOpt : getFrontendActionTable())
2510     if (ActionOpt.first == ProgramAction)
2511       return OptSpecifier(ActionOpt.second);
2512 
2513   return None;
2514 }
2515 
2516 static void GenerateFrontendArgs(const FrontendOptions &Opts,
2517                                  SmallVectorImpl<const char *> &Args,
2518                                  CompilerInvocation::StringAllocator SA,
2519                                  bool IsHeader) {
2520   const FrontendOptions &FrontendOpts = Opts;
2521 #define FRONTEND_OPTION_WITH_MARSHALLING(                                      \
2522     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2523     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2524     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2525     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2526   GENERATE_OPTION_WITH_MARSHALLING(                                            \
2527       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
2528       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2529 #include "clang/Driver/Options.inc"
2530 #undef FRONTEND_OPTION_WITH_MARSHALLING
2531 
2532   Optional<OptSpecifier> ProgramActionOpt =
2533       getProgramActionOpt(Opts.ProgramAction);
2534 
2535   // Generating a simple flag covers most frontend actions.
2536   std::function<void()> GenerateProgramAction = [&]() {
2537     GenerateArg(Args, *ProgramActionOpt, SA);
2538   };
2539 
2540   if (!ProgramActionOpt) {
2541     // PluginAction is the only program action handled separately.
2542     assert(Opts.ProgramAction == frontend::PluginAction &&
2543            "Frontend action without option.");
2544     GenerateProgramAction = [&]() {
2545       GenerateArg(Args, OPT_plugin, Opts.ActionName, SA);
2546     };
2547   }
2548 
2549   // FIXME: Simplify the complex 'AST dump' command line.
2550   if (Opts.ProgramAction == frontend::ASTDump) {
2551     GenerateProgramAction = [&]() {
2552       // ASTDumpLookups, ASTDumpDeclTypes and ASTDumpFilter are generated via
2553       // marshalling infrastructure.
2554 
2555       if (Opts.ASTDumpFormat != ADOF_Default) {
2556         StringRef Format;
2557         switch (Opts.ASTDumpFormat) {
2558         case ADOF_Default:
2559           llvm_unreachable("Default AST dump format.");
2560         case ADOF_JSON:
2561           Format = "json";
2562           break;
2563         }
2564 
2565         if (Opts.ASTDumpAll)
2566           GenerateArg(Args, OPT_ast_dump_all_EQ, Format, SA);
2567         if (Opts.ASTDumpDecls)
2568           GenerateArg(Args, OPT_ast_dump_EQ, Format, SA);
2569       } else {
2570         if (Opts.ASTDumpAll)
2571           GenerateArg(Args, OPT_ast_dump_all, SA);
2572         if (Opts.ASTDumpDecls)
2573           GenerateArg(Args, OPT_ast_dump, SA);
2574       }
2575     };
2576   }
2577 
2578   if (Opts.ProgramAction == frontend::FixIt && !Opts.FixItSuffix.empty()) {
2579     GenerateProgramAction = [&]() {
2580       GenerateArg(Args, OPT_fixit_EQ, Opts.FixItSuffix, SA);
2581     };
2582   }
2583 
2584   GenerateProgramAction();
2585 
2586   for (const auto &PluginArgs : Opts.PluginArgs) {
2587     Option Opt = getDriverOptTable().getOption(OPT_plugin_arg);
2588     const char *Spelling =
2589         SA(Opt.getPrefix() + Opt.getName() + PluginArgs.first);
2590     for (const auto &PluginArg : PluginArgs.second)
2591       denormalizeString(Args, Spelling, SA, Opt.getKind(), 0, PluginArg);
2592   }
2593 
2594   for (const auto &Ext : Opts.ModuleFileExtensions)
2595     if (auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2596       GenerateArg(Args, OPT_ftest_module_file_extension_EQ, TestExt->str(), SA);
2597 
2598   if (!Opts.CodeCompletionAt.FileName.empty())
2599     GenerateArg(Args, OPT_code_completion_at, Opts.CodeCompletionAt.ToString(),
2600                 SA);
2601 
2602   for (const auto &Plugin : Opts.Plugins)
2603     GenerateArg(Args, OPT_load, Plugin, SA);
2604 
2605   // ASTDumpDecls and ASTDumpAll already handled with ProgramAction.
2606 
2607   for (const auto &ModuleFile : Opts.ModuleFiles)
2608     GenerateArg(Args, OPT_fmodule_file, ModuleFile, SA);
2609 
2610   if (Opts.AuxTargetCPU)
2611     GenerateArg(Args, OPT_aux_target_cpu, *Opts.AuxTargetCPU, SA);
2612 
2613   if (Opts.AuxTargetFeatures)
2614     for (const auto &Feature : *Opts.AuxTargetFeatures)
2615       GenerateArg(Args, OPT_aux_target_feature, Feature, SA);
2616 
2617   {
2618     StringRef Preprocessed = Opts.DashX.isPreprocessed() ? "-cpp-output" : "";
2619     StringRef ModuleMap =
2620         Opts.DashX.getFormat() == InputKind::ModuleMap ? "-module-map" : "";
2621     StringRef HeaderUnit = "";
2622     switch (Opts.DashX.getHeaderUnitKind()) {
2623     case InputKind::HeaderUnit_None:
2624       break;
2625     case InputKind::HeaderUnit_User:
2626       HeaderUnit = "-user";
2627       break;
2628     case InputKind::HeaderUnit_System:
2629       HeaderUnit = "-system";
2630       break;
2631     case InputKind::HeaderUnit_Abs:
2632       HeaderUnit = "-header-unit";
2633       break;
2634     }
2635     StringRef Header = IsHeader ? "-header" : "";
2636 
2637     StringRef Lang;
2638     switch (Opts.DashX.getLanguage()) {
2639     case Language::C:
2640       Lang = "c";
2641       break;
2642     case Language::OpenCL:
2643       Lang = "cl";
2644       break;
2645     case Language::OpenCLCXX:
2646       Lang = "clcpp";
2647       break;
2648     case Language::CUDA:
2649       Lang = "cuda";
2650       break;
2651     case Language::HIP:
2652       Lang = "hip";
2653       break;
2654     case Language::CXX:
2655       Lang = "c++";
2656       break;
2657     case Language::ObjC:
2658       Lang = "objective-c";
2659       break;
2660     case Language::ObjCXX:
2661       Lang = "objective-c++";
2662       break;
2663     case Language::RenderScript:
2664       Lang = "renderscript";
2665       break;
2666     case Language::Asm:
2667       Lang = "assembler-with-cpp";
2668       break;
2669     case Language::Unknown:
2670       assert(Opts.DashX.getFormat() == InputKind::Precompiled &&
2671              "Generating -x argument for unknown language (not precompiled).");
2672       Lang = "ast";
2673       break;
2674     case Language::LLVM_IR:
2675       Lang = "ir";
2676       break;
2677     case Language::HLSL:
2678       Lang = "hlsl";
2679       break;
2680     }
2681 
2682     GenerateArg(Args, OPT_x,
2683                 Lang + HeaderUnit + Header + ModuleMap + Preprocessed, SA);
2684   }
2685 
2686   // OPT_INPUT has a unique class, generate it directly.
2687   for (const auto &Input : Opts.Inputs)
2688     Args.push_back(SA(Input.getFile()));
2689 }
2690 
2691 static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
2692                               DiagnosticsEngine &Diags, bool &IsHeaderFile) {
2693   unsigned NumErrorsBefore = Diags.getNumErrors();
2694 
2695   FrontendOptions &FrontendOpts = Opts;
2696 
2697 #define FRONTEND_OPTION_WITH_MARSHALLING(                                      \
2698     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2699     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2700     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2701     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2702   PARSE_OPTION_WITH_MARSHALLING(                                               \
2703       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
2704       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
2705 #include "clang/Driver/Options.inc"
2706 #undef FRONTEND_OPTION_WITH_MARSHALLING
2707 
2708   Opts.ProgramAction = frontend::ParseSyntaxOnly;
2709   if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2710     OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2711     Optional<frontend::ActionKind> ProgramAction = getFrontendAction(Opt);
2712     assert(ProgramAction && "Option specifier not in Action_Group.");
2713 
2714     if (ProgramAction == frontend::ASTDump &&
2715         (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2716       unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2717                          .CaseLower("default", ADOF_Default)
2718                          .CaseLower("json", ADOF_JSON)
2719                          .Default(std::numeric_limits<unsigned>::max());
2720 
2721       if (Val != std::numeric_limits<unsigned>::max())
2722         Opts.ASTDumpFormat = static_cast<ASTDumpOutputFormat>(Val);
2723       else {
2724         Diags.Report(diag::err_drv_invalid_value)
2725             << A->getAsString(Args) << A->getValue();
2726         Opts.ASTDumpFormat = ADOF_Default;
2727       }
2728     }
2729 
2730     if (ProgramAction == frontend::FixIt && Opt == OPT_fixit_EQ)
2731       Opts.FixItSuffix = A->getValue();
2732 
2733     if (ProgramAction == frontend::GenerateInterfaceStubs) {
2734       StringRef ArgStr =
2735           Args.hasArg(OPT_interface_stub_version_EQ)
2736               ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2737               : "ifs-v1";
2738       if (ArgStr == "experimental-yaml-elf-v1" ||
2739           ArgStr == "experimental-ifs-v1" || ArgStr == "experimental-ifs-v2" ||
2740           ArgStr == "experimental-tapi-elf-v1") {
2741         std::string ErrorMessage =
2742             "Invalid interface stub format: " + ArgStr.str() +
2743             " is deprecated.";
2744         Diags.Report(diag::err_drv_invalid_value)
2745             << "Must specify a valid interface stub format type, ie: "
2746                "-interface-stub-version=ifs-v1"
2747             << ErrorMessage;
2748         ProgramAction = frontend::ParseSyntaxOnly;
2749       } else if (!ArgStr.startswith("ifs-")) {
2750         std::string ErrorMessage =
2751             "Invalid interface stub format: " + ArgStr.str() + ".";
2752         Diags.Report(diag::err_drv_invalid_value)
2753             << "Must specify a valid interface stub format type, ie: "
2754                "-interface-stub-version=ifs-v1"
2755             << ErrorMessage;
2756         ProgramAction = frontend::ParseSyntaxOnly;
2757       }
2758     }
2759 
2760     Opts.ProgramAction = *ProgramAction;
2761   }
2762 
2763   if (const Arg* A = Args.getLastArg(OPT_plugin)) {
2764     Opts.Plugins.emplace_back(A->getValue(0));
2765     Opts.ProgramAction = frontend::PluginAction;
2766     Opts.ActionName = A->getValue();
2767   }
2768   for (const auto *AA : Args.filtered(OPT_plugin_arg))
2769     Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2770 
2771   for (const std::string &Arg :
2772          Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2773     std::string BlockName;
2774     unsigned MajorVersion;
2775     unsigned MinorVersion;
2776     bool Hashed;
2777     std::string UserInfo;
2778     if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion,
2779                                         MinorVersion, Hashed, UserInfo)) {
2780       Diags.Report(diag::err_test_module_file_extension_format) << Arg;
2781 
2782       continue;
2783     }
2784 
2785     // Add the testing module file extension.
2786     Opts.ModuleFileExtensions.push_back(
2787         std::make_shared<TestModuleFileExtension>(
2788             BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2789   }
2790 
2791   if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2792     Opts.CodeCompletionAt =
2793       ParsedSourceLocation::FromString(A->getValue());
2794     if (Opts.CodeCompletionAt.FileName.empty())
2795       Diags.Report(diag::err_drv_invalid_value)
2796         << A->getAsString(Args) << A->getValue();
2797   }
2798 
2799   Opts.Plugins = Args.getAllArgValues(OPT_load);
2800   Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2801   Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2802   // Only the -fmodule-file=<file> form.
2803   for (const auto *A : Args.filtered(OPT_fmodule_file)) {
2804     StringRef Val = A->getValue();
2805     if (!Val.contains('='))
2806       Opts.ModuleFiles.push_back(std::string(Val));
2807   }
2808 
2809   if (Opts.ProgramAction != frontend::GenerateModule && Opts.IsSystemModule)
2810     Diags.Report(diag::err_drv_argument_only_allowed_with) << "-fsystem-module"
2811                                                            << "-emit-module";
2812 
2813   if (Args.hasArg(OPT_aux_target_cpu))
2814     Opts.AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
2815   if (Args.hasArg(OPT_aux_target_feature))
2816     Opts.AuxTargetFeatures = Args.getAllArgValues(OPT_aux_target_feature);
2817 
2818   if (Opts.ARCMTAction != FrontendOptions::ARCMT_None &&
2819       Opts.ObjCMTAction != FrontendOptions::ObjCMT_None) {
2820     Diags.Report(diag::err_drv_argument_not_allowed_with)
2821       << "ARC migration" << "ObjC migration";
2822   }
2823 
2824   InputKind DashX(Language::Unknown);
2825   if (const Arg *A = Args.getLastArg(OPT_x)) {
2826     StringRef XValue = A->getValue();
2827 
2828     // Parse suffixes:
2829     // '<lang>(-[{header-unit,user,system}-]header|[-module-map][-cpp-output])'.
2830     // FIXME: Supporting '<lang>-header-cpp-output' would be useful.
2831     bool Preprocessed = XValue.consume_back("-cpp-output");
2832     bool ModuleMap = XValue.consume_back("-module-map");
2833     // Detect and consume the header indicator.
2834     bool IsHeader =
2835         XValue != "precompiled-header" && XValue.consume_back("-header");
2836 
2837     // If we have c++-{user,system}-header, that indicates a header unit input
2838     // likewise, if the user put -fmodule-header together with a header with an
2839     // absolute path (header-unit-header).
2840     InputKind::HeaderUnitKind HUK = InputKind::HeaderUnit_None;
2841     if (IsHeader || Preprocessed) {
2842       if (XValue.consume_back("-header-unit"))
2843         HUK = InputKind::HeaderUnit_Abs;
2844       else if (XValue.consume_back("-system"))
2845         HUK = InputKind::HeaderUnit_System;
2846       else if (XValue.consume_back("-user"))
2847         HUK = InputKind::HeaderUnit_User;
2848     }
2849 
2850     // The value set by this processing is an un-preprocessed source which is
2851     // not intended to be a module map or header unit.
2852     IsHeaderFile = IsHeader && !Preprocessed && !ModuleMap &&
2853                    HUK == InputKind::HeaderUnit_None;
2854 
2855     // Principal languages.
2856     DashX = llvm::StringSwitch<InputKind>(XValue)
2857                 .Case("c", Language::C)
2858                 .Case("cl", Language::OpenCL)
2859                 .Case("clcpp", Language::OpenCLCXX)
2860                 .Case("cuda", Language::CUDA)
2861                 .Case("hip", Language::HIP)
2862                 .Case("c++", Language::CXX)
2863                 .Case("objective-c", Language::ObjC)
2864                 .Case("objective-c++", Language::ObjCXX)
2865                 .Case("renderscript", Language::RenderScript)
2866                 .Case("hlsl", Language::HLSL)
2867                 .Default(Language::Unknown);
2868 
2869     // "objc[++]-cpp-output" is an acceptable synonym for
2870     // "objective-c[++]-cpp-output".
2871     if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap &&
2872         HUK == InputKind::HeaderUnit_None)
2873       DashX = llvm::StringSwitch<InputKind>(XValue)
2874                   .Case("objc", Language::ObjC)
2875                   .Case("objc++", Language::ObjCXX)
2876                   .Default(Language::Unknown);
2877 
2878     // Some special cases cannot be combined with suffixes.
2879     if (DashX.isUnknown() && !Preprocessed && !IsHeaderFile && !ModuleMap &&
2880         HUK == InputKind::HeaderUnit_None)
2881       DashX = llvm::StringSwitch<InputKind>(XValue)
2882                   .Case("cpp-output", InputKind(Language::C).getPreprocessed())
2883                   .Case("assembler-with-cpp", Language::Asm)
2884                   .Cases("ast", "pcm", "precompiled-header",
2885                          InputKind(Language::Unknown, InputKind::Precompiled))
2886                   .Case("ir", Language::LLVM_IR)
2887                   .Default(Language::Unknown);
2888 
2889     if (DashX.isUnknown())
2890       Diags.Report(diag::err_drv_invalid_value)
2891         << A->getAsString(Args) << A->getValue();
2892 
2893     if (Preprocessed)
2894       DashX = DashX.getPreprocessed();
2895     // A regular header is considered mutually exclusive with a header unit.
2896     if (HUK != InputKind::HeaderUnit_None) {
2897       DashX = DashX.withHeaderUnit(HUK);
2898       IsHeaderFile = true;
2899     } else if (IsHeaderFile)
2900       DashX = DashX.getHeader();
2901     if (ModuleMap)
2902       DashX = DashX.withFormat(InputKind::ModuleMap);
2903   }
2904 
2905   // '-' is the default input if none is given.
2906   std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
2907   Opts.Inputs.clear();
2908   if (Inputs.empty())
2909     Inputs.push_back("-");
2910 
2911   if (DashX.getHeaderUnitKind() != InputKind::HeaderUnit_None &&
2912       Inputs.size() > 1)
2913     Diags.Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
2914 
2915   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
2916     InputKind IK = DashX;
2917     if (IK.isUnknown()) {
2918       IK = FrontendOptions::getInputKindForExtension(
2919         StringRef(Inputs[i]).rsplit('.').second);
2920       // FIXME: Warn on this?
2921       if (IK.isUnknown())
2922         IK = Language::C;
2923       // FIXME: Remove this hack.
2924       if (i == 0)
2925         DashX = IK;
2926     }
2927 
2928     bool IsSystem = false;
2929 
2930     // The -emit-module action implicitly takes a module map.
2931     if (Opts.ProgramAction == frontend::GenerateModule &&
2932         IK.getFormat() == InputKind::Source) {
2933       IK = IK.withFormat(InputKind::ModuleMap);
2934       IsSystem = Opts.IsSystemModule;
2935     }
2936 
2937     Opts.Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
2938   }
2939 
2940   Opts.DashX = DashX;
2941 
2942   return Diags.getNumErrors() == NumErrorsBefore;
2943 }
2944 
2945 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
2946                                                  void *MainAddr) {
2947   std::string ClangExecutable =
2948       llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
2949   return Driver::GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
2950 }
2951 
2952 static void GenerateHeaderSearchArgs(HeaderSearchOptions &Opts,
2953                                      SmallVectorImpl<const char *> &Args,
2954                                      CompilerInvocation::StringAllocator SA) {
2955   const HeaderSearchOptions *HeaderSearchOpts = &Opts;
2956 #define HEADER_SEARCH_OPTION_WITH_MARSHALLING(                                 \
2957     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
2958     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
2959     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
2960     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
2961   GENERATE_OPTION_WITH_MARSHALLING(                                            \
2962       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
2963       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
2964 #include "clang/Driver/Options.inc"
2965 #undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
2966 
2967   if (Opts.UseLibcxx)
2968     GenerateArg(Args, OPT_stdlib_EQ, "libc++", SA);
2969 
2970   if (!Opts.ModuleCachePath.empty())
2971     GenerateArg(Args, OPT_fmodules_cache_path, Opts.ModuleCachePath, SA);
2972 
2973   for (const auto &File : Opts.PrebuiltModuleFiles)
2974     GenerateArg(Args, OPT_fmodule_file, File.first + "=" + File.second, SA);
2975 
2976   for (const auto &Path : Opts.PrebuiltModulePaths)
2977     GenerateArg(Args, OPT_fprebuilt_module_path, Path, SA);
2978 
2979   for (const auto &Macro : Opts.ModulesIgnoreMacros)
2980     GenerateArg(Args, OPT_fmodules_ignore_macro, Macro.val(), SA);
2981 
2982   auto Matches = [](const HeaderSearchOptions::Entry &Entry,
2983                     llvm::ArrayRef<frontend::IncludeDirGroup> Groups,
2984                     llvm::Optional<bool> IsFramework,
2985                     llvm::Optional<bool> IgnoreSysRoot) {
2986     return llvm::is_contained(Groups, Entry.Group) &&
2987            (!IsFramework || (Entry.IsFramework == *IsFramework)) &&
2988            (!IgnoreSysRoot || (Entry.IgnoreSysRoot == *IgnoreSysRoot));
2989   };
2990 
2991   auto It = Opts.UserEntries.begin();
2992   auto End = Opts.UserEntries.end();
2993 
2994   // Add -I..., -F..., and -index-header-map options in order.
2995   for (; It < End &&
2996          Matches(*It, {frontend::IndexHeaderMap, frontend::Angled}, None, true);
2997        ++It) {
2998     OptSpecifier Opt = [It, Matches]() {
2999       if (Matches(*It, frontend::IndexHeaderMap, true, true))
3000         return OPT_F;
3001       if (Matches(*It, frontend::IndexHeaderMap, false, true))
3002         return OPT_I;
3003       if (Matches(*It, frontend::Angled, true, true))
3004         return OPT_F;
3005       if (Matches(*It, frontend::Angled, false, true))
3006         return OPT_I;
3007       llvm_unreachable("Unexpected HeaderSearchOptions::Entry.");
3008     }();
3009 
3010     if (It->Group == frontend::IndexHeaderMap)
3011       GenerateArg(Args, OPT_index_header_map, SA);
3012     GenerateArg(Args, Opt, It->Path, SA);
3013   };
3014 
3015   // Note: some paths that came from "[-iprefix=xx] -iwithprefixbefore=yy" may
3016   // have already been generated as "-I[xx]yy". If that's the case, their
3017   // position on command line was such that this has no semantic impact on
3018   // include paths.
3019   for (; It < End &&
3020          Matches(*It, {frontend::After, frontend::Angled}, false, true);
3021        ++It) {
3022     OptSpecifier Opt =
3023         It->Group == frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3024     GenerateArg(Args, Opt, It->Path, SA);
3025   }
3026 
3027   // Note: Some paths that came from "-idirafter=xxyy" may have already been
3028   // generated as "-iwithprefix=xxyy". If that's the case, their position on
3029   // command line was such that this has no semantic impact on include paths.
3030   for (; It < End && Matches(*It, {frontend::After}, false, true); ++It)
3031     GenerateArg(Args, OPT_idirafter, It->Path, SA);
3032   for (; It < End && Matches(*It, {frontend::Quoted}, false, true); ++It)
3033     GenerateArg(Args, OPT_iquote, It->Path, SA);
3034   for (; It < End && Matches(*It, {frontend::System}, false, None); ++It)
3035     GenerateArg(Args, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3036                 It->Path, SA);
3037   for (; It < End && Matches(*It, {frontend::System}, true, true); ++It)
3038     GenerateArg(Args, OPT_iframework, It->Path, SA);
3039   for (; It < End && Matches(*It, {frontend::System}, true, false); ++It)
3040     GenerateArg(Args, OPT_iframeworkwithsysroot, It->Path, SA);
3041 
3042   // Add the paths for the various language specific isystem flags.
3043   for (; It < End && Matches(*It, {frontend::CSystem}, false, true); ++It)
3044     GenerateArg(Args, OPT_c_isystem, It->Path, SA);
3045   for (; It < End && Matches(*It, {frontend::CXXSystem}, false, true); ++It)
3046     GenerateArg(Args, OPT_cxx_isystem, It->Path, SA);
3047   for (; It < End && Matches(*It, {frontend::ObjCSystem}, false, true); ++It)
3048     GenerateArg(Args, OPT_objc_isystem, It->Path, SA);
3049   for (; It < End && Matches(*It, {frontend::ObjCXXSystem}, false, true); ++It)
3050     GenerateArg(Args, OPT_objcxx_isystem, It->Path, SA);
3051 
3052   // Add the internal paths from a driver that detects standard include paths.
3053   // Note: Some paths that came from "-internal-isystem" arguments may have
3054   // already been generated as "-isystem". If that's the case, their position on
3055   // command line was such that this has no semantic impact on include paths.
3056   for (; It < End &&
3057          Matches(*It, {frontend::System, frontend::ExternCSystem}, false, true);
3058        ++It) {
3059     OptSpecifier Opt = It->Group == frontend::System
3060                            ? OPT_internal_isystem
3061                            : OPT_internal_externc_isystem;
3062     GenerateArg(Args, Opt, It->Path, SA);
3063   }
3064 
3065   assert(It == End && "Unhandled HeaderSearchOption::Entry.");
3066 
3067   // Add the path prefixes which are implicitly treated as being system headers.
3068   for (const auto &P : Opts.SystemHeaderPrefixes) {
3069     OptSpecifier Opt = P.IsSystemHeader ? OPT_system_header_prefix
3070                                         : OPT_no_system_header_prefix;
3071     GenerateArg(Args, Opt, P.Prefix, SA);
3072   }
3073 
3074   for (const std::string &F : Opts.VFSOverlayFiles)
3075     GenerateArg(Args, OPT_ivfsoverlay, F, SA);
3076 }
3077 
3078 static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
3079                                   DiagnosticsEngine &Diags,
3080                                   const std::string &WorkingDir) {
3081   unsigned NumErrorsBefore = Diags.getNumErrors();
3082 
3083   HeaderSearchOptions *HeaderSearchOpts = &Opts;
3084 
3085 #define HEADER_SEARCH_OPTION_WITH_MARSHALLING(                                 \
3086     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
3087     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
3088     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
3089     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
3090   PARSE_OPTION_WITH_MARSHALLING(                                               \
3091       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
3092       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
3093 #include "clang/Driver/Options.inc"
3094 #undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3095 
3096   if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3097     Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
3098 
3099   // Canonicalize -fmodules-cache-path before storing it.
3100   SmallString<128> P(Args.getLastArgValue(OPT_fmodules_cache_path));
3101   if (!(P.empty() || llvm::sys::path::is_absolute(P))) {
3102     if (WorkingDir.empty())
3103       llvm::sys::fs::make_absolute(P);
3104     else
3105       llvm::sys::fs::make_absolute(WorkingDir, P);
3106   }
3107   llvm::sys::path::remove_dots(P);
3108   Opts.ModuleCachePath = std::string(P.str());
3109 
3110   // Only the -fmodule-file=<name>=<file> form.
3111   for (const auto *A : Args.filtered(OPT_fmodule_file)) {
3112     StringRef Val = A->getValue();
3113     if (Val.contains('=')) {
3114       auto Split = Val.split('=');
3115       Opts.PrebuiltModuleFiles.insert(
3116           {std::string(Split.first), std::string(Split.second)});
3117     }
3118   }
3119   for (const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3120     Opts.AddPrebuiltModulePath(A->getValue());
3121 
3122   for (const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3123     StringRef MacroDef = A->getValue();
3124     Opts.ModulesIgnoreMacros.insert(
3125         llvm::CachedHashString(MacroDef.split('=').first));
3126   }
3127 
3128   // Add -I..., -F..., and -index-header-map options in order.
3129   bool IsIndexHeaderMap = false;
3130   bool IsSysrootSpecified =
3131       Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3132   for (const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3133     if (A->getOption().matches(OPT_index_header_map)) {
3134       // -index-header-map applies to the next -I or -F.
3135       IsIndexHeaderMap = true;
3136       continue;
3137     }
3138 
3139     frontend::IncludeDirGroup Group =
3140         IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled;
3141 
3142     bool IsFramework = A->getOption().matches(OPT_F);
3143     std::string Path = A->getValue();
3144 
3145     if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {
3146       SmallString<32> Buffer;
3147       llvm::sys::path::append(Buffer, Opts.Sysroot,
3148                               llvm::StringRef(A->getValue()).substr(1));
3149       Path = std::string(Buffer.str());
3150     }
3151 
3152     Opts.AddPath(Path, Group, IsFramework,
3153                  /*IgnoreSysroot*/ true);
3154     IsIndexHeaderMap = false;
3155   }
3156 
3157   // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
3158   StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
3159   for (const auto *A :
3160        Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3161     if (A->getOption().matches(OPT_iprefix))
3162       Prefix = A->getValue();
3163     else if (A->getOption().matches(OPT_iwithprefix))
3164       Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
3165     else
3166       Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
3167   }
3168 
3169   for (const auto *A : Args.filtered(OPT_idirafter))
3170     Opts.AddPath(A->getValue(), frontend::After, false, true);
3171   for (const auto *A : Args.filtered(OPT_iquote))
3172     Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
3173   for (const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
3174     Opts.AddPath(A->getValue(), frontend::System, false,
3175                  !A->getOption().matches(OPT_iwithsysroot));
3176   for (const auto *A : Args.filtered(OPT_iframework))
3177     Opts.AddPath(A->getValue(), frontend::System, true, true);
3178   for (const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3179     Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,
3180                  /*IgnoreSysRoot=*/false);
3181 
3182   // Add the paths for the various language specific isystem flags.
3183   for (const auto *A : Args.filtered(OPT_c_isystem))
3184     Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
3185   for (const auto *A : Args.filtered(OPT_cxx_isystem))
3186     Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
3187   for (const auto *A : Args.filtered(OPT_objc_isystem))
3188     Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
3189   for (const auto *A : Args.filtered(OPT_objcxx_isystem))
3190     Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
3191 
3192   // Add the internal paths from a driver that detects standard include paths.
3193   for (const auto *A :
3194        Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3195     frontend::IncludeDirGroup Group = frontend::System;
3196     if (A->getOption().matches(OPT_internal_externc_isystem))
3197       Group = frontend::ExternCSystem;
3198     Opts.AddPath(A->getValue(), Group, false, true);
3199   }
3200 
3201   // Add the path prefixes which are implicitly treated as being system headers.
3202   for (const auto *A :
3203        Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3204     Opts.AddSystemHeaderPrefix(
3205         A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3206 
3207   for (const auto *A : Args.filtered(OPT_ivfsoverlay))
3208     Opts.AddVFSOverlayFile(A->getValue());
3209 
3210   return Diags.getNumErrors() == NumErrorsBefore;
3211 }
3212 
3213 /// Check if input file kind and language standard are compatible.
3214 static bool IsInputCompatibleWithStandard(InputKind IK,
3215                                           const LangStandard &S) {
3216   switch (IK.getLanguage()) {
3217   case Language::Unknown:
3218   case Language::LLVM_IR:
3219     llvm_unreachable("should not parse language flags for this input");
3220 
3221   case Language::C:
3222   case Language::ObjC:
3223   case Language::RenderScript:
3224     return S.getLanguage() == Language::C;
3225 
3226   case Language::OpenCL:
3227     return S.getLanguage() == Language::OpenCL ||
3228            S.getLanguage() == Language::OpenCLCXX;
3229 
3230   case Language::OpenCLCXX:
3231     return S.getLanguage() == Language::OpenCLCXX;
3232 
3233   case Language::CXX:
3234   case Language::ObjCXX:
3235     return S.getLanguage() == Language::CXX;
3236 
3237   case Language::CUDA:
3238     // FIXME: What -std= values should be permitted for CUDA compilations?
3239     return S.getLanguage() == Language::CUDA ||
3240            S.getLanguage() == Language::CXX;
3241 
3242   case Language::HIP:
3243     return S.getLanguage() == Language::CXX || S.getLanguage() == Language::HIP;
3244 
3245   case Language::Asm:
3246     // Accept (and ignore) all -std= values.
3247     // FIXME: The -std= value is not ignored; it affects the tokenization
3248     // and preprocessing rules if we're preprocessing this asm input.
3249     return true;
3250 
3251   case Language::HLSL:
3252     return S.getLanguage() == Language::HLSL;
3253   }
3254 
3255   llvm_unreachable("unexpected input language");
3256 }
3257 
3258 /// Get language name for given input kind.
3259 static StringRef GetInputKindName(InputKind IK) {
3260   switch (IK.getLanguage()) {
3261   case Language::C:
3262     return "C";
3263   case Language::ObjC:
3264     return "Objective-C";
3265   case Language::CXX:
3266     return "C++";
3267   case Language::ObjCXX:
3268     return "Objective-C++";
3269   case Language::OpenCL:
3270     return "OpenCL";
3271   case Language::OpenCLCXX:
3272     return "C++ for OpenCL";
3273   case Language::CUDA:
3274     return "CUDA";
3275   case Language::RenderScript:
3276     return "RenderScript";
3277   case Language::HIP:
3278     return "HIP";
3279 
3280   case Language::Asm:
3281     return "Asm";
3282   case Language::LLVM_IR:
3283     return "LLVM IR";
3284 
3285   case Language::HLSL:
3286     return "HLSL";
3287 
3288   case Language::Unknown:
3289     break;
3290   }
3291   llvm_unreachable("unknown input language");
3292 }
3293 
3294 void CompilerInvocation::GenerateLangArgs(const LangOptions &Opts,
3295                                           SmallVectorImpl<const char *> &Args,
3296                                           StringAllocator SA,
3297                                           const llvm::Triple &T, InputKind IK) {
3298   if (IK.getFormat() == InputKind::Precompiled ||
3299       IK.getLanguage() == Language::LLVM_IR) {
3300     if (Opts.ObjCAutoRefCount)
3301       GenerateArg(Args, OPT_fobjc_arc, SA);
3302     if (Opts.PICLevel != 0)
3303       GenerateArg(Args, OPT_pic_level, Twine(Opts.PICLevel), SA);
3304     if (Opts.PIE)
3305       GenerateArg(Args, OPT_pic_is_pie, SA);
3306     for (StringRef Sanitizer : serializeSanitizerKinds(Opts.Sanitize))
3307       GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
3308 
3309     return;
3310   }
3311 
3312   OptSpecifier StdOpt;
3313   switch (Opts.LangStd) {
3314   case LangStandard::lang_opencl10:
3315   case LangStandard::lang_opencl11:
3316   case LangStandard::lang_opencl12:
3317   case LangStandard::lang_opencl20:
3318   case LangStandard::lang_opencl30:
3319   case LangStandard::lang_openclcpp10:
3320   case LangStandard::lang_openclcpp2021:
3321     StdOpt = OPT_cl_std_EQ;
3322     break;
3323   default:
3324     StdOpt = OPT_std_EQ;
3325     break;
3326   }
3327 
3328   auto LangStandard = LangStandard::getLangStandardForKind(Opts.LangStd);
3329   GenerateArg(Args, StdOpt, LangStandard.getName(), SA);
3330 
3331   if (Opts.IncludeDefaultHeader)
3332     GenerateArg(Args, OPT_finclude_default_header, SA);
3333   if (Opts.DeclareOpenCLBuiltins)
3334     GenerateArg(Args, OPT_fdeclare_opencl_builtins, SA);
3335 
3336   const LangOptions *LangOpts = &Opts;
3337 
3338 #define LANG_OPTION_WITH_MARSHALLING(                                          \
3339     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
3340     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
3341     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
3342     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
3343   GENERATE_OPTION_WITH_MARSHALLING(                                            \
3344       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
3345       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
3346 #include "clang/Driver/Options.inc"
3347 #undef LANG_OPTION_WITH_MARSHALLING
3348 
3349   // The '-fcf-protection=' option is generated by CodeGenOpts generator.
3350 
3351   if (Opts.ObjC) {
3352     GenerateArg(Args, OPT_fobjc_runtime_EQ, Opts.ObjCRuntime.getAsString(), SA);
3353 
3354     if (Opts.GC == LangOptions::GCOnly)
3355       GenerateArg(Args, OPT_fobjc_gc_only, SA);
3356     else if (Opts.GC == LangOptions::HybridGC)
3357       GenerateArg(Args, OPT_fobjc_gc, SA);
3358     else if (Opts.ObjCAutoRefCount == 1)
3359       GenerateArg(Args, OPT_fobjc_arc, SA);
3360 
3361     if (Opts.ObjCWeakRuntime)
3362       GenerateArg(Args, OPT_fobjc_runtime_has_weak, SA);
3363 
3364     if (Opts.ObjCWeak)
3365       GenerateArg(Args, OPT_fobjc_weak, SA);
3366 
3367     if (Opts.ObjCSubscriptingLegacyRuntime)
3368       GenerateArg(Args, OPT_fobjc_subscripting_legacy_runtime, SA);
3369   }
3370 
3371   if (Opts.GNUCVersion != 0) {
3372     unsigned Major = Opts.GNUCVersion / 100 / 100;
3373     unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3374     unsigned Patch = Opts.GNUCVersion % 100;
3375     GenerateArg(Args, OPT_fgnuc_version_EQ,
3376                 Twine(Major) + "." + Twine(Minor) + "." + Twine(Patch), SA);
3377   }
3378 
3379   if (Opts.IgnoreXCOFFVisibility)
3380     GenerateArg(Args, OPT_mignore_xcoff_visibility, SA);
3381 
3382   if (Opts.SignedOverflowBehavior == LangOptions::SOB_Trapping) {
3383     GenerateArg(Args, OPT_ftrapv, SA);
3384     GenerateArg(Args, OPT_ftrapv_handler, Opts.OverflowHandler, SA);
3385   } else if (Opts.SignedOverflowBehavior == LangOptions::SOB_Defined) {
3386     GenerateArg(Args, OPT_fwrapv, SA);
3387   }
3388 
3389   if (Opts.MSCompatibilityVersion != 0) {
3390     unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3391     unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3392     unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3393     GenerateArg(Args, OPT_fms_compatibility_version,
3394                 Twine(Major) + "." + Twine(Minor) + "." + Twine(Subminor), SA);
3395   }
3396 
3397   if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS()) {
3398     if (!Opts.Trigraphs)
3399       GenerateArg(Args, OPT_fno_trigraphs, SA);
3400   } else {
3401     if (Opts.Trigraphs)
3402       GenerateArg(Args, OPT_ftrigraphs, SA);
3403   }
3404 
3405   if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3406     GenerateArg(Args, OPT_fblocks, SA);
3407 
3408   if (Opts.ConvergentFunctions &&
3409       !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice))
3410     GenerateArg(Args, OPT_fconvergent_functions, SA);
3411 
3412   if (Opts.NoBuiltin && !Opts.Freestanding)
3413     GenerateArg(Args, OPT_fno_builtin, SA);
3414 
3415   if (!Opts.NoBuiltin)
3416     for (const auto &Func : Opts.NoBuiltinFuncs)
3417       GenerateArg(Args, OPT_fno_builtin_, Func, SA);
3418 
3419   if (Opts.LongDoubleSize == 128)
3420     GenerateArg(Args, OPT_mlong_double_128, SA);
3421   else if (Opts.LongDoubleSize == 64)
3422     GenerateArg(Args, OPT_mlong_double_64, SA);
3423   else if (Opts.LongDoubleSize == 80)
3424     GenerateArg(Args, OPT_mlong_double_80, SA);
3425 
3426   // Not generating '-mrtd', it's just an alias for '-fdefault-calling-conv='.
3427 
3428   // OpenMP was requested via '-fopenmp', not implied by '-fopenmp-simd' or
3429   // '-fopenmp-targets='.
3430   if (Opts.OpenMP && !Opts.OpenMPSimd) {
3431     GenerateArg(Args, OPT_fopenmp, SA);
3432 
3433     if (Opts.OpenMP != 50)
3434       GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3435 
3436     if (!Opts.OpenMPUseTLS)
3437       GenerateArg(Args, OPT_fnoopenmp_use_tls, SA);
3438 
3439     if (Opts.OpenMPIsDevice)
3440       GenerateArg(Args, OPT_fopenmp_is_device, SA);
3441 
3442     if (Opts.OpenMPIRBuilder)
3443       GenerateArg(Args, OPT_fopenmp_enable_irbuilder, SA);
3444   }
3445 
3446   if (Opts.OpenMPSimd) {
3447     GenerateArg(Args, OPT_fopenmp_simd, SA);
3448 
3449     if (Opts.OpenMP != 50)
3450       GenerateArg(Args, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP), SA);
3451   }
3452 
3453   if (Opts.OpenMPThreadSubscription)
3454     GenerateArg(Args, OPT_fopenmp_assume_threads_oversubscription, SA);
3455 
3456   if (Opts.OpenMPTeamSubscription)
3457     GenerateArg(Args, OPT_fopenmp_assume_teams_oversubscription, SA);
3458 
3459   if (Opts.OpenMPTargetDebug != 0)
3460     GenerateArg(Args, OPT_fopenmp_target_debug_EQ,
3461                 Twine(Opts.OpenMPTargetDebug), SA);
3462 
3463   if (Opts.OpenMPCUDANumSMs != 0)
3464     GenerateArg(Args, OPT_fopenmp_cuda_number_of_sm_EQ,
3465                 Twine(Opts.OpenMPCUDANumSMs), SA);
3466 
3467   if (Opts.OpenMPCUDABlocksPerSM != 0)
3468     GenerateArg(Args, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3469                 Twine(Opts.OpenMPCUDABlocksPerSM), SA);
3470 
3471   if (Opts.OpenMPCUDAReductionBufNum != 1024)
3472     GenerateArg(Args, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3473                 Twine(Opts.OpenMPCUDAReductionBufNum), SA);
3474 
3475   if (!Opts.OMPTargetTriples.empty()) {
3476     std::string Targets;
3477     llvm::raw_string_ostream OS(Targets);
3478     llvm::interleave(
3479         Opts.OMPTargetTriples, OS,
3480         [&OS](const llvm::Triple &T) { OS << T.str(); }, ",");
3481     GenerateArg(Args, OPT_fopenmp_targets_EQ, OS.str(), SA);
3482   }
3483 
3484   if (!Opts.OMPHostIRFile.empty())
3485     GenerateArg(Args, OPT_fopenmp_host_ir_file_path, Opts.OMPHostIRFile, SA);
3486 
3487   if (Opts.OpenMPCUDAMode)
3488     GenerateArg(Args, OPT_fopenmp_cuda_mode, SA);
3489 
3490   // The arguments used to set Optimize, OptimizeSize and NoInlineDefine are
3491   // generated from CodeGenOptions.
3492 
3493   if (Opts.DefaultFPContractMode == LangOptions::FPM_Fast)
3494     GenerateArg(Args, OPT_ffp_contract, "fast", SA);
3495   else if (Opts.DefaultFPContractMode == LangOptions::FPM_On)
3496     GenerateArg(Args, OPT_ffp_contract, "on", SA);
3497   else if (Opts.DefaultFPContractMode == LangOptions::FPM_Off)
3498     GenerateArg(Args, OPT_ffp_contract, "off", SA);
3499   else if (Opts.DefaultFPContractMode == LangOptions::FPM_FastHonorPragmas)
3500     GenerateArg(Args, OPT_ffp_contract, "fast-honor-pragmas", SA);
3501 
3502   for (StringRef Sanitizer : serializeSanitizerKinds(Opts.Sanitize))
3503     GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
3504 
3505   // Conflating '-fsanitize-system-ignorelist' and '-fsanitize-ignorelist'.
3506   for (const std::string &F : Opts.NoSanitizeFiles)
3507     GenerateArg(Args, OPT_fsanitize_ignorelist_EQ, F, SA);
3508 
3509   if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver3_8)
3510     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "3.8", SA);
3511   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver4)
3512     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "4.0", SA);
3513   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver6)
3514     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "6.0", SA);
3515   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver7)
3516     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "7.0", SA);
3517   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver9)
3518     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "9.0", SA);
3519   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver11)
3520     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "11.0", SA);
3521   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver12)
3522     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "12.0", SA);
3523   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver14)
3524     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "14.0", SA);
3525   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver15)
3526     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "15.0", SA);
3527 
3528   if (Opts.getSignReturnAddressScope() ==
3529       LangOptions::SignReturnAddressScopeKind::All)
3530     GenerateArg(Args, OPT_msign_return_address_EQ, "all", SA);
3531   else if (Opts.getSignReturnAddressScope() ==
3532            LangOptions::SignReturnAddressScopeKind::NonLeaf)
3533     GenerateArg(Args, OPT_msign_return_address_EQ, "non-leaf", SA);
3534 
3535   if (Opts.getSignReturnAddressKey() ==
3536       LangOptions::SignReturnAddressKeyKind::BKey)
3537     GenerateArg(Args, OPT_msign_return_address_key_EQ, "b_key", SA);
3538 
3539   if (Opts.CXXABI)
3540     GenerateArg(Args, OPT_fcxx_abi_EQ, TargetCXXABI::getSpelling(*Opts.CXXABI),
3541                 SA);
3542 
3543   if (Opts.RelativeCXXABIVTables)
3544     GenerateArg(Args, OPT_fexperimental_relative_cxx_abi_vtables, SA);
3545   else
3546     GenerateArg(Args, OPT_fno_experimental_relative_cxx_abi_vtables, SA);
3547 
3548   if (Opts.UseTargetPathSeparator)
3549     GenerateArg(Args, OPT_ffile_reproducible, SA);
3550   else
3551     GenerateArg(Args, OPT_fno_file_reproducible, SA);
3552 
3553   for (const auto &MP : Opts.MacroPrefixMap)
3554     GenerateArg(Args, OPT_fmacro_prefix_map_EQ, MP.first + "=" + MP.second, SA);
3555 
3556   if (!Opts.RandstructSeed.empty())
3557     GenerateArg(Args, OPT_frandomize_layout_seed_EQ, Opts.RandstructSeed, SA);
3558 }
3559 
3560 bool CompilerInvocation::ParseLangArgs(LangOptions &Opts, ArgList &Args,
3561                                        InputKind IK, const llvm::Triple &T,
3562                                        std::vector<std::string> &Includes,
3563                                        DiagnosticsEngine &Diags) {
3564   unsigned NumErrorsBefore = Diags.getNumErrors();
3565 
3566   if (IK.getFormat() == InputKind::Precompiled ||
3567       IK.getLanguage() == Language::LLVM_IR) {
3568     // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
3569     // PassManager in BackendUtil.cpp. They need to be initialized no matter
3570     // what the input type is.
3571     if (Args.hasArg(OPT_fobjc_arc))
3572       Opts.ObjCAutoRefCount = 1;
3573     // PICLevel and PIELevel are needed during code generation and this should
3574     // be set regardless of the input type.
3575     Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
3576     Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3577     parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
3578                         Diags, Opts.Sanitize);
3579 
3580     return Diags.getNumErrors() == NumErrorsBefore;
3581   }
3582 
3583   // Other LangOpts are only initialized when the input is not AST or LLVM IR.
3584   // FIXME: Should we really be parsing this for an Language::Asm input?
3585 
3586   // FIXME: Cleanup per-file based stuff.
3587   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
3588   if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3589     LangStd = LangStandard::getLangKind(A->getValue());
3590     if (LangStd == LangStandard::lang_unspecified) {
3591       Diags.Report(diag::err_drv_invalid_value)
3592         << A->getAsString(Args) << A->getValue();
3593       // Report supported standards with short description.
3594       for (unsigned KindValue = 0;
3595            KindValue != LangStandard::lang_unspecified;
3596            ++KindValue) {
3597         const LangStandard &Std = LangStandard::getLangStandardForKind(
3598           static_cast<LangStandard::Kind>(KindValue));
3599         if (IsInputCompatibleWithStandard(IK, Std)) {
3600           auto Diag = Diags.Report(diag::note_drv_use_standard);
3601           Diag << Std.getName() << Std.getDescription();
3602           unsigned NumAliases = 0;
3603 #define LANGSTANDARD(id, name, lang, desc, features)
3604 #define LANGSTANDARD_ALIAS(id, alias) \
3605           if (KindValue == LangStandard::lang_##id) ++NumAliases;
3606 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
3607 #include "clang/Basic/LangStandards.def"
3608           Diag << NumAliases;
3609 #define LANGSTANDARD(id, name, lang, desc, features)
3610 #define LANGSTANDARD_ALIAS(id, alias) \
3611           if (KindValue == LangStandard::lang_##id) Diag << alias;
3612 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
3613 #include "clang/Basic/LangStandards.def"
3614         }
3615       }
3616     } else {
3617       // Valid standard, check to make sure language and standard are
3618       // compatible.
3619       const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
3620       if (!IsInputCompatibleWithStandard(IK, Std)) {
3621         Diags.Report(diag::err_drv_argument_not_allowed_with)
3622           << A->getAsString(Args) << GetInputKindName(IK);
3623       }
3624     }
3625   }
3626 
3627   // -cl-std only applies for OpenCL language standards.
3628   // Override the -std option in this case.
3629   if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3630     LangStandard::Kind OpenCLLangStd
3631       = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3632         .Cases("cl", "CL", LangStandard::lang_opencl10)
3633         .Cases("cl1.0", "CL1.0", LangStandard::lang_opencl10)
3634         .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
3635         .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
3636         .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
3637         .Cases("cl3.0", "CL3.0", LangStandard::lang_opencl30)
3638         .Cases("clc++", "CLC++", LangStandard::lang_openclcpp10)
3639         .Cases("clc++1.0", "CLC++1.0", LangStandard::lang_openclcpp10)
3640         .Cases("clc++2021", "CLC++2021", LangStandard::lang_openclcpp2021)
3641         .Default(LangStandard::lang_unspecified);
3642 
3643     if (OpenCLLangStd == LangStandard::lang_unspecified) {
3644       Diags.Report(diag::err_drv_invalid_value)
3645         << A->getAsString(Args) << A->getValue();
3646     }
3647     else
3648       LangStd = OpenCLLangStd;
3649   }
3650 
3651   // These need to be parsed now. They are used to set OpenCL defaults.
3652   Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3653   Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3654 
3655   LangOptions::setLangDefaults(Opts, IK.getLanguage(), T, Includes, LangStd);
3656 
3657   // The key paths of codegen options defined in Options.td start with
3658   // "LangOpts->". Let's provide the expected variable name and type.
3659   LangOptions *LangOpts = &Opts;
3660 
3661 #define LANG_OPTION_WITH_MARSHALLING(                                          \
3662     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
3663     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
3664     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
3665     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
3666   PARSE_OPTION_WITH_MARSHALLING(                                               \
3667       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
3668       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
3669 #include "clang/Driver/Options.inc"
3670 #undef LANG_OPTION_WITH_MARSHALLING
3671 
3672   if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3673     StringRef Name = A->getValue();
3674     if (Name == "full" || Name == "branch") {
3675       Opts.CFProtectionBranch = 1;
3676     }
3677   }
3678 
3679   if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3680       !Args.hasArg(OPT_sycl_std_EQ)) {
3681     // If the user supplied -fsycl-is-device or -fsycl-is-host, but failed to
3682     // provide -sycl-std=, we want to default it to whatever the default SYCL
3683     // version is. I could not find a way to express this with the options
3684     // tablegen because we still want this value to be SYCL_None when the user
3685     // is not in device or host mode.
3686     Opts.setSYCLVersion(LangOptions::SYCL_Default);
3687   }
3688 
3689   if (Opts.ObjC) {
3690     if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3691       StringRef value = arg->getValue();
3692       if (Opts.ObjCRuntime.tryParse(value))
3693         Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
3694     }
3695 
3696     if (Args.hasArg(OPT_fobjc_gc_only))
3697       Opts.setGC(LangOptions::GCOnly);
3698     else if (Args.hasArg(OPT_fobjc_gc))
3699       Opts.setGC(LangOptions::HybridGC);
3700     else if (Args.hasArg(OPT_fobjc_arc)) {
3701       Opts.ObjCAutoRefCount = 1;
3702       if (!Opts.ObjCRuntime.allowsARC())
3703         Diags.Report(diag::err_arc_unsupported_on_runtime);
3704     }
3705 
3706     // ObjCWeakRuntime tracks whether the runtime supports __weak, not
3707     // whether the feature is actually enabled.  This is predominantly
3708     // determined by -fobjc-runtime, but we allow it to be overridden
3709     // from the command line for testing purposes.
3710     if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3711       Opts.ObjCWeakRuntime = 1;
3712     else
3713       Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak();
3714 
3715     // ObjCWeak determines whether __weak is actually enabled.
3716     // Note that we allow -fno-objc-weak to disable this even in ARC mode.
3717     if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3718       if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3719         assert(!Opts.ObjCWeak);
3720       } else if (Opts.getGC() != LangOptions::NonGC) {
3721         Diags.Report(diag::err_objc_weak_with_gc);
3722       } else if (!Opts.ObjCWeakRuntime) {
3723         Diags.Report(diag::err_objc_weak_unsupported);
3724       } else {
3725         Opts.ObjCWeak = 1;
3726       }
3727     } else if (Opts.ObjCAutoRefCount) {
3728       Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3729     }
3730 
3731     if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3732       Opts.ObjCSubscriptingLegacyRuntime =
3733         (Opts.ObjCRuntime.getKind() == ObjCRuntime::FragileMacOSX);
3734   }
3735 
3736   if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
3737     // Check that the version has 1 to 3 components and the minor and patch
3738     // versions fit in two decimal digits.
3739     VersionTuple GNUCVer;
3740     bool Invalid = GNUCVer.tryParse(A->getValue());
3741     unsigned Major = GNUCVer.getMajor();
3742     unsigned Minor = GNUCVer.getMinor().value_or(0);
3743     unsigned Patch = GNUCVer.getSubminor().value_or(0);
3744     if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
3745       Diags.Report(diag::err_drv_invalid_value)
3746           << A->getAsString(Args) << A->getValue();
3747     }
3748     Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
3749   }
3750 
3751   if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
3752     Opts.IgnoreXCOFFVisibility = 1;
3753 
3754   if (Args.hasArg(OPT_ftrapv)) {
3755     Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
3756     // Set the handler, if one is specified.
3757     Opts.OverflowHandler =
3758         std::string(Args.getLastArgValue(OPT_ftrapv_handler));
3759   }
3760   else if (Args.hasArg(OPT_fwrapv))
3761     Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
3762 
3763   Opts.MSCompatibilityVersion = 0;
3764   if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
3765     VersionTuple VT;
3766     if (VT.tryParse(A->getValue()))
3767       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3768                                                 << A->getValue();
3769     Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
3770                                   VT.getMinor().value_or(0) * 100000 +
3771                                   VT.getSubminor().value_or(0);
3772   }
3773 
3774   // Mimicking gcc's behavior, trigraphs are only enabled if -trigraphs
3775   // is specified, or -std is set to a conforming mode.
3776   // Trigraphs are disabled by default in c++1z onwards.
3777   // For z/OS, trigraphs are enabled by default (without regard to the above).
3778   Opts.Trigraphs =
3779       (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS();
3780   Opts.Trigraphs =
3781       Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
3782 
3783   Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
3784     && Opts.OpenCLVersion == 200);
3785 
3786   Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
3787                              Opts.SYCLIsDevice ||
3788                              Args.hasArg(OPT_fconvergent_functions);
3789 
3790   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
3791   if (!Opts.NoBuiltin)
3792     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
3793   if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
3794     if (A->getOption().matches(options::OPT_mlong_double_64))
3795       Opts.LongDoubleSize = 64;
3796     else if (A->getOption().matches(options::OPT_mlong_double_80))
3797       Opts.LongDoubleSize = 80;
3798     else if (A->getOption().matches(options::OPT_mlong_double_128))
3799       Opts.LongDoubleSize = 128;
3800     else
3801       Opts.LongDoubleSize = 0;
3802   }
3803   if (Opts.FastRelaxedMath)
3804     Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
3805 
3806   llvm::sort(Opts.ModuleFeatures);
3807 
3808   // -mrtd option
3809   if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3810     if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
3811       Diags.Report(diag::err_drv_argument_not_allowed_with)
3812           << A->getSpelling() << "-fdefault-calling-conv";
3813     else {
3814       if (T.getArch() != llvm::Triple::x86)
3815         Diags.Report(diag::err_drv_argument_not_allowed_with)
3816             << A->getSpelling() << T.getTriple();
3817       else
3818         Opts.setDefaultCallingConv(LangOptions::DCC_StdCall);
3819     }
3820   }
3821 
3822   // Check if -fopenmp is specified and set default version to 5.0.
3823   Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 50 : 0;
3824   // Check if -fopenmp-simd is specified.
3825   bool IsSimdSpecified =
3826       Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
3827                    /*Default=*/false);
3828   Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
3829   Opts.OpenMPUseTLS =
3830       Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
3831   Opts.OpenMPIsDevice =
3832       Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
3833   Opts.OpenMPIRBuilder =
3834       Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
3835   bool IsTargetSpecified =
3836       Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
3837 
3838   Opts.ConvergentFunctions = Opts.ConvergentFunctions || Opts.OpenMPIsDevice;
3839 
3840   if (Opts.OpenMP || Opts.OpenMPSimd) {
3841     if (int Version = getLastArgIntValue(
3842             Args, OPT_fopenmp_version_EQ,
3843             (IsSimdSpecified || IsTargetSpecified) ? 50 : Opts.OpenMP, Diags))
3844       Opts.OpenMP = Version;
3845     // Provide diagnostic when a given target is not expected to be an OpenMP
3846     // device or host.
3847     if (!Opts.OpenMPIsDevice) {
3848       switch (T.getArch()) {
3849       default:
3850         break;
3851       // Add unsupported host targets here:
3852       case llvm::Triple::nvptx:
3853       case llvm::Triple::nvptx64:
3854         Diags.Report(diag::err_drv_omp_host_target_not_supported) << T.str();
3855         break;
3856       }
3857     }
3858   }
3859 
3860   // Set the flag to prevent the implementation from emitting device exception
3861   // handling code for those requiring so.
3862   if ((Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN())) ||
3863       Opts.OpenCLCPlusPlus) {
3864 
3865     Opts.Exceptions = 0;
3866     Opts.CXXExceptions = 0;
3867   }
3868   if (Opts.OpenMPIsDevice && T.isNVPTX()) {
3869     Opts.OpenMPCUDANumSMs =
3870         getLastArgIntValue(Args, options::OPT_fopenmp_cuda_number_of_sm_EQ,
3871                            Opts.OpenMPCUDANumSMs, Diags);
3872     Opts.OpenMPCUDABlocksPerSM =
3873         getLastArgIntValue(Args, options::OPT_fopenmp_cuda_blocks_per_sm_EQ,
3874                            Opts.OpenMPCUDABlocksPerSM, Diags);
3875     Opts.OpenMPCUDAReductionBufNum = getLastArgIntValue(
3876         Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3877         Opts.OpenMPCUDAReductionBufNum, Diags);
3878   }
3879 
3880   // Set the value of the debugging flag used in the new offloading device RTL.
3881   // Set either by a specific value or to a default if not specified.
3882   if (Opts.OpenMPIsDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
3883                               Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
3884     Opts.OpenMPTargetDebug = getLastArgIntValue(
3885         Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
3886     if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
3887       Opts.OpenMPTargetDebug = 1;
3888   }
3889 
3890   if (Opts.OpenMPIsDevice) {
3891     if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
3892       Opts.OpenMPTeamSubscription = true;
3893     if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
3894       Opts.OpenMPThreadSubscription = true;
3895   }
3896 
3897   // Get the OpenMP target triples if any.
3898   if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
3899     enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
3900     auto getArchPtrSize = [](const llvm::Triple &T) {
3901       if (T.isArch16Bit())
3902         return Arch16Bit;
3903       if (T.isArch32Bit())
3904         return Arch32Bit;
3905       assert(T.isArch64Bit() && "Expected 64-bit architecture");
3906       return Arch64Bit;
3907     };
3908 
3909     for (unsigned i = 0; i < A->getNumValues(); ++i) {
3910       llvm::Triple TT(A->getValue(i));
3911 
3912       if (TT.getArch() == llvm::Triple::UnknownArch ||
3913           !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
3914             TT.getArch() == llvm::Triple::nvptx ||
3915             TT.getArch() == llvm::Triple::nvptx64 ||
3916             TT.getArch() == llvm::Triple::amdgcn ||
3917             TT.getArch() == llvm::Triple::x86 ||
3918             TT.getArch() == llvm::Triple::x86_64))
3919         Diags.Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
3920       else if (getArchPtrSize(T) != getArchPtrSize(TT))
3921         Diags.Report(diag::err_drv_incompatible_omp_arch)
3922             << A->getValue(i) << T.str();
3923       else
3924         Opts.OMPTargetTriples.push_back(TT);
3925     }
3926   }
3927 
3928   // Get OpenMP host file path if any and report if a non existent file is
3929   // found
3930   if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
3931     Opts.OMPHostIRFile = A->getValue();
3932     if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
3933       Diags.Report(diag::err_drv_omp_host_ir_file_not_found)
3934           << Opts.OMPHostIRFile;
3935   }
3936 
3937   // Set CUDA mode for OpenMP target NVPTX/AMDGCN if specified in options
3938   Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) &&
3939                         Args.hasArg(options::OPT_fopenmp_cuda_mode);
3940 
3941   // FIXME: Eliminate this dependency.
3942   unsigned Opt = getOptimizationLevel(Args, IK, Diags),
3943        OptSize = getOptimizationLevelSize(Args);
3944   Opts.Optimize = Opt != 0;
3945   Opts.OptimizeSize = OptSize != 0;
3946 
3947   // This is the __NO_INLINE__ define, which just depends on things like the
3948   // optimization level and -fno-inline, not actually whether the backend has
3949   // inlining enabled.
3950   Opts.NoInlineDefine = !Opts.Optimize;
3951   if (Arg *InlineArg = Args.getLastArg(
3952           options::OPT_finline_functions, options::OPT_finline_hint_functions,
3953           options::OPT_fno_inline_functions, options::OPT_fno_inline))
3954     if (InlineArg->getOption().matches(options::OPT_fno_inline))
3955       Opts.NoInlineDefine = true;
3956 
3957   if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
3958     StringRef Val = A->getValue();
3959     if (Val == "fast")
3960       Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
3961     else if (Val == "on")
3962       Opts.setDefaultFPContractMode(LangOptions::FPM_On);
3963     else if (Val == "off")
3964       Opts.setDefaultFPContractMode(LangOptions::FPM_Off);
3965     else if (Val == "fast-honor-pragmas")
3966       Opts.setDefaultFPContractMode(LangOptions::FPM_FastHonorPragmas);
3967     else
3968       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
3969   }
3970 
3971   // Parse -fsanitize= arguments.
3972   parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
3973                       Diags, Opts.Sanitize);
3974   Opts.NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
3975   std::vector<std::string> systemIgnorelists =
3976       Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
3977   Opts.NoSanitizeFiles.insert(Opts.NoSanitizeFiles.end(),
3978                               systemIgnorelists.begin(),
3979                               systemIgnorelists.end());
3980 
3981   if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
3982     Opts.setClangABICompat(LangOptions::ClangABI::Latest);
3983 
3984     StringRef Ver = A->getValue();
3985     std::pair<StringRef, StringRef> VerParts = Ver.split('.');
3986     unsigned Major, Minor = 0;
3987 
3988     // Check the version number is valid: either 3.x (0 <= x <= 9) or
3989     // y or y.0 (4 <= y <= current version).
3990     if (!VerParts.first.startswith("0") &&
3991         !VerParts.first.getAsInteger(10, Major) &&
3992         3 <= Major && Major <= CLANG_VERSION_MAJOR &&
3993         (Major == 3 ? VerParts.second.size() == 1 &&
3994                       !VerParts.second.getAsInteger(10, Minor)
3995                     : VerParts.first.size() == Ver.size() ||
3996                       VerParts.second == "0")) {
3997       // Got a valid version number.
3998       if (Major == 3 && Minor <= 8)
3999         Opts.setClangABICompat(LangOptions::ClangABI::Ver3_8);
4000       else if (Major <= 4)
4001         Opts.setClangABICompat(LangOptions::ClangABI::Ver4);
4002       else if (Major <= 6)
4003         Opts.setClangABICompat(LangOptions::ClangABI::Ver6);
4004       else if (Major <= 7)
4005         Opts.setClangABICompat(LangOptions::ClangABI::Ver7);
4006       else if (Major <= 9)
4007         Opts.setClangABICompat(LangOptions::ClangABI::Ver9);
4008       else if (Major <= 11)
4009         Opts.setClangABICompat(LangOptions::ClangABI::Ver11);
4010       else if (Major <= 12)
4011         Opts.setClangABICompat(LangOptions::ClangABI::Ver12);
4012       else if (Major <= 14)
4013         Opts.setClangABICompat(LangOptions::ClangABI::Ver14);
4014       else if (Major <= 15)
4015         Opts.setClangABICompat(LangOptions::ClangABI::Ver15);
4016     } else if (Ver != "latest") {
4017       Diags.Report(diag::err_drv_invalid_value)
4018           << A->getAsString(Args) << A->getValue();
4019     }
4020   }
4021 
4022   if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4023     StringRef SignScope = A->getValue();
4024 
4025     if (SignScope.equals_insensitive("none"))
4026       Opts.setSignReturnAddressScope(
4027           LangOptions::SignReturnAddressScopeKind::None);
4028     else if (SignScope.equals_insensitive("all"))
4029       Opts.setSignReturnAddressScope(
4030           LangOptions::SignReturnAddressScopeKind::All);
4031     else if (SignScope.equals_insensitive("non-leaf"))
4032       Opts.setSignReturnAddressScope(
4033           LangOptions::SignReturnAddressScopeKind::NonLeaf);
4034     else
4035       Diags.Report(diag::err_drv_invalid_value)
4036           << A->getAsString(Args) << SignScope;
4037 
4038     if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4039       StringRef SignKey = A->getValue();
4040       if (!SignScope.empty() && !SignKey.empty()) {
4041         if (SignKey.equals_insensitive("a_key"))
4042           Opts.setSignReturnAddressKey(
4043               LangOptions::SignReturnAddressKeyKind::AKey);
4044         else if (SignKey.equals_insensitive("b_key"))
4045           Opts.setSignReturnAddressKey(
4046               LangOptions::SignReturnAddressKeyKind::BKey);
4047         else
4048           Diags.Report(diag::err_drv_invalid_value)
4049               << A->getAsString(Args) << SignKey;
4050       }
4051     }
4052   }
4053 
4054   // The value can be empty, which indicates the system default should be used.
4055   StringRef CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4056   if (!CXXABI.empty()) {
4057     if (!TargetCXXABI::isABI(CXXABI)) {
4058       Diags.Report(diag::err_invalid_cxx_abi) << CXXABI;
4059     } else {
4060       auto Kind = TargetCXXABI::getKind(CXXABI);
4061       if (!TargetCXXABI::isSupportedCXXABI(T, Kind))
4062         Diags.Report(diag::err_unsupported_cxx_abi) << CXXABI << T.str();
4063       else
4064         Opts.CXXABI = Kind;
4065     }
4066   }
4067 
4068   Opts.RelativeCXXABIVTables =
4069       Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4070                    options::OPT_fno_experimental_relative_cxx_abi_vtables,
4071                    TargetCXXABI::usesRelativeVTables(T));
4072 
4073   for (const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4074     auto Split = StringRef(A).split('=');
4075     Opts.MacroPrefixMap.insert(
4076         {std::string(Split.first), std::string(Split.second)});
4077   }
4078 
4079   Opts.UseTargetPathSeparator =
4080       !Args.getLastArg(OPT_fno_file_reproducible) &&
4081       (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4082        Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4083        Args.getLastArg(OPT_ffile_reproducible));
4084 
4085   // Error if -mvscale-min is unbounded.
4086   if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4087     unsigned VScaleMin;
4088     if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4089       Diags.Report(diag::err_cc1_unbounded_vscale_min);
4090   }
4091 
4092   if (const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4093     std::ifstream SeedFile(A->getValue(0));
4094 
4095     if (!SeedFile.is_open())
4096       Diags.Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4097           << A->getValue(0);
4098 
4099     std::getline(SeedFile, Opts.RandstructSeed);
4100   }
4101 
4102   if (const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4103     Opts.RandstructSeed = A->getValue(0);
4104 
4105   // Validate options for HLSL
4106   if (Opts.HLSL) {
4107     bool SupportedTarget = T.getArch() == llvm::Triple::dxil &&
4108                            T.getOS() == llvm::Triple::ShaderModel;
4109     if (!SupportedTarget)
4110       Diags.Report(diag::err_drv_hlsl_unsupported_target) << T.str();
4111   }
4112 
4113   return Diags.getNumErrors() == NumErrorsBefore;
4114 }
4115 
4116 static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
4117   switch (Action) {
4118   case frontend::ASTDeclList:
4119   case frontend::ASTDump:
4120   case frontend::ASTPrint:
4121   case frontend::ASTView:
4122   case frontend::EmitAssembly:
4123   case frontend::EmitBC:
4124   case frontend::EmitHTML:
4125   case frontend::EmitLLVM:
4126   case frontend::EmitLLVMOnly:
4127   case frontend::EmitCodeGenOnly:
4128   case frontend::EmitObj:
4129   case frontend::ExtractAPI:
4130   case frontend::FixIt:
4131   case frontend::GenerateModule:
4132   case frontend::GenerateModuleInterface:
4133   case frontend::GenerateHeaderModule:
4134   case frontend::GenerateHeaderUnit:
4135   case frontend::GeneratePCH:
4136   case frontend::GenerateInterfaceStubs:
4137   case frontend::ParseSyntaxOnly:
4138   case frontend::ModuleFileInfo:
4139   case frontend::VerifyPCH:
4140   case frontend::PluginAction:
4141   case frontend::RewriteObjC:
4142   case frontend::RewriteTest:
4143   case frontend::RunAnalysis:
4144   case frontend::TemplightDump:
4145   case frontend::MigrateSource:
4146     return false;
4147 
4148   case frontend::DumpCompilerOptions:
4149   case frontend::DumpRawTokens:
4150   case frontend::DumpTokens:
4151   case frontend::InitOnly:
4152   case frontend::PrintPreamble:
4153   case frontend::PrintPreprocessedInput:
4154   case frontend::RewriteMacros:
4155   case frontend::RunPreprocessorOnly:
4156   case frontend::PrintDependencyDirectivesSourceMinimizerOutput:
4157     return true;
4158   }
4159   llvm_unreachable("invalid frontend action");
4160 }
4161 
4162 static void GeneratePreprocessorArgs(PreprocessorOptions &Opts,
4163                                      SmallVectorImpl<const char *> &Args,
4164                                      CompilerInvocation::StringAllocator SA,
4165                                      const LangOptions &LangOpts,
4166                                      const FrontendOptions &FrontendOpts,
4167                                      const CodeGenOptions &CodeGenOpts) {
4168   PreprocessorOptions *PreprocessorOpts = &Opts;
4169 
4170 #define PREPROCESSOR_OPTION_WITH_MARSHALLING(                                  \
4171     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
4172     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
4173     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
4174     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
4175   GENERATE_OPTION_WITH_MARSHALLING(                                            \
4176       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
4177       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4178 #include "clang/Driver/Options.inc"
4179 #undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4180 
4181   if (Opts.PCHWithHdrStop && !Opts.PCHWithHdrStopCreate)
4182     GenerateArg(Args, OPT_pch_through_hdrstop_use, SA);
4183 
4184   for (const auto &D : Opts.DeserializedPCHDeclsToErrorOn)
4185     GenerateArg(Args, OPT_error_on_deserialized_pch_decl, D, SA);
4186 
4187   if (Opts.PrecompiledPreambleBytes != std::make_pair(0u, false))
4188     GenerateArg(Args, OPT_preamble_bytes_EQ,
4189                 Twine(Opts.PrecompiledPreambleBytes.first) + "," +
4190                     (Opts.PrecompiledPreambleBytes.second ? "1" : "0"),
4191                 SA);
4192 
4193   for (const auto &M : Opts.Macros) {
4194     // Don't generate __CET__ macro definitions. They are implied by the
4195     // -fcf-protection option that is generated elsewhere.
4196     if (M.first == "__CET__=1" && !M.second &&
4197         !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4198       continue;
4199     if (M.first == "__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4200         !CodeGenOpts.CFProtectionBranch)
4201       continue;
4202     if (M.first == "__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4203         CodeGenOpts.CFProtectionBranch)
4204       continue;
4205 
4206     GenerateArg(Args, M.second ? OPT_U : OPT_D, M.first, SA);
4207   }
4208 
4209   for (const auto &I : Opts.Includes) {
4210     // Don't generate OpenCL includes. They are implied by other flags that are
4211     // generated elsewhere.
4212     if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4213         ((LangOpts.DeclareOpenCLBuiltins && I == "opencl-c-base.h") ||
4214          I == "opencl-c.h"))
4215       continue;
4216     // Don't generate HLSL includes. They are implied by other flags that are
4217     // generated elsewhere.
4218     if (LangOpts.HLSL && I == "hlsl.h")
4219       continue;
4220 
4221     GenerateArg(Args, OPT_include, I, SA);
4222   }
4223 
4224   for (const auto &CI : Opts.ChainedIncludes)
4225     GenerateArg(Args, OPT_chain_include, CI, SA);
4226 
4227   for (const auto &RF : Opts.RemappedFiles)
4228     GenerateArg(Args, OPT_remap_file, RF.first + ";" + RF.second, SA);
4229 
4230   if (Opts.SourceDateEpoch)
4231     GenerateArg(Args, OPT_source_date_epoch, Twine(*Opts.SourceDateEpoch), SA);
4232 
4233   // Don't handle LexEditorPlaceholders. It is implied by the action that is
4234   // generated elsewhere.
4235 }
4236 
4237 static bool ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
4238                                   DiagnosticsEngine &Diags,
4239                                   frontend::ActionKind Action,
4240                                   const FrontendOptions &FrontendOpts) {
4241   unsigned NumErrorsBefore = Diags.getNumErrors();
4242 
4243   PreprocessorOptions *PreprocessorOpts = &Opts;
4244 
4245 #define PREPROCESSOR_OPTION_WITH_MARSHALLING(                                  \
4246     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
4247     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
4248     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
4249     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
4250   PARSE_OPTION_WITH_MARSHALLING(                                               \
4251       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
4252       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
4253 #include "clang/Driver/Options.inc"
4254 #undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4255 
4256   Opts.PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4257                         Args.hasArg(OPT_pch_through_hdrstop_use);
4258 
4259   for (const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4260     Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue());
4261 
4262   if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4263     StringRef Value(A->getValue());
4264     size_t Comma = Value.find(',');
4265     unsigned Bytes = 0;
4266     unsigned EndOfLine = 0;
4267 
4268     if (Comma == StringRef::npos ||
4269         Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4270         Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4271       Diags.Report(diag::err_drv_preamble_format);
4272     else {
4273       Opts.PrecompiledPreambleBytes.first = Bytes;
4274       Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
4275     }
4276   }
4277 
4278   // Add the __CET__ macro if a CFProtection option is set.
4279   if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4280     StringRef Name = A->getValue();
4281     if (Name == "branch")
4282       Opts.addMacroDef("__CET__=1");
4283     else if (Name == "return")
4284       Opts.addMacroDef("__CET__=2");
4285     else if (Name == "full")
4286       Opts.addMacroDef("__CET__=3");
4287   }
4288 
4289   // Add macros from the command line.
4290   for (const auto *A : Args.filtered(OPT_D, OPT_U)) {
4291     if (A->getOption().matches(OPT_D))
4292       Opts.addMacroDef(A->getValue());
4293     else
4294       Opts.addMacroUndef(A->getValue());
4295   }
4296 
4297   // Add the ordered list of -includes.
4298   for (const auto *A : Args.filtered(OPT_include))
4299     Opts.Includes.emplace_back(A->getValue());
4300 
4301   for (const auto *A : Args.filtered(OPT_chain_include))
4302     Opts.ChainedIncludes.emplace_back(A->getValue());
4303 
4304   for (const auto *A : Args.filtered(OPT_remap_file)) {
4305     std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');
4306 
4307     if (Split.second.empty()) {
4308       Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4309       continue;
4310     }
4311 
4312     Opts.addRemappedFile(Split.first, Split.second);
4313   }
4314 
4315   if (const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4316     StringRef Epoch = A->getValue();
4317     // SOURCE_DATE_EPOCH, if specified, must be a non-negative decimal integer.
4318     // On time64 systems, pick 253402300799 (the UNIX timestamp of
4319     // 9999-12-31T23:59:59Z) as the upper bound.
4320     const uint64_t MaxTimestamp =
4321         std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4322     uint64_t V;
4323     if (Epoch.getAsInteger(10, V) || V > MaxTimestamp) {
4324       Diags.Report(diag::err_fe_invalid_source_date_epoch)
4325           << Epoch << MaxTimestamp;
4326     } else {
4327       Opts.SourceDateEpoch = V;
4328     }
4329   }
4330 
4331   // Always avoid lexing editor placeholders when we're just running the
4332   // preprocessor as we never want to emit the
4333   // "editor placeholder in source file" error in PP only mode.
4334   if (isStrictlyPreprocessorAction(Action))
4335     Opts.LexEditorPlaceholders = false;
4336 
4337   return Diags.getNumErrors() == NumErrorsBefore;
4338 }
4339 
4340 static void GeneratePreprocessorOutputArgs(
4341     const PreprocessorOutputOptions &Opts, SmallVectorImpl<const char *> &Args,
4342     CompilerInvocation::StringAllocator SA, frontend::ActionKind Action) {
4343   const PreprocessorOutputOptions &PreprocessorOutputOpts = Opts;
4344 
4345 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(                           \
4346     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
4347     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
4348     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
4349     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
4350   GENERATE_OPTION_WITH_MARSHALLING(                                            \
4351       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
4352       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4353 #include "clang/Driver/Options.inc"
4354 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4355 
4356   bool Generate_dM = isStrictlyPreprocessorAction(Action) && !Opts.ShowCPP;
4357   if (Generate_dM)
4358     GenerateArg(Args, OPT_dM, SA);
4359   if (!Generate_dM && Opts.ShowMacros)
4360     GenerateArg(Args, OPT_dD, SA);
4361   if (Opts.DirectivesOnly)
4362     GenerateArg(Args, OPT_fdirectives_only, SA);
4363 }
4364 
4365 static bool ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
4366                                         ArgList &Args, DiagnosticsEngine &Diags,
4367                                         frontend::ActionKind Action) {
4368   unsigned NumErrorsBefore = Diags.getNumErrors();
4369 
4370   PreprocessorOutputOptions &PreprocessorOutputOpts = Opts;
4371 
4372 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(                           \
4373     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
4374     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
4375     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
4376     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
4377   PARSE_OPTION_WITH_MARSHALLING(                                               \
4378       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
4379       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
4380 #include "clang/Driver/Options.inc"
4381 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4382 
4383   Opts.ShowCPP = isStrictlyPreprocessorAction(Action) && !Args.hasArg(OPT_dM);
4384   Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4385   Opts.DirectivesOnly = Args.hasArg(OPT_fdirectives_only);
4386 
4387   return Diags.getNumErrors() == NumErrorsBefore;
4388 }
4389 
4390 static void GenerateTargetArgs(const TargetOptions &Opts,
4391                                SmallVectorImpl<const char *> &Args,
4392                                CompilerInvocation::StringAllocator SA) {
4393   const TargetOptions *TargetOpts = &Opts;
4394 #define TARGET_OPTION_WITH_MARSHALLING(                                        \
4395     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
4396     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
4397     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
4398     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
4399   GENERATE_OPTION_WITH_MARSHALLING(                                            \
4400       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
4401       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
4402 #include "clang/Driver/Options.inc"
4403 #undef TARGET_OPTION_WITH_MARSHALLING
4404 
4405   if (!Opts.SDKVersion.empty())
4406     GenerateArg(Args, OPT_target_sdk_version_EQ, Opts.SDKVersion.getAsString(),
4407                 SA);
4408   if (!Opts.DarwinTargetVariantSDKVersion.empty())
4409     GenerateArg(Args, OPT_darwin_target_variant_sdk_version_EQ,
4410                 Opts.DarwinTargetVariantSDKVersion.getAsString(), SA);
4411 }
4412 
4413 static bool ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
4414                             DiagnosticsEngine &Diags) {
4415   unsigned NumErrorsBefore = Diags.getNumErrors();
4416 
4417   TargetOptions *TargetOpts = &Opts;
4418 
4419 #define TARGET_OPTION_WITH_MARSHALLING(                                        \
4420     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
4421     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
4422     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
4423     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
4424   PARSE_OPTION_WITH_MARSHALLING(                                               \
4425       Args, Diags, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,     \
4426       IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)
4427 #include "clang/Driver/Options.inc"
4428 #undef TARGET_OPTION_WITH_MARSHALLING
4429 
4430   if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4431     llvm::VersionTuple Version;
4432     if (Version.tryParse(A->getValue()))
4433       Diags.Report(diag::err_drv_invalid_value)
4434           << A->getAsString(Args) << A->getValue();
4435     else
4436       Opts.SDKVersion = Version;
4437   }
4438   if (Arg *A =
4439           Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4440     llvm::VersionTuple Version;
4441     if (Version.tryParse(A->getValue()))
4442       Diags.Report(diag::err_drv_invalid_value)
4443           << A->getAsString(Args) << A->getValue();
4444     else
4445       Opts.DarwinTargetVariantSDKVersion = Version;
4446   }
4447 
4448   return Diags.getNumErrors() == NumErrorsBefore;
4449 }
4450 
4451 bool CompilerInvocation::CreateFromArgsImpl(
4452     CompilerInvocation &Res, ArrayRef<const char *> CommandLineArgs,
4453     DiagnosticsEngine &Diags, const char *Argv0) {
4454   unsigned NumErrorsBefore = Diags.getNumErrors();
4455 
4456   // Parse the arguments.
4457   const OptTable &Opts = getDriverOptTable();
4458   const unsigned IncludedFlagsBitmask = options::CC1Option;
4459   unsigned MissingArgIndex, MissingArgCount;
4460   InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4461                                      MissingArgCount, IncludedFlagsBitmask);
4462   LangOptions &LangOpts = *Res.getLangOpts();
4463 
4464   // Check for missing argument error.
4465   if (MissingArgCount)
4466     Diags.Report(diag::err_drv_missing_argument)
4467         << Args.getArgString(MissingArgIndex) << MissingArgCount;
4468 
4469   // Issue errors on unknown arguments.
4470   for (const auto *A : Args.filtered(OPT_UNKNOWN)) {
4471     auto ArgString = A->getAsString(Args);
4472     std::string Nearest;
4473     if (Opts.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
4474       Diags.Report(diag::err_drv_unknown_argument) << ArgString;
4475     else
4476       Diags.Report(diag::err_drv_unknown_argument_with_suggestion)
4477           << ArgString << Nearest;
4478   }
4479 
4480   ParseFileSystemArgs(Res.getFileSystemOpts(), Args, Diags);
4481   ParseMigratorArgs(Res.getMigratorOpts(), Args, Diags);
4482   ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
4483   ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
4484                       /*DefaultDiagColor=*/false);
4485   ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags, LangOpts.IsHeaderFile);
4486   // FIXME: We shouldn't have to pass the DashX option around here
4487   InputKind DashX = Res.getFrontendOpts().DashX;
4488   ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
4489   llvm::Triple T(Res.getTargetOpts().Triple);
4490   ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args, Diags,
4491                         Res.getFileSystemOpts().WorkingDir);
4492 
4493   ParseLangArgs(LangOpts, Args, DashX, T, Res.getPreprocessorOpts().Includes,
4494                 Diags);
4495   if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
4496     LangOpts.ObjCExceptions = 1;
4497 
4498   for (auto Warning : Res.getDiagnosticOpts().Warnings) {
4499     if (Warning == "misexpect" &&
4500         !Diags.isIgnored(diag::warn_profile_data_misexpect, SourceLocation())) {
4501       Res.getCodeGenOpts().MisExpect = true;
4502     }
4503   }
4504 
4505   if (LangOpts.CUDA) {
4506     // During CUDA device-side compilation, the aux triple is the
4507     // triple used for host compilation.
4508     if (LangOpts.CUDAIsDevice)
4509       Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
4510   }
4511 
4512   // Set the triple of the host for OpenMP device compile.
4513   if (LangOpts.OpenMPIsDevice)
4514     Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
4515 
4516   ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags, T,
4517                    Res.getFrontendOpts().OutputFile, LangOpts);
4518 
4519   // FIXME: Override value name discarding when asan or msan is used because the
4520   // backend passes depend on the name of the alloca in order to print out
4521   // names.
4522   Res.getCodeGenOpts().DiscardValueNames &=
4523       !LangOpts.Sanitize.has(SanitizerKind::Address) &&
4524       !LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4525       !LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4526       !LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4527 
4528   ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, Diags,
4529                         Res.getFrontendOpts().ProgramAction,
4530                         Res.getFrontendOpts());
4531   ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args, Diags,
4532                               Res.getFrontendOpts().ProgramAction);
4533 
4534   ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args, Diags,
4535                             Res.getFrontendOpts().ProgramAction,
4536                             Res.getPreprocessorOutputOpts().ShowLineMarkers);
4537   if (!Res.getDependencyOutputOpts().OutputFile.empty() &&
4538       Res.getDependencyOutputOpts().Targets.empty())
4539     Diags.Report(diag::err_fe_dependency_file_requires_MT);
4540 
4541   // If sanitizer is enabled, disable OPT_ffine_grained_bitfield_accesses.
4542   if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&
4543       !Res.getLangOpts()->Sanitize.empty()) {
4544     Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;
4545     Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4546   }
4547 
4548   // Store the command-line for using in the CodeView backend.
4549   if (Res.getCodeGenOpts().CodeViewCommandLine) {
4550     Res.getCodeGenOpts().Argv0 = Argv0;
4551     append_range(Res.getCodeGenOpts().CommandLineArgs, CommandLineArgs);
4552   }
4553 
4554   FixupInvocation(Res, Diags, Args, DashX);
4555 
4556   return Diags.getNumErrors() == NumErrorsBefore;
4557 }
4558 
4559 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Invocation,
4560                                         ArrayRef<const char *> CommandLineArgs,
4561                                         DiagnosticsEngine &Diags,
4562                                         const char *Argv0) {
4563   CompilerInvocation DummyInvocation;
4564 
4565   return RoundTrip(
4566       [](CompilerInvocation &Invocation, ArrayRef<const char *> CommandLineArgs,
4567          DiagnosticsEngine &Diags, const char *Argv0) {
4568         return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4569       },
4570       [](CompilerInvocation &Invocation, SmallVectorImpl<const char *> &Args,
4571          StringAllocator SA) {
4572         Args.push_back("-cc1");
4573         Invocation.generateCC1CommandLine(Args, SA);
4574       },
4575       Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4576 }
4577 
4578 std::string CompilerInvocation::getModuleHash() const {
4579   // FIXME: Consider using SHA1 instead of MD5.
4580   llvm::HashBuilder<llvm::MD5, llvm::support::endianness::native> HBuilder;
4581 
4582   // Note: For QoI reasons, the things we use as a hash here should all be
4583   // dumped via the -module-info flag.
4584 
4585   // Start the signature with the compiler version.
4586   HBuilder.add(getClangFullRepositoryVersion());
4587 
4588   // Also include the serialization version, in case LLVM_APPEND_VC_REV is off
4589   // and getClangFullRepositoryVersion() doesn't include git revision.
4590   HBuilder.add(serialization::VERSION_MAJOR, serialization::VERSION_MINOR);
4591 
4592   // Extend the signature with the language options
4593 #define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
4594 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description)                   \
4595   HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
4596 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
4597 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4598 #include "clang/Basic/LangOptions.def"
4599 
4600   HBuilder.addRange(LangOpts->ModuleFeatures);
4601 
4602   HBuilder.add(LangOpts->ObjCRuntime);
4603   HBuilder.addRange(LangOpts->CommentOpts.BlockCommandNames);
4604 
4605   // Extend the signature with the target options.
4606   HBuilder.add(TargetOpts->Triple, TargetOpts->CPU, TargetOpts->TuneCPU,
4607                TargetOpts->ABI);
4608   HBuilder.addRange(TargetOpts->FeaturesAsWritten);
4609 
4610   // Extend the signature with preprocessor options.
4611   const PreprocessorOptions &ppOpts = getPreprocessorOpts();
4612   HBuilder.add(ppOpts.UsePredefines, ppOpts.DetailedRecord);
4613 
4614   const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
4615   for (const auto &Macro : getPreprocessorOpts().Macros) {
4616     // If we're supposed to ignore this macro for the purposes of modules,
4617     // don't put it into the hash.
4618     if (!hsOpts.ModulesIgnoreMacros.empty()) {
4619       // Check whether we're ignoring this macro.
4620       StringRef MacroDef = Macro.first;
4621       if (hsOpts.ModulesIgnoreMacros.count(
4622               llvm::CachedHashString(MacroDef.split('=').first)))
4623         continue;
4624     }
4625 
4626     HBuilder.add(Macro);
4627   }
4628 
4629   // Extend the signature with the sysroot and other header search options.
4630   HBuilder.add(hsOpts.Sysroot, hsOpts.ModuleFormat, hsOpts.UseDebugInfo,
4631                hsOpts.UseBuiltinIncludes, hsOpts.UseStandardSystemIncludes,
4632                hsOpts.UseStandardCXXIncludes, hsOpts.UseLibcxx,
4633                hsOpts.ModulesValidateDiagnosticOptions);
4634   HBuilder.add(hsOpts.ResourceDir);
4635 
4636   if (hsOpts.ModulesStrictContextHash) {
4637     HBuilder.addRange(hsOpts.SystemHeaderPrefixes);
4638     HBuilder.addRange(hsOpts.UserEntries);
4639 
4640     const DiagnosticOptions &diagOpts = getDiagnosticOpts();
4641 #define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
4642 #define ENUM_DIAGOPT(Name, Type, Bits, Default)                                \
4643   HBuilder.add(diagOpts.get##Name());
4644 #include "clang/Basic/DiagnosticOptions.def"
4645 #undef DIAGOPT
4646 #undef ENUM_DIAGOPT
4647   }
4648 
4649   // Extend the signature with the user build path.
4650   HBuilder.add(hsOpts.ModuleUserBuildPath);
4651 
4652   // Extend the signature with the module file extensions.
4653   for (const auto &ext : getFrontendOpts().ModuleFileExtensions)
4654     ext->hashExtension(HBuilder);
4655 
4656   // When compiling with -gmodules, also hash -fdebug-prefix-map as it
4657   // affects the debug info in the PCM.
4658   if (getCodeGenOpts().DebugTypeExtRefs)
4659     HBuilder.addRange(getCodeGenOpts().DebugPrefixMap);
4660 
4661   // Extend the signature with the enabled sanitizers, if at least one is
4662   // enabled. Sanitizers which cannot affect AST generation aren't hashed.
4663   SanitizerSet SanHash = LangOpts->Sanitize;
4664   SanHash.clear(getPPTransparentSanitizers());
4665   if (!SanHash.empty())
4666     HBuilder.add(SanHash.Mask);
4667 
4668   llvm::MD5::MD5Result Result;
4669   HBuilder.getHasher().final(Result);
4670   uint64_t Hash = Result.high() ^ Result.low();
4671   return toString(llvm::APInt(64, Hash), 36, /*Signed=*/false);
4672 }
4673 
4674 void CompilerInvocation::generateCC1CommandLine(
4675     SmallVectorImpl<const char *> &Args, StringAllocator SA) const {
4676   llvm::Triple T(TargetOpts->Triple);
4677 
4678   GenerateFileSystemArgs(FileSystemOpts, Args, SA);
4679   GenerateMigratorArgs(MigratorOpts, Args, SA);
4680   GenerateAnalyzerArgs(*AnalyzerOpts, Args, SA);
4681   GenerateDiagnosticArgs(*DiagnosticOpts, Args, SA, false);
4682   GenerateFrontendArgs(FrontendOpts, Args, SA, LangOpts->IsHeaderFile);
4683   GenerateTargetArgs(*TargetOpts, Args, SA);
4684   GenerateHeaderSearchArgs(*HeaderSearchOpts, Args, SA);
4685   GenerateLangArgs(*LangOpts, Args, SA, T, FrontendOpts.DashX);
4686   GenerateCodeGenArgs(CodeGenOpts, Args, SA, T, FrontendOpts.OutputFile,
4687                       &*LangOpts);
4688   GeneratePreprocessorArgs(*PreprocessorOpts, Args, SA, *LangOpts, FrontendOpts,
4689                            CodeGenOpts);
4690   GeneratePreprocessorOutputArgs(PreprocessorOutputOpts, Args, SA,
4691                                  FrontendOpts.ProgramAction);
4692   GenerateDependencyOutputArgs(DependencyOutputOpts, Args, SA);
4693 }
4694 
4695 std::vector<std::string> CompilerInvocation::getCC1CommandLine() const {
4696   // Set up string allocator.
4697   llvm::BumpPtrAllocator Alloc;
4698   llvm::StringSaver Strings(Alloc);
4699   auto SA = [&Strings](const Twine &Arg) { return Strings.save(Arg).data(); };
4700 
4701   // Synthesize full command line from the CompilerInvocation, including "-cc1".
4702   SmallVector<const char *, 32> Args{"-cc1"};
4703   generateCC1CommandLine(Args, SA);
4704 
4705   // Convert arguments to the return type.
4706   return std::vector<std::string>{Args.begin(), Args.end()};
4707 }
4708 
4709 void CompilerInvocation::resetNonModularOptions() {
4710   getLangOpts()->resetNonModularOptions();
4711   getPreprocessorOpts().resetNonModularOptions();
4712 }
4713 
4714 void CompilerInvocation::clearImplicitModuleBuildOptions() {
4715   getLangOpts()->ImplicitModules = false;
4716   getHeaderSearchOpts().ImplicitModuleMaps = false;
4717   getHeaderSearchOpts().ModuleCachePath.clear();
4718   getHeaderSearchOpts().ModulesValidateOncePerBuildSession = false;
4719   getHeaderSearchOpts().BuildSessionTimestamp = 0;
4720   // The specific values we canonicalize to for pruning don't affect behaviour,
4721   /// so use the default values so they may be dropped from the command-line.
4722   getHeaderSearchOpts().ModuleCachePruneInterval = 7 * 24 * 60 * 60;
4723   getHeaderSearchOpts().ModuleCachePruneAfter = 31 * 24 * 60 * 60;
4724 }
4725 
4726 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
4727 clang::createVFSFromCompilerInvocation(const CompilerInvocation &CI,
4728                                        DiagnosticsEngine &Diags) {
4729   return createVFSFromCompilerInvocation(CI, Diags,
4730                                          llvm::vfs::getRealFileSystem());
4731 }
4732 
4733 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
4734 clang::createVFSFromCompilerInvocation(
4735     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
4736     IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
4737   if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
4738     return BaseFS;
4739 
4740   IntrusiveRefCntPtr<llvm::vfs::FileSystem> Result = BaseFS;
4741   // earlier vfs files are on the bottom
4742   for (const auto &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
4743     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
4744         Result->getBufferForFile(File);
4745     if (!Buffer) {
4746       Diags.Report(diag::err_missing_vfs_overlay_file) << File;
4747       continue;
4748     }
4749 
4750     IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = llvm::vfs::getVFSFromYAML(
4751         std::move(Buffer.get()), /*DiagHandler*/ nullptr, File,
4752         /*DiagContext*/ nullptr, Result);
4753     if (!FS) {
4754       Diags.Report(diag::err_invalid_vfs_overlay) << File;
4755       continue;
4756     }
4757 
4758     Result = FS;
4759   }
4760   return Result;
4761 }
4762