blob: 692d04a100db77d8c6395c063eda7feeff259461 [file] [log] [blame]
//===- unittests/Frontend/CompilerInvocationTest.cpp - CI tests //---------===//
//
// 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 "clang/Basic/TargetOptions.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/TextDiagnosticBuffer.h"
#include "clang/Lex/PreprocessorOptions.h"
#include "clang/Serialization/ModuleFileExtension.h"
#include "llvm/Support/Host.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using namespace llvm;
using namespace clang;
using ::testing::Contains;
using ::testing::HasSubstr;
using ::testing::StrEq;
namespace {
class CommandLineTest : public ::testing::Test {
public:
IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
SmallVector<const char *, 32> GeneratedArgs;
SmallVector<std::string, 32> GeneratedArgsStorage;
CompilerInvocation Invocation;
const char *operator()(const Twine &Arg) {
return GeneratedArgsStorage.emplace_back(Arg.str()).c_str();
}
CommandLineTest()
: Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions(),
new TextDiagnosticBuffer())) {
}
};
template <typename M>
std::string describeContainsN(M InnerMatcher, unsigned N, bool Negation) {
StringRef Contains = Negation ? "doesn't contain" : "contains";
StringRef Instance = N == 1 ? " instance " : " instances ";
StringRef Element = "of element that ";
std::ostringstream Inner;
InnerMatcher.impl().DescribeTo(&Inner);
return (Contains + " exactly " + Twine(N) + Instance + Element + Inner.str())
.str();
}
MATCHER_P2(ContainsN, InnerMatcher, N,
describeContainsN(InnerMatcher, N, negation)) {
auto InnerMatches = [this](const auto &Element) {
::testing::internal::DummyMatchResultListener InnerListener;
return InnerMatcher.impl().MatchAndExplain(Element, &InnerListener);
};
return count_if(arg, InnerMatches) == N;
}
TEST(ContainsN, Empty) {
const char *Array[] = {""};
ASSERT_THAT(Array, ContainsN(StrEq("x"), 0));
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
}
TEST(ContainsN, Zero) {
const char *Array[] = {"y"};
ASSERT_THAT(Array, ContainsN(StrEq("x"), 0));
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
}
TEST(ContainsN, One) {
const char *Array[] = {"a", "b", "x", "z"};
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 0)));
ASSERT_THAT(Array, ContainsN(StrEq("x"), 1));
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
}
TEST(ContainsN, Two) {
const char *Array[] = {"x", "a", "b", "x"};
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 0)));
ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
ASSERT_THAT(Array, ContainsN(StrEq("x"), 2));
}
// Copy constructor/assignment perform deep copy of reference-counted pointers.
TEST(CompilerInvocationTest, DeepCopyConstructor) {
CompilerInvocation A;
A.getAnalyzerOpts()->Config["Key"] = "Old";
CompilerInvocation B(A);
B.getAnalyzerOpts()->Config["Key"] = "New";
ASSERT_EQ(A.getAnalyzerOpts()->Config["Key"], "Old");
}
TEST(CompilerInvocationTest, DeepCopyAssignment) {
CompilerInvocation A;
A.getAnalyzerOpts()->Config["Key"] = "Old";
CompilerInvocation B;
B = A;
B.getAnalyzerOpts()->Config["Key"] = "New";
ASSERT_EQ(A.getAnalyzerOpts()->Config["Key"], "Old");
}
// Boolean option with a keypath that defaults to true.
// The only flag with a negative spelling can set the keypath to false.
TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagNotPresent) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file"))));
}
TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagPresent) {
const char *Args[] = {"-fno-temp-file"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getFrontendOpts().UseTemporary);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file")));
}
TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagUnknownPresent) {
const char *Args[] = {"-ftemp-file"};
// Driver-only flag.
ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
}
// Boolean option with a keypath that defaults to true.
// The flag with negative spelling can set the keypath to false.
// The flag with positive spelling can reset the keypath to true.
TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNone) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-autolink"))));
}
TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNegChange) {
const char *Args[] = {"-fno-autolink"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().Autolink);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-autolink")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
}
TEST_F(CommandLineTest, BoolOptionDefaultTruePresentPosReset) {
const char *Args[] = {"-fautolink"};
// Driver-only flag.
ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);
}
// Boolean option with a keypath that defaults to false.
// The flag with negative spelling can set the keypath to true.
// The flag with positive spelling can reset the keypath to false.
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNone) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-inline-line-tables"))));
}
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegChange) {
const char *Args[] = {"-gno-inline-line-tables"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getCodeGenOpts().NoInlineLineTables);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gno-inline-line-tables")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
}
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosReset) {
const char *Args[] = {"-ginline-line-tables"};
// Driver-only flag.
ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
}
// Boolean option with a keypath that defaults to false.
// The flag with positive spelling can set the keypath to true.
// The flag with negative spelling can reset the keypath to false.
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNoneX) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gcodeview-ghash"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
}
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosChange) {
const char *Args[] = {"-gcodeview-ghash"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getCodeGenOpts().CodeViewGHash);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gcodeview-ghash")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
}
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegReset) {
const char *Args[] = {"-gno-codeview-ghash"};
// Driver-only flag.
ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
}
// 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 negative spelling can set the keypath to false.
static constexpr unsigned PassManagerDefault =
!static_cast<unsigned>(LLVM_ENABLE_NEW_PASS_MANAGER);
static constexpr const char *PassManagerResetByFlag =
LLVM_ENABLE_NEW_PASS_MANAGER ? "-fno-legacy-pass-manager"
: "-flegacy-pass-manager";
static constexpr const char *PassManagerChangedByFlag =
LLVM_ENABLE_NEW_PASS_MANAGER ? "-flegacy-pass-manager"
: "-fno-legacy-pass-manager";
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentNone) {
const char *Args = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
}
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentChange) {
const char *Args[] = {PassManagerChangedByFlag};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, !PassManagerDefault);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq(PassManagerChangedByFlag)));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
}
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentReset) {
const char *Args[] = {PassManagerResetByFlag};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
}
// Boolean option that gets the CC1Option flag from a let statement (which
// is applied **after** the record is defined):
//
// let Flags = [CC1Option] in {
// defm option : BoolOption<...>;
// }
TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNone) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
}
TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentPos) {
const char *Args[] = {"-fdebug-pass-manager"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getCodeGenOpts().DebugPassManager);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fdebug-pass-manager"), 1));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
}
TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNeg) {
const char *Args[] = {"-fno-debug-pass-manager"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
}
TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) {
const char *Args[] = {"-fmodules-strict-context-hash"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash")));
}
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) {
const char *TripleCStr = "i686-apple-darwin9";
const char *Args[] = {"-triple", TripleCStr};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr)));
}
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredPresent) {
const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {"-triple", DefaultTriple.c_str()};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Triple should always be emitted even if it is the default
ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
}
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) {
const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Triple should always be emitted even if it is the default
ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
}
TEST_F(CommandLineTest, SeparateEnumNonDefault) {
const char *Args[] = {"-mrelocation-model", "static"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::Static);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Non default relocation model.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-mrelocation-model")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("static")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=static"))));
}
TEST_F(CommandLineTest, SeparateEnumDefault) {
const char *Args[] = {"-mrelocation-model", "pic"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::PIC_);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Default relocation model.
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("pic"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=pic"))));
}
TEST_F(CommandLineTest, JoinedEnumNonDefault) {
const char *Args[] = {"-fobjc-dispatch-method=non-legacy"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
CodeGenOptions::NonLegacy);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
Contains(StrEq("-fobjc-dispatch-method=non-legacy")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("non-legacy"))));
}
TEST_F(CommandLineTest, JoinedEnumDefault) {
const char *Args[] = {"-fobjc-dispatch-method=legacy"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
CodeGenOptions::Legacy);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-fobjc-dispatch-method=legacy"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("legacy"))));
}
TEST_F(CommandLineTest, StringVectorEmpty) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles.empty());
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-fmodule-map-file"))));
}
TEST_F(CommandLineTest, StringVectorSingle) {
const char *Args[] = {"-fmodule-map-file=a"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getFrontendOpts().ModuleMapFiles,
std::vector<std::string>({"a"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 1));
}
TEST_F(CommandLineTest, StringVectorMultiple) {
const char *Args[] = {"-fmodule-map-file=a", "-fmodule-map-file=b"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles ==
std::vector<std::string>({"a", "b"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=b"), 1));
ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 2));
}
// CommaJoined option with MarshallingInfoStringVector.
TEST_F(CommandLineTest, StringVectorCommaJoinedNone) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getLangOpts()->CommentOpts.BlockCommandNames.empty());
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
Not(Contains(HasSubstr("-fcomment-block-commands"))));
}
TEST_F(CommandLineTest, StringVectorCommaJoinedSingle) {
const char *Args[] = {"-fcomment-block-commands=x,y"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
std::vector<std::string>({"x", "y"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
ContainsN(StrEq("-fcomment-block-commands=x,y"), 1));
}
TEST_F(CommandLineTest, StringVectorCommaJoinedMultiple) {
const char *Args[] = {"-fcomment-block-commands=x,y",
"-fcomment-block-commands=a,b"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
std::vector<std::string>({"x", "y", "a", "b"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
ContainsN(StrEq("-fcomment-block-commands=x,y,a,b"), 1));
}
// A flag that should be parsed only if a condition is met.
TEST_F(CommandLineTest, ConditionalParsingIfFalseFlagNotPresent) {
const char *Args[] = {""};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsDevice);
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
}
TEST_F(CommandLineTest, ConditionalParsingIfFalseFlagPresent) {
const char *Args[] = {"-sycl-std=2017"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsDevice);
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-device"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
}
TEST_F(CommandLineTest, ConditionalParsingIfNonsenseSyclStdArg) {
const char *Args[] = {"-fsycl-is-device", "-sycl-std=garbage"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_TRUE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
}
TEST_F(CommandLineTest, ConditionalParsingIfOddSyclStdArg1) {
const char *Args[] = {"-fsycl-is-device", "-sycl-std=121"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=2017")));
}
TEST_F(CommandLineTest, ConditionalParsingIfOddSyclStdArg2) {
const char *Args[] = {"-fsycl-is-device", "-sycl-std=1.2.1"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=2017")));
}
TEST_F(CommandLineTest, ConditionalParsingIfOddSyclStdArg3) {
const char *Args[] = {"-fsycl-is-device", "-sycl-std=sycl-1.2.1"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=2017")));
}
TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagNotPresentHost) {
const char *Args[] = {"-fsycl-is-host"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(),
LangOptions::SYCL_Default);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-host")));
ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=")));
}
TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagNotPresentDevice) {
const char *Args[] = {"-fsycl-is-device"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(),
LangOptions::SYCL_Default);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=")));
}
TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagPresent) {
const char *Args[] = {"-fsycl-is-device", "-sycl-std=2017"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-sycl-std=2017")));
}
// Wide integer option.
TEST_F(CommandLineTest, WideIntegerHighValue) {
const char *Args[] = {"-fbuild-session-timestamp=1609827494445723662"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_EQ(Invocation.getHeaderSearchOpts().BuildSessionTimestamp,
1609827494445723662ull);
}
// Tree of boolean options that can be (directly or transitively) implied by
// their parent:
//
// * -cl-unsafe-math-optimizations
// * -cl-mad-enable
// * -menable-unsafe-fp-math
// * -freciprocal-math
TEST_F(CommandLineTest, ImpliedBoolOptionsNoFlagPresent) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_FALSE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_FALSE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_FALSE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Not generated - missing.
ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
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("-freciprocal-math"))));
}
TEST_F(CommandLineTest, ImpliedBoolOptionsRootFlagPresent) {
const char *Args[] = {"-cl-unsafe-math-optimizations"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
// Explicitly provided root flag.
ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
// Directly implied by explicitly provided root flag.
ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
// Transitively implied by explicitly provided root flag.
ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Generated - explicitly provided.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
// Not generated - implied by the generated root flag.
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("-freciprocal-math"))));
}
TEST_F(CommandLineTest, ImpliedBoolOptionsAllFlagsPresent) {
const char *Args[] = {"-cl-unsafe-math-optimizations", "-cl-mad-enable",
"-menable-unsafe-fp-math", "-freciprocal-math"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Generated - explicitly provided.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
// Not generated - implied by their generated parent.
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("-freciprocal-math"))));
}
TEST_F(CommandLineTest, ImpliedBoolOptionsImpliedFlagsPresent) {
const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math",
"-freciprocal-math"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Not generated - missing.
ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
// Generated - explicitly provided.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
// Not generated - implied by its generated parent.
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
}
TEST_F(CommandLineTest, PresentAndNotImpliedGenerated) {
const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Present options that were not implied are generated.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
}
// Diagnostic option.
TEST_F(CommandLineTest, DiagnosticOptionPresent) {
const char *Args[] = {"-verify=xyz"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_EQ(Invocation.getDiagnosticOpts().VerifyPrefixes,
std::vector<std::string>({"xyz"}));
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-verify=xyz"), 1));
}
// Option default depends on language standard.
TEST_F(CommandLineTest, DigraphsImplied) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getLangOpts()->Digraphs);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-digraphs"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
}
TEST_F(CommandLineTest, DigraphsDisabled) {
const char *Args[] = {"-fno-digraphs"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getLangOpts()->Digraphs);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-digraphs")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
}
TEST_F(CommandLineTest, DigraphsNotImplied) {
const char *Args[] = {"-std=c89"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_FALSE(Invocation.getLangOpts()->Digraphs);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-digraphs"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
}
TEST_F(CommandLineTest, DigraphsEnabled) {
const char *Args[] = {"-std=c89", "-fdigraphs"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getLangOpts()->Digraphs);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fdigraphs")));
}
struct DummyModuleFileExtension
: public llvm::RTTIExtends<DummyModuleFileExtension, ModuleFileExtension> {
static char ID;
ModuleFileExtensionMetadata getExtensionMetadata() const override {
return {};
};
void hashExtension(ExtensionHashBuilder &HBuilder) const override {}
std::unique_ptr<ModuleFileExtensionWriter>
createExtensionWriter(ASTWriter &Writer) override {
return {};
}
std::unique_ptr<ModuleFileExtensionReader>
createExtensionReader(const ModuleFileExtensionMetadata &Metadata,
ASTReader &Reader, serialization::ModuleFile &Mod,
const llvm::BitstreamCursor &Stream) override {
return {};
}
};
char DummyModuleFileExtension::ID = 0;
TEST_F(CommandLineTest, TestModuleFileExtension) {
const char *Args[] = {"-ftest-module-file-extension=first:2:1:0:first",
"-ftest-module-file-extension=second:3:2:1:second"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_THAT(Invocation.getFrontendOpts().ModuleFileExtensions.size(), 2);
// Exercise the check that only serializes instances of
// TestModuleFileExtension by providing an instance of another
// ModuleFileExtension subclass.
Invocation.getFrontendOpts().ModuleFileExtensions.push_back(
std::make_shared<DummyModuleFileExtension>());
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
ContainsN(HasSubstr("-ftest-module-file-extension="), 2));
ASSERT_THAT(
GeneratedArgs,
Contains(StrEq("-ftest-module-file-extension=first:2:1:0:first")));
ASSERT_THAT(
GeneratedArgs,
Contains(StrEq("-ftest-module-file-extension=second:3:2:1:second")));
}
TEST_F(CommandLineTest, RoundTrip) {
// Testing one marshalled and one manually generated option from each
// CompilerInvocation member.
const char *Args[] = {
"-round-trip-args",
// LanguageOptions
"-std=c17",
"-fmax-tokens=10",
// TargetOptions
"-target-sdk-version=1.2.3",
"-meabi",
"4",
// DiagnosticOptions
"-Wundef-prefix=XY",
"-fdiagnostics-format",
"clang",
// HeaderSearchOptions
"-stdlib=libc++",
"-fimplicit-module-maps",
// PreprocessorOptions
"-DXY=AB",
"-include-pch",
"a.pch",
// AnalyzerOptions
"-analyzer-config",
"ctu-import-threshold=42",
"-unoptimized-cfg",
// MigratorOptions (no manually handled arguments)
"-no-ns-alloc-error",
// CodeGenOptions
"-debug-info-kind=limited",
"-debug-info-macro",
// DependencyOutputOptions
"--show-includes",
"-H",
// FileSystemOptions (no manually handled arguments)
"-working-directory",
"folder",
// FrontendOptions
"-load",
"plugin",
"-ast-merge",
// PreprocessorOutputOptions
"-dD",
"-CC",
};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
ASSERT_TRUE(Invocation.getLangOpts()->C17);
ASSERT_EQ(Invocation.getLangOpts()->MaxTokens, 10u);
ASSERT_EQ(Invocation.getTargetOpts().SDKVersion, llvm::VersionTuple(1, 2, 3));
ASSERT_EQ(Invocation.getTargetOpts().EABIVersion, EABI::EABI4);
ASSERT_THAT(Invocation.getDiagnosticOpts().UndefPrefixes,
Contains(StrEq("XY")));
ASSERT_EQ(Invocation.getDiagnosticOpts().getFormat(),
TextDiagnosticFormat::Clang);
ASSERT_TRUE(Invocation.getHeaderSearchOpts().UseLibcxx);
ASSERT_TRUE(Invocation.getHeaderSearchOpts().ImplicitModuleMaps);
ASSERT_THAT(Invocation.getPreprocessorOpts().Macros,
Contains(std::make_pair(std::string("XY=AB"), false)));
ASSERT_EQ(Invocation.getPreprocessorOpts().ImplicitPCHInclude, "a.pch");
ASSERT_EQ(Invocation.getAnalyzerOpts()->Config["ctu-import-threshold"], "42");
ASSERT_TRUE(Invocation.getAnalyzerOpts()->UnoptimizedCFG);
ASSERT_TRUE(Invocation.getMigratorOpts().NoNSAllocReallocError);
ASSERT_EQ(Invocation.getCodeGenOpts().getDebugInfo(),
codegenoptions::DebugInfoKind::LimitedDebugInfo);
ASSERT_TRUE(Invocation.getCodeGenOpts().MacroDebugInfo);
ASSERT_EQ(Invocation.getDependencyOutputOpts().ShowIncludesDest,
ShowIncludesDestination::Stdout);
ASSERT_TRUE(Invocation.getDependencyOutputOpts().ShowHeaderIncludes);
}
TEST_F(CommandLineTest, PluginArgsRoundTripDeterminism) {
const char *Args[] = {
"-plugin-arg-blink-gc-plugin", "no-members-in-stack-allocated",
"-plugin-arg-find-bad-constructs", "checked-ptr-as-trivial-member",
"-plugin-arg-find-bad-constructs", "check-ipc",
// Enable round-trip to ensure '-plugin-arg' generation is deterministic.
"-round-trip-args"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
}
} // anonymous namespace