GlobalISel: extend legalizer interface to handle multiple types.

Instructions like G_ICMP have multiple types that may need to be legalized (the
boolean output and nearly arbitrary inputs in this case). So the legalizer must
be capable of deciding what to do for each of them separately.

llvm-svn: 279554

1 files changed, 42 insertions, 22 deletions

diff --git a/llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp b/llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp
index 5f217623cac..946f3b4c0c9 100644
--- a/llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/MachineLegalizerTest.cpp
@@ -52,51 +52,71 @@ namespace {
 
 
 TEST(MachineLegalizerTest, ScalarRISC) {
+  using namespace TargetOpcode;
   MachineLegalizer L;
   // Typical RISCy set of operations based on AArch64.
-  L.setAction(TargetOpcode::G_ADD, LLT::scalar(8), WidenScalar);
-  L.setAction(TargetOpcode::G_ADD, LLT::scalar(16), WidenScalar);
-  L.setAction(TargetOpcode::G_ADD, LLT::scalar(32), Legal);
-  L.setAction(TargetOpcode::G_ADD, LLT::scalar(64), Legal);
+  L.setAction({G_ADD, LLT::scalar(8)}, WidenScalar);
+  L.setAction({G_ADD, LLT::scalar(16)}, WidenScalar);
+  L.setAction({G_ADD, LLT::scalar(32)}, Legal);
+  L.setAction({G_ADD, LLT::scalar(64)}, Legal);
   L.computeTables();
 
   // Check we infer the correct types and actually do what we're told.
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::scalar(8)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(8)}),
                         std::make_pair(WidenScalar, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::scalar(16)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(16)}),
                         std::make_pair(WidenScalar, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::scalar(32)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(32)}),
                         std::make_pair(Legal, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::scalar(64)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(64)}),
                         std::make_pair(Legal, LLT::scalar(64)));
 
   // Make sure the default for over-sized types applies.
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::scalar(128)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::scalar(128)}),
                         std::make_pair(NarrowScalar, LLT::scalar(64)));
 }
 
 TEST(MachineLegalizerTest, VectorRISC) {
+  using namespace TargetOpcode;
   MachineLegalizer L;
   // Typical RISCy set of operations based on ARM.
-  L.setScalarInVectorAction(TargetOpcode::G_ADD, LLT::scalar(8), Legal);
-  L.setScalarInVectorAction(TargetOpcode::G_ADD, LLT::scalar(16), Legal);
-  L.setScalarInVectorAction(TargetOpcode::G_ADD, LLT::scalar(32), Legal);
-
-  L.setAction(TargetOpcode::G_ADD, LLT::vector(8, 8), Legal);
-  L.setAction(TargetOpcode::G_ADD, LLT::vector(16, 8), Legal);
-  L.setAction(TargetOpcode::G_ADD, LLT::vector(4, 16), Legal);
-  L.setAction(TargetOpcode::G_ADD, LLT::vector(8, 16), Legal);
-  L.setAction(TargetOpcode::G_ADD, LLT::vector(2, 32), Legal);
-  L.setAction(TargetOpcode::G_ADD, LLT::vector(4, 32), Legal);
+  L.setScalarInVectorAction(G_ADD, LLT::scalar(8), Legal);
+  L.setScalarInVectorAction(G_ADD, LLT::scalar(16), Legal);
+  L.setScalarInVectorAction(G_ADD, LLT::scalar(32), 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.computeTables();
 
   // Check we infer the correct types and actually do what we're told for some
   // simple cases.
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::vector(2, 8)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::vector(2, 8)}),
             std::make_pair(MoreElements, LLT::vector(8, 8)));
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::vector(8, 8)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 8)}),
             std::make_pair(Legal, LLT::vector(8, 8)));
-  ASSERT_EQ(L.getAction(TargetOpcode::G_ADD, LLT::vector(8, 32)),
+  ASSERT_EQ(L.getAction({G_ADD, LLT::vector(8, 32)}),
             std::make_pair(FewerElements, LLT::vector(4, 32)));
 }
+
+TEST(MachineLegalizerTest, MultipleTypes) {
+  using namespace TargetOpcode;
+  MachineLegalizer L;
+
+  // Typical RISCy set of operations based on AArch64.
+  L.setAction({G_PTRTOINT, 0, LLT::scalar(64)}, Legal);
+  L.setAction({G_PTRTOINT, 1, LLT::pointer(0)}, Legal);
+
+  L.setAction({G_PTRTOINT, 0, LLT::scalar(32)}, WidenScalar);
+  L.computeTables();
+
+  // Check we infer the correct types and actually do what we're told.
+  ASSERT_EQ(L.getAction({G_PTRTOINT, 0, LLT::scalar(64)}),
+                        std::make_pair(Legal, LLT::scalar(64)));
+  ASSERT_EQ(L.getAction({G_PTRTOINT, 1, LLT::pointer(0)}),
+                        std::make_pair(Legal, LLT::pointer(0)));
+}
 }