655bea4226
Per the comments, `hash_code` values "are not stable to save or persist", so are unsuitable for the module hash, which must persist across compilations for the implicit module hashes to match. Note that in practice, today, `hash_code` are stable. But this is an implementation detail, with a clear `FIXME` indicating we should switch to a per-execution seed. The stability of `MD5` also allows modules cross-compilation use-cases. The `size_t` underlying storage for `hash_code` varying across platforms could cause mismatching hashes when cross-compiling from a 64bit target to a 32bit target. Note that native endianness is still used for the hash computation. So hashes will differ between platforms of different endianness. Reviewed By: jansvoboda11 Differential Revision: https://reviews.llvm.org/D102943
997 lines
36 KiB
C++
997 lines
36 KiB
C++
//===- 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
|