538 lines
16 KiB
C++
538 lines
16 KiB
C++
|
//===- unittests/Driver/MultilibTest.cpp --- Multilib 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
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
//
|
||
|
|
// Unit tests for Multilib and MultilibSet
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
|
||
|
|
#include "clang/Driver/Multilib.h"
|
||
|
|
#include "../../lib/Driver/ToolChains/CommonArgs.h"
|
||
|
|
#include "clang/Basic/LLVM.h"
|
||
|
|
#include "clang/Basic/Version.h"
|
||
|
|
#include "llvm/ADT/ArrayRef.h"
|
||
|
|
#include "llvm/ADT/StringRef.h"
|
||
|
|
#include "llvm/ADT/StringSwitch.h"
|
||
|
|
#include "llvm/Support/SourceMgr.h"
|
||
|
|
#include "gtest/gtest.h"
|
||
|
|
|
||
|
|
using namespace clang::driver;
|
||
|
|
using namespace clang;
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqReflexivity1) {
|
||
|
|
Multilib M;
|
||
|
|
ASSERT_TRUE(M == M) << "Multilib::operator==() is not reflexive";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqReflexivity2) {
|
||
|
|
ASSERT_TRUE(Multilib() == Multilib())
|
||
|
|
<< "Separately constructed default multilibs are not equal";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqReflexivity3) {
|
||
|
|
Multilib M1({}, {}, {}, {"+foo"});
|
||
|
|
Multilib M2({}, {}, {}, {"+foo"});
|
||
|
|
ASSERT_TRUE(M1 == M2) << "Multilibs with the same flag should be the same";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqInequivalence1) {
|
||
|
|
Multilib M1({}, {}, {}, {"+foo"});
|
||
|
|
Multilib M2({}, {}, {}, {"-foo"});
|
||
|
|
ASSERT_FALSE(M1 == M2) << "Multilibs with conflicting flags are not the same";
|
||
|
|
ASSERT_FALSE(M2 == M1)
|
||
|
|
<< "Multilibs with conflicting flags are not the same (commuted)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqInequivalence2) {
|
||
|
|
Multilib M1;
|
||
|
|
Multilib M2({}, {}, {}, {"+foo"});
|
||
|
|
ASSERT_FALSE(M1 == M2) << "Flags make Multilibs different";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqEquivalence2) {
|
||
|
|
Multilib M1("/64");
|
||
|
|
Multilib M2("/64");
|
||
|
|
ASSERT_TRUE(M1 == M2)
|
||
|
|
<< "Constructor argument must match Multilib::gccSuffix()";
|
||
|
|
ASSERT_TRUE(M2 == M1)
|
||
|
|
<< "Constructor argument must match Multilib::gccSuffix() (commuted)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqEquivalence3) {
|
||
|
|
Multilib M1("", "/32");
|
||
|
|
Multilib M2("", "/32");
|
||
|
|
ASSERT_TRUE(M1 == M2)
|
||
|
|
<< "Constructor argument must match Multilib::osSuffix()";
|
||
|
|
ASSERT_TRUE(M2 == M1)
|
||
|
|
<< "Constructor argument must match Multilib::osSuffix() (commuted)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqEquivalence4) {
|
||
|
|
Multilib M1("", "", "/16");
|
||
|
|
Multilib M2("", "", "/16");
|
||
|
|
ASSERT_TRUE(M1 == M2)
|
||
|
|
<< "Constructor argument must match Multilib::includeSuffix()";
|
||
|
|
ASSERT_TRUE(M2 == M1)
|
||
|
|
<< "Constructor argument must match Multilib::includeSuffix() (commuted)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqInequivalence3) {
|
||
|
|
Multilib M1("/foo");
|
||
|
|
Multilib M2("/bar");
|
||
|
|
ASSERT_FALSE(M1 == M2) << "Differing gccSuffixes should be different";
|
||
|
|
ASSERT_FALSE(M2 == M1)
|
||
|
|
<< "Differing gccSuffixes should be different (commuted)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqInequivalence4) {
|
||
|
|
Multilib M1("", "/foo");
|
||
|
|
Multilib M2("", "/bar");
|
||
|
|
ASSERT_FALSE(M1 == M2) << "Differing osSuffixes should be different";
|
||
|
|
ASSERT_FALSE(M2 == M1)
|
||
|
|
<< "Differing osSuffixes should be different (commuted)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, OpEqInequivalence5) {
|
||
|
|
Multilib M1("", "", "/foo");
|
||
|
|
Multilib M2("", "", "/bar");
|
||
|
|
ASSERT_FALSE(M1 == M2) << "Differing includeSuffixes should be different";
|
||
|
|
ASSERT_FALSE(M2 == M1)
|
||
|
|
<< "Differing includeSuffixes should be different (commuted)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, Construction1) {
|
||
|
|
Multilib M("/gcc64", "/os64", "/inc64");
|
||
|
|
ASSERT_TRUE(M.gccSuffix() == "/gcc64");
|
||
|
|
ASSERT_TRUE(M.osSuffix() == "/os64");
|
||
|
|
ASSERT_TRUE(M.includeSuffix() == "/inc64");
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, Construction2) {
|
||
|
|
Multilib M1;
|
||
|
|
Multilib M2("");
|
||
|
|
Multilib M3("", "");
|
||
|
|
Multilib M4("", "", "");
|
||
|
|
ASSERT_TRUE(M1 == M2)
|
||
|
|
<< "Default arguments to Multilib constructor broken (first argument)";
|
||
|
|
ASSERT_TRUE(M1 == M3)
|
||
|
|
<< "Default arguments to Multilib constructor broken (second argument)";
|
||
|
|
ASSERT_TRUE(M1 == M4)
|
||
|
|
<< "Default arguments to Multilib constructor broken (third argument)";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, Construction3) {
|
||
|
|
Multilib M({}, {}, {}, {"+f1", "+f2", "-f3"});
|
||
|
|
for (Multilib::flags_list::const_iterator I = M.flags().begin(),
|
||
|
|
E = M.flags().end();
|
||
|
|
I != E; ++I) {
|
||
|
|
ASSERT_TRUE(llvm::StringSwitch<bool>(*I)
|
||
|
|
.Cases("+f1", "+f2", "-f3", true)
|
||
|
|
.Default(false));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SetPushback) {
|
||
|
|
MultilibSet MS({
|
||
|
|
Multilib("/one"),
|
||
|
|
Multilib("/two"),
|
||
|
|
});
|
||
|
|
ASSERT_TRUE(MS.size() == 2);
|
||
|
|
for (MultilibSet::const_iterator I = MS.begin(), E = MS.end(); I != E; ++I) {
|
||
|
|
ASSERT_TRUE(llvm::StringSwitch<bool>(I->gccSuffix())
|
||
|
|
.Cases("/one", "/two", true)
|
||
|
|
.Default(false));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SetPriority) {
|
||
|
|
MultilibSet MS({
|
||
|
|
Multilib("/foo", {}, {}, {"+foo"}),
|
||
|
|
Multilib("/bar", {}, {}, {"+bar"}),
|
||
|
|
});
|
||
|
|
Multilib::flags_list Flags1 = {"+foo", "-bar"};
|
||
|
|
llvm::SmallVector<Multilib> Selection1;
|
||
|
|
ASSERT_TRUE(MS.select(Flags1, Selection1))
|
||
|
|
<< "Flag set was {\"+foo\"}, but selection not found";
|
||
|
|
ASSERT_TRUE(Selection1.back().gccSuffix() == "/foo")
|
||
|
|
<< "Selection picked " << Selection1.back() << " which was not expected";
|
||
|
|
|
||
|
|
Multilib::flags_list Flags2 = {"+foo", "+bar"};
|
||
|
|
llvm::SmallVector<Multilib> Selection2;
|
||
|
|
ASSERT_TRUE(MS.select(Flags2, Selection2))
|
||
|
|
<< "Flag set was {\"+bar\"}, but selection not found";
|
||
|
|
ASSERT_TRUE(Selection2.back().gccSuffix() == "/bar")
|
||
|
|
<< "Selection picked " << Selection2.back() << " which was not expected";
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SelectMultiple) {
|
||
|
|
MultilibSet MS({
|
||
|
|
Multilib("/a", {}, {}, {"x"}),
|
||
|
|
Multilib("/b", {}, {}, {"y"}),
|
||
|
|
});
|
||
|
|
llvm::SmallVector<Multilib> Selection;
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select({"x"}, Selection));
|
||
|
|
ASSERT_EQ(1u, Selection.size());
|
||
|
|
EXPECT_EQ("/a", Selection[0].gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select({"y"}, Selection));
|
||
|
|
ASSERT_EQ(1u, Selection.size());
|
||
|
|
EXPECT_EQ("/b", Selection[0].gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select({"y", "x"}, Selection));
|
||
|
|
ASSERT_EQ(2u, Selection.size());
|
||
|
|
EXPECT_EQ("/a", Selection[0].gccSuffix());
|
||
|
|
EXPECT_EQ("/b", Selection[1].gccSuffix());
|
||
|
|
}
|
||
|
|
|
||
|
|
static void diagnosticCallback(const llvm::SMDiagnostic &D, void *Out) {
|
||
|
|
*reinterpret_cast<std::string *>(Out) = D.getMessage();
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool parseYaml(MultilibSet &MS, std::string &Diagnostic,
|
||
|
|
const char *Data) {
|
||
|
|
auto ErrorOrMS = MultilibSet::parseYaml(llvm::MemoryBufferRef(Data, "TEST"),
|
||
|
|
diagnosticCallback, &Diagnostic);
|
||
|
|
if (ErrorOrMS.getError())
|
||
|
|
return false;
|
||
|
|
MS = std::move(ErrorOrMS.get());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool parseYaml(MultilibSet &MS, const char *Data) {
|
||
|
|
auto ErrorOrMS = MultilibSet::parseYaml(llvm::MemoryBufferRef(Data, "TEST"));
|
||
|
|
if (ErrorOrMS.getError())
|
||
|
|
return false;
|
||
|
|
MS = std::move(ErrorOrMS.get());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// When updating this version also update MultilibVersionCurrent in Multilib.cpp
|
||
|
|
#define YAML_PREAMBLE "MultilibVersion: 1.0\n"
|
||
|
|
|
||
|
|
TEST(MultilibTest, ParseInvalid) {
|
||
|
|
std::string Diagnostic;
|
||
|
|
|
||
|
|
MultilibSet MS;
|
||
|
|
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic, R"(
|
||
|
|
Variants: []
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(
|
||
|
|
StringRef(Diagnostic).contains("missing required key 'MultilibVersion'"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
// Reject files with a different major version
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic,
|
||
|
|
R"(
|
||
|
|
MultilibVersion: 2.0
|
||
|
|
Variants: []
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(
|
||
|
|
StringRef(Diagnostic).contains("multilib version 2.0 is unsupported"))
|
||
|
|
<< Diagnostic;
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic,
|
||
|
|
R"(
|
||
|
|
MultilibVersion: 0.1
|
||
|
|
Variants: []
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(
|
||
|
|
StringRef(Diagnostic).contains("multilib version 0.1 is unsupported"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
// Reject files with a later minor version
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic,
|
||
|
|
R"(
|
||
|
|
MultilibVersion: 1.9
|
||
|
|
Variants: []
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(
|
||
|
|
StringRef(Diagnostic).contains("multilib version 1.9 is unsupported"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
// Accept files with the same major version and the same or earlier minor
|
||
|
|
// version
|
||
|
|
EXPECT_TRUE(parseYaml(MS, Diagnostic, R"(
|
||
|
|
MultilibVersion: 1.0
|
||
|
|
Variants: []
|
||
|
|
)")) << Diagnostic;
|
||
|
|
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic, YAML_PREAMBLE));
|
||
|
|
EXPECT_TRUE(StringRef(Diagnostic).contains("missing required key 'Variants'"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: /abc
|
||
|
|
Flags: []
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(StringRef(Diagnostic).contains("paths must be relative"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Flags: []
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(StringRef(Diagnostic).contains("missing required key 'Dir'"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: .
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(StringRef(Diagnostic).contains("missing required key 'Flags'"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic, YAML_PREAMBLE R"(
|
||
|
|
Variants: []
|
||
|
|
Mappings:
|
||
|
|
- Match: abc
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(StringRef(Diagnostic).contains("value required for 'Flags'"))
|
||
|
|
<< Diagnostic;
|
||
|
|
|
||
|
|
EXPECT_FALSE(parseYaml(MS, Diagnostic, YAML_PREAMBLE R"(
|
||
|
|
Variants: []
|
||
|
|
Mappings:
|
||
|
|
- Dir: .
|
||
|
|
Match: '('
|
||
|
|
Flags: []
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(StringRef(Diagnostic).contains("parentheses not balanced"))
|
||
|
|
<< Diagnostic;
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, Parse) {
|
||
|
|
MultilibSet MS;
|
||
|
|
EXPECT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: .
|
||
|
|
Flags: []
|
||
|
|
)"));
|
||
|
|
EXPECT_EQ(1U, MS.size());
|
||
|
|
EXPECT_EQ("", MS.begin()->gccSuffix());
|
||
|
|
|
||
|
|
EXPECT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: abc
|
||
|
|
Flags: []
|
||
|
|
)"));
|
||
|
|
EXPECT_EQ(1U, MS.size());
|
||
|
|
EXPECT_EQ("/abc", MS.begin()->gccSuffix());
|
||
|
|
|
||
|
|
EXPECT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: pqr
|
||
|
|
Flags: [-mfloat-abi=soft]
|
||
|
|
)"));
|
||
|
|
EXPECT_EQ(1U, MS.size());
|
||
|
|
EXPECT_EQ("/pqr", MS.begin()->gccSuffix());
|
||
|
|
EXPECT_EQ(std::vector<std::string>({"-mfloat-abi=soft"}),
|
||
|
|
MS.begin()->flags());
|
||
|
|
|
||
|
|
EXPECT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: pqr
|
||
|
|
Flags: [-mfloat-abi=soft, -fno-exceptions]
|
||
|
|
)"));
|
||
|
|
EXPECT_EQ(1U, MS.size());
|
||
|
|
EXPECT_EQ(std::vector<std::string>({"-mfloat-abi=soft", "-fno-exceptions"}),
|
||
|
|
MS.begin()->flags());
|
||
|
|
|
||
|
|
EXPECT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: a
|
||
|
|
Flags: []
|
||
|
|
- Dir: b
|
||
|
|
Flags: []
|
||
|
|
)"));
|
||
|
|
EXPECT_EQ(2U, MS.size());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SelectSoft) {
|
||
|
|
MultilibSet MS;
|
||
|
|
llvm::SmallVector<Multilib> Selected;
|
||
|
|
ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: s
|
||
|
|
Flags: [-mfloat-abi=soft]
|
||
|
|
Mappings:
|
||
|
|
- Match: -mfloat-abi=softfp
|
||
|
|
Flags: [-mfloat-abi=soft]
|
||
|
|
)"));
|
||
|
|
EXPECT_TRUE(MS.select({"-mfloat-abi=soft"}, Selected));
|
||
|
|
EXPECT_TRUE(MS.select({"-mfloat-abi=softfp"}, Selected));
|
||
|
|
EXPECT_FALSE(MS.select({"-mfloat-abi=hard"}, Selected));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SelectSoftFP) {
|
||
|
|
MultilibSet MS;
|
||
|
|
llvm::SmallVector<Multilib> Selected;
|
||
|
|
ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: f
|
||
|
|
Flags: [-mfloat-abi=softfp]
|
||
|
|
)"));
|
||
|
|
EXPECT_FALSE(MS.select({"-mfloat-abi=soft"}, Selected));
|
||
|
|
EXPECT_TRUE(MS.select({"-mfloat-abi=softfp"}, Selected));
|
||
|
|
EXPECT_FALSE(MS.select({"-mfloat-abi=hard"}, Selected));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SelectHard) {
|
||
|
|
// If hard float is all that's available then select that only if compiling
|
||
|
|
// with hard float.
|
||
|
|
MultilibSet MS;
|
||
|
|
llvm::SmallVector<Multilib> Selected;
|
||
|
|
ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: h
|
||
|
|
Flags: [-mfloat-abi=hard]
|
||
|
|
)"));
|
||
|
|
EXPECT_FALSE(MS.select({"-mfloat-abi=soft"}, Selected));
|
||
|
|
EXPECT_FALSE(MS.select({"-mfloat-abi=softfp"}, Selected));
|
||
|
|
EXPECT_TRUE(MS.select({"-mfloat-abi=hard"}, Selected));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SelectFloatABI) {
|
||
|
|
MultilibSet MS;
|
||
|
|
llvm::SmallVector<Multilib> Selected;
|
||
|
|
ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: s
|
||
|
|
Flags: [-mfloat-abi=soft]
|
||
|
|
- Dir: f
|
||
|
|
Flags: [-mfloat-abi=softfp]
|
||
|
|
- Dir: h
|
||
|
|
Flags: [-mfloat-abi=hard]
|
||
|
|
Mappings:
|
||
|
|
- Match: -mfloat-abi=softfp
|
||
|
|
Flags: [-mfloat-abi=soft]
|
||
|
|
)"));
|
||
|
|
MS.select({"-mfloat-abi=soft"}, Selected);
|
||
|
|
EXPECT_EQ("/s", Selected.back().gccSuffix());
|
||
|
|
MS.select({"-mfloat-abi=softfp"}, Selected);
|
||
|
|
EXPECT_EQ("/f", Selected.back().gccSuffix());
|
||
|
|
MS.select({"-mfloat-abi=hard"}, Selected);
|
||
|
|
EXPECT_EQ("/h", Selected.back().gccSuffix());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SelectFloatABIReversed) {
|
||
|
|
// If soft is specified after softfp then softfp will never be
|
||
|
|
// selected because soft is compatible with softfp and last wins.
|
||
|
|
MultilibSet MS;
|
||
|
|
llvm::SmallVector<Multilib> Selected;
|
||
|
|
ASSERT_TRUE(parseYaml(MS, YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: h
|
||
|
|
Flags: [-mfloat-abi=hard]
|
||
|
|
- Dir: f
|
||
|
|
Flags: [-mfloat-abi=softfp]
|
||
|
|
- Dir: s
|
||
|
|
Flags: [-mfloat-abi=soft]
|
||
|
|
Mappings:
|
||
|
|
- Match: -mfloat-abi=softfp
|
||
|
|
Flags: [-mfloat-abi=soft]
|
||
|
|
)"));
|
||
|
|
MS.select({"-mfloat-abi=soft"}, Selected);
|
||
|
|
EXPECT_EQ("/s", Selected.back().gccSuffix());
|
||
|
|
MS.select({"-mfloat-abi=softfp"}, Selected);
|
||
|
|
EXPECT_EQ("/s", Selected.back().gccSuffix());
|
||
|
|
MS.select({"-mfloat-abi=hard"}, Selected);
|
||
|
|
EXPECT_EQ("/h", Selected.back().gccSuffix());
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST(MultilibTest, SelectMClass) {
|
||
|
|
const char *MultilibSpec = YAML_PREAMBLE R"(
|
||
|
|
Variants:
|
||
|
|
- Dir: thumb/v6-m/nofp
|
||
|
|
Flags: [--target=thumbv6m-none-unknown-eabi, -mfpu=none]
|
||
|
|
|
||
|
|
- Dir: thumb/v7-m/nofp
|
||
|
|
Flags: [--target=thumbv7m-none-unknown-eabi, -mfpu=none]
|
||
|
|
|
||
|
|
- Dir: thumb/v7e-m/nofp
|
||
|
|
Flags: [--target=thumbv7em-none-unknown-eabi, -mfpu=none]
|
||
|
|
|
||
|
|
- Dir: thumb/v8-m.main/nofp
|
||
|
|
Flags: [--target=thumbv8m.main-none-unknown-eabi, -mfpu=none]
|
||
|
|
|
||
|
|
- Dir: thumb/v8.1-m.main/nofp/nomve
|
||
|
|
Flags: [--target=thumbv8.1m.main-none-unknown-eabi, -mfpu=none]
|
||
|
|
|
||
|
|
- Dir: thumb/v7e-m/fpv4_sp_d16
|
||
|
|
Flags: [--target=thumbv7em-none-unknown-eabihf, -mfpu=fpv4-sp-d16]
|
||
|
|
|
||
|
|
- Dir: thumb/v7e-m/fpv5_d16
|
||
|
|
Flags: [--target=thumbv7em-none-unknown-eabihf, -mfpu=fpv5-d16]
|
||
|
|
|
||
|
|
- Dir: thumb/v8-m.main/fp
|
||
|
|
Flags: [--target=thumbv8m.main-none-unknown-eabihf]
|
||
|
|
|
||
|
|
- Dir: thumb/v8.1-m.main/fp
|
||
|
|
Flags: [--target=thumbv8.1m.main-none-unknown-eabihf]
|
||
|
|
|
||
|
|
- Dir: thumb/v8.1-m.main/nofp/mve
|
||
|
|
Flags: [--target=thumbv8.1m.main-none-unknown-eabihf, -march=thumbv8.1m.main+mve]
|
||
|
|
|
||
|
|
Mappings:
|
||
|
|
- Match: --target=thumbv8(\.[0-9]+)?m\.base-none-unknown-eabi
|
||
|
|
Flags: [--target=thumbv6m-none-unknown-eabi]
|
||
|
|
- Match: -target=thumbv8\.[1-9]m\.main-none-unknown-eabi
|
||
|
|
Flags: [--target=thumbv8.1m.main-none-unknown-eabi]
|
||
|
|
- Match: -target=thumbv8\.[1-9]m\.main-none-unknown-eabihf
|
||
|
|
Flags: [--target=thumbv8.1m.main-none-unknown-eabihf]
|
||
|
|
- Match: -march=thumbv8\.[1-9]m\.main.*\+mve($|\+).*
|
||
|
|
Flags: [-march=thumbv8.1m.main+mve]
|
||
|
|
)";
|
||
|
|
|
||
|
|
MultilibSet MS;
|
||
|
|
llvm::SmallVector<Multilib> Selected;
|
||
|
|
ASSERT_TRUE(parseYaml(MS, MultilibSpec));
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select({"--target=thumbv6m-none-unknown-eabi", "-mfpu=none"},
|
||
|
|
Selected));
|
||
|
|
EXPECT_EQ("/thumb/v6-m/nofp", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select({"--target=thumbv7m-none-unknown-eabi", "-mfpu=none"},
|
||
|
|
Selected));
|
||
|
|
EXPECT_EQ("/thumb/v7-m/nofp", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select({"--target=thumbv7em-none-unknown-eabi", "-mfpu=none"},
|
||
|
|
Selected));
|
||
|
|
EXPECT_EQ("/thumb/v7e-m/nofp", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select(
|
||
|
|
{"--target=thumbv8m.main-none-unknown-eabi", "-mfpu=none"}, Selected));
|
||
|
|
EXPECT_EQ("/thumb/v8-m.main/nofp", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select(
|
||
|
|
{"--target=thumbv8.1m.main-none-unknown-eabi", "-mfpu=none"}, Selected));
|
||
|
|
EXPECT_EQ("/thumb/v8.1-m.main/nofp/nomve", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(
|
||
|
|
MS.select({"--target=thumbv7em-none-unknown-eabihf", "-mfpu=fpv4-sp-d16"},
|
||
|
|
Selected));
|
||
|
|
EXPECT_EQ("/thumb/v7e-m/fpv4_sp_d16", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select(
|
||
|
|
{"--target=thumbv7em-none-unknown-eabihf", "-mfpu=fpv5-d16"}, Selected));
|
||
|
|
EXPECT_EQ("/thumb/v7e-m/fpv5_d16", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(
|
||
|
|
MS.select({"--target=thumbv8m.main-none-unknown-eabihf"}, Selected));
|
||
|
|
EXPECT_EQ("/thumb/v8-m.main/fp", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(
|
||
|
|
MS.select({"--target=thumbv8.1m.main-none-unknown-eabihf"}, Selected));
|
||
|
|
EXPECT_EQ("/thumb/v8.1-m.main/fp", Selected.back().gccSuffix());
|
||
|
|
|
||
|
|
ASSERT_TRUE(MS.select({"--target=thumbv8.1m.main-none-unknown-eabihf",
|
||
|
|
"-mfpu=none", "-march=thumbv8.1m.main+dsp+mve"},
|
||
|
|
Selected));
|
||
|
|
EXPECT_EQ("/thumb/v8.1-m.main/nofp/mve", Selected.back().gccSuffix());
|
||
|
|
}
|