diff options
| author | Dimitry Andric <dim@FreeBSD.org> | 2017-01-02 19:17:04 +0000 |
|---|---|---|
| committer | Dimitry Andric <dim@FreeBSD.org> | 2017-01-02 19:17:04 +0000 |
| commit | b915e9e0fc85ba6f398b3fab0db6a81a8913af94 (patch) | |
| tree | 98b8f811c7aff2547cab8642daf372d6c59502fb /unittests/CodeGen/GlobalISel | |
| parent | 6421cca32f69ac849537a3cff78c352195e99f1b (diff) | |
Vendor import of llvm trunk r290819:vendor/llvm/llvm-trunk-r290819
Notes
Notes:
svn path=/vendor/llvm/dist/; revision=311116
svn path=/vendor/llvm/llvm-trunk-r290819/; revision=311117; tag=vendor/llvm/llvm-trunk-r290819
Diffstat (limited to 'unittests/CodeGen/GlobalISel')
| -rw-r--r-- | unittests/CodeGen/GlobalISel/CMakeLists.txt | 10 | ||||
| -rw-r--r-- | unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp | 120 |
2 files changed, 130 insertions, 0 deletions
diff --git a/unittests/CodeGen/GlobalISel/CMakeLists.txt b/unittests/CodeGen/GlobalISel/CMakeLists.txt new file mode 100644 index 000000000000..94e31159c6bb --- /dev/null +++ b/unittests/CodeGen/GlobalISel/CMakeLists.txt @@ -0,0 +1,10 @@ +set(LLVM_LINK_COMPONENTS + GlobalISel + CodeGen + ) + +if(LLVM_BUILD_GLOBAL_ISEL) + add_llvm_unittest(GlobalISelTests + LegalizerInfoTest.cpp + ) +endif() diff --git a/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp new file mode 100644 index 000000000000..882df5f25216 --- /dev/null +++ b/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp @@ -0,0 +1,120 @@ +//===- llvm/unittest/CodeGen/GlobalISel/LegalizerInfoTest.cpp -------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h" +#include "llvm/Target/TargetOpcodes.h" +#include "gtest/gtest.h" + +using namespace llvm; + +// Define a couple of pretty printers to help debugging when things go wrong. +namespace llvm { +std::ostream & +operator<<(std::ostream &OS, const llvm::LegalizerInfo::LegalizeAction Act) { + switch (Act) { + case LegalizerInfo::Lower: OS << "Lower"; break; + case LegalizerInfo::Legal: OS << "Legal"; break; + case LegalizerInfo::NarrowScalar: OS << "NarrowScalar"; break; + case LegalizerInfo::WidenScalar: OS << "WidenScalar"; break; + case LegalizerInfo::FewerElements: OS << "FewerElements"; break; + case LegalizerInfo::MoreElements: OS << "MoreElements"; break; + case LegalizerInfo::Libcall: OS << "Libcall"; break; + case LegalizerInfo::Custom: OS << "Custom"; break; + case LegalizerInfo::Unsupported: OS << "Unsupported"; break; + case LegalizerInfo::NotFound: OS << "NotFound"; + } + return OS; +} + +std::ostream & +operator<<(std::ostream &OS, const llvm::LLT Ty) { + std::string Repr; + raw_string_ostream SS{Repr}; + Ty.print(SS); + OS << SS.str(); + return OS; +} +} + +namespace { + + +TEST(LegalizerInfoTest, ScalarRISC) { + using namespace TargetOpcode; + LegalizerInfo L; + // Typical RISCy set of operations based on AArch64. + L.setAction({G_ADD, LLT::scalar(8)}, LegalizerInfo::WidenScalar); + L.setAction({G_ADD, LLT::scalar(16)}, LegalizerInfo::WidenScalar); + L.setAction({G_ADD, LLT::scalar(32)}, LegalizerInfo::Legal); + L.setAction({G_ADD, LLT::scalar(64)}, LegalizerInfo::Legal); + L.computeTables(); + + // Check we infer the correct types and actually do what we're told. + ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(8)}), + std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32))); + ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(16)}), + std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32))); + ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(32)}), + std::make_pair(LegalizerInfo::Legal, LLT::scalar(32))); + ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(64)}), + std::make_pair(LegalizerInfo::Legal, LLT::scalar(64))); + + // Make sure the default for over-sized types applies. + ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(128)}), + std::make_pair(LegalizerInfo::NarrowScalar, LLT::scalar(64))); +} + +TEST(LegalizerInfoTest, VectorRISC) { + using namespace TargetOpcode; + LegalizerInfo L; + // Typical RISCy set of operations based on ARM. + L.setScalarInVectorAction(G_ADD, LLT::scalar(8), LegalizerInfo::Legal); + L.setScalarInVectorAction(G_ADD, LLT::scalar(16), LegalizerInfo::Legal); + L.setScalarInVectorAction(G_ADD, LLT::scalar(32), LegalizerInfo::Legal); + + L.setAction({G_ADD, LLT::vector(8, 8)}, LegalizerInfo::Legal); + L.setAction({G_ADD, LLT::vector(16, 8)}, LegalizerInfo::Legal); + L.setAction({G_ADD, LLT::vector(4, 16)}, LegalizerInfo::Legal); + L.setAction({G_ADD, LLT::vector(8, 16)}, LegalizerInfo::Legal); + L.setAction({G_ADD, LLT::vector(2, 32)}, LegalizerInfo::Legal); + L.setAction({G_ADD, LLT::vector(4, 32)}, LegalizerInfo::Legal); + L.computeTables(); + + // Check we infer the correct types and actually do what we're told for some + // simple cases. + ASSERT_EQ(L.getAction({G_ADD, LLT::vector(2, 8)}), + std::make_pair(LegalizerInfo::MoreElements, LLT::vector(8, 8))); + ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 8)}), + std::make_pair(LegalizerInfo::Legal, LLT::vector(8, 8))); + ASSERT_EQ( + L.getAction({G_ADD, LLT::vector(8, 32)}), + std::make_pair(LegalizerInfo::FewerElements, LLT::vector(4, 32))); +} + +TEST(LegalizerInfoTest, MultipleTypes) { + using namespace TargetOpcode; + LegalizerInfo L; + LLT p0 = LLT::pointer(0, 64); + LLT s32 = LLT::scalar(32); + LLT s64 = LLT::scalar(64); + + // Typical RISCy set of operations based on AArch64. + L.setAction({G_PTRTOINT, 0, s64}, LegalizerInfo::Legal); + L.setAction({G_PTRTOINT, 1, p0}, LegalizerInfo::Legal); + + L.setAction({G_PTRTOINT, 0, s32}, LegalizerInfo::WidenScalar); + L.computeTables(); + + // Check we infer the correct types and actually do what we're told. + ASSERT_EQ(L.getAction({G_PTRTOINT, 0, s64}), + std::make_pair(LegalizerInfo::Legal, s64)); + ASSERT_EQ(L.getAction({G_PTRTOINT, 1, p0}), + std::make_pair(LegalizerInfo::Legal, p0)); +} +} |