diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
index 876fc54..a661d92 100644
--- a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
@@ -29,6 +29,7 @@
   case Custom: OS << "Custom"; break;
   case Unsupported: OS << "Unsupported"; break;
   case NotFound: OS << "NotFound";
+  case UseLegacyRules: OS << "UseLegacyRules"; break;
   }
   return OS;
 }
@@ -62,34 +63,28 @@
   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(WidenScalar, 0, LLT::scalar(32)));
+              LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),
-              LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+              LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),
-              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
+              LegalizeActionStep(Legal, 0, LLT{}));
     ASSERT_EQ(L.getAction({opcode, {LLT::scalar(64)}}),
-              LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
+              LegalizeActionStep(Legal, 0, LLT{}));
 
     // Make sure the default for over-sized types applies.
-    ASSERT_EQ(
-        L.getAction({opcode, {LLT::scalar(128)}}),
-        LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, 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)}}),
-        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)));
+    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)));
   }
 }
 
@@ -114,23 +109,18 @@
   // 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(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)));
+            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)}}),
-      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)));
+  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) {
@@ -150,15 +140,15 @@
 
   // Check we infer the correct types and actually do what we're told.
   ASSERT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),
-            LegalizerInfo::LegalizeActionStep(Legal, 0, LLT{}));
+            LegalizeActionStep(Legal, 0, LLT{}));
 
   // Make sure we also handle unusual sizes
   ASSERT_EQ(
       L.getAction({G_PTRTOINT, {LLT::scalar(65), s64}}),
-      LegalizerInfo::LegalizeActionStep(NarrowScalar, 0, s64));
+      LegalizeActionStep(NarrowScalar, 0, s64));
   ASSERT_EQ(
       L.getAction({G_PTRTOINT, {s64, LLT::pointer(0, 32)}}),
-      LegalizerInfo::LegalizeActionStep(Unsupported, 1, LLT::pointer(0, 32)));
+      LegalizeActionStep(Unsupported, 1, LLT::pointer(0, 32)));
 }
 
 TEST(LegalizerInfoTest, MultipleSteps) {
@@ -175,9 +165,9 @@
   L.computeTables();
 
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(16)}}),
-            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+            LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),
-            LegalizerInfo::LegalizeActionStep(Lower, 0, LLT::scalar(32)));
+            LegalizeActionStep(Lower, 0, LLT::scalar(32)));
 }
 
 TEST(LegalizerInfoTest, SizeChangeStrategy) {
@@ -193,19 +183,19 @@
   // 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(Legal, 0, LLT{}));
+              LegalizeActionStep(Legal, 0, LLT{}));
   }
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),
-            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
+            LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),
-            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
+            LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),
-            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(16)));
+            LegalizeActionStep(WidenScalar, 0, LLT::scalar(16)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),
-            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+            LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),
-            LegalizerInfo::LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
+            LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
   ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),
-            LegalizerInfo::LegalizeActionStep(Unsupported, 0, LLT::scalar(33)));
+            LegalizeActionStep(Unsupported, 0, LLT::scalar(33)));
 }
 }