[globalisel] Make LegalizerInfo::LegalizeAction available outside of LegalizerInfo. NFC

Summary:
The improvements to the LegalizerInfo discussed in D42244 require that
LegalizerInfo::LegalizeAction be available for use in other classes. As such,
it needs to be moved out of LegalizerInfo. This has been done separately to the
next patch to minimize the noise in that patch.

llvm-svn: 323669

1 files changed, 80 insertions, 92 deletions

diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
index fc5e53900f5..876fc5465bf 100644
--- a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
@@ -12,22 +12,23 @@
 #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";
   }
   return OS;
 }
@@ -51,7 +52,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);
   }
@@ -61,38 +62,34 @@ 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)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                                LLT::scalar(32)));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                                LLT::scalar(32)));
-    ASSERT_EQ(
-        L.getAction({opcode, {LLT::scalar(32)}}),
-        LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
-    ASSERT_EQ(
-        L.getAction({opcode, {LLT::scalar(64)}}),
-        LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),
+              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
+    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(64)}}),
+              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
 
     // Make sure the default for over-sized types applies.
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(128)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::NarrowScalar, 0,
-                                                LLT::scalar(64)));
+    ASSERT_EQ(
+        L.getAction({opcode, {LLT::scalar(128)}}),
+        LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));
     // Make sure we also handle unusual sizes
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(1)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                                LLT::scalar(32)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(31)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                                LLT::scalar(32)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(33)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                                LLT::scalar(64)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(63)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                                LLT::scalar(64)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(65)}}),
-              LegalizerInfo::LegalizeActionStep(LegalizerInfo::NarrowScalar, 0,
-                                                LLT::scalar(64)));
+    ASSERT_EQ(
+        L.getAction({opcode, {LLT::scalar(1)}}),
+        LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+    ASSERT_EQ(
+        L.getAction({opcode, {LLT::scalar(31)}}),
+        LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+    ASSERT_EQ(
+        L.getAction({opcode, {LLT::scalar(33)}}),
+        LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
+    ASSERT_EQ(
+        L.getAction({opcode, {LLT::scalar(63)}}),
+        LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
+    ASSERT_EQ(
+        L.getAction({opcode, {LLT::scalar(65)}}),
+        LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));
   }
 }
 
@@ -100,40 +97,40 @@ 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)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
-  ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 7)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::vector(8, 8)));
-  ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(2, 8)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::MoreElements, 0,
-                                              LLT::vector(8, 8)));
-  ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 32)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::FewerElements, 0,
-                                              LLT::vector(4, 32)));
+            LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
+  ASSERT_EQ(
+      L.getAction({G_ADD, {LLT::vector(8, 7)}}),
+      LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::vector(8, 8)));
+  ASSERT_EQ(
+      L.getAction({G_ADD, {LLT::vector(2, 8)}}),
+      LegalizerInfo::LegalizeActionStep(MoreElements, 0, LLT::vector(8, 8)));
+  ASSERT_EQ(
+      L.getAction({G_ADD, {LLT::vector(8, 32)}}),
+      LegalizerInfo::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)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::vector(3, 8)));
-  ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(3, 8)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::MoreElements, 0,
-                                              LLT::vector(8, 8)));
+  ASSERT_EQ(
+      L.getAction({G_ADD, {LLT::vector(3, 3)}}),
+      LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::vector(3, 8)));
+  ASSERT_EQ(
+      L.getAction({G_ADD, {LLT::vector(3, 8)}}),
+      LegalizerInfo::LegalizeActionStep(MoreElements, 0, LLT::vector(8, 8)));
 }
 
 TEST(LegalizerInfoTest, MultipleTypes) {
@@ -143,8 +140,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);
@@ -153,15 +150,15 @@ TEST(LegalizerInfoTest, MultipleTypes) {
 
   // Check we infer the correct types and actually do what we're told.
   ASSERT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+            LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
 
   // Make sure we also handle unusual sizes
   ASSERT_EQ(
       L.getAction({G_PTRTOINT, {LLT::scalar(65), s64}}),
-      LegalizerInfo::LegalizeActionStep(LegalizerInfo::NarrowScalar, 0, s64));
-  ASSERT_EQ(L.getAction({G_PTRTOINT, {s64, LLT::pointer(0, 32)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Unsupported, 1,
-                                              LLT::pointer(0, 32)));
+      LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, s64));
+  ASSERT_EQ(
+      L.getAction({G_PTRTOINT, {s64, LLT::pointer(0, 32)}}),
+      LegalizerInfo::LegalizeActionStep(Unsupported, 1, LLT::pointer(0, 32)));
 }
 
 TEST(LegalizerInfoTest, MultipleSteps) {
@@ -172,24 +169,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)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::scalar(32)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Lower, 0,
-                                              LLT::scalar(32)));
+            LegalizerInfo::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);
@@ -197,27 +192,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)}}),
-        LegalizerInfo::LegalizeActionStep(LegalizerInfo::Legal, 0, LLT{}));
+    ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(Size)}}),
+              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
   }
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::scalar(8)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::scalar(8)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::scalar(16)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(16)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::scalar(32)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::WidenScalar, 0,
-                                              LLT::scalar(32)));
+            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),
-            LegalizerInfo::LegalizeActionStep(LegalizerInfo::Unsupported, 0,
-                                              LLT::scalar(33)));
+            LegalizerInfo::LegalizeActionStep(Unsupported, 0, LLT::scalar(33)));
 }
 }