GlobalISel: Add convenience mutatations to scalarize

[paquette]

include/llvm/CodeGen/GlobalISel/LegalizerInfo.h

242

This comment doesn't seem to fit. Maybe

"Scalarize the type for the given type index"?

Or, to avoid cyclical use of the term "scalar",

"Break up the vector type for the given type index into scalar types"?

[arsenm]

Reword comment

[paquette]

LGTM

[arsenm]

r352143

include/llvm/CodeGen/GlobalISel/LegalizerInfo.h

typePairInSet(unsigned TypeIdx0, unsigned TypeIdx1,
               std::initializer_list<std::pair<LLT, LLT>> TypesInit);
 /// True iff the given types for the given pair of type indexes is one of the
 /// specified type pairs.
 LegalityPredicate typePairAndMemSizeInSet(
     unsigned TypeIdx0, unsigned TypeIdx1, unsigned MMOIdx,
     std::initializer_list<TypePairAndMemSize> TypesAndMemSizeInit);
 /// True iff the specified type index is a scalar.
 LegalityPredicate isScalar(unsigned TypeIdx);
+/// True iff the specified type index is a vector.
+LegalityPredicate isVector(unsigned TypeIdx);
+
 /// True iff the specified type index is a scalar that's narrower than the given
 /// size.
 LegalityPredicate narrowerThan(unsigned TypeIdx, unsigned Size);
 /// True iff the specified type index is a scalar that's wider than the given
 /// size.
 LegalityPredicate widerThan(unsigned TypeIdx, unsigned Size);
 /// True iff the specified type index is a scalar whose size is not a power of
 /// 2.

 LegalizeMutation changeTo(unsigned TypeIdx, LLT Ty);
 /// Keep the same type as the given type index.
 LegalizeMutation changeTo(unsigned TypeIdx, unsigned FromTypeIdx);
 /// Widen the type for the given type index to the next power of 2.
 LegalizeMutation widenScalarToNextPow2(unsigned TypeIdx, unsigned Min = 0);
 /// Add more elements to the type for the given type index to the next power of
 /// 2.
 LegalizeMutation moreElementsToNextPow2(unsigned TypeIdx, unsigned Min = 0);
+
+/// Repeat the operation for each vector element.
+LegalizeMutation scalarize(unsigned TypeIdx);
 } // end namespace LegalizeMutations
 
 /// A single rule in a legalizer info ruleset.
 /// The specified action is chosen when the predicate is true. Where appropriate
 /// for the action (e.g. for WidenScalar) the new type is selected using the
 /// given mutator.
 class LegalizeRule {
   LegalityPredicate Predicate;
public:
   }
 
   LegalizeRuleSet &narrowScalar(unsigned TypeIdx, LegalizeMutation Mutation) {
     using namespace LegalityPredicates;
     return actionIf(LegalizeAction::NarrowScalar, isScalar(typeIdx(TypeIdx)),
                     Mutation);
   }
 
+  LegalizeRuleSet &scalarize(unsigned TypeIdx) {
+    using namespace LegalityPredicates;
+    return actionIf(LegalizeAction::FewerElements, isVector(typeIdx(TypeIdx)),
+                    LegalizeMutations::scalarize(TypeIdx));
+  }
+
+
   /// Ensure the scalar is at least as wide as Ty.
   LegalizeRuleSet &minScalar(unsigned TypeIdx, const LLT &Ty) {
     using namespace LegalityPredicates;
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::WidenScalar,
                     narrowerThan(TypeIdx, Ty.getSizeInBits()),
                     changeTo(typeIdx(TypeIdx), Ty));
   }

lib/CodeGen/GlobalISel/LegalityPredicates.cpp

 }
 
 LegalityPredicate LegalityPredicates::isScalar(unsigned TypeIdx) {
   return [=](const LegalityQuery &Query) {
     return Query.Types[TypeIdx].isScalar();
   };
 }
 
+LegalityPredicate LegalityPredicates::isVector(unsigned TypeIdx) {
+  return [=](const LegalityQuery &Query) {
+    return Query.Types[TypeIdx].isVector();
+  };
+}
+
 LegalityPredicate LegalityPredicates::narrowerThan(unsigned TypeIdx,
                                                    unsigned Size) {
   return [=](const LegalityQuery &Query) {
     const LLT &QueryTy = Query.Types[TypeIdx];
     return QueryTy.isScalar() && QueryTy.getSizeInBits() < Size;
   };
 }
 

lib/CodeGen/GlobalISel/LegalizeMutations.cpp

return [=](const LegalityQuery &Query) {
     const LLT &VecTy = Query.Types[TypeIdx];
     unsigned NewNumElements = 1 << Log2_32_Ceil(VecTy.getNumElements());
     if (NewNumElements < Min)
       NewNumElements = Min;
     return std::make_pair(
         TypeIdx, LLT::vector(NewNumElements, VecTy.getScalarSizeInBits()));
   };
 }
+
+LegalizeMutation LegalizeMutations::scalarize(unsigned TypeIdx) {
+  return [=](const LegalityQuery &Query) {
+    return std::make_pair(TypeIdx, Query.Types[TypeIdx].getElementType());
+  };
+}

lib/Target/AArch64/AArch64LegalizerInfo.cpp

 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Type.h"
 
 using namespace llvm;
 using namespace LegalizeActions;
+using namespace LegalizeMutations;
 using namespace LegalityPredicates;
 
 AArch64LegalizerInfo::AArch64LegalizerInfo(const AArch64Subtarget &ST) {
   using namespace TargetOpcode;
   const LLT p0 = LLT::pointer(0, 64);
   const LLT s1 = LLT::scalar(1);
   const LLT s8 = LLT::scalar(8);
   const LLT s16 = LLT::scalar(16);
auto notValidElt = [](const LegalityQuery &Query, unsigned TypeIdx) {
         const LLT &EltTy = Ty.getElementType();
         if (EltTy.getSizeInBits() < 8 || EltTy.getSizeInBits() > 64)
           return true;
         if (!isPowerOf2_32(EltTy.getSizeInBits()))
           return true;
       }
       return false;
     };
-    auto scalarize =
-        [](const LegalityQuery &Query, unsigned TypeIdx) {
-          const LLT &Ty = Query.Types[TypeIdx];
-          return std::make_pair(TypeIdx, Ty.getElementType());
-        };
 
     // FIXME: This rule is horrible, but specifies the same as what we had
     // before with the particularly strange definitions removed (e.g.
     // s8 = G_MERGE_VALUES s32, s32).
     // Part of the complexity comes from these ops being extremely flexible. For
     // example, you can build/decompose vectors with it, concatenate vectors,
     // etc. and in addition to this you can also bitcast with it at the same
     // time. We've been considering breaking it up into multiple ops to make it
     // more manageable throughout the backend.
     getActionDefinitionsBuilder(Op)
         // Break up vectors with weird elements into scalars
         .fewerElementsIf(
             [=](const LegalityQuery &Query) { return notValidElt(Query, 0); },
-            [=](const LegalityQuery &Query) { return scalarize(Query, 0); })
+            scalarize(0))
         .fewerElementsIf(
             [=](const LegalityQuery &Query) { return notValidElt(Query, 1); },
-            [=](const LegalityQuery &Query) { return scalarize(Query, 1); })
+            scalarize(1))
         // Clamp the big scalar to s8-s512 and make it either a power of 2, 192,
         // or 384.
         .clampScalar(BigTyIdx, s8, s512)
         .widenScalarIf(
             [=](const LegalityQuery &Query) {
               const LLT &Ty = Query.Types[BigTyIdx];
               return !isPowerOf2_32(Ty.getSizeInBits()) &&
                      Ty.getSizeInBits() % 64 != 0;
getActionDefinitionsBuilder(Op)
           const LLT &LitTy = Query.Types[LitTyIdx];
           if (BigTy.isVector() && BigTy.getSizeInBits() < 32)
             return false;
           if (LitTy.isVector() && LitTy.getSizeInBits() < 32)
             return false;
           return BigTy.getSizeInBits() % LitTy.getSizeInBits() == 0;
         })
         // Any vectors left are the wrong size. Scalarize them.
-        .fewerElementsIf([](const LegalityQuery &Query) { return true; },
-                         [](const LegalityQuery &Query) {
-                           return std::make_pair(
-                               0, Query.Types[0].getElementType());
-                         })
-        .fewerElementsIf([](const LegalityQuery &Query) { return true; },
-                         [](const LegalityQuery &Query) {
-                           return std::make_pair(
-                               1, Query.Types[1].getElementType());
-                         });
+      .scalarize(0)
+      .scalarize(1);
   }
 
   getActionDefinitionsBuilder(G_EXTRACT_VECTOR_ELT)
       .unsupportedIf([=](const LegalityQuery &Query) {
         const LLT &EltTy = Query.Types[1].getElementType();
         return Query.Types[0] != EltTy;
       })
       .minScalar(2, s64)

lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp

 #include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/CodeGen/ValueTypes.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Debug.h"
 
 using namespace llvm;
 using namespace LegalizeActions;
+using namespace LegalizeMutations;
+using namespace LegalityPredicates;
 
 AMDGPULegalizerInfo::AMDGPULegalizerInfo(const GCNSubtarget &ST,
                                          const GCNTargetMachine &TM) {
   using namespace TargetOpcode;
 
-  auto scalarize =
-    [=](const LegalityQuery &Query, unsigned TypeIdx) {
-    const LLT &Ty = Query.Types[TypeIdx];
-    return std::make_pair(TypeIdx, Ty.getElementType());
-  };
-
   auto GetAddrSpacePtr = [&TM](unsigned AS) {
     return LLT::pointer(AS, TM.getPointerSizeInBits(AS));
   };
 
   const LLT S1 = LLT::scalar(1);
   const LLT S16 = LLT::scalar(16);
   const LLT S32 = LLT::scalar(32);
   const LLT S64 = LLT::scalar(64);
AMDGPULegalizerInfo::AMDGPULegalizerInfo(const GCNSubtarget &ST,
   getActionDefinitionsBuilder(G_CONSTANT)
     .legalFor({S1, S32, S64, V2S32, V2S16})
     .clampScalar(0, S32, S64)
     // FIXME: Hack until odd splits handled
     .fewerElementsIf(
       [=](const LegalityQuery &Query) {
         return Query.Types[0].isVector() &&
                Query.Types[0].getNumElements() % 2 != 0;},
-      [=](const LegalityQuery &Query) { return scalarize(Query, 0); })
+      scalarize(0))
     .fewerElementsIf(
       [=](const LegalityQuery &Query) {
         return Query.Types[0].isVector() &&
           Query.Types[0].getElementType().getSizeInBits() < 32;
       },
-      [=](const LegalityQuery &Query) { return scalarize(Query, 0); })
+      scalarize(0))
     .widenScalarToNextPow2(0);
 
   setAction({G_FRAME_INDEX, PrivatePtr}, Legal);
 
   getActionDefinitionsBuilder(
     { G_FADD, G_FMUL, G_FNEG, G_FABS, G_FMA})
     .legalFor({S32, S64});
 
   getActionDefinitionsBuilder(G_FPTRUNC)
     .legalFor({{S32, S64}});
 
   getActionDefinitionsBuilder(G_FPEXT)
     .legalFor({{S64, S32}, {S32, S16}})
     .lowerFor({{S64, S16}}) // FIXME: Implement
-    .fewerElementsIf(
-      [](const LegalityQuery &Query) {
-        return Query.Types[0].isVector();
-      },
-      [](const LegalityQuery &Query) {
-        return std::make_pair(
-          0, Query.Types[0].getElementType());
-      });
+    .scalarize(0);
 
   // Use actual fsub instruction
   setAction({G_FSUB, S32}, Legal);
 
   // Must use fadd + fneg
   setAction({G_FSUB, S64}, Lower);
 
   setAction({G_FCMP, S1}, Legal);
   setAction({G_FCMP, 1, S32}, Legal);
   setAction({G_FCMP, 1, S64}, Legal);
 
   getActionDefinitionsBuilder({G_SEXT, G_ZEXT, G_ANYEXT})
     .legalFor({{S64, S32}, {S32, S16}, {S64, S16},
                {S32, S1}, {S64, S1}, {S16, S1}})
-    .fewerElementsIf(
-      [](const LegalityQuery &Query) {
-        return Query.Types[0].isVector();
-      },
-      [](const LegalityQuery &Query) {
-        return std::make_pair(
-          0, Query.Types[0].getElementType());
-      });
+    .scalarize(0);
 
   getActionDefinitionsBuilder(G_TRUNC)
     .legalFor({{S32, S64}, {S16, S32}, {S16, S64}})
-    .fewerElementsIf(
-      [](const LegalityQuery &Query) {
-        return Query.Types[0].isVector();
-      },
-      [](const LegalityQuery &Query) {
-        return std::make_pair(
-          0, Query.Types[0].getElementType());
-      });
+    .scalarize(0);
 
   setAction({G_FPTOSI, S32}, Legal);
   setAction({G_FPTOSI, 1, S32}, Legal);
 
   setAction({G_SITOFP, S32}, Legal);
   setAction({G_SITOFP, 1, S32}, Legal);
 
   setAction({G_UITOFP, S32}, Legal);
AMDGPULegalizerInfo::AMDGPULegalizerInfo(const GCNSubtarget &ST,
   }
 
   setAction({G_BLOCK_ADDR, CodePtr}, Legal);
 
   getActionDefinitionsBuilder({G_ICMP, G_FCMP})
     .legalFor({{S1, S32}, {S1, S64}})
     .widenScalarToNextPow2(1)
     .clampScalar(1, S32, S64)
-    .clampMaxNumElements(0, S1, 1)
-    .clampMaxNumElements(1, S32, 1);
+    .scalarize(0);
 
   setAction({G_CTLZ, S32}, Legal);
   setAction({G_CTLZ_ZERO_UNDEF, S32}, Legal);
   setAction({G_CTTZ, S32}, Legal);
   setAction({G_CTTZ_ZERO_UNDEF, S32}, Legal);
   setAction({G_BSWAP, S32}, Legal);
   setAction({G_CTPOP, S32}, Legal);
 
.fewerElementsIf(
           return true;
 
         LLT Ty = Query.Types[0];
 
         // FIXME: Hack until odd splits handled
         return Ty.isVector() &&
           (Ty.getScalarSizeInBits() > 32 || Ty.getNumElements() % 2 != 0);
       },
-      [=](const LegalityQuery &Query) { return scalarize(Query, 0); })
+      scalarize(0))
     // FIXME: Handle 16-bit vectors better
     .fewerElementsIf(
       [=](const LegalityQuery &Query) {
         return Query.Types[0].isVector() &&
                Query.Types[0].getElementType().getSizeInBits() < 32;},
-      [=](const LegalityQuery &Query) { return scalarize(Query, 0); })
+      scalarize(0))
     .clampMaxNumElements(0, S32, 2)
     .clampMaxNumElements(1, S1, 1);
 
 
 
   // TODO: Only the low 4/5/6 bits of the shift amount are observed, so we can
   // be more flexible with the shift amount type.
   auto &Shifts = getActionDefinitionsBuilder({G_SHL, G_LSHR, G_ASHR})
auto notValidElt = [=](const LegalityQuery &Query, unsigned TypeIdx) {
       }
       return false;
     };
 
     getActionDefinitionsBuilder(Op)
       // Break up vectors with weird elements into scalars
       .fewerElementsIf(
         [=](const LegalityQuery &Query) { return notValidElt(Query, 0); },
-        [=](const LegalityQuery &Query) { return scalarize(Query, 0); })
+        scalarize(0))
       .fewerElementsIf(
         [=](const LegalityQuery &Query) { return notValidElt(Query, 1); },
-        [=](const LegalityQuery &Query) { return scalarize(Query, 1); })
+        scalarize(1))
       .clampScalar(BigTyIdx, S32, S512)
       .widenScalarIf(
         [=](const LegalityQuery &Query) {
           const LLT &Ty = Query.Types[BigTyIdx];
           return !isPowerOf2_32(Ty.getSizeInBits()) &&
                  Ty.getSizeInBits() % 16 != 0;
         },
         [=](const LegalityQuery &Query) {
getActionDefinitionsBuilder(Op)
           if (LitTy.isVector() && LitTy.getSizeInBits() < 32)
             return false;
 
           return BigTy.getSizeInBits() % 16 == 0 &&
                  LitTy.getSizeInBits() % 16 == 0 &&
                  BigTy.getSizeInBits() <= 512;
         })
       // Any vectors left are the wrong size. Scalarize them.
-      .fewerElementsIf([](const LegalityQuery &Query) {
-          return Query.Types[0].isVector();
-        },
-        [](const LegalityQuery &Query) {
-          return std::make_pair(
-            0, Query.Types[0].getElementType());
-        })
-      .fewerElementsIf([](const LegalityQuery &Query) {
-          return Query.Types[1].isVector();
-        },
-        [](const LegalityQuery &Query) {
-          return std::make_pair(
-            1, Query.Types[1].getElementType());
-        });
-
+      .scalarize(0)
+      .scalarize(1);
   }
 
   computeTables();
   verify(*ST.getInstrInfo());
 }