implement cache

Author: tgymnich

llvm/include/llvm/CodeGen/GlobalISel/GISelValueTracking.h

@@ -38,6 +38,7 @@ class GISelValueTracking : public GISelChangeObserver {
   unsigned MaxDepth;
   /// Cache maintained during a computeKnownBits request.
   SmallDenseMap<Register, KnownBits, 16> ComputeKnownBitsCache;
+  SmallDenseMap<Register, KnownFPClass, 16> ComputeKnownFPClassCache;
 
   void computeKnownBitsMin(Register Src0, Register Src1, KnownBits &Known,
                            const APInt &DemandedElts, unsigned Depth = 0);
@@ -112,23 +113,20 @@ class GISelValueTracking : public GISelChangeObserver {
   /// floating point classes should be queried. Queries not specified in \p
   /// InterestedClasses should be reliable if they are determined during the
   /// query.
-  KnownFPClass computeKnownFPClass(Register R, const APInt &DemandedElts,
-                                   FPClassTest InterestedClasses,
-                                   unsigned Depth);
+  KnownFPClass getKnownFPClass(Register R, const APInt &DemandedElts,
+                               FPClassTest InterestedClasses, unsigned Depth);
 
-  KnownFPClass computeKnownFPClass(Register R,
-                                   FPClassTest InterestedClasses = fcAllFlags,
-                                   unsigned Depth = 0);
+  KnownFPClass getKnownFPClass(Register R,
+                               FPClassTest InterestedClasses = fcAllFlags,
+                               unsigned Depth = 0);
 
   /// Wrapper to account for known fast math flags at the use instruction.
-  KnownFPClass computeKnownFPClass(Register R, const APInt &DemandedElts,
-                                   uint32_t Flags,
-                                   FPClassTest InterestedClasses,
-                                   unsigned Depth);
-
-  KnownFPClass computeKnownFPClass(Register R, uint32_t Flags,
-                                   FPClassTest InterestedClasses,
-                                   unsigned Depth);
+  KnownFPClass getKnownFPClass(Register R, const APInt &DemandedElts,
+                               uint32_t Flags, FPClassTest InterestedClasses,
+                               unsigned Depth);
+
+  KnownFPClass getKnownFPClass(Register R, uint32_t Flags,
+                               FPClassTest InterestedClasses, unsigned Depth);
 
   // Observer API. No-op for non-caching implementation.
   void erasingInstr(MachineInstr &MI) override {}

llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp

@@ -751,6 +751,12 @@ void GISelValueTracking::computeKnownFPClass(Register R,
     return;
   }
 
+  auto CacheEntry = ComputeKnownFPClassCache.find(R);
+  if (CacheEntry != ComputeKnownFPClassCache.end()) {
+    Known = CacheEntry->second;
+    return;
+  }
+
   if (auto Cst = GFConstant::getConstant(R, MRI)) {
     switch (Cst->getKind()) {
     case GFConstant::GFConstantKind::Scalar: {
@@ -1816,25 +1822,38 @@ void GISelValueTracking::computeKnownFPClass(Register R,
     break;
   }
   }
+
+  // Update the cache.
+  ComputeKnownFPClassCache[R] = Known;
 }
 
 KnownFPClass
-GISelValueTracking::computeKnownFPClass(Register R, const APInt &DemandedElts,
+GISelValueTracking::getKnownFPClass(Register R, const APInt &DemandedElts,
                                         FPClassTest InterestedClasses,
                                         unsigned Depth) {
+  // For now, we only maintain the cache during one request.
+  assert(ComputeKnownFPClassCache.empty() && "Cache should have been cleared");
+
   KnownFPClass KnownClasses;
   computeKnownFPClass(R, DemandedElts, InterestedClasses, KnownClasses, Depth);
+  ComputeKnownFPClassCache.clear();
+  
   return KnownClasses;
 }
 
-KnownFPClass GISelValueTracking::computeKnownFPClass(
+KnownFPClass GISelValueTracking::getKnownFPClass(
     Register R, FPClassTest InterestedClasses, unsigned Depth) {
+  // For now, we only maintain the cache during one request.
+  assert(ComputeKnownFPClassCache.empty() && "Cache should have been cleared");
+
   KnownFPClass Known;
   computeKnownFPClass(R, Known, InterestedClasses, Depth);
+  ComputeKnownFPClassCache.clear();
+  
   return Known;
 }
 
-KnownFPClass GISelValueTracking::computeKnownFPClass(
+KnownFPClass GISelValueTracking::getKnownFPClass(
     Register R, const APInt &DemandedElts, uint32_t Flags,
     FPClassTest InterestedClasses, unsigned Depth) {
   if (Flags & MachineInstr::MIFlag::FmNoNans)
@@ -1843,7 +1862,7 @@ KnownFPClass GISelValueTracking::computeKnownFPClass(
     InterestedClasses &= ~fcInf;
 
   KnownFPClass Result =
-      computeKnownFPClass(R, DemandedElts, InterestedClasses, Depth);
+      getKnownFPClass(R, DemandedElts, InterestedClasses, Depth);
 
   if (Flags & MachineInstr::MIFlag::FmNoNans)
     Result.KnownFPClasses &= ~fcNan;
@@ -1852,12 +1871,12 @@ KnownFPClass GISelValueTracking::computeKnownFPClass(
   return Result;
 }
 
-KnownFPClass GISelValueTracking::computeKnownFPClass(
+KnownFPClass GISelValueTracking::getKnownFPClass(
     Register R, uint32_t Flags, FPClassTest InterestedClasses, unsigned Depth) {
   LLT Ty = MRI.getType(R);
   APInt DemandedElts =
       Ty.isFixedVector() ? APInt::getAllOnes(Ty.getNumElements()) : APInt(1, 1);
-  return computeKnownFPClass(R, DemandedElts, Flags, InterestedClasses, Depth);
+  return getKnownFPClass(R, DemandedElts, Flags, InterestedClasses, Depth);
 }
 
 /// Compute number of sign bits for the intersection of \p Src0 and \p Src1

llvm/lib/CodeGen/GlobalISel/Utils.cpp

@@ -817,7 +817,7 @@ bool llvm::isKnownNeverNaN(Register Val, const MachineRegisterInfo &MRI,
   if (DefMI->getFlag(MachineInstr::FmNoNans) || TM.Options.NoNaNsFPMath)
     return true;
 
-  KnownFPClass FPClass = VT->computeKnownFPClass(Val, fcNan);
+  KnownFPClass FPClass = VT->getKnownFPClass(Val, fcNan);
   if (SNaN)
     return FPClass.isKnownNever(fcSNan);