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