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