GlobalISel: Try to make legalize rules more useful for vectors

Mostly keep the existing functions on scalars, but add versions which
also operate based on the vector element size.

llvm-svn: 353430

1 files changed, 126 insertions, 0 deletions

diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
index 4578b95c203..3617388c04e 100644
--- a/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
@@ -206,11 +206,21 @@ TEST(LegalizerInfoTest, SizeChangeStrategy) {
 TEST(LegalizerInfoTest, RuleSets) {
   using namespace TargetOpcode;
 
+  const LLT s5 = LLT::scalar(5);
+  const LLT s8 = LLT::scalar(8);
+  const LLT s16 = LLT::scalar(16);
   const LLT s32 = LLT::scalar(32);
+  const LLT s33 = LLT::scalar(33);
+  const LLT s64 = LLT::scalar(64);
 
+  const LLT v2s5 = LLT::vector(2, 5);
+  const LLT v2s8 = LLT::vector(2, 8);
+  const LLT v2s16 = LLT::vector(2, 16);
   const LLT v2s32 = LLT::vector(2, 32);
   const LLT v3s32 = LLT::vector(3, 32);
   const LLT v4s32 = LLT::vector(4, 32);
+  const LLT v2s33 = LLT::vector(2, 33);
+  const LLT v2s64 = LLT::vector(2, 64);
 
   const LLT p0 = LLT::pointer(0, 32);
   const LLT v3p0 = LLT::vector(3, p0);
@@ -229,4 +239,120 @@ TEST(LegalizerInfoTest, RuleSets) {
     EXPECT_ACTION(MoreElements, 0, v4p0, LegalityQuery(G_IMPLICIT_DEF, {v3p0}));
     EXPECT_ACTION(MoreElements, 0, v4s32, LegalityQuery(G_IMPLICIT_DEF, {v3s32}));
   }
+
+  // Test minScalarOrElt
+  {
+    LegalizerInfo LI;
+    LI.getActionDefinitionsBuilder(G_OR)
+      .legalFor({s32})
+      .minScalarOrElt(0, s32);
+    LI.computeTables();
+
+    EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_OR, {s16}));
+    EXPECT_ACTION(WidenScalar, 0, v2s32, LegalityQuery(G_OR, {v2s16}));
+  }
+
+  // Test maxScalarOrELt
+  {
+    LegalizerInfo LI;
+    LI.getActionDefinitionsBuilder(G_AND)
+      .legalFor({s16})
+      .maxScalarOrElt(0, s16);
+    LI.computeTables();
+
+    EXPECT_ACTION(NarrowScalar, 0, s16, LegalityQuery(G_AND, {s32}));
+    EXPECT_ACTION(NarrowScalar, 0, v2s16, LegalityQuery(G_AND, {v2s32}));
+  }
+
+  // Test clampScalarOrElt
+  {
+    LegalizerInfo LI;
+    LI.getActionDefinitionsBuilder(G_XOR)
+      .legalFor({s16})
+      .clampScalarOrElt(0, s16, s32);
+    LI.computeTables();
+
+    EXPECT_ACTION(NarrowScalar, 0, s32, LegalityQuery(G_XOR, {s64}));
+    EXPECT_ACTION(WidenScalar, 0, s16, LegalityQuery(G_XOR, {s8}));
+
+    // Make sure the number of elements is preserved.
+    EXPECT_ACTION(NarrowScalar, 0, v2s32, LegalityQuery(G_XOR, {v2s64}));
+    EXPECT_ACTION(WidenScalar, 0, v2s16, LegalityQuery(G_XOR, {v2s8}));
+  }
+
+  // Test minScalar
+  {
+    LegalizerInfo LI;
+    LI.getActionDefinitionsBuilder(G_OR)
+      .legalFor({s32})
+      .minScalar(0, s32);
+    LI.computeTables();
+
+    // Only handle scalars, ignore vectors.
+    EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_OR, {s16}));
+    EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_OR, {v2s16}));
+  }
+
+  // Test maxScalar
+  {
+    LegalizerInfo LI;
+    LI.getActionDefinitionsBuilder(G_AND)
+      .legalFor({s16})
+      .maxScalar(0, s16);
+    LI.computeTables();
+
+    // Only handle scalars, ignore vectors.
+    EXPECT_ACTION(NarrowScalar, 0, s16, LegalityQuery(G_AND, {s32}));
+    EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_AND, {v2s32}));
+  }
+
+  // Test clampScalar
+  {
+    LegalizerInfo LI;
+
+    LI.getActionDefinitionsBuilder(G_XOR)
+      .legalFor({s16})
+      .clampScalar(0, s16, s32);
+    LI.computeTables();
+
+    EXPECT_ACTION(NarrowScalar, 0, s32, LegalityQuery(G_XOR, {s64}));
+    EXPECT_ACTION(WidenScalar, 0, s16, LegalityQuery(G_XOR, {s8}));
+
+    // Only handle scalars, ignore vectors.
+    EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_XOR, {v2s64}));
+    EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_XOR, {v2s8}));
+  }
+
+  // Test widenScalarOrEltToNextPow2
+  {
+    LegalizerInfo LI;
+
+    LI.getActionDefinitionsBuilder(G_AND)
+      .legalFor({s32})
+      .widenScalarOrEltToNextPow2(0, 32);
+    LI.computeTables();
+
+    // Handle scalars and vectors
+    EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_AND, {s5}));
+    EXPECT_ACTION(WidenScalar, 0, v2s32, LegalityQuery(G_AND, {v2s5}));
+    EXPECT_ACTION(WidenScalar, 0, s64, LegalityQuery(G_AND, {s33}));
+    EXPECT_ACTION(WidenScalar, 0, v2s64, LegalityQuery(G_AND, {v2s33}));
+  }
+
+  // Test widenScalarToNextPow2
+  {
+    LegalizerInfo LI;
+
+    LI.getActionDefinitionsBuilder(G_AND)
+      .legalFor({s32})
+      .widenScalarToNextPow2(0, 32);
+    LI.computeTables();
+
+    EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_AND, {s5}));
+    EXPECT_ACTION(WidenScalar, 0, s64, LegalityQuery(G_AND, {s33}));
+
+    // Do nothing for vectors.
+    EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_AND, {v2s5}));
+    EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_AND, {v2s33}));
+  }
 }