summaryrefslogtreecommitdiff
path: root/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp')
-rw-r--r--unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp167
1 files changed, 85 insertions, 82 deletions
diff --git a/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
index ca7b47e87eda..42371e63da9d 100644
--- a/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
+++ b/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
@@ -12,22 +12,24 @@
#include "gtest/gtest.h"
using namespace llvm;
+using namespace LegalizeActions;
// 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) {
+operator<<(std::ostream &OS, const 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";
+ case Lower: OS << "Lower"; break;
+ case Legal: OS << "Legal"; break;
+ case NarrowScalar: OS << "NarrowScalar"; break;
+ case WidenScalar: OS << "WidenScalar"; break;
+ case FewerElements: OS << "FewerElements"; break;
+ case MoreElements: OS << "MoreElements"; break;
+ case Libcall: OS << "Libcall"; break;
+ case Custom: OS << "Custom"; break;
+ case Unsupported: OS << "Unsupported"; break;
+ case NotFound: OS << "NotFound"; break;
+ case UseLegacyRules: OS << "UseLegacyRules"; break;
}
return OS;
}
@@ -51,7 +53,7 @@ TEST(LegalizerInfoTest, ScalarRISC) {
// Typical RISCy set of operations based on AArch64.
for (unsigned Op : {G_ADD, G_SUB}) {
for (unsigned Size : {32, 64})
- L.setAction({Op, 0, LLT::scalar(Size)}, LegalizerInfo::Legal);
+ L.setAction({Op, 0, LLT::scalar(Size)}, Legal);
L.setLegalizeScalarToDifferentSizeStrategy(
Op, 0, LegalizerInfo::widenToLargerTypesAndNarrowToLargest);
}
@@ -60,29 +62,29 @@ TEST(LegalizerInfoTest, ScalarRISC) {
for (unsigned opcode : {G_ADD, G_SUB}) {
// Check we infer the correct types and actually do what we're told.
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(8)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(16)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(32)}),
- std::make_pair(LegalizerInfo::Legal, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(64)}),
- std::make_pair(LegalizerInfo::Legal, LLT::scalar(64)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(8)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),
+ LegalizeActionStep(Legal, 0, LLT{}));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(64)}}),
+ LegalizeActionStep(Legal, 0, LLT{}));
// Make sure the default for over-sized types applies.
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(128)}),
- std::make_pair(LegalizerInfo::NarrowScalar, LLT::scalar(64)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(128)}}),
+ LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));
// Make sure we also handle unusual sizes
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(1)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(31)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(33)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(64)));
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(63)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(64)));
- ASSERT_EQ(L.getAction({opcode, LLT::scalar(65)}),
- std::make_pair(LegalizerInfo::NarrowScalar, LLT::scalar(64)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(1)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(31)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(33)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(63)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
+ ASSERT_EQ(L.getAction({opcode, {LLT::scalar(65)}}),
+ LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));
}
}
@@ -90,35 +92,35 @@ TEST(LegalizerInfoTest, VectorRISC) {
using namespace TargetOpcode;
LegalizerInfo L;
// Typical RISCy set of operations based on ARM.
- 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.setAction({G_ADD, LLT::vector(8, 8)}, Legal);
+ L.setAction({G_ADD, LLT::vector(16, 8)}, Legal);
+ L.setAction({G_ADD, LLT::vector(4, 16)}, Legal);
+ L.setAction({G_ADD, LLT::vector(8, 16)}, Legal);
+ L.setAction({G_ADD, LLT::vector(2, 32)}, Legal);
+ L.setAction({G_ADD, LLT::vector(4, 32)}, Legal);
L.setLegalizeVectorElementToDifferentSizeStrategy(
G_ADD, 0, LegalizerInfo::widenToLargerTypesUnsupportedOtherwise);
- L.setAction({G_ADD, 0, LLT::scalar(32)}, LegalizerInfo::Legal);
+ L.setAction({G_ADD, 0, LLT::scalar(32)}, 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(8, 8)}),
- std::make_pair(LegalizerInfo::Legal, LLT::vector(8, 8)));
- ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 7)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::vector(8, 8)));
- 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, 32)}),
- std::make_pair(LegalizerInfo::FewerElements, LLT::vector(4, 32)));
+ ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 8)}}),
+ LegalizeActionStep(Legal, 0, LLT{}));
+ ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 7)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::vector(8, 8)));
+ ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(2, 8)}}),
+ LegalizeActionStep(MoreElements, 0, LLT::vector(8, 8)));
+ ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 32)}}),
+ LegalizeActionStep(FewerElements, 0, LLT::vector(4, 32)));
// Check a few non-power-of-2 sizes:
- ASSERT_EQ(L.getAction({G_ADD, LLT::vector(3, 3)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::vector(3, 8)));
- ASSERT_EQ(L.getAction({G_ADD, LLT::vector(3, 8)}),
- std::make_pair(LegalizerInfo::MoreElements, LLT::vector(8, 8)));
+ ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(3, 3)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::vector(3, 8)));
+ ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(3, 8)}}),
+ LegalizeActionStep(MoreElements, 0, LLT::vector(8, 8)));
}
TEST(LegalizerInfoTest, MultipleTypes) {
@@ -128,8 +130,8 @@ TEST(LegalizerInfoTest, MultipleTypes) {
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, s64}, Legal);
+ L.setAction({G_PTRTOINT, 1, p0}, Legal);
L.setLegalizeScalarToDifferentSizeStrategy(
G_PTRTOINT, 0, LegalizerInfo::widenToLargerTypesAndNarrowToLargest);
@@ -137,15 +139,16 @@ TEST(LegalizerInfoTest, MultipleTypes) {
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));
+ ASSERT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),
+ LegalizeActionStep(Legal, 0, LLT{}));
+
// Make sure we also handle unusual sizes
- ASSERT_EQ(L.getAction({G_PTRTOINT, 0, LLT::scalar(65)}),
- std::make_pair(LegalizerInfo::NarrowScalar, s64));
- ASSERT_EQ(L.getAction({G_PTRTOINT, 1, LLT::pointer(0, 32)}),
- std::make_pair(LegalizerInfo::Unsupported, LLT::pointer(0, 32)));
+ ASSERT_EQ(
+ L.getAction({G_PTRTOINT, {LLT::scalar(65), s64}}),
+ LegalizeActionStep(NarrowScalar, 0, s64));
+ ASSERT_EQ(
+ L.getAction({G_PTRTOINT, {s64, LLT::pointer(0, 32)}}),
+ LegalizeActionStep(Unsupported, 1, LLT::pointer(0, 32)));
}
TEST(LegalizerInfoTest, MultipleSteps) {
@@ -156,22 +159,22 @@ TEST(LegalizerInfoTest, MultipleSteps) {
L.setLegalizeScalarToDifferentSizeStrategy(
G_UREM, 0, LegalizerInfo::widenToLargerTypesUnsupportedOtherwise);
- L.setAction({G_UREM, 0, s32}, LegalizerInfo::Lower);
- L.setAction({G_UREM, 0, s64}, LegalizerInfo::Lower);
+ L.setAction({G_UREM, 0, s32}, Lower);
+ L.setAction({G_UREM, 0, s64}, Lower);
L.computeTables();
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(16)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(32)}),
- std::make_pair(LegalizerInfo::Lower, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(16)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),
+ LegalizeActionStep(Lower, 0, LLT::scalar(32)));
}
TEST(LegalizerInfoTest, SizeChangeStrategy) {
using namespace TargetOpcode;
LegalizerInfo L;
for (unsigned Size : {1, 8, 16, 32})
- L.setAction({G_UREM, 0, LLT::scalar(Size)}, LegalizerInfo::Legal);
+ L.setAction({G_UREM, 0, LLT::scalar(Size)}, Legal);
L.setLegalizeScalarToDifferentSizeStrategy(
G_UREM, 0, LegalizerInfo::widenToLargerTypesUnsupportedOtherwise);
@@ -179,20 +182,20 @@ TEST(LegalizerInfoTest, SizeChangeStrategy) {
// Check we infer the correct types and actually do what we're told.
for (unsigned Size : {1, 8, 16, 32}) {
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(Size)}),
- std::make_pair(LegalizerInfo::Legal, LLT::scalar(Size)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(Size)}}),
+ LegalizeActionStep(Legal, 0, LLT{}));
}
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(2)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(8)));
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(7)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(8)));
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(9)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(16)));
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(17)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(31)}),
- std::make_pair(LegalizerInfo::WidenScalar, LLT::scalar(32)));
- ASSERT_EQ(L.getAction({G_UREM, LLT::scalar(33)}),
- std::make_pair(LegalizerInfo::Unsupported, LLT::scalar(33)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(16)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),
+ LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+ ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),
+ LegalizeActionStep(Unsupported, 0, LLT::scalar(33)));
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-08 14:13:55 +0000