403 changes: 291 additions & 112 deletions clang/unittests/Frontend/CompilerInvocationTest.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@

#include "clang/Frontend/CompilerInvocation.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/TextDiagnosticBuffer.h"
#include "llvm/Support/Host.h"

#include "gmock/gmock.h"
Expand All @@ -17,217 +18,395 @@ using namespace llvm;
using namespace clang;

using ::testing::Contains;
using ::testing::Each;
using ::testing::StrEq;
using ::testing::StrNe;

namespace {
struct OptsPopulationTest : public ::testing::Test {
IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
CompilerInvocation CInvok;

OptsPopulationTest()
: Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions())) {}
};

class CC1CommandLineGenerationTest : public ::testing::Test {
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();
}

CC1CommandLineGenerationTest()
: Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions())) {}
CommandLineTest()
: Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions(),
new TextDiagnosticBuffer())) {
}
};

TEST_F(OptsPopulationTest, OptIsInitializedWithCustomDefaultValue) {
const char *Args[] = {"clang", "-xc++"};
// 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[] = {""};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

ASSERT_FALSE(Diags->hasErrorOccurred());
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"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

ASSERT_FALSE(Diags->hasErrorOccurred());
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"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

// Driver-only flag.
ASSERT_TRUE(Diags->hasErrorOccurred());
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[] = {""};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);

// TODO: Test argument generation.
}

TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNegChange) {
const char *Args[] = {"-fno-autolink"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().Autolink);

// TODO: Test argument generation.
}

TEST_F(CommandLineTest, BoolOptionDefaultTruePresentPosReset) {
const char *Args[] = {"-fautolink"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_TRUE(Diags->hasErrorOccurred()); // Driver-only flag.
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[] = {""};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);

// TODO: Test argument generation.
}

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegChange) {
const char *Args[] = {"-gno-inline-line-tables"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().NoInlineLineTables);

// TODO: Test argument generation.
}

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosReset) {
const char *Args[] = {"-ginline-line-tables"};

CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_TRUE(Diags->hasErrorOccurred()); // Driver-only flag.
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(CInvok.getFrontendOpts().UseTemporary);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);

// TODO: Test argument generation.
}

TEST_F(OptsPopulationTest, OptOfNegativeFlagIsPopulatedWithFalse) {
const char *Args[] = {"clang", "-xc++", "-fno-temp-file"};
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosChange) {
const char *Args[] = {"-gcodeview-ghash"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().CodeViewGHash);

// TODO: Test argument generation.
}

CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegReset) {
const char *Args[] = {"-gno-codeview-ghash"};

ASSERT_FALSE(CInvok.getFrontendOpts().UseTemporary);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_TRUE(Diags->hasErrorOccurred()); // Driver-only flag.
ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
}

TEST_F(OptsPopulationTest, OptsOfImpliedPositiveFlagArePopulatedWithTrue) {
const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"};
// 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.

// NOTE: The following tests need to be updated when we start enabling the new
// pass manager by default.

CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentNone) {
const char *Args = {""};

// Explicitly provided flag.
ASSERT_TRUE(CInvok.getLangOpts()->CLUnsafeMath);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

// Flags directly implied by explicitly provided flag.
ASSERT_TRUE(CInvok.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(CInvok.getLangOpts()->UnsafeFPMath);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().ExperimentalNewPassManager);

// Flag transitively implied by explicitly provided flag.
ASSERT_TRUE(CInvok.getLangOpts()->AllowRecip);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-fexperimental-new-pass-manager"))));
}

TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineFlag) {
const char *Args[] = {"clang", "-xc++", "-fmodules-strict-context-hash", "-"};
TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentPos) {
const char *Args[] = {"-fexperimental-new-pass-manager"};

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getCodeGenOpts().ExperimentalNewPassManager);

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
Contains(StrEq("-fexperimental-new-pass-manager")));
ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-fno-experimental-new-pass-manager"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentNeg) {
const char *Args[] = {"-fno-experimental-new-pass-manager"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getCodeGenOpts().ExperimentalNewPassManager);

Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs,
Contains(StrEq("-fno-experimental-new-pass-manager")));
ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-fexperimental-new-pass-manager"))));
}

TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) {
const char *Args[] = {"-fmodules-strict-context-hash"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

ASSERT_FALSE(Diags->hasErrorOccurred());

Invocation.generateCC1CommandLine(GeneratedArgs, *this);

ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash")));
}

TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineSeparate) {
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) {
const char *TripleCStr = "i686-apple-darwin9";
const char *Args[] = {"clang", "-xc++", "-triple", TripleCStr, "-"};
const char *Args[] = {"-triple", TripleCStr};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);

ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr)));
}

TEST_F(CC1CommandLineGenerationTest,
CanGenerateCC1CommandLineSeparateRequiredPresent) {
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredPresent) {
const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {"clang", "-xc++", "-triple", DefaultTriple.c_str(),
"-"};
const char *Args[] = {"-triple", DefaultTriple.c_str()};

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_FALSE(Diags->hasErrorOccurred());

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(CC1CommandLineGenerationTest,
CanGenerateCC1CommandLineSeparateRequiredAbsent) {
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) {
const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {"clang", "-xc++", "-"};
const char *Args[] = {""};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
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(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineSeparateEnum) {
const char *RelocationModelCStr = "static";
const char *Args[] = {"clang", "-xc++", "-mrelocation-model",
RelocationModelCStr, "-"};

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateEnumNonDefault) {
const char *Args[] = {"-mrelocation-model", "static"};

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

// Non default relocation model
ASSERT_THAT(GeneratedArgs, Contains(StrEq(RelocationModelCStr)));
GeneratedArgs.clear();
ASSERT_FALSE(Diags->hasErrorOccurred());

RelocationModelCStr = "pic";
Args[3] = RelocationModelCStr;
Invocation.generateCC1CommandLine(GeneratedArgs, *this);

CompilerInvocation CInvok1;
CompilerInvocation::CreateFromArgs(CInvok1, Args, *Diags);

CInvok1.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Each(StrNe(RelocationModelCStr)));
// Non default relocation model.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("static")));
}

TEST_F(CC1CommandLineGenerationTest, NotPresentNegativeFlagNotGenerated) {
const char *Args[] = {"clang", "-xc++"};
TEST_F(CommandLineTest, CanGenerateCC1COmmandLineSeparateEnumDefault) {
const char *Args[] = {"-mrelocation-model", "pic"};

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_FALSE(Diags->hasErrorOccurred());

ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file"))));
}
Invocation.generateCC1CommandLine(GeneratedArgs, *this);

TEST_F(CC1CommandLineGenerationTest, PresentNegativeFlagGenerated) {
const char *Args[] = {"clang", "-xc++", "-fno-temp-file"};

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
// Default relocation model.
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("pic"))));
}

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
// 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

ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file")));
}
TEST_F(CommandLineTest, ImpliedBoolOptionsNoFlagPresent) {
const char *Args[] = {""};

TEST_F(CC1CommandLineGenerationTest, NotPresentAndNotImpliedNotGenerated) {
const char *Args[] = {"clang", "-xc++"};
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_FALSE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_FALSE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_FALSE(Invocation.getLangOpts()->AllowRecip);

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);

// Missing options are not generated.
// 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(CC1CommandLineGenerationTest, NotPresentAndImpliedNotGenerated) {
const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"};
TEST_F(CommandLineTest, ImpliedBoolOptionsRootFlagPresent) {
const char *Args[] = {"-cl-unsafe-math-optimizations"};

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_FALSE(Diags->hasErrorOccurred());
// 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);

// Missing options that were implied are not generated.
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(CC1CommandLineGenerationTest, PresentAndImpliedNotGenerated) {
const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations",
"-cl-mad-enable", "-menable-unsafe-fp-math"};
TEST_F(CommandLineTest, ImpliedBoolOptionsAllFlagsPresent) {
const char *Args[] = {"-cl-unsafe-math-optimizations", "-cl-mad-enable",
"-menable-unsafe-fp-math", "-freciprocal-math"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);

// Present options that were also implied are not generated.
// 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(CC1CommandLineGenerationTest, PresentAndNotImpliedGenerated) {
const char *Args[] = {"clang", "-xc++", "-cl-mad-enable",
"-menable-unsafe-fp-math"};
TEST_F(CommandLineTest, ImpliedBoolOptionsImpliedFlagsPresent) {
const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math",
"-freciprocal-math"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());
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"};

CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

CompilerInvocation CInvok;
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
ASSERT_FALSE(Diags->hasErrorOccurred());

CInvok.generateCC1CommandLine(GeneratedArgs, *this);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);

// Present options that were not implied are generated.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
Expand Down