GlobalISel: Improve gtest usage

Don't unnecessarily use ASSERT_*, and print the MachineFunction
on failure.

llvm-svn: 353072

1 files changed, 29 insertions, 37 deletions

diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
index 732194f6359..4578b95c203 100644
--- a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
@@ -8,6 +8,7 @@
 
 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
+#include "GISelMITest.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
@@ -33,15 +34,6 @@ operator<<(std::ostream &OS, const LegalizeAction Act) {
   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;
-}
-
 std::ostream &operator<<(std::ostream &OS, const llvm::LegalizeActionStep Ty) {
   OS << "LegalizeActionStep(" << Ty.Action << ", " << Ty.TypeIdx << ", "
      << Ty.NewType << ')';
@@ -67,28 +59,28 @@ 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)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(8)}}),
               LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),
               LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),
               LegalizeActionStep(Legal, 0, LLT{}));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(64)}}),
+    EXPECT_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)}}),
+    EXPECT_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)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(1)}}),
               LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(31)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(31)}}),
               LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(33)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(33)}}),
               LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(63)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(63)}}),
               LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));
-    ASSERT_EQ(L.getAction({opcode, {LLT::scalar(65)}}),
+    EXPECT_EQ(L.getAction({opcode, {LLT::scalar(65)}}),
               LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));
   }
 }
@@ -113,18 +105,18 @@ TEST(LegalizerInfoTest, VectorRISC) {
 
   // 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)}}),
+  EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(8, 8)}}),
             LegalizeActionStep(Legal, 0, LLT{}));
-  ASSERT_EQ(L.getAction({G_ADD, {LLT::vector(8, 7)}}),
+  EXPECT_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)}}),
+  EXPECT_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)}}),
+  EXPECT_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)}}),
+  EXPECT_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)}}),
+  EXPECT_EQ(L.getAction({G_ADD, {LLT::vector(3, 8)}}),
             LegalizeActionStep(MoreElements, 0, LLT::vector(8, 8)));
 }
 
@@ -144,14 +136,14 @@ TEST(LegalizerInfoTest, MultipleTypes) {
   L.computeTables();
 
   // Check we infer the correct types and actually do what we're told.
-  ASSERT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),
+  EXPECT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),
             LegalizeActionStep(Legal, 0, LLT{}));
 
   // Make sure we also handle unusual sizes
-  ASSERT_EQ(
+  EXPECT_EQ(
       L.getAction({G_PTRTOINT, {LLT::scalar(65), s64}}),
       LegalizeActionStep(NarrowScalar, 0, s64));
-  ASSERT_EQ(
+  EXPECT_EQ(
       L.getAction({G_PTRTOINT, {s64, LLT::pointer(0, 32)}}),
       LegalizeActionStep(Unsupported, 1, LLT::pointer(0, 32)));
 }
@@ -169,9 +161,9 @@ TEST(LegalizerInfoTest, MultipleSteps) {
 
   L.computeTables();
 
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(16)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(16)}}),
             LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),
             LegalizeActionStep(Lower, 0, LLT::scalar(32)));
 }
 
@@ -187,20 +179,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)}}),
+    EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(Size)}}),
               LegalizeActionStep(Legal, 0, LLT{}));
   }
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),
             LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),
             LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),
             LegalizeActionStep(WidenScalar, 0, LLT::scalar(16)));
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),
             LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),
             LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));
-  ASSERT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),
+  EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),
             LegalizeActionStep(Unsupported, 0, LLT::scalar(33)));
 }
 }