This is an archive of the discontinued LLVM Phabricator instance.

Differential D93700

[clang][cli] Report the actual argument parsing result
ClosedPublic

Authored by jansvoboda11 on Dec 22 2020, 6:47 AM.

Details

Reviewers
dexonsmith
Bigcheese
Commits
rG33f90f38e11c: [clang][cli] Report the actual argument parsing result

Diff Detail

Event Timeline

jansvoboda11 requested review of this revision.Dec 22 2020, 6:47 AM
jansvoboda11 created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptDec 22 2020, 6:47 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
Harbormaster completed remote builds in B83265: Diff 313327.Dec 22 2020, 6:54 AM
jansvoboda11 added a child revision: D84673: [clang][cli] Port DiagnosticOpts to new option parsing system.Dec 22 2020, 7:25 AM
Bigcheese accepted this revision.Jan 5 2021, 8:40 AM

LGTM

This revision is now accepted and ready to land.Jan 5 2021, 8:40 AM
This revision was landed with ongoing or failed builds.Jan 7 2021, 3:37 AM
Closed by commit rG33f90f38e11c: [clang][cli] Report the actual argument parsing result (authored by jansvoboda11). · Explain Why
This revision was automatically updated to reflect the committed changes.
jansvoboda11 added a commit: rG33f90f38e11c: [clang][cli] Report the actual argument parsing result.

Revision Contents

PathSize
clang/
lib/
Frontend/
47 lines
unittests/
Frontend/
139 lines

Diff 313327

clang/lib/Frontend/CompilerInvocation.cpp

//===- CompilerInvocation.cpp ---------------------------------------------===// //===- CompilerInvocation.cpp ---------------------------------------------===//
Lint: Lint
Inline Actions

clang-format not found in user's PATH; not linting file.

Lint: Lint: clang-format not found in user's PATH; not linting file.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Normalizers // Normalizers
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define SIMPLE_ENUM_VALUE_TABLE #define SIMPLE_ENUM_VALUE_TABLE
#include "clang/Driver/Options.inc" #include "clang/Driver/Options.inc"
#undef SIMPLE_ENUM_VALUE_TABLE #undef SIMPLE_ENUM_VALUE_TABLE
static llvm::Optional<bool> normalizeSimpleFlag(OptSpecifier Opt, static llvm::Optional<bool>
unsigned TableIndex, normalizeSimpleFlag(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args,
const ArgList &Args, DiagnosticsEngine &Diags, bool &Success) {
DiagnosticsEngine &Diags) {
if (Args.hasArg(Opt)) if (Args.hasArg(Opt))
return true; return true;
return None; return None;
} }
static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned,
const ArgList &Args, const ArgList &Args,
DiagnosticsEngine &) { DiagnosticsEngine &,
bool &Success) {
if (Args.hasArg(Opt)) if (Args.hasArg(Opt))
return false; return false;
return None; return None;
} }
/// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but /// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but
/// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with /// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with
/// unnecessary template instantiations and just ignore it with a variadic /// unnecessary template instantiations and just ignore it with a variadic
Show All 9 Linestemplate <typename T> static constexpr bool is_uint64_t_convertible() {
return !std::is_same<T, uint64_t>::value && return !std::is_same<T, uint64_t>::value &&
llvm::is_integral_or_enum<T>::value; llvm::is_integral_or_enum<T>::value;
} }
template <typename T, template <typename T,
std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false> std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
static auto makeFlagToValueNormalizer(T Value) { static auto makeFlagToValueNormalizer(T Value) {
return [Value](OptSpecifier Opt, unsigned, const ArgList &Args, return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
DiagnosticsEngine &) -> Optional<T> { DiagnosticsEngine &, bool &Success) -> Optional<T> {
if (Args.hasArg(Opt)) if (Args.hasArg(Opt))
return Value; return Value;
return None; return None;
}; };
} }
template <typename T, template <typename T,
std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false> std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>
static auto makeFlagToValueNormalizer(T Value) { static auto makeFlagToValueNormalizer(T Value) {
return makeFlagToValueNormalizer(uint64_t(Value)); return makeFlagToValueNormalizer(uint64_t(Value));
} }
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,
OptSpecifier OtherOpt) { OptSpecifier OtherOpt) {
return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned, return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned,
const ArgList &Args, const ArgList &Args, DiagnosticsEngine &,
DiagnosticsEngine &) -> Optional<bool> { bool &Success) -> Optional<bool> {
if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) { if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
return A->getOption().matches(Opt) ? Value : OtherValue; return A->getOption().matches(Opt) ? Value : OtherValue;
} }
return None; return None;
}; };
} }
static auto makeBooleanOptionDenormalizer(bool Value) { static auto makeBooleanOptionDenormalizer(bool Value) {
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) { findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) {
for (int I = 0, E = Table.Size; I != E; ++I) for (int I = 0, E = Table.Size; I != E; ++I)
if (Value == Table.Table[I].Value) if (Value == Table.Table[I].Value)
return Table.Table[I]; return Table.Table[I];
return None; return None;
} }
static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt, static llvm::Optional<unsigned>
unsigned TableIndex, normalizeSimpleEnum(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args,
const ArgList &Args, DiagnosticsEngine &Diags, bool &Success) {
DiagnosticsEngine &Diags) {
assert(TableIndex < SimpleEnumValueTablesSize); assert(TableIndex < SimpleEnumValueTablesSize);
const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex]; const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
auto *Arg = Args.getLastArg(Opt); auto *Arg = Args.getLastArg(Opt);
if (!Arg) if (!Arg)
return None; return None;
StringRef ArgValue = Arg->getValue(); StringRef ArgValue = Arg->getValue();
if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue)) if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue))
return MaybeEnumVal->Value; return MaybeEnumVal->Value;
Success = false;
Diags.Report(diag::err_drv_invalid_value) Diags.Report(diag::err_drv_invalid_value)
<< Arg->getAsString(Args) << ArgValue; << Arg->getAsString(Args) << ArgValue;
return None; return None;
} }
static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args, static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args,
const char *Spelling, const char *Spelling,
CompilerInvocation::StringAllocator SA, CompilerInvocation::StringAllocator SA,
Show All 17 Linesstatic void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args,
Option::OptionClass OptClass, Option::OptionClass OptClass,
unsigned TableIndex, T Value) { unsigned TableIndex, T Value) {
return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex, return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
static_cast<unsigned>(Value)); static_cast<unsigned>(Value));
} }
static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex, static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex,
const ArgList &Args, const ArgList &Args,
DiagnosticsEngine &Diags) { DiagnosticsEngine &Diags,
bool &Success) {
auto *Arg = Args.getLastArg(Opt); auto *Arg = Args.getLastArg(Opt);
if (!Arg) if (!Arg)
return None; return None;
return std::string(Arg->getValue()); return std::string(Arg->getValue());
} }
template <typename IntTy> template <typename IntTy>
static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int, static Optional<IntTy>
const ArgList &Args, normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args,
DiagnosticsEngine &Diags) { DiagnosticsEngine &Diags, bool &Success) {
auto *Arg = Args.getLastArg(Opt); auto *Arg = Args.getLastArg(Opt);
if (!Arg) if (!Arg)
return None; return None;
IntTy Res; IntTy Res;
if (StringRef(Arg->getValue()).getAsInteger(0, Res)) { if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
Success = false;
Diags.Report(diag::err_drv_invalid_int_value) Diags.Report(diag::err_drv_invalid_int_value)
<< Arg->getAsString(Args) << Arg->getValue(); << Arg->getAsString(Args) << Arg->getValue();
} }
return Res; return Res;
} }
static Optional<std::vector<std::string>> static Optional<std::vector<std::string>>
normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args,
DiagnosticsEngine &) { DiagnosticsEngine &, bool &Success) {
return Args.getAllArgValues(Opt); return Args.getAllArgValues(Opt);
} }
static void denormalizeStringVector(SmallVectorImpl<const char *> &Args, static void denormalizeStringVector(SmallVectorImpl<const char *> &Args,
const char *Spelling, const char *Spelling,
CompilerInvocation::StringAllocator SA, CompilerInvocation::StringAllocator SA,
Option::OptionClass OptClass, Option::OptionClass OptClass,
unsigned TableIndex, unsigned TableIndex,
Show All 19 Linesstatic void denormalizeStringVector(SmallVectorImpl<const char *> &Args,
default: default:
llvm_unreachable("Cannot denormalize an option with option class " llvm_unreachable("Cannot denormalize an option with option class "
"incompatible with string vector denormalization."); "incompatible with string vector denormalization.");
} }
} }
static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex, static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
const ArgList &Args, const ArgList &Args,
DiagnosticsEngine &Diags) { DiagnosticsEngine &Diags,
bool &Success) {
auto *Arg = Args.getLastArg(Opt); auto *Arg = Args.getLastArg(Opt);
if (!Arg) if (!Arg)
return None; return None;
return llvm::Triple::normalize(Arg->getValue()); return llvm::Triple::normalize(Arg->getValue());
} }
template <typename T, typename U> template <typename T, typename U>
static T mergeForwardValue(T KeyPath, U Value) { static T mergeForwardValue(T KeyPath, U Value) {
▲ Show 20 Lines • Show All 2,617 Lines • ▼ Show 20 Lines if (Version.tryParse(A->getValue()))
<< A->getAsString(Args) << A->getValue(); << A->getAsString(Args) << A->getValue();
else else
Opts.SDKVersion = Version; Opts.SDKVersion = Version;
} }
} }
bool CompilerInvocation::parseSimpleArgs(const ArgList &Args, bool CompilerInvocation::parseSimpleArgs(const ArgList &Args,
DiagnosticsEngine &Diags) { DiagnosticsEngine &Diags) {
bool Success = true;
#define OPTION_WITH_MARSHALLING( \ #define OPTION_WITH_MARSHALLING( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \ HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \ IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
TABLE_INDEX) \ TABLE_INDEX) \
if ((FLAGS)&options::CC1Option) { \ if ((FLAGS)&options::CC1Option) { \
this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE); \ this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE); \
if (IMPLIED_CHECK) \ if (IMPLIED_CHECK) \
this->KEYPATH = MERGER(this->KEYPATH, IMPLIED_VALUE); \ this->KEYPATH = MERGER(this->KEYPATH, IMPLIED_VALUE); \
if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, Args, Diags)) \ if (auto MaybeValue = \
NORMALIZER(OPT_##ID, TABLE_INDEX, Args, Diags, Success)) \
this->KEYPATH = MERGER( \ this->KEYPATH = MERGER( \
this->KEYPATH, static_cast<decltype(this->KEYPATH)>(*MaybeValue)); \ this->KEYPATH, static_cast<decltype(this->KEYPATH)>(*MaybeValue)); \
} }
#include "clang/Driver/Options.inc" #include "clang/Driver/Options.inc"
#undef OPTION_WITH_MARSHALLING #undef OPTION_WITH_MARSHALLING
return true;
return Success;
} }
bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
ArrayRef<const char *> CommandLineArgs, ArrayRef<const char *> CommandLineArgs,
DiagnosticsEngine &Diags, DiagnosticsEngine &Diags,
const char *Argv0) { const char *Argv0) {
bool Success = true; bool Success = true;
▲ Show 20 Lines • Show All 293 Lines • Show Last 20 Lines

clang/unittests/Frontend/CompilerInvocationTest.cpp

//===- unittests/Frontend/CompilerInvocationTest.cpp - CI tests //---------===// //===- unittests/Frontend/CompilerInvocationTest.cpp - CI tests //---------===//
Lint: Lint
Inline Actions

clang-format not found in user's PATH; not linting file.

Lint: Lint: clang-format not found in user's PATH; not linting file.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
} }
// Boolean option with a keypath that defaults to true. // Boolean option with a keypath that defaults to true.
// The only flag with a negative spelling can set the keypath to false. // The only flag with a negative spelling can set the keypath to false.
TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagNotPresent) { TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagNotPresent) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary); ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file"))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagPresent) { TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagPresent) {
const char *Args[] = {"-fno-temp-file"}; const char *Args[] = {"-fno-temp-file"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getFrontendOpts().UseTemporary); ASSERT_FALSE(Invocation.getFrontendOpts().UseTemporary);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file")));
} }
TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagUnknownPresent) { TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagUnknownPresent) {
const char *Args[] = {"-ftemp-file"}; const char *Args[] = {"-ftemp-file"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
// Driver-only flag. // Driver-only flag.
ASSERT_TRUE(Diags->hasErrorOccurred()); ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary); ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
} }
// Boolean option with a keypath that defaults to true. // Boolean option with a keypath that defaults to true.
// The flag with negative spelling can set the keypath to false. // The flag with negative spelling can set the keypath to false.
// The flag with positive spelling can reset the keypath to true. // The flag with positive spelling can reset the keypath to true.
TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNone) { TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNone) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink); ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-autolink")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-autolink"))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNegChange) { TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNegChange) {
const char *Args[] = {"-fno-autolink"}; const char *Args[] = {"-fno-autolink"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().Autolink); ASSERT_FALSE(Invocation.getCodeGenOpts().Autolink);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-autolink"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-autolink")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultTruePresentPosReset) { TEST_F(CommandLineTest, BoolOptionDefaultTruePresentPosReset) {
const char *Args[] = {"-fautolink"}; const char *Args[] = {"-fautolink"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); // Driver-only flag.
ASSERT_TRUE(Diags->hasErrorOccurred()); // Driver-only flag. ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink); ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);
} }
// Boolean option with a keypath that defaults to false. // Boolean option with a keypath that defaults to false.
// The flag with negative spelling can set the keypath to true. // The flag with negative spelling can set the keypath to true.
// The flag with positive spelling can reset the keypath to false. // The flag with positive spelling can reset the keypath to false.
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNone) { TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNone) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables); ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-inline-line-tables")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-inline-line-tables"))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegChange) { TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegChange) {
const char *Args[] = {"-gno-inline-line-tables"}; const char *Args[] = {"-gno-inline-line-tables"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().NoInlineLineTables); ASSERT_TRUE(Invocation.getCodeGenOpts().NoInlineLineTables);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gno-inline-line-tables"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gno-inline-line-tables")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosReset) { TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosReset) {
const char *Args[] = {"-ginline-line-tables"}; const char *Args[] = {"-ginline-line-tables"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); // Driver-only flag.
ASSERT_TRUE(Diags->hasErrorOccurred()); // Driver-only flag. ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables); ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
} }
// Boolean option with a keypath that defaults to false. // Boolean option with a keypath that defaults to false.
// The flag with positive spelling can set the keypath to true. // The flag with positive spelling can set the keypath to true.
// The flag with negative spelling can reset the keypath to false. // The flag with negative spelling can reset the keypath to false.
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNoneX) { TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNoneX) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash); ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gcodeview-ghash")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gcodeview-ghash"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosChange) { TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosChange) {
const char *Args[] = {"-gcodeview-ghash"}; const char *Args[] = {"-gcodeview-ghash"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().CodeViewGHash); ASSERT_TRUE(Invocation.getCodeGenOpts().CodeViewGHash);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gcodeview-ghash"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gcodeview-ghash")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegReset) { TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegReset) {
const char *Args[] = {"-gno-codeview-ghash"}; const char *Args[] = {"-gno-codeview-ghash"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); // Driver-only flag.
ASSERT_TRUE(Diags->hasErrorOccurred()); // Driver-only flag. ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash); ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
} }
// Boolean option with a keypath that defaults to an arbitrary expression. // Boolean option with a keypath that defaults to an arbitrary expression.
// The flag with positive spelling can set the keypath to true. // The flag with positive spelling can set the keypath to true.
// The flag with negative spelling can set the keypath to false. // The flag with negative spelling can set the keypath to false.
static constexpr unsigned PassManagerDefault = static constexpr unsigned PassManagerDefault =
!static_cast<unsigned>(LLVM_ENABLE_NEW_PASS_MANAGER); !static_cast<unsigned>(LLVM_ENABLE_NEW_PASS_MANAGER);
static constexpr const char *PassManagerResetByFlag = static constexpr const char *PassManagerResetByFlag =
LLVM_ENABLE_NEW_PASS_MANAGER ? "-fno-legacy-pass-manager" LLVM_ENABLE_NEW_PASS_MANAGER ? "-fno-legacy-pass-manager"
: "-flegacy-pass-manager"; : "-flegacy-pass-manager";
static constexpr const char *PassManagerChangedByFlag = static constexpr const char *PassManagerChangedByFlag =
LLVM_ENABLE_NEW_PASS_MANAGER ? "-flegacy-pass-manager" LLVM_ENABLE_NEW_PASS_MANAGER ? "-flegacy-pass-manager"
: "-fno-legacy-pass-manager"; : "-fno-legacy-pass-manager";
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentNone) { TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentNone) {
const char *Args = {""}; const char *Args = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault); ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag)))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag)))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentChange) { TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentChange) {
const char *Args[] = {PassManagerChangedByFlag}; const char *Args[] = {PassManagerChangedByFlag};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, !PassManagerDefault); ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, !PassManagerDefault);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq(PassManagerChangedByFlag))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(PassManagerChangedByFlag)));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag)))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
} }
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentReset) { TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentReset) {
const char *Args[] = {PassManagerResetByFlag}; const char *Args[] = {PassManagerResetByFlag};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault); ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag)))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag)))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
} }
// Boolean option that gets the CC1Option flag from a let statement (which // Boolean option that gets the CC1Option flag from a let statement (which
// is applied **after** the record is defined): // is applied **after** the record is defined):
// //
// let Flags = [CC1Option] in { // let Flags = [CC1Option] in {
// defm option : BoolOption<...>; // defm option : BoolOption<...>;
// } // }
TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNone) { TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNone) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager); ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
} }
TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentPos) { TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentPos) {
const char *Args[] = {"-fdebug-pass-manager"}; const char *Args[] = {"-fdebug-pass-manager"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().DebugPassManager); ASSERT_TRUE(Invocation.getCodeGenOpts().DebugPassManager);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fdebug-pass-manager"), 1)); ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fdebug-pass-manager"), 1));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
} }
TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNeg) { TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNeg) {
const char *Args[] = {"-fno-debug-pass-manager"}; const char *Args[] = {"-fno-debug-pass-manager"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager); ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) {
const char *Args[] = {"-fmodules-strict-context-hash"}; const char *Args[] = {"-fmodules-strict-context-hash"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash")));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) {
const char *TripleCStr = "i686-apple-darwin9"; const char *TripleCStr = "i686-apple-darwin9";
const char *Args[] = {"-triple", TripleCStr}; const char *Args[] = {"-triple", TripleCStr};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr)));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredPresent) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredPresent) {
const std::string DefaultTriple = const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()); llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {"-triple", DefaultTriple.c_str()}; const char *Args[] = {"-triple", DefaultTriple.c_str()};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Triple should always be emitted even if it is the default // Triple should always be emitted even if it is the default
ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str()))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) {
const std::string DefaultTriple = const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()); llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Triple should always be emitted even if it is the default // Triple should always be emitted even if it is the default
ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str()))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
} }
TEST_F(CommandLineTest, SeparateEnumNonDefault) { TEST_F(CommandLineTest, SeparateEnumNonDefault) {
const char *Args[] = {"-mrelocation-model", "static"}; const char *Args[] = {"-mrelocation-model", "static"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::Static); ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::Static);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Non default relocation model. // Non default relocation model.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-mrelocation-model"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-mrelocation-model")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("static"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("static")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=static")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=static"))));
} }
TEST_F(CommandLineTest, SeparateEnumDefault) { TEST_F(CommandLineTest, SeparateEnumDefault) {
const char *Args[] = {"-mrelocation-model", "pic"}; const char *Args[] = {"-mrelocation-model", "pic"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::PIC_); ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::PIC_);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Default relocation model. // Default relocation model.
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("pic")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("pic"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=pic")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=pic"))));
} }
TEST_F(CommandLineTest, JoinedEnumNonDefault) { TEST_F(CommandLineTest, JoinedEnumNonDefault) {
const char *Args[] = {"-fobjc-dispatch-method=non-legacy"}; const char *Args[] = {"-fobjc-dispatch-method=non-legacy"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(), ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
CodeGenOptions::NonLegacy); CodeGenOptions::NonLegacy);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
Contains(StrEq("-fobjc-dispatch-method=non-legacy"))); Contains(StrEq("-fobjc-dispatch-method=non-legacy")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method=")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("non-legacy")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("non-legacy"))));
} }
TEST_F(CommandLineTest, JoinedEnumDefault) { TEST_F(CommandLineTest, JoinedEnumDefault) {
const char *Args[] = {"-fobjc-dispatch-method=legacy"}; const char *Args[] = {"-fobjc-dispatch-method=legacy"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(), ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
CodeGenOptions::Legacy); CodeGenOptions::Legacy);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-fobjc-dispatch-method=legacy")))); Not(Contains(StrEq("-fobjc-dispatch-method=legacy"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method=")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("legacy")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("legacy"))));
} }
TEST_F(CommandLineTest, StringVectorEmpty) { TEST_F(CommandLineTest, StringVectorEmpty) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles.empty()); ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles.empty());
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-fmodule-map-file")))); ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-fmodule-map-file"))));
} }
TEST_F(CommandLineTest, StringVectorSingle) { TEST_F(CommandLineTest, StringVectorSingle) {
const char *Args[] = {"-fmodule-map-file=a"}; const char *Args[] = {"-fmodule-map-file=a"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getFrontendOpts().ModuleMapFiles, ASSERT_EQ(Invocation.getFrontendOpts().ModuleMapFiles,
std::vector<std::string>({"a"})); std::vector<std::string>({"a"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1)); ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 1)); ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 1));
} }
TEST_F(CommandLineTest, StringVectorMultiple) { TEST_F(CommandLineTest, StringVectorMultiple) {
const char *Args[] = {"-fmodule-map-file=a", "-fmodule-map-file=b"}; const char *Args[] = {"-fmodule-map-file=a", "-fmodule-map-file=b"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles == ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles ==
std::vector<std::string>({"a", "b"})); std::vector<std::string>({"a", "b"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1)); ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=b"), 1)); ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=b"), 1));
ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 2)); ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 2));
} }
// CommaJoined option with MarshallingInfoStringVector. // CommaJoined option with MarshallingInfoStringVector.
TEST_F(CommandLineTest, StringVectorCommaJoinedNone) { TEST_F(CommandLineTest, StringVectorCommaJoinedNone) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getLangOpts()->CommentOpts.BlockCommandNames.empty()); ASSERT_TRUE(Invocation.getLangOpts()->CommentOpts.BlockCommandNames.empty());
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
Not(Contains(HasSubstr("-fcomment-block-commands")))); Not(Contains(HasSubstr("-fcomment-block-commands"))));
} }
TEST_F(CommandLineTest, StringVectorCommaJoinedSingle) { TEST_F(CommandLineTest, StringVectorCommaJoinedSingle) {
const char *Args[] = {"-fcomment-block-commands=x,y"}; const char *Args[] = {"-fcomment-block-commands=x,y"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames, ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
std::vector<std::string>({"x", "y"})); std::vector<std::string>({"x", "y"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
ContainsN(StrEq("-fcomment-block-commands=x,y"), 1)); ContainsN(StrEq("-fcomment-block-commands=x,y"), 1));
} }
TEST_F(CommandLineTest, StringVectorCommaJoinedMultiple) { TEST_F(CommandLineTest, StringVectorCommaJoinedMultiple) {
const char *Args[] = {"-fcomment-block-commands=x,y", const char *Args[] = {"-fcomment-block-commands=x,y",
"-fcomment-block-commands=a,b"}; "-fcomment-block-commands=a,b"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames, ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
std::vector<std::string>({"x", "y", "a", "b"})); std::vector<std::string>({"x", "y", "a", "b"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
ContainsN(StrEq("-fcomment-block-commands=x,y,a,b"), 1)); ContainsN(StrEq("-fcomment-block-commands=x,y,a,b"), 1));
} }
// Tree of boolean options that can be (directly or transitively) implied by // Tree of boolean options that can be (directly or transitively) implied by
// their parent: // their parent:
// //
// * -cl-unsafe-math-optimizations // * -cl-unsafe-math-optimizations
// * -cl-mad-enable // * -cl-mad-enable
// * -menable-unsafe-fp-math // * -menable-unsafe-fp-math
// * -freciprocal-math // * -freciprocal-math
TEST_F(CommandLineTest, ImpliedBoolOptionsNoFlagPresent) { TEST_F(CommandLineTest, ImpliedBoolOptionsNoFlagPresent) {
const char *Args[] = {""}; const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath); ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_FALSE(Invocation.getCodeGenOpts().LessPreciseFPMAD); ASSERT_FALSE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_FALSE(Invocation.getLangOpts()->UnsafeFPMath); ASSERT_FALSE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_FALSE(Invocation.getLangOpts()->AllowRecip); ASSERT_FALSE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Not generated - missing. // Not generated - missing.
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-cl-unsafe-math-optimizations")))); Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
} }
TEST_F(CommandLineTest, ImpliedBoolOptionsRootFlagPresent) { TEST_F(CommandLineTest, ImpliedBoolOptionsRootFlagPresent) {
const char *Args[] = {"-cl-unsafe-math-optimizations"}; const char *Args[] = {"-cl-unsafe-math-optimizations"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
// Explicitly provided root flag. // Explicitly provided root flag.
ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath); ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
// Directly implied by explicitly provided root flag. // Directly implied by explicitly provided root flag.
ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD); ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath); ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
// Transitively implied by explicitly provided root flag. // Transitively implied by explicitly provided root flag.
ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip); ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Generated - explicitly provided. // Generated - explicitly provided.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
// Not generated - implied by the generated root flag. // Not generated - implied by the generated root flag.
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
} }
TEST_F(CommandLineTest, ImpliedBoolOptionsAllFlagsPresent) { TEST_F(CommandLineTest, ImpliedBoolOptionsAllFlagsPresent) {
const char *Args[] = {"-cl-unsafe-math-optimizations", "-cl-mad-enable", const char *Args[] = {"-cl-unsafe-math-optimizations", "-cl-mad-enable",
"-menable-unsafe-fp-math", "-freciprocal-math"}; "-menable-unsafe-fp-math", "-freciprocal-math"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath); ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD); ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath); ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip); ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Generated - explicitly provided. // Generated - explicitly provided.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
// Not generated - implied by their generated parent. // Not generated - implied by their generated parent.
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
} }
TEST_F(CommandLineTest, ImpliedBoolOptionsImpliedFlagsPresent) { TEST_F(CommandLineTest, ImpliedBoolOptionsImpliedFlagsPresent) {
const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math", const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math",
"-freciprocal-math"}; "-freciprocal-math"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath); ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD); ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath); ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip); ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Not generated - missing. // Not generated - missing.
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-cl-unsafe-math-optimizations")))); Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
// Generated - explicitly provided. // Generated - explicitly provided.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
// Not generated - implied by its generated parent. // Not generated - implied by its generated parent.
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
} }
TEST_F(CommandLineTest, PresentAndNotImpliedGenerated) { TEST_F(CommandLineTest, PresentAndNotImpliedGenerated) {
const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math"}; const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags); ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Diags->hasErrorOccurred());
Invocation.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Present options that were not implied are generated. // Present options that were not implied are generated.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
} }
} // anonymous namespace } // anonymous namespace