[GlobalISel][LLT] Introduce FPInfo for LLT (Enable bfloat, ppc128float and others in GlobalISel)

llvm/include/llvm/CodeGen/GlobalISel/GIMatchTableExecutorImpl.h

@@ -285,24 +285,46 @@ bool GIMatchTableExecutor::executeMatchTable(
         break;
       }
       const LLT Ty = MRI.getType(MO.getReg());
-      const auto TyI = ExecInfo.TypeIDMap.find(Ty);
-      if (TyI == ExecInfo.TypeIDMap.end()) {
-        CurrentIdx = Default;
-        break;
-      }
-      const int64_t TypeID = TyI->second;
-      if (TypeID < LowerBound || UpperBound <= TypeID) {
-        CurrentIdx = Default;
+
+      SmallVector<LLT> TypesToTry;
+      TypesToTry.push_back(Ty);
+
+      // Always try the integer patterns as we now consider that to be generic
+      // (to an extent)
+      if (LLT::getUseExtended() && !Ty.getScalarType().isInteger())
+        TypesToTry.push_back(
+            Ty.changeElementType(LLT::integer(Ty.getScalarSizeInBits())));
+
+      if (LLT::getUseExtended() && Ty.isAnyScalar() &&
+          Ty.getScalarSizeInBits() > 8)
+        TypesToTry.push_back(
+            Ty.changeElementType(LLT::floatIEEE(Ty.getScalarSizeInBits())));
+
+      const auto JumpTableBase = CurrentIdx;
+      bool Matched = false;
+      for (LLT Type : TypesToTry) {
+        const auto TyI = ExecInfo.TypeIDMap.find(Type);
+        if (TyI == ExecInfo.TypeIDMap.end())
+          continue;
+        const int64_t TypeID = TyI->second;
+        if (TypeID < LowerBound || UpperBound <= TypeID)
+          continue;
+        const auto NumEntry = (TypeID - LowerBound);
+        // Each entry is 4 bytes
+        CurrentIdx =
+            readBytesAs<uint32_t>(MatchTable + JumpTableBase + (NumEntry * 4));
+        if (!CurrentIdx) {
+          CurrentIdx = Default;
+          continue;
+        }
+        Matched = true;
         break;
       }
-      const auto NumEntry = (TypeID - LowerBound);
-      // Each entry is 4 bytes
-      CurrentIdx =
-          readBytesAs<uint32_t>(MatchTable + CurrentIdx + (NumEntry * 4));
-      if (!CurrentIdx) {
+      if (!Matched) {
         CurrentIdx = Default;
         break;
       }
+
       OnFailResumeAt.push_back(Default);
       break;
     }

llvm/include/llvm/CodeGen/GlobalISel/IRTranslator.h

@@ -649,6 +649,8 @@ class IRTranslator : public MachineFunctionPass {
 
   StackProtectorDescriptor SPDescriptor;
 
+  bool mayTranslateUserTypes(const User &U) const;
+
   /// Switch analysis and optimization.
   class GISelSwitchLowering : public SwitchCG::SwitchLowering {
   public:

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

@@ -402,6 +402,11 @@ LLVM_ABI LegalizeMutation changeElementCountTo(unsigned TypeIdx,
 LLVM_ABI LegalizeMutation changeElementSizeTo(unsigned TypeIdx,
                                               unsigned FromTypeIdx);
 
+/// Change the scalar size or element size to have the same scalar size as the
+/// type \p NewTy. Unlike changeElementTo, this discards pointer types and only
+/// changes the size.
+LLVM_ABI LegalizeMutation changeElementSizeTo(unsigned TypeIdx, LLT NewTy);
+
 /// Widen the scalar type or vector element type for the given type index to the
 /// next power of 2.
 LLVM_ABI LegalizeMutation widenScalarOrEltToNextPow2(unsigned TypeIdx,
@@ -1040,7 +1045,7 @@ class LegalizeRuleSet {
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::WidenScalar,
                     scalarOrEltNarrowerThan(TypeIdx, Ty.getScalarSizeInBits()),
-                    changeElementTo(typeIdx(TypeIdx), Ty));
+                    changeElementSizeTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Ensure the scalar or element is at least as wide as Ty.
@@ -1051,7 +1056,7 @@ class LegalizeRuleSet {
     return actionIf(LegalizeAction::WidenScalar,
                     all(Predicate, scalarOrEltNarrowerThan(
                                        TypeIdx, Ty.getScalarSizeInBits())),
-                    changeElementTo(typeIdx(TypeIdx), Ty));
+                    changeElementSizeTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Ensure the vector size is at least as wide as VectorSize by promoting the
@@ -1070,7 +1075,8 @@ class LegalizeRuleSet {
           const LLT VecTy = Query.Types[TypeIdx];
           unsigned NumElts = VecTy.getNumElements();
           unsigned MinSize = VectorSize / NumElts;
-          LLT NewTy = LLT::fixed_vector(NumElts, LLT::scalar(MinSize));
+          LLT NewTy = LLT::fixed_vector(
+              NumElts, VecTy.getElementType().changeElementSize(MinSize));
           return std::make_pair(TypeIdx, NewTy);
         });
   }
@@ -1081,7 +1087,7 @@ class LegalizeRuleSet {
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::WidenScalar,
                     scalarNarrowerThan(TypeIdx, Ty.getSizeInBits()),
-                    changeTo(typeIdx(TypeIdx), Ty));
+                    changeElementSizeTo(typeIdx(TypeIdx), Ty));
   }
   LegalizeRuleSet &minScalar(bool Pred, unsigned TypeIdx, const LLT Ty) {
     if (!Pred)
@@ -1102,7 +1108,7 @@ class LegalizeRuleSet {
                  QueryTy.getSizeInBits() < Ty.getSizeInBits() &&
                  Predicate(Query);
         },
-        changeTo(typeIdx(TypeIdx), Ty));
+        changeElementSizeTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Ensure the scalar is at most as wide as Ty.
@@ -1111,7 +1117,7 @@ class LegalizeRuleSet {
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::NarrowScalar,
                     scalarOrEltWiderThan(TypeIdx, Ty.getScalarSizeInBits()),
-                    changeElementTo(typeIdx(TypeIdx), Ty));
+                    changeElementSizeTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Ensure the scalar is at most as wide as Ty.
@@ -1120,7 +1126,7 @@ class LegalizeRuleSet {
     using namespace LegalizeMutations;
     return actionIf(LegalizeAction::NarrowScalar,
                     scalarWiderThan(TypeIdx, Ty.getSizeInBits()),
-                    changeTo(typeIdx(TypeIdx), Ty));
+                    changeElementSizeTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Conditionally limit the maximum size of the scalar.
@@ -1138,7 +1144,7 @@ class LegalizeRuleSet {
                  QueryTy.getSizeInBits() > Ty.getSizeInBits() &&
                  Predicate(Query);
         },
-        changeElementTo(typeIdx(TypeIdx), Ty));
+        changeElementSizeTo(typeIdx(TypeIdx), Ty));
   }
 
   /// Limit the range of scalar sizes to MinTy and MaxTy.
@@ -1203,9 +1209,8 @@ class LegalizeRuleSet {
                  Predicate(Query);
         },
         [=](const LegalityQuery &Query) {
-          LLT T = Query.Types[LargeTypeIdx];
-          if (T.isPointerVector())
-            T = T.changeElementType(LLT::scalar(T.getScalarSizeInBits()));
+          LLT T = Query.Types[TypeIdx].changeElementSize(
+              Query.Types[LargeTypeIdx].getScalarSizeInBits());
           return std::make_pair(TypeIdx, T);
         });
   }

llvm/include/llvm/CodeGen/LowLevelTypeUtils.h

@@ -41,6 +41,6 @@ LLVM_ABI LLT getLLTForMVT(MVT Ty);
 /// Get the appropriate floating point arithmetic semantic based on the bit size
 /// of the given scalar LLT.
 LLVM_ABI const llvm::fltSemantics &getFltSemanticForLLT(LLT Ty);
-}
+} // namespace llvm
 
 #endif // LLVM_CODEGEN_LOWLEVELTYPEUTILS_H

llvm/include/llvm/CodeGen/TargetLowering.h

@@ -442,7 +442,7 @@ class LLVM_ABI TargetLoweringBase {
   /// G_INSERT_VECTOR_ELT, G_EXTRACT_VECTOR_ELT,
   /// G_INSERT_SUBVECTOR, and G_EXTRACT_SUBVECTOR
   LLT getVectorIdxLLT(const DataLayout &DL) const {
-    return LLT::scalar(getVectorIdxWidth(DL));
+    return LLT::buildInteger(getVectorIdxWidth(DL));
   }
 
   /// Returns the type to be used for the EVL/AVL operand of VP nodes: