OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity
llvm-project/clang/unittests/Driver/ToolChainTest.cpp

665 lines
27 KiB
C++
Raw Blame History

//===- unittests/Driver/ToolChainTest.cpp --- ToolChain 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 ToolChains.
//
//===----------------------------------------------------------------------===//
#include "clang/Driver/ToolChain.h"
#include "clang/Basic/DiagnosticIDs.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/LLVM.h"
#include "clang/Driver/Compilation.h"
#include "clang/Driver/Driver.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/MC/TargetRegistry.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/VirtualFileSystem.h"
#include "llvm/Support/raw_ostream.h"
#include "gtest/gtest.h"
#include <memory>
using namespace clang;
using namespace clang::driver;
namespace {
TEST(ToolChainTest, VFSGCCInstallation) {
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
struct TestDiagnosticConsumer : public DiagnosticConsumer {};
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
const char *EmptyFiles[] = {
"foo.cpp",
"/bin/clang",
"/usr/lib/gcc/arm-linux-gnueabi/4.6.1/crtbegin.o",
"/usr/lib/gcc/arm-linux-gnueabi/4.6.1/crtend.o",
"/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/crtbegin.o",
"/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/crtend.o",
"/usr/lib/arm-linux-gnueabi/crt1.o",
"/usr/lib/arm-linux-gnueabi/crti.o",
"/usr/lib/arm-linux-gnueabi/crtn.o",
"/usr/lib/arm-linux-gnueabihf/crt1.o",
"/usr/lib/arm-linux-gnueabihf/crti.o",
"/usr/lib/arm-linux-gnueabihf/crtn.o",
"/usr/include/arm-linux-gnueabi/.keep",
"/usr/include/arm-linux-gnueabihf/.keep",
"/lib/arm-linux-gnueabi/.keep",
"/lib/arm-linux-gnueabihf/.keep",
"/sysroot/usr/lib/gcc/arm-linux-gnueabi/4.5.1/crtbegin.o",
"/sysroot/usr/lib/gcc/arm-linux-gnueabi/4.5.1/crtend.o",
"/sysroot/usr/lib/gcc/arm-linux-gnueabihf/4.5.3/crtbegin.o",
"/sysroot/usr/lib/gcc/arm-linux-gnueabihf/4.5.3/crtend.o",
"/sysroot/usr/lib/arm-linux-gnueabi/crt1.o",
"/sysroot/usr/lib/arm-linux-gnueabi/crti.o",
"/sysroot/usr/lib/arm-linux-gnueabi/crtn.o",
"/sysroot/usr/lib/arm-linux-gnueabihf/crt1.o",
"/sysroot/usr/lib/arm-linux-gnueabihf/crti.o",
"/sysroot/usr/lib/arm-linux-gnueabihf/crtn.o",
"/sysroot/usr/include/arm-linux-gnueabi/.keep",
"/sysroot/usr/include/arm-linux-gnueabihf/.keep",
"/sysroot/lib/arm-linux-gnueabi/.keep",
"/sysroot/lib/arm-linux-gnueabihf/.keep",
};
for (const char *Path : EmptyFiles)
InMemoryFileSystem->addFile(Path, 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
{
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags,
"clang LLVM compiler", InMemoryFileSystem);
std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
{"-fsyntax-only", "--gcc-toolchain=", "--sysroot=", "foo.cpp"}));
ASSERT_TRUE(C);
std::string S;
{
llvm::raw_string_ostream OS(S);
C->getDefaultToolChain().printVerboseInfo(OS);
}
if (is_style_windows(llvm::sys::path::Style::native))
std::replace(S.begin(), S.end(), '\\', '/');
EXPECT_EQ(
"Found candidate GCC installation: "
"/usr/lib/gcc/arm-linux-gnueabihf/4.6.3\n"
"Selected GCC installation: /usr/lib/gcc/arm-linux-gnueabihf/4.6.3\n"
"Candidate multilib: .;@m32\n"
"Selected multilib: .;@m32\n",
S);
}
{
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags,
"clang LLVM compiler", InMemoryFileSystem);
std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
{"-fsyntax-only", "--gcc-toolchain=", "--sysroot=/sysroot",
"foo.cpp"}));
ASSERT_TRUE(C);
std::string S;
{
llvm::raw_string_ostream OS(S);
C->getDefaultToolChain().printVerboseInfo(OS);
}
if (is_style_windows(llvm::sys::path::Style::native))
std::replace(S.begin(), S.end(), '\\', '/');
// Test that 4.5.3 from --sysroot is not overridden by 4.6.3 (larger
// version) from /usr.
EXPECT_EQ("Found candidate GCC installation: "
"/sysroot/usr/lib/gcc/arm-linux-gnueabihf/4.5.3\n"
"Selected GCC installation: "
"/sysroot/usr/lib/gcc/arm-linux-gnueabihf/4.5.3\n"
"Candidate multilib: .;@m32\n"
"Selected multilib: .;@m32\n",
S);
}
}
TEST(ToolChainTest, VFSGCCInstallationRelativeDir) {
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
struct TestDiagnosticConsumer : public DiagnosticConsumer {};
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
Driver TheDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
"clang LLVM compiler", InMemoryFileSystem);
const char *EmptyFiles[] = {
"foo.cpp", "/home/test/lib/gcc/arm-linux-gnueabi/4.6.1/crtbegin.o",
"/home/test/include/arm-linux-gnueabi/.keep"};
for (const char *Path : EmptyFiles)
InMemoryFileSystem->addFile(Path, 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
{"-fsyntax-only", "--gcc-toolchain=", "foo.cpp"}));
EXPECT_TRUE(C);
std::string S;
{
llvm::raw_string_ostream OS(S);
C->getDefaultToolChain().printVerboseInfo(OS);
}
if (is_style_windows(llvm::sys::path::Style::native))
std::replace(S.begin(), S.end(), '\\', '/');
EXPECT_EQ("Found candidate GCC installation: "
"/home/test/bin/../lib/gcc/arm-linux-gnueabi/4.6.1\n"
"Selected GCC installation: "
"/home/test/bin/../lib/gcc/arm-linux-gnueabi/4.6.1\n"
"Candidate multilib: .;@m32\n"
"Selected multilib: .;@m32\n",
S);
}
TEST(ToolChainTest, DefaultDriverMode) {
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
struct TestDiagnosticConsumer : public DiagnosticConsumer {};
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
Driver CCDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
"clang LLVM compiler", InMemoryFileSystem);
CCDriver.setCheckInputsExist(false);
Driver CXXDriver("/home/test/bin/clang++", "arm-linux-gnueabi", Diags,
"clang LLVM compiler", InMemoryFileSystem);
CXXDriver.setCheckInputsExist(false);
Driver CLDriver("/home/test/bin/clang-cl", "arm-linux-gnueabi", Diags,
"clang LLVM compiler", InMemoryFileSystem);
CLDriver.setCheckInputsExist(false);
std::unique_ptr<Compilation> CC(CCDriver.BuildCompilation(
{ "/home/test/bin/clang", "foo.cpp"}));
std::unique_ptr<Compilation> CXX(CXXDriver.BuildCompilation(
{ "/home/test/bin/clang++", "foo.cpp"}));
std::unique_ptr<Compilation> CL(CLDriver.BuildCompilation(
{ "/home/test/bin/clang-cl", "foo.cpp"}));
EXPECT_TRUE(CC);
EXPECT_TRUE(CXX);
EXPECT_TRUE(CL);
EXPECT_TRUE(CCDriver.CCCIsCC());
EXPECT_TRUE(CXXDriver.CCCIsCXX());
EXPECT_TRUE(CLDriver.IsCLMode());
}
TEST(ToolChainTest, InvalidArgument) {
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
struct TestDiagnosticConsumer : public DiagnosticConsumer {};
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags);
std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
{"-fsyntax-only", "-fan-unknown-option", "foo.cpp"}));
EXPECT_TRUE(C);
EXPECT_TRUE(C->containsError());
}
TEST(ToolChainTest, ParsedClangName) {
ParsedClangName Empty;
EXPECT_TRUE(Empty.TargetPrefix.empty());
EXPECT_TRUE(Empty.ModeSuffix.empty());
EXPECT_TRUE(Empty.DriverMode == nullptr);
EXPECT_FALSE(Empty.TargetIsValid);
ParsedClangName DriverOnly("clang", nullptr);
EXPECT_TRUE(DriverOnly.TargetPrefix.empty());
EXPECT_TRUE(DriverOnly.ModeSuffix == "clang");
EXPECT_TRUE(DriverOnly.DriverMode == nullptr);
EXPECT_FALSE(DriverOnly.TargetIsValid);
ParsedClangName DriverOnly2("clang++", "--driver-mode=g++");
EXPECT_TRUE(DriverOnly2.TargetPrefix.empty());
EXPECT_TRUE(DriverOnly2.ModeSuffix == "clang++");
EXPECT_STREQ(DriverOnly2.DriverMode, "--driver-mode=g++");
EXPECT_FALSE(DriverOnly2.TargetIsValid);
ParsedClangName TargetAndMode("i386", "clang-g++", "--driver-mode=g++", true);
EXPECT_TRUE(TargetAndMode.TargetPrefix == "i386");
EXPECT_TRUE(TargetAndMode.ModeSuffix == "clang-g++");
EXPECT_STREQ(TargetAndMode.DriverMode, "--driver-mode=g++");
EXPECT_TRUE(TargetAndMode.TargetIsValid);
}
TEST(ToolChainTest, GetTargetAndMode) {
llvm::InitializeAllTargets();
std::string IgnoredError;
if (!llvm::TargetRegistry::lookupTarget("x86_64", IgnoredError))
return;
ParsedClangName Res = ToolChain::getTargetAndModeFromProgramName("clang");
EXPECT_TRUE(Res.TargetPrefix.empty());
EXPECT_TRUE(Res.ModeSuffix == "clang");
EXPECT_TRUE(Res.DriverMode == nullptr);
EXPECT_FALSE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("clang++");
EXPECT_TRUE(Res.TargetPrefix.empty());
EXPECT_TRUE(Res.ModeSuffix == "clang++");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=g++");
EXPECT_FALSE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("clang++6.0");
EXPECT_TRUE(Res.TargetPrefix.empty());
EXPECT_TRUE(Res.ModeSuffix == "clang++");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=g++");
EXPECT_FALSE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("clang++-release");
EXPECT_TRUE(Res.TargetPrefix.empty());
EXPECT_TRUE(Res.ModeSuffix == "clang++");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=g++");
EXPECT_FALSE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("x86_64-clang++");
EXPECT_TRUE(Res.TargetPrefix == "x86_64");
EXPECT_TRUE(Res.ModeSuffix == "clang++");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=g++");
EXPECT_TRUE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName(
"x86_64-linux-gnu-clang-c++");
EXPECT_TRUE(Res.TargetPrefix == "x86_64-linux-gnu");
EXPECT_TRUE(Res.ModeSuffix == "clang-c++");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=g++");
EXPECT_TRUE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName(
"x86_64-linux-gnu-clang-c++-tot");
EXPECT_TRUE(Res.TargetPrefix == "x86_64-linux-gnu");
EXPECT_TRUE(Res.ModeSuffix == "clang-c++");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=g++");
EXPECT_TRUE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("qqq");
EXPECT_TRUE(Res.TargetPrefix.empty());
EXPECT_TRUE(Res.ModeSuffix.empty());
EXPECT_TRUE(Res.DriverMode == nullptr);
EXPECT_FALSE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("x86_64-qqq");
EXPECT_TRUE(Res.TargetPrefix.empty());
EXPECT_TRUE(Res.ModeSuffix.empty());
EXPECT_TRUE(Res.DriverMode == nullptr);
EXPECT_FALSE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("qqq-clang-cl");
EXPECT_TRUE(Res.TargetPrefix == "qqq");
EXPECT_TRUE(Res.ModeSuffix == "clang-cl");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=cl");
EXPECT_FALSE(Res.TargetIsValid);
Res = ToolChain::getTargetAndModeFromProgramName("clang-dxc");
EXPECT_TRUE(Res.TargetPrefix.empty());
EXPECT_TRUE(Res.ModeSuffix == "clang-dxc");
EXPECT_STREQ(Res.DriverMode, "--driver-mode=dxc");
EXPECT_FALSE(Res.TargetIsValid);
}
TEST(ToolChainTest, CommandOutput) {
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
struct TestDiagnosticConsumer : public DiagnosticConsumer {};
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
Driver CCDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
"clang LLVM compiler", InMemoryFileSystem);
CCDriver.setCheckInputsExist(false);
std::unique_ptr<Compilation> CC(
CCDriver.BuildCompilation({"/home/test/bin/clang", "foo.cpp"}));
const JobList &Jobs = CC->getJobs();
const auto &CmdCompile = Jobs.getJobs().front();
const auto &InFile = CmdCompile->getInputInfos().front().getFilename();
EXPECT_STREQ(InFile, "foo.cpp");
auto ObjFile = CmdCompile->getOutputFilenames().front();
EXPECT_TRUE(StringRef(ObjFile).endswith(".o"));
const auto &CmdLink = Jobs.getJobs().back();
const auto LinkInFile = CmdLink->getInputInfos().front().getFilename();
EXPECT_EQ(ObjFile, LinkInFile);
auto ExeFile = CmdLink->getOutputFilenames().front();
EXPECT_EQ("a.out", ExeFile);
}
TEST(ToolChainTest, PostCallback) {
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
struct TestDiagnosticConsumer : public DiagnosticConsumer {};
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
// The executable path must not exist.
Driver CCDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
"clang LLVM compiler", InMemoryFileSystem);
CCDriver.setCheckInputsExist(false);
std::unique_ptr<Compilation> CC(
CCDriver.BuildCompilation({"/home/test/bin/clang", "foo.cpp"}));
bool CallbackHasCalled = false;
CC->setPostCallback(
[&](const Command &C, int Ret) { CallbackHasCalled = true; });
const JobList &Jobs = CC->getJobs();
auto &CmdCompile = Jobs.getJobs().front();
const Command *FailingCmd = nullptr;
CC->ExecuteCommand(*CmdCompile, FailingCmd);
EXPECT_TRUE(CallbackHasCalled);
}
TEST(GetDriverMode, PrefersLastDriverMode) {
static constexpr const char *Args[] = {"clang-cl", "--driver-mode=foo",
"--driver-mode=bar", "foo.cpp"};
EXPECT_EQ(getDriverMode(Args[0], llvm::makeArrayRef(Args).slice(1)), "bar");
}
struct SimpleDiagnosticConsumer : public DiagnosticConsumer {
void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
const Diagnostic &Info) override {
if (DiagLevel == DiagnosticsEngine::Level::Error) {
Errors.emplace_back();
Info.FormatDiagnostic(Errors.back());
} else {
Msgs.emplace_back();
Info.FormatDiagnostic(Msgs.back());
}
}
void clear() override {
Msgs.clear();
Errors.clear();
DiagnosticConsumer::clear();
}
std::vector<SmallString<32>> Msgs;
std::vector<SmallString<32>> Errors;
};
static void validateTargetProfile(
StringRef TargetProfile, StringRef ExpectTriple,
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> &InMemoryFileSystem,
DiagnosticsEngine &Diags) {
Driver TheDriver("/bin/clang", "", Diags, "", InMemoryFileSystem);
std::unique_ptr<Compilation> C{TheDriver.BuildCompilation(
{"clang", "--driver-mode=dxc", TargetProfile.data(), "foo.hlsl"})};
EXPECT_TRUE(C);
EXPECT_STREQ(TheDriver.getTargetTriple().c_str(), ExpectTriple.data());
EXPECT_EQ(Diags.getNumErrors(), 0u);
}
static void validateTargetProfile(
StringRef TargetProfile, StringRef ExpectError,
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> &InMemoryFileSystem,
DiagnosticsEngine &Diags, SimpleDiagnosticConsumer *DiagConsumer,
unsigned NumOfErrors) {
Driver TheDriver("/bin/clang", "", Diags, "", InMemoryFileSystem);
std::unique_ptr<Compilation> C{TheDriver.BuildCompilation(
{"clang", "--driver-mode=dxc", TargetProfile.data(), "foo.hlsl"})};
EXPECT_TRUE(C);
EXPECT_EQ(Diags.getNumErrors(), NumOfErrors);
EXPECT_STREQ(DiagConsumer->Errors.back().c_str(), ExpectError.data());
Diags.Clear();
DiagConsumer->clear();
}
TEST(DxcModeTest, TargetProfileValidation) {
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
InMemoryFileSystem->addFile("foo.hlsl", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
auto *DiagConsumer = new SimpleDiagnosticConsumer;
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagConsumer);
validateTargetProfile("-Tvs_6_0", "dxil--shadermodel6.0-vertex",
InMemoryFileSystem, Diags);
validateTargetProfile("-Ths_6_1", "dxil--shadermodel6.1-hull",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tds_6_2", "dxil--shadermodel6.2-domain",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tds_6_2", "dxil--shadermodel6.2-domain",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tgs_6_3", "dxil--shadermodel6.3-geometry",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tps_6_4", "dxil--shadermodel6.4-pixel",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tcs_6_5", "dxil--shadermodel6.5-compute",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tms_6_6", "dxil--shadermodel6.6-mesh",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tas_6_7", "dxil--shadermodel6.7-amplification",
InMemoryFileSystem, Diags);
validateTargetProfile("-Tlib_6_x", "dxil--shadermodel6.15-library",
InMemoryFileSystem, Diags);
// Invalid tests.
validateTargetProfile("-Tpss_6_1", "invalid profile : pss_6_1",
InMemoryFileSystem, Diags, DiagConsumer, 1);
validateTargetProfile("-Tps_6_x", "invalid profile : ps_6_x",
InMemoryFileSystem, Diags, DiagConsumer, 2);
validateTargetProfile("-Tlib_6_1", "invalid profile : lib_6_1",
InMemoryFileSystem, Diags, DiagConsumer, 3);
validateTargetProfile("-Tfoo", "invalid profile : foo", InMemoryFileSystem,
Diags, DiagConsumer, 4);
validateTargetProfile("", "target profile option (-T) is missing",
InMemoryFileSystem, Diags, DiagConsumer, 5);
}
TEST(DxcModeTest, ValidatorVersionValidation) {
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
InMemoryFileSystem->addFile("foo.hlsl", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
auto *DiagConsumer = new SimpleDiagnosticConsumer;
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagConsumer);
Driver TheDriver("/bin/clang", "", Diags, "", InMemoryFileSystem);
std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
{"clang", "--driver-mode=dxc", "-Tlib_6_7", "foo.hlsl"}));
EXPECT_TRUE(C);
EXPECT_TRUE(!C->containsError());
auto &TC = C->getDefaultToolChain();
bool ContainsError = false;
auto Args = TheDriver.ParseArgStrings({"-validator-version", "1.1"}, false,
ContainsError);
EXPECT_FALSE(ContainsError);
auto DAL = std::make_unique<llvm::opt::DerivedArgList>(Args);
for (auto *A : Args)
DAL->append(A);
std::unique_ptr<llvm::opt::DerivedArgList> TranslatedArgs{
TC.TranslateArgs(*DAL, "0", Action::OffloadKind::OFK_None)};
EXPECT_NE(TranslatedArgs, nullptr);
if (TranslatedArgs) {
auto *A = TranslatedArgs->getLastArg(
clang::driver::options::OPT_dxil_validator_version);
EXPECT_NE(A, nullptr);
if (A)
EXPECT_STREQ(A->getValue(), "1.1");
}
EXPECT_EQ(Diags.getNumErrors(), 0u);
// Invalid tests.
Args = TheDriver.ParseArgStrings({"-validator-version", "0.1"}, false,
ContainsError);
EXPECT_FALSE(ContainsError);
DAL = std::make_unique<llvm::opt::DerivedArgList>(Args);
for (auto *A : Args)
DAL->append(A);
TranslatedArgs.reset(
TC.TranslateArgs(*DAL, "0", Action::OffloadKind::OFK_None));
EXPECT_EQ(Diags.getNumErrors(), 1u);
EXPECT_STREQ(DiagConsumer->Errors.back().c_str(),
"invalid validator version : 0.1\nIf validator major version is "
"0, minor version must also be 0.");
Diags.Clear();
DiagConsumer->clear();
Args = TheDriver.ParseArgStrings({"-validator-version", "1"}, false,
ContainsError);
EXPECT_FALSE(ContainsError);
DAL = std::make_unique<llvm::opt::DerivedArgList>(Args);
for (auto *A : Args)
DAL->append(A);
TranslatedArgs.reset(
TC.TranslateArgs(*DAL, "0", Action::OffloadKind::OFK_None));
EXPECT_EQ(Diags.getNumErrors(), 2u);
EXPECT_STREQ(DiagConsumer->Errors.back().c_str(),
"invalid validator version : 1\nFormat of validator version is "
"\"<major>.<minor>\" (ex:\"1.4\").");
Diags.Clear();
DiagConsumer->clear();
Args = TheDriver.ParseArgStrings({"-validator-version", "-Tlib_6_7"}, false,
ContainsError);
EXPECT_FALSE(ContainsError);
DAL = std::make_unique<llvm::opt::DerivedArgList>(Args);
for (auto *A : Args)
DAL->append(A);
TranslatedArgs.reset(
TC.TranslateArgs(*DAL, "0", Action::OffloadKind::OFK_None));
EXPECT_EQ(Diags.getNumErrors(), 3u);
EXPECT_STREQ(
DiagConsumer->Errors.back().c_str(),
"invalid validator version : -Tlib_6_7\nFormat of validator version is "
"\"<major>.<minor>\" (ex:\"1.4\").");
Diags.Clear();
DiagConsumer->clear();
Args = TheDriver.ParseArgStrings({"-validator-version", "foo"}, false,
ContainsError);
EXPECT_FALSE(ContainsError);
DAL = std::make_unique<llvm::opt::DerivedArgList>(Args);
for (auto *A : Args)
DAL->append(A);
TranslatedArgs.reset(
TC.TranslateArgs(*DAL, "0", Action::OffloadKind::OFK_None));
EXPECT_EQ(Diags.getNumErrors(), 4u);
EXPECT_STREQ(
DiagConsumer->Errors.back().c_str(),
"invalid validator version : foo\nFormat of validator version is "
"\"<major>.<minor>\" (ex:\"1.4\").");
Diags.Clear();
DiagConsumer->clear();
}
TEST(ToolChainTest, Toolsets) {
// Ignore this test on Windows hosts.
llvm::Triple Host(llvm::sys::getProcessTriple());
if (Host.isOSWindows())
GTEST_SKIP();
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
// Check (newer) GCC toolset installation.
{
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
// These should be ignored.
InMemoryFileSystem->addFile("/opt/rh/gcc-toolset-2", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
InMemoryFileSystem->addFile("/opt/rh/gcc-toolset-", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
InMemoryFileSystem->addFile("/opt/rh/gcc-toolset--", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
InMemoryFileSystem->addFile("/opt/rh/gcc-toolset--1", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
// File needed for GCC installation detection.
InMemoryFileSystem->addFile("/opt/rh/gcc-toolset-12/root/usr/lib/gcc/"
"x86_64-redhat-linux/11/crtbegin.o",
0, llvm::MemoryBuffer::getMemBuffer("\n"));
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new SimpleDiagnosticConsumer);
Driver TheDriver("/bin/clang", "x86_64-redhat-linux", Diags,
"clang LLVM compiler", InMemoryFileSystem);
std::unique_ptr<Compilation> C(
TheDriver.BuildCompilation({"clang", "--gcc-toolchain="}));
ASSERT_TRUE(C);
std::string S;
{
llvm::raw_string_ostream OS(S);
C->getDefaultToolChain().printVerboseInfo(OS);
}
EXPECT_EQ("Found candidate GCC installation: "
"/opt/rh/gcc-toolset-12/root/usr/lib/gcc/x86_64-redhat-linux/11\n"
"Selected GCC installation: "
"/opt/rh/gcc-toolset-12/root/usr/lib/gcc/x86_64-redhat-linux/11\n"
"Candidate multilib: .;@m64\n"
"Selected multilib: .;@m64\n",
S);
}
// And older devtoolset.
{
IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
new llvm::vfs::InMemoryFileSystem);
// These should be ignored.
InMemoryFileSystem->addFile("/opt/rh/devtoolset-2", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
InMemoryFileSystem->addFile("/opt/rh/devtoolset-", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
InMemoryFileSystem->addFile("/opt/rh/devtoolset--", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
InMemoryFileSystem->addFile("/opt/rh/devtoolset--1", 0,
llvm::MemoryBuffer::getMemBuffer("\n"));
// File needed for GCC installation detection.
InMemoryFileSystem->addFile("/opt/rh/devtoolset-12/root/usr/lib/gcc/"
"x86_64-redhat-linux/11/crtbegin.o",
0, llvm::MemoryBuffer::getMemBuffer("\n"));
DiagnosticsEngine Diags(DiagID, &*DiagOpts, new SimpleDiagnosticConsumer);
Driver TheDriver("/bin/clang", "x86_64-redhat-linux", Diags,
"clang LLVM compiler", InMemoryFileSystem);
std::unique_ptr<Compilation> C(
TheDriver.BuildCompilation({"clang", "--gcc-toolchain="}));
ASSERT_TRUE(C);
std::string S;
{
llvm::raw_string_ostream OS(S);
C->getDefaultToolChain().printVerboseInfo(OS);
}
EXPECT_EQ("Found candidate GCC installation: "
"/opt/rh/devtoolset-12/root/usr/lib/gcc/x86_64-redhat-linux/11\n"
"Selected GCC installation: "
"/opt/rh/devtoolset-12/root/usr/lib/gcc/x86_64-redhat-linux/11\n"
"Candidate multilib: .;@m64\n"
"Selected multilib: .;@m64\n",
S);
}
}
} // end anonymous namespace.
Reference in New Issue View Git Blame Copy Permalink