[GlobalISel][Legalizer] Fix minScalarEltSameAsIf to handle p0 element types.

[aemerson]

Summary

The mutation the action generates tries to change the input type into the element type of larger vector type. This doesn't work if the larger element type is a vector of pointers since it creates an illegal mutation between scalar and pointer types.

[arsenm]

llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp

441

Also add a test with a non-0 address space

llvm/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h

LegalizeRuleSet &minScalarEltSameAsIf(LegalityPredicate Predicate,
     return widenScalarIf(
         [=](const LegalityQuery &Query) {
           return Query.Types[LargeTypeIdx].getScalarSizeInBits() >
                      Query.Types[TypeIdx].getScalarSizeInBits() &&
                  Predicate(Query);
         },
         [=](const LegalityQuery &Query) {
           LLT T = Query.Types[LargeTypeIdx];
+          if (T.isVector() && T.getElementType().isPointer())
+            T = T.changeElementType(LLT::scalar(T.getScalarSizeInBits()));
           return std::make_pair(TypeIdx, T);
         });
   }
 
   /// Conditionally narrow the scalar or elt to match the size of another.
   LegalizeRuleSet &maxScalarEltSameAsIf(LegalityPredicate Predicate,
                                         unsigned TypeIdx,
                                         unsigned SmallTypeIdx) {

llvm/unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp

TEST(LegalizerInfoTest, RuleSets) {
   const LLT v2s32 = LLT::fixed_vector(2, 32);
   const LLT v3s32 = LLT::fixed_vector(3, 32);
   const LLT v4s32 = LLT::fixed_vector(4, 32);
   const LLT v8s32 = LLT::fixed_vector(8, 32);
   const LLT v2s33 = LLT::fixed_vector(2, 33);
   const LLT v2s64 = LLT::fixed_vector(2, 64);
 
   const LLT p0 = LLT::pointer(0, 32);
+  const LLT v2p0 = LLT::fixed_vector(2, p0);
   const LLT v3p0 = LLT::fixed_vector(3, p0);
   const LLT v4p0 = LLT::fixed_vector(4, p0);
 
   const LLT s1 = LLT::scalar(1);
   const LLT v2s1 = LLT::fixed_vector(2, 1);
   const LLT v4s1 = LLT::fixed_vector(4, 1);
 
   {
// Test changeElementCountTo
     EXPECT_ACTION(FewerElements, 0, v2s32, LegalityQuery(G_ADD, {v4s32}));
     EXPECT_ACTION(FewerElements, 0, s32, LegalityQuery(G_ADD, {v8s32}));
 
     EXPECT_ACTION(FewerElements, 0, LLT::scalable_vector(2, 16),
                   LegalityQuery(G_ADD, {LLT::scalable_vector(4, 16)}));
     EXPECT_ACTION(FewerElements, 0, s16,
                   LegalityQuery(G_ADD, {LLT::scalable_vector(8, 16)}));
   }
+
+  // Test minScalarEltSameAsIf
+  {
+    LegalizerInfo LI;
+    auto &LegacyInfo = LI.getLegacyLegalizerInfo();
+
+    LI.getActionDefinitionsBuilder(G_SELECT).minScalarEltSameAsIf(
+        all(isVector(0), isVector(1)), 1, 0);
+    LegacyInfo.computeTables();
+
+    EXPECT_ACTION(WidenScalar, 1, v2s32, LegalityQuery(G_SELECT, {v2p0, v2s1}));
+  }
 }
 
 TEST(LegalizerInfoTest, MMOAlignment) {
   using namespace TargetOpcode;
 
   const LLT s32 = LLT::scalar(32);
   const LLT p0 = LLT::pointer(0, 64);