//===- CompilerInvocation.cpp ---------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "clang/Frontend/CompilerInvocation.h"

#include "TestModuleFileExtension.h"

#include "clang/Basic/Builtins.h"

#include "clang/Basic/CharInfo.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/Basic/CommentOptions.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/DiagnosticDriver.h"

#include "clang/Basic/DiagnosticFrontend.h"

#include "clang/Basic/DiagnosticOptions.h"

#include "clang/Basic/FileSystemOptions.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/LangStandard.h"

#include "clang/Basic/ObjCRuntime.h"

#include "clang/Basic/Sanitizers.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/TargetOptions.h"

#include "clang/Basic/Version.h"

#include "clang/Basic/XRayInstr.h"

#include "clang/Config/config.h"

#include "clang/Frontend/CommandLineSourceLoc.h"

#include "clang/Frontend/DependencyOutputOptions.h"

#include "clang/Frontend/FrontendOptions.h"

#include "clang/Frontend/MigratorOptions.h"

#include "clang/Frontend/PreprocessorOutputOptions.h"

#include "clang/Frontend/TextDiagnosticBuffer.h"

#include "clang/Frontend/Utils.h"

#include "clang/Lex/HeaderSearchOptions.h"

#include "clang/Lex/PreprocessorOptions.h"

#include "clang/Options/Options.h"

#include "clang/Serialization/ASTBitCodes.h"

#include "clang/Serialization/ModuleFileExtension.h"

#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"

#include "llvm/ADT/APInt.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/CachedHashString.h"

#include "llvm/ADT/FloatingPointMode.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/ADT/Twine.h"

#include "llvm/Config/llvm-config.h"

#include "llvm/Frontend/Debug/Options.h"

#include "llvm/IR/DebugInfoMetadata.h"

#include "llvm/Linker/Linker.h"

#include "llvm/MC/MCTargetOptions.h"

#include "llvm/Option/Arg.h"

#include "llvm/Option/ArgList.h"

#include "llvm/Option/OptSpecifier.h"

#include "llvm/Option/OptTable.h"

#include "llvm/Option/Option.h"

#include "llvm/ProfileData/InstrProfReader.h"

#include "llvm/Remarks/HotnessThresholdParser.h"

#include "llvm/Support/CodeGen.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/Error.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/ErrorOr.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/HashBuilder.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/Process.h"

#include "llvm/Support/Regex.h"

#include "llvm/Support/VersionTuple.h"

#include "llvm/Support/VirtualFileSystem.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/Target/TargetOptions.h"

#include "llvm/TargetParser/Host.h"

#include "llvm/TargetParser/Triple.h"

#include <algorithm>

#include <cassert>

#include <cstddef>

#include <cstring>

#include <ctime>

#include <fstream>

#include <limits>

#include <memory>

#include <optional>

#include <string>

#include <tuple>

#include <type_traits>

#include <utility>

#include <vector>

using namespace clang;

using namespace options;

using namespace llvm::opt;

//===----------------------------------------------------------------------===//

// Helpers.

//===----------------------------------------------------------------------===//

// Parse misexpect tolerance argument value.

// Valid option values are integers in the range [0, 100)

static Expected<std::optional<uint32_t>> parseToleranceOption(StringRef Arg) {

uint32_t Val;

if (Arg.getAsInteger(10, Val))

return llvm::createStringError(llvm::inconvertibleErrorCode(),

"Not an integer: %s", Arg.data());

return Val;

}

//===----------------------------------------------------------------------===//

// Initialization.

//===----------------------------------------------------------------------===//

template <class T> std::shared_ptr<T> make_shared_copy(const T &X) {

return std::make_shared<T>(X);

}

CompilerInvocationBase::CompilerInvocationBase()

: LangOpts(std::make_shared<LangOptions>()),

TargetOpts(std::make_shared<TargetOptions>()),

DiagnosticOpts(std::make_shared<DiagnosticOptions>()),

HSOpts(std::make_shared<HeaderSearchOptions>()),

PPOpts(std::make_shared<PreprocessorOptions>()),

AnalyzerOpts(std::make_shared<AnalyzerOptions>()),

MigratorOpts(std::make_shared<MigratorOptions>()),

APINotesOpts(std::make_shared<APINotesOptions>()),

CodeGenOpts(std::make_shared<CodeGenOptions>()),

FSOpts(std::make_shared<FileSystemOptions>()),

FrontendOpts(std::make_shared<FrontendOptions>()),

DependencyOutputOpts(std::make_shared<DependencyOutputOptions>()),

PreprocessorOutputOpts(std::make_shared<PreprocessorOutputOptions>()) {}

CompilerInvocationBase &

CompilerInvocationBase::deep_copy_assign(const CompilerInvocationBase &X) {

if (this != &X) {

LangOpts = make_shared_copy(X.getLangOpts());

TargetOpts = make_shared_copy(X.getTargetOpts());

DiagnosticOpts = make_shared_copy(X.getDiagnosticOpts());

HSOpts = make_shared_copy(X.getHeaderSearchOpts());

PPOpts = make_shared_copy(X.getPreprocessorOpts());

AnalyzerOpts = make_shared_copy(X.getAnalyzerOpts());

MigratorOpts = make_shared_copy(X.getMigratorOpts());

APINotesOpts = make_shared_copy(X.getAPINotesOpts());

CodeGenOpts = make_shared_copy(X.getCodeGenOpts());

FSOpts = make_shared_copy(X.getFileSystemOpts());

FrontendOpts = make_shared_copy(X.getFrontendOpts());

DependencyOutputOpts = make_shared_copy(X.getDependencyOutputOpts());

PreprocessorOutputOpts = make_shared_copy(X.getPreprocessorOutputOpts());

}

return *this;

}

CompilerInvocationBase &

CompilerInvocationBase::shallow_copy_assign(const CompilerInvocationBase &X) {

if (this != &X) {

LangOpts = X.LangOpts;

TargetOpts = X.TargetOpts;

DiagnosticOpts = X.DiagnosticOpts;

HSOpts = X.HSOpts;

PPOpts = X.PPOpts;

AnalyzerOpts = X.AnalyzerOpts;

MigratorOpts = X.MigratorOpts;

APINotesOpts = X.APINotesOpts;

CodeGenOpts = X.CodeGenOpts;

FSOpts = X.FSOpts;

FrontendOpts = X.FrontendOpts;

DependencyOutputOpts = X.DependencyOutputOpts;

PreprocessorOutputOpts = X.PreprocessorOutputOpts;

}

return *this;

}

CompilerInvocation::CompilerInvocation(const CowCompilerInvocation &X)

: CompilerInvocationBase(EmptyConstructor{}) {

CompilerInvocationBase::deep_copy_assign(X);

}

CompilerInvocation &

CompilerInvocation::operator=(const CowCompilerInvocation &X) {

CompilerInvocationBase::deep_copy_assign(X);

return *this;

}

template <typename T>

T &ensureOwned(std::shared_ptr<T> &Storage) {

if (Storage.use_count() > 1)

Storage = std::make_shared<T>(*Storage);

return *Storage;

}

LangOptions &CowCompilerInvocation::getMutLangOpts() {

return ensureOwned(LangOpts);

}

TargetOptions &CowCompilerInvocation::getMutTargetOpts() {

return ensureOwned(TargetOpts);

}

DiagnosticOptions &CowCompilerInvocation::getMutDiagnosticOpts() {

return ensureOwned(DiagnosticOpts);

}

HeaderSearchOptions &CowCompilerInvocation::getMutHeaderSearchOpts() {

return ensureOwned(HSOpts);

}

PreprocessorOptions &CowCompilerInvocation::getMutPreprocessorOpts() {

return ensureOwned(PPOpts);

}

AnalyzerOptions &CowCompilerInvocation::getMutAnalyzerOpts() {

return ensureOwned(AnalyzerOpts);

}

MigratorOptions &CowCompilerInvocation::getMutMigratorOpts() {

return ensureOwned(MigratorOpts);

}

APINotesOptions &CowCompilerInvocation::getMutAPINotesOpts() {

return ensureOwned(APINotesOpts);

}

CodeGenOptions &CowCompilerInvocation::getMutCodeGenOpts() {

return ensureOwned(CodeGenOpts);

}

FileSystemOptions &CowCompilerInvocation::getMutFileSystemOpts() {

return ensureOwned(FSOpts);

}

FrontendOptions &CowCompilerInvocation::getMutFrontendOpts() {

return ensureOwned(FrontendOpts);

}

DependencyOutputOptions &CowCompilerInvocation::getMutDependencyOutputOpts() {

return ensureOwned(DependencyOutputOpts);

}

PreprocessorOutputOptions &

CowCompilerInvocation::getMutPreprocessorOutputOpts() {

return ensureOwned(PreprocessorOutputOpts);

}

//===----------------------------------------------------------------------===//

// Normalizers

//===----------------------------------------------------------------------===//

using ArgumentConsumer = CompilerInvocation::ArgumentConsumer;

#define OPTTABLE_STR_TABLE_CODE

#include "clang/Options/Options.inc"

#undef OPTTABLE_STR_TABLE_CODE

static llvm::StringRef lookupStrInTable(unsigned Offset) {

return OptionStrTable[Offset];

}

#define SIMPLE_ENUM_VALUE_TABLE

#include "clang/Options/Options.inc"

#undef SIMPLE_ENUM_VALUE_TABLE

static std::optional<bool> normalizeSimpleFlag(OptSpecifier Opt,

unsigned TableIndex,

const ArgList &Args,

DiagnosticsEngine &Diags) {

if (Args.hasArg(Opt))

return true;

return std::nullopt;

}

static std::optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt,

unsigned,

const ArgList &Args,

DiagnosticsEngine &) {

if (Args.hasArg(Opt))

return false;

return std::nullopt;

}

/// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but

/// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with

/// unnecessary template instantiations and just ignore it with a variadic

/// argument.

static void denormalizeSimpleFlag(ArgumentConsumer Consumer,

unsigned SpellingOffset, Option::OptionClass,

unsigned, /*T*/...) {

Consumer(lookupStrInTable(SpellingOffset));

}

static void denormalizeSimpleFlag(ArgumentConsumer Consumer,

const Twine &Spelling, Option::OptionClass,

unsigned, /*T*/...) {

Consumer(Spelling);

}

template <typename T> static constexpr bool is_uint64_t_convertible() {

return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;

}

template <typename T,

std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>

static auto makeFlagToValueNormalizer(T Value) {

return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,

DiagnosticsEngine &) -> std::optional<T> {

if (Args.hasArg(Opt))

return Value;

return std::nullopt;

};

}

template <typename T,

std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>

static auto makeFlagToValueNormalizer(T Value) {

return makeFlagToValueNormalizer(uint64_t(Value));

}

static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,

OptSpecifier OtherOpt) {

return [Value, OtherValue,

OtherOpt](OptSpecifier Opt, unsigned, const ArgList &Args,

DiagnosticsEngine &) -> std::optional<bool> {

if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {

return A->getOption().matches(Opt) ? Value : OtherValue;

}

return std::nullopt;

};

}

static auto makeBooleanOptionDenormalizer(bool Value) {

return [Value](ArgumentConsumer Consumer, unsigned SpellingOffset,

Option::OptionClass, unsigned, bool KeyPath) {

if (KeyPath == Value)

Consumer(lookupStrInTable(SpellingOffset));

};

}

static void denormalizeStringImpl(ArgumentConsumer Consumer,

const Twine &Spelling,

Option::OptionClass OptClass, unsigned,

const Twine &Value) {

switch (OptClass) {

case Option::SeparateClass:

case Option::JoinedOrSeparateClass:

case Option::JoinedAndSeparateClass:

Consumer(Spelling);

Consumer(Value);

break;

case Option::JoinedClass:

case Option::CommaJoinedClass:

Consumer(Spelling + Value);

break;

default:

llvm_unreachable("Cannot denormalize an option with option class "

"incompatible with string denormalization.");

}

}

template <typename T>

static void

denormalizeString(ArgumentConsumer Consumer, unsigned SpellingOffset,

Option::OptionClass OptClass, unsigned TableIndex, T Value) {

denormalizeStringImpl(Consumer, lookupStrInTable(SpellingOffset), OptClass,

TableIndex, Twine(Value));

}

template <typename T>

static void denormalizeString(ArgumentConsumer Consumer, const Twine &Spelling,

Option::OptionClass OptClass, unsigned TableIndex,

T Value) {

denormalizeStringImpl(Consumer, Spelling, OptClass, TableIndex, Twine(Value));

}

static std::optional<SimpleEnumValue>

findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) {

for (int I = 0, E = Table.Size; I != E; ++I)

if (Name == Table.Table[I].Name)

return Table.Table[I];

return std::nullopt;

}

static std::optional<SimpleEnumValue>

findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) {

for (int I = 0, E = Table.Size; I != E; ++I)

if (Value == Table.Table[I].Value)

return Table.Table[I];

return std::nullopt;

}

static std::optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,

unsigned TableIndex,

const ArgList &Args,

DiagnosticsEngine &Diags) {

assert(TableIndex < SimpleEnumValueTablesSize);

const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];

auto *Arg = Args.getLastArg(Opt);

if (!Arg)

return std::nullopt;

StringRef ArgValue = Arg->getValue();

if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue))

return MaybeEnumVal->Value;

Diags.Report(diag::err_drv_invalid_value)

<< Arg->getAsString(Args) << ArgValue;

return std::nullopt;

}

static void denormalizeSimpleEnumImpl(ArgumentConsumer Consumer,

unsigned SpellingOffset,

Option::OptionClass OptClass,

unsigned TableIndex, unsigned Value) {

assert(TableIndex < SimpleEnumValueTablesSize);

const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];

if (auto MaybeEnumVal = findValueTableByValue(Table, Value)) {

denormalizeString(Consumer, lookupStrInTable(SpellingOffset), OptClass,

TableIndex, MaybeEnumVal->Name);

} else {

llvm_unreachable("The simple enum value was not correctly defined in "

"the tablegen option description");

}

}

template <typename T>

static void denormalizeSimpleEnum(ArgumentConsumer Consumer,

unsigned SpellingOffset,

Option::OptionClass OptClass,

unsigned TableIndex, T Value) {

return denormalizeSimpleEnumImpl(Consumer, SpellingOffset, OptClass,

TableIndex, static_cast<unsigned>(Value));

}

static std::optional<std::string> normalizeString(OptSpecifier Opt,

int TableIndex,

const ArgList &Args,

DiagnosticsEngine &Diags) {

auto *Arg = Args.getLastArg(Opt);

if (!Arg)

return std::nullopt;

return std::string(Arg->getValue());

}

template <typename IntTy>

static std::optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int,

const ArgList &Args,

DiagnosticsEngine &Diags) {

auto *Arg = Args.getLastArg(Opt);

if (!Arg)

return std::nullopt;

IntTy Res;

if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {

Diags.Report(diag::err_drv_invalid_int_value)

<< Arg->getAsString(Args) << Arg->getValue();

return std::nullopt;

}

return Res;

}

static std::optional<std::vector<std::string>>

normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args,

DiagnosticsEngine &) {

return Args.getAllArgValues(Opt);

}

static void denormalizeStringVector(ArgumentConsumer Consumer,

unsigned SpellingOffset,

Option::OptionClass OptClass,

unsigned TableIndex,

const std::vector<std::string> &Values) {

switch (OptClass) {

case Option::CommaJoinedClass: {

std::string CommaJoinedValue;

if (!Values.empty()) {

CommaJoinedValue.append(Values.front());

for (const std::string &Value : llvm::drop_begin(Values, 1)) {

CommaJoinedValue.append(",");

CommaJoinedValue.append(Value);

}

}

denormalizeString(Consumer, SpellingOffset,

Option::OptionClass::JoinedClass, TableIndex,

CommaJoinedValue);

break;

}

case Option::JoinedClass:

case Option::SeparateClass:

case Option::JoinedOrSeparateClass:

for (const std::string &Value : Values)

denormalizeString(Consumer, SpellingOffset, OptClass, TableIndex, Value);

break;

default:

llvm_unreachable("Cannot denormalize an option with option class "

"incompatible with string vector denormalization.");

}

}

static std::optional<std::string> normalizeTriple(OptSpecifier Opt,

int TableIndex,

const ArgList &Args,

DiagnosticsEngine &Diags) {

auto *Arg = Args.getLastArg(Opt);

if (!Arg)

return std::nullopt;

return llvm::Triple::normalize(Arg->getValue());

}

template <typename T, typename U>

static T mergeForwardValue(T KeyPath, U Value) {

return static_cast<T>(Value);

}

template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {

return KeyPath | Value;

}

template <typename T> static T extractForwardValue(T KeyPath) {

return KeyPath;

}

template <typename T, typename U, U Value>

static T extractMaskValue(T KeyPath) {

return ((KeyPath & Value) == Value) ? static_cast<T>(Value) : T();

}

#define PARSE_OPTION_WITH_MARSHALLING( \

ARGS, DIAGS, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, \

ALIASARGS, FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, \

METAVAR, VALUES, SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \

DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \

MERGER, EXTRACTOR, TABLE_INDEX) \

if ((VISIBILITY) & options::CC1Option) { \

KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \

if (IMPLIED_CHECK) \

KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \

if (SHOULD_PARSE) \

if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \

KEYPATH = \

MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \

}

// Capture the extracted value as a lambda argument to avoid potential issues

// with lifetime extension of the reference.

#define GENERATE_OPTION_WITH_MARSHALLING( \

CONSUMER, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, ALIASARGS, \

FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \

SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \

IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \

TABLE_INDEX) \

if ((VISIBILITY) & options::CC1Option) { \

[&](const auto &Extracted) { \

if (ALWAYS_EMIT || \

(Extracted != \

static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \

: (DEFAULT_VALUE)))) \

DENORMALIZER(CONSUMER, SPELLING_OFFSET, Option::KIND##Class, \

TABLE_INDEX, Extracted); \

}(EXTRACTOR(KEYPATH)); \

}

static StringRef GetInputKindName(InputKind IK);

static bool FixupInvocation(CompilerInvocation &Invocation,

DiagnosticsEngine &Diags, const ArgList &Args,

InputKind IK) {

unsigned NumErrorsBefore = Diags.getNumErrors();

LangOptions &LangOpts = Invocation.getLangOpts();

CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts();

TargetOptions &TargetOpts = Invocation.getTargetOpts();

FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();

CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;

CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;

CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;

CodeGenOpts.DisableFree = FrontendOpts.DisableFree;

FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex;

if (FrontendOpts.ShowStats)

CodeGenOpts.ClearASTBeforeBackend = false;

LangOpts.SanitizeCoverage = CodeGenOpts.hasSanitizeCoverage();

LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;

LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;

LangOpts.CurrentModule = LangOpts.ModuleName;

llvm::Triple T(TargetOpts.Triple);

llvm::Triple::ArchType Arch = T.getArch();

CodeGenOpts.CodeModel = TargetOpts.CodeModel;

CodeGenOpts.LargeDataThreshold = TargetOpts.LargeDataThreshold;

if (CodeGenOpts.getExceptionHandling() !=

CodeGenOptions::ExceptionHandlingKind::None &&

T.isWindowsMSVCEnvironment())

Diags.Report(diag::err_fe_invalid_exception_model)

<< static_cast<unsigned>(CodeGenOpts.getExceptionHandling()) << T.str();

if (LangOpts.AppleKext && !LangOpts.CPlusPlus)

Diags.Report(diag::warn_c_kext);

if (LangOpts.NewAlignOverride &&

!llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {

Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);

Diags.Report(diag::err_fe_invalid_alignment)

<< A->getAsString(Args) << A->getValue();

LangOpts.NewAlignOverride = 0;

}

// The -f[no-]raw-string-literals option is only valid in C and in C++

// standards before C++11.

if (LangOpts.CPlusPlus11) {

if (Args.hasArg(OPT_fraw_string_literals, OPT_fno_raw_string_literals)) {

Args.claimAllArgs(OPT_fraw_string_literals, OPT_fno_raw_string_literals);

Diags.Report(diag::warn_drv_fraw_string_literals_in_cxx11)

<< bool(LangOpts.RawStringLiterals);

}

// Do not allow disabling raw string literals in C++11 or later.

LangOpts.RawStringLiterals = true;

}

if (Args.hasArg(OPT_freflection) && !LangOpts.CPlusPlus26) {

Diags.Report(diag::err_drv_reflection_requires_cxx26)

<< Args.getLastArg(options::OPT_freflection)->getAsString(Args);

}

LangOpts.NamedLoops =

Args.hasFlag(OPT_fnamed_loops, OPT_fno_named_loops, LangOpts.C2y);

// Prevent the user from specifying both -fsycl-is-device and -fsycl-is-host.

if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)

Diags.Report(diag::err_drv_argument_not_allowed_with) << "-fsycl-is-device"

<< "-fsycl-is-host";

if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)

Diags.Report(diag::err_drv_argument_not_allowed_with)

<< "-fgnu89-inline" << GetInputKindName(IK);

if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)

Diags.Report(diag::err_drv_argument_not_allowed_with)

<< "-hlsl-entry" << GetInputKindName(IK);

if (Args.hasArg(OPT_fdx_rootsignature_version) && !LangOpts.HLSL)

Diags.Report(diag::err_drv_argument_not_allowed_with)

<< "-fdx-rootsignature-version" << GetInputKindName(IK);

if (Args.hasArg(OPT_fdx_rootsignature_define) && !LangOpts.HLSL)

Diags.Report(diag::err_drv_argument_not_allowed_with)

<< "-fdx-rootsignature-define" << GetInputKindName(IK);

if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)

Diags.Report(diag::warn_ignored_hip_only_option)

<< Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);

if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)

Diags.Report(diag::warn_ignored_hip_only_option)

<< Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);

// HLSL invocations should always have -Wconversion, -Wvector-conversion, and

// -Wmatrix-conversion by default.

if (LangOpts.HLSL) {

auto &Warnings = Invocation.getDiagnosticOpts().Warnings;

if (!llvm::is_contained(Warnings, "conversion"))

Warnings.insert(Warnings.begin(), "conversion");

if (!llvm::is_contained(Warnings, "vector-conversion"))

Warnings.insert(Warnings.begin(), "vector-conversion");

if (!llvm::is_contained(Warnings, "matrix-conversion"))

Warnings.insert(Warnings.begin(), "matrix-conversion");

}

// When these options are used, the compiler is allowed to apply

// optimizations that may affect the final result. For example

// (x+y)+z is transformed to x+(y+z) but may not give the same

// final result; it's not value safe.

// Another example can be to simplify x/x to 1.0 but x could be 0.0, INF

// or NaN. Final result may then differ. An error is issued when the eval

// method is set with one of these options.

if (Args.hasArg(OPT_ffp_eval_method_EQ)) {

if (LangOpts.ApproxFunc)

Diags.Report(diag::err_incompatible_fp_eval_method_options) << 0;

if (LangOpts.AllowFPReassoc)

Diags.Report(diag::err_incompatible_fp_eval_method_options) << 1;

if (LangOpts.AllowRecip)

Diags.Report(diag::err_incompatible_fp_eval_method_options) << 2;

}

// -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.

// This option should be deprecated for CL > 1.0 because

// this option was added for compatibility with OpenCL 1.0.

if (Args.getLastArg(OPT_cl_strict_aliasing) &&

(LangOpts.getOpenCLCompatibleVersion() > 100))

Diags.Report(diag::warn_option_invalid_ocl_version)

<< LangOpts.getOpenCLVersionString()

<< Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);

if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {

auto DefaultCC = LangOpts.getDefaultCallingConv();

bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||

DefaultCC == LangOptions::DCC_StdCall) &&

Arch != llvm::Triple::x86;

emitError |= (DefaultCC == LangOptions::DCC_VectorCall ||

DefaultCC == LangOptions::DCC_RegCall) &&

!T.isX86();

emitError |= DefaultCC == LangOptions::DCC_RtdCall && Arch != llvm::Triple::m68k;

if (emitError)

Diags.Report(diag::err_drv_argument_not_allowed_with)

<< A->getSpelling() << T.getTriple();

}

return Diags.getNumErrors() == NumErrorsBefore;

}

//===----------------------------------------------------------------------===//

// Deserialization (from args)

//===----------------------------------------------------------------------===//

static void GenerateArg(ArgumentConsumer Consumer,

llvm::opt::OptSpecifier OptSpecifier) {

Option Opt = getDriverOptTable().getOption(OptSpecifier);

denormalizeSimpleFlag(Consumer, Opt.getPrefixedName(),

Option::OptionClass::FlagClass, 0);

}

static void GenerateArg(ArgumentConsumer Consumer,

llvm::opt::OptSpecifier OptSpecifier,

const Twine &Value) {

Option Opt = getDriverOptTable().getOption(OptSpecifier);

denormalizeString(Consumer, Opt.getPrefixedName(), Opt.getKind(), 0, Value);

}

// Parse command line arguments into CompilerInvocation.

using ParseFn =

llvm::function_ref<bool(CompilerInvocation &, ArrayRef<const char *>,

DiagnosticsEngine &, const char *)>;

// Generate command line arguments from CompilerInvocation.

using GenerateFn = llvm::function_ref<void(

CompilerInvocation &, SmallVectorImpl<const char *> &,

CompilerInvocation::StringAllocator)>;

/// May perform round-trip of command line arguments. By default, the round-trip

/// is enabled in assert builds. This can be overwritten at run-time via the

/// "-round-trip-args" and "-no-round-trip-args" command line flags, or via the

/// ForceRoundTrip parameter.

///

/// During round-trip, the command line arguments are parsed into a dummy

/// CompilerInvocation, which is used to generate the command line arguments

/// again. The real CompilerInvocation is then created by parsing the generated

/// arguments, not the original ones. This (in combination with tests covering

/// argument behavior) ensures the generated command line is complete (doesn't

/// drop/mangle any arguments).

///

/// Finally, we check the command line that was used to create the real

/// CompilerInvocation instance. By default, we compare it to the command line

/// the real CompilerInvocation generates. This checks whether the generator is

/// deterministic. If \p CheckAgainstOriginalInvocation is enabled, we instead

/// compare it to the original command line to verify the original command-line

/// was canonical and can round-trip exactly.

static bool RoundTrip(ParseFn Parse, GenerateFn Generate,

CompilerInvocation &RealInvocation,

CompilerInvocation &DummyInvocation,

ArrayRef<const char *> CommandLineArgs,

DiagnosticsEngine &Diags, const char *Argv0,

bool CheckAgainstOriginalInvocation = false,

bool ForceRoundTrip = false) {

#ifndef NDEBUG

bool DoRoundTripDefault = true;

#else

bool DoRoundTripDefault = false;

#endif

bool DoRoundTrip = DoRoundTripDefault;

if (ForceRoundTrip) {

DoRoundTrip = true;

} else {

for (const auto *Arg : CommandLineArgs) {

if (Arg == StringRef("-round-trip-args"))

DoRoundTrip = true;

if (Arg == StringRef("-no-round-trip-args"))

DoRoundTrip = false;

}

}

// If round-trip was not requested, simply run the parser with the real

// invocation diagnostics.

if (!DoRoundTrip)

return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);

// Serializes quoted (and potentially escaped) arguments.

auto SerializeArgs = [](ArrayRef<const char *> Args) {

std::string Buffer;

llvm::raw_string_ostream OS(Buffer);

for (const char *Arg : Args) {

llvm::sys::printArg(OS, Arg, /*Quote=*/true);

OS << ' ';

}

return Buffer;

};

// Setup a dummy DiagnosticsEngine.

DiagnosticOptions DummyDiagOpts;

DiagnosticsEngine DummyDiags(DiagnosticIDs::create(), DummyDiagOpts);

DummyDiags.setClient(new TextDiagnosticBuffer());

// Run the first parse on the original arguments with the dummy invocation and

// diagnostics.

if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||

DummyDiags.getNumWarnings() != 0) {

// If the first parse did not succeed, it must be user mistake (invalid

// command line arguments). We won't be able to generate arguments that

// would reproduce the same result. Let's fail again with the real

// invocation and diagnostics, so all side-effects of parsing are visible.

unsigned NumWarningsBefore = Diags.getNumWarnings();

auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);

if (!Success || Diags.getNumWarnings() != NumWarningsBefore)

return Success;

// Parse with original options and diagnostics succeeded even though it

// shouldn't have. Something is off.

Diags.Report(diag::err_cc1_round_trip_fail_then_ok);

Diags.Report(diag::note_cc1_round_trip_original)

<< SerializeArgs(CommandLineArgs);

return false;

}

// Setup string allocator.

llvm::BumpPtrAllocator Alloc;

llvm::StringSaver StringPool(Alloc);

auto SA = [&StringPool](const Twine &Arg) {

return StringPool.save(Arg).data();

};

// Generate arguments from the dummy invocation. If Generate is the

// inverse of Parse, the newly generated arguments must have the same

// semantics as the original.

SmallVector<const char *> GeneratedArgs;

Generate(DummyInvocation, GeneratedArgs, SA);

// Run the second parse, now on the generated arguments, and with the real

// invocation and diagnostics. The result is what we will end up using for the

// rest of compilation, so if Generate is not inverse of Parse, something down

// the line will break.

bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);

// The first parse on original arguments succeeded, but second parse of

// generated arguments failed. Something must be wrong with the generator.

if (!Success2) {

Diags.Report(diag::err_cc1_round_trip_ok_then_fail);

Diags.Report(diag::note_cc1_round_trip_generated)

<< 1 << SerializeArgs(GeneratedArgs);

return false;

}

SmallVector<const char *> ComparisonArgs;

if (CheckAgainstOriginalInvocation)

// Compare against original arguments.

ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());

else

// Generate arguments again, this time from the options we will end up using

// for the rest of the compilation.

Generate(RealInvocation, ComparisonArgs, SA);

// Compares two lists of arguments.

auto Equal = [](const ArrayRef<const char *> A,

const ArrayRef<const char *> B) {

return llvm::equal(A, B, [](const char *AElem, const char *BElem) {

return StringRef(AElem) == StringRef(BElem);

});

};

// If we generated different arguments from what we assume are two

// semantically equivalent CompilerInvocations, the Generate function may

// be non-deterministic.

if (!Equal(GeneratedArgs, ComparisonArgs)) {

Diags.Report(diag::err_cc1_round_trip_mismatch);

Diags.Report(diag::note_cc1_round_trip_generated)

<< 1 << SerializeArgs(GeneratedArgs);

Diags.Report(diag::note_cc1_round_trip_generated)

<< 2 << SerializeArgs(ComparisonArgs);

return false;

}

Diags.Report(diag::remark_cc1_round_trip_generated)

<< 1 << SerializeArgs(GeneratedArgs);

Diags.Report(diag::remark_cc1_round_trip_generated)

<< 2 << SerializeArgs(ComparisonArgs);

return Success2;

}

bool CompilerInvocation::checkCC1RoundTrip(ArrayRef<const char *> Args,

DiagnosticsEngine &Diags,

const char *Argv0) {

CompilerInvocation DummyInvocation1, DummyInvocation2;

return RoundTrip(

[](CompilerInvocation &Invocation, ArrayRef<const char *> CommandLineArgs,

DiagnosticsEngine &Diags, const char *Argv0) {

return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);

},

[](CompilerInvocation &Invocation, SmallVectorImpl<const char *> &Args,

StringAllocator SA) {

Args.push_back("-cc1");

Invocation.generateCC1CommandLine(Args, SA);

},

DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,

/*CheckAgainstOriginalInvocation=*/true, /*ForceRoundTrip=*/true);

}

static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,

OptSpecifier GroupWithValue,

std::vector<std::string> &Diagnostics) {

for (auto *A : Args.filtered(Group)) {

if (A->getOption().getKind() == Option::FlagClass) {

// The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add

// its name (minus the "W" or "R" at the beginning) to the diagnostics.

Diagnostics.push_back(

std::string(A->getOption().getName().drop_front(1)));

} else if (A->getOption().matches(GroupWithValue)) {

// This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic

// group. Add only the group name to the diagnostics.

Diagnostics.push_back(

std::string(A->getOption().getName().drop_front(1).rtrim("=-")));

} else {

// Otherwise, add its value (for OPT_W_Joined and similar).

Diagnostics.push_back(A->getValue());

}

}

}

// Parse the Static Analyzer configuration. If \p Diags is set to nullptr,

// it won't verify the input.

static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts,

DiagnosticsEngine *Diags);

static void getAllNoBuiltinFuncValues(ArgList &Args,

std::vector<std::string> &Funcs) {

std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);

auto BuiltinEnd = llvm::partition(Values, Builtin::Context::isBuiltinFunc);

Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);

}

static void GenerateAnalyzerArgs(const AnalyzerOptions &Opts,

ArgumentConsumer Consumer) {

const AnalyzerOptions *AnalyzerOpts = &Opts;

#define ANALYZER_OPTION_WITH_MARSHALLING(...) \

GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)

#include "clang/Options/Options.inc"

#undef ANALYZER_OPTION_WITH_MARSHALLING

if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) {

switch (Opts.AnalysisConstraintsOpt) {

#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \

case NAME##Model: \

GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \

break;

#include "clang/StaticAnalyzer/Core/Analyses.def"

default:

llvm_unreachable("Tried to generate unknown analysis constraint.");

}

}

if (Opts.AnalysisDiagOpt != PD_HTML) {

switch (Opts.AnalysisDiagOpt) {

#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \

case PD_##NAME: \

GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \

break;

#include "clang/StaticAnalyzer/Core/Analyses.def"

default:

llvm_unreachable("Tried to generate unknown analysis diagnostic client.");

}

}

if (Opts.AnalysisPurgeOpt != PurgeStmt) {

switch (Opts.AnalysisPurgeOpt) {

#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \

case NAME: \

GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \

break;

#include "clang/StaticAnalyzer/Core/Analyses.def"

default:

llvm_unreachable("Tried to generate unknown analysis purge mode.");

}

}

if (Opts.InliningMode != NoRedundancy) {

switch (Opts.InliningMode) {

#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \

case NAME: \

GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \

break;

#include "clang/StaticAnalyzer/Core/Analyses.def"

default:

llvm_unreachable("Tried to generate unknown analysis inlining mode.");

}