[GlobalISel][NFC] Rename GISelKnownBits to GISelValueTracking (llvm#133466)

- rename `GISelKnownBits` to `GISelValueTracking` to analyze more than
just `KnownBits` in the future

Author: tgymnich

llvm/docs/GlobalISel/KnownBits.rst

@@ -61,23 +61,23 @@ dependency with ``INITIALIZE_PASS_DEPENDENCY``.
 
 .. code-block:: c++
 
-  #include "llvm/CodeGen/GlobalISel/GISelKnownBits.h"
+  #include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
 
   ...
 
   INITIALIZE_PASS_BEGIN(...)
-  INITIALIZE_PASS_DEPENDENCY(GISelKnownBitsAnalysis)
+  INITIALIZE_PASS_DEPENDENCY(GISelValueTrackingAnalysis)
   INITIALIZE_PASS_END(...)
 
 and require the pass in ``getAnalysisUsage``.
 
 .. code-block:: c++
 
   void MyPass::getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<GISelKnownBitsAnalysis>();
+    AU.addRequired<GISelValueTrackingAnalysis>();
     // Optional: If your pass preserves known bits analysis (many do) then
     //           indicate that it's preserved for re-use by another pass here.
-    AU.addPreserved<GISelKnownBitsAnalysis>();
+    AU.addPreserved<GISelValueTrackingAnalysis>();
   }
 
 Then it's just a matter of fetching the analysis and using it:
@@ -86,10 +86,10 @@ Then it's just a matter of fetching the analysis and using it:
 
   bool MyPass::runOnMachineFunction(MachineFunction &MF) {
     ...
-    GISelKnownBits &KB = getAnalysis<GISelKnownBitsAnalysis>().get(MF);
+    GISelValueTracking &VT = getAnalysis<GISelValueTrackingAnalysis>().get(MF);
     ...
     MachineInstr *MI = ...;
-    KnownBits Known = KB->getKnownBits(MI->getOperand(0).getReg());
+    KnownBits Known = VT->getKnownBits(MI->getOperand(0).getReg());
     if (Known.Zeros & 1) {
       // Bit 0 is known to be zero
     }

llvm/include/llvm/CodeGen/GlobalISel/Combiner.h

@@ -58,7 +58,7 @@ class Combiner : public GIMatchTableExecutor {
   /// If CSEInfo is not null, then the Combiner will use CSEInfo as the observer
   /// and also create a CSEMIRBuilder. Pass nullptr if CSE is not needed.
   Combiner(MachineFunction &MF, CombinerInfo &CInfo,
-           const TargetPassConfig *TPC, GISelKnownBits *KB,
+           const TargetPassConfig *TPC, GISelValueTracking *VT,
            GISelCSEInfo *CSEInfo = nullptr);
   virtual ~Combiner();
 
@@ -72,7 +72,7 @@ class Combiner : public GIMatchTableExecutor {
   MachineIRBuilder &B;
   MachineFunction &MF;
   MachineRegisterInfo &MRI;
-  GISelKnownBits *KB;
+  GISelValueTracking *VT;
 
   const TargetPassConfig *TPC;
   GISelCSEInfo *CSEInfo;

llvm/include/llvm/CodeGen/GlobalISel/CombinerHelper.h

@@ -38,7 +38,7 @@ class MachineInstrBuilder;
 class MachineRegisterInfo;
 class MachineInstr;
 class MachineOperand;
-class GISelKnownBits;
+class GISelValueTracking;
 class MachineDominatorTree;
 class LegalizerInfo;
 struct LegalityQuery;
@@ -106,7 +106,7 @@ class CombinerHelper {
   MachineIRBuilder &Builder;
   MachineRegisterInfo &MRI;
   GISelChangeObserver &Observer;
-  GISelKnownBits *KB;
+  GISelValueTracking *VT;
   MachineDominatorTree *MDT;
   bool IsPreLegalize;
   const LegalizerInfo *LI;
@@ -115,14 +115,11 @@ class CombinerHelper {
 
 public:
   CombinerHelper(GISelChangeObserver &Observer, MachineIRBuilder &B,
-                 bool IsPreLegalize,
-                 GISelKnownBits *KB = nullptr,
+                 bool IsPreLegalize, GISelValueTracking *VT = nullptr,
                  MachineDominatorTree *MDT = nullptr,
                  const LegalizerInfo *LI = nullptr);
 
-  GISelKnownBits *getKnownBits() const {
-    return KB;
-  }
+  GISelValueTracking *getValueTracking() const { return VT; }
 
   MachineIRBuilder &getBuilder() const {
     return Builder;

llvm/include/llvm/CodeGen/GlobalISel/GIMatchTableExecutor.h

@@ -41,7 +41,7 @@ class MachineBasicBlock;
 class ProfileSummaryInfo;
 class APInt;
 class APFloat;
-class GISelKnownBits;
+class GISelValueTracking;
 class MachineInstr;
 class MachineIRBuilder;
 class MachineInstrBuilder;
@@ -588,7 +588,7 @@ class GIMatchTableExecutor {
   virtual ~GIMatchTableExecutor() = default;
 
   CodeGenCoverage *CoverageInfo = nullptr;
-  GISelKnownBits *KB = nullptr;
+  GISelValueTracking *VT = nullptr;
   MachineFunction *MF = nullptr;
   ProfileSummaryInfo *PSI = nullptr;
   BlockFrequencyInfo *BFI = nullptr;
@@ -598,12 +598,12 @@ class GIMatchTableExecutor {
   virtual void setupGeneratedPerFunctionState(MachineFunction &MF) = 0;
 
   /// Setup per-MF executor state.
-  virtual void setupMF(MachineFunction &mf, GISelKnownBits *kb,
+  virtual void setupMF(MachineFunction &mf, GISelValueTracking *vt,
                        CodeGenCoverage *covinfo = nullptr,
                        ProfileSummaryInfo *psi = nullptr,
                        BlockFrequencyInfo *bfi = nullptr) {
     CoverageInfo = covinfo;
-    KB = kb;
+    VT = vt;
     MF = &mf;
     PSI = psi;
     BFI = bfi;

llvm/include/llvm/CodeGen/GlobalISel/GISelKnownBits.h renamed to llvm/include/llvm/CodeGen/GlobalISel/GISelValueTracking.h

@@ -1,4 +1,4 @@
-//===- llvm/CodeGen/GlobalISel/GISelKnownBits.h ---------------*- C++ -*-===//
+//===- llvm/CodeGen/GlobalISel/GISelValueTracking.h -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -11,8 +11,8 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CODEGEN_GLOBALISEL_GISELKNOWNBITS_H
-#define LLVM_CODEGEN_GLOBALISEL_GISELKNOWNBITS_H
+#ifndef LLVM_CODEGEN_GLOBALISEL_GISELVALUETRACKING_H
+#define LLVM_CODEGEN_GLOBALISEL_GISELVALUETRACKING_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
@@ -26,7 +26,7 @@ namespace llvm {
 class TargetLowering;
 class DataLayout;
 
-class GISelKnownBits : public GISelChangeObserver {
+class GISelValueTracking : public GISelChangeObserver {
   MachineFunction &MF;
   MachineRegisterInfo &MRI;
   const TargetLowering &TL;
@@ -36,23 +36,18 @@ class GISelKnownBits : public GISelChangeObserver {
   SmallDenseMap<Register, KnownBits, 16> ComputeKnownBitsCache;
 
   void computeKnownBitsMin(Register Src0, Register Src1, KnownBits &Known,
-                           const APInt &DemandedElts,
-                           unsigned Depth = 0);
+                           const APInt &DemandedElts, unsigned Depth = 0);
 
   unsigned computeNumSignBitsMin(Register Src0, Register Src1,
                                  const APInt &DemandedElts, unsigned Depth = 0);
 
 public:
-  GISelKnownBits(MachineFunction &MF, unsigned MaxDepth = 6);
-  virtual ~GISelKnownBits() = default;
+  GISelValueTracking(MachineFunction &MF, unsigned MaxDepth = 6);
+  virtual ~GISelValueTracking() = default;
 
-  const MachineFunction &getMachineFunction() const {
-    return MF;
-  }
+  const MachineFunction &getMachineFunction() const { return MF; }
 
-  const DataLayout &getDataLayout() const {
-    return DL;
-  }
+  const DataLayout &getDataLayout() const { return DL; }
 
   virtual void computeKnownBitsImpl(Register R, KnownBits &Known,
                                     const APInt &DemandedElts,
@@ -83,8 +78,7 @@ class GISelKnownBits : public GISelChangeObserver {
   /// predicate to simplify operations downstream.
   bool signBitIsZero(Register Op);
 
-  static void computeKnownBitsForAlignment(KnownBits &Known,
-                                           Align Alignment) {
+  static void computeKnownBitsForAlignment(KnownBits &Known, Align Alignment) {
     // The low bits are known zero if the pointer is aligned.
     Known.Zero.setLowBits(Log2(Alignment));
   }
@@ -103,26 +97,26 @@ class GISelKnownBits : public GISelChangeObserver {
 };
 
 /// To use KnownBitsInfo analysis in a pass,
-/// KnownBitsInfo &Info = getAnalysis<GISelKnownBitsInfoAnalysis>().get(MF);
+/// KnownBitsInfo &Info = getAnalysis<GISelValueTrackingInfoAnalysis>().get(MF);
 /// Add to observer if the Info is caching.
 /// WrapperObserver.addObserver(Info);
 
 /// Eventually add other features such as caching/ser/deserializing
-/// to MIR etc. Those implementations can derive from GISelKnownBits
+/// to MIR etc. Those implementations can derive from GISelValueTracking
 /// and override computeKnownBitsImpl.
-class GISelKnownBitsAnalysis : public MachineFunctionPass {
-  std::unique_ptr<GISelKnownBits> Info;
+class GISelValueTrackingAnalysis : public MachineFunctionPass {
+  std::unique_ptr<GISelValueTracking> Info;
 
 public:
   static char ID;
-  GISelKnownBitsAnalysis() : MachineFunctionPass(ID) {
-    initializeGISelKnownBitsAnalysisPass(*PassRegistry::getPassRegistry());
+  GISelValueTrackingAnalysis() : MachineFunctionPass(ID) {
+    initializeGISelValueTrackingAnalysisPass(*PassRegistry::getPassRegistry());
   }
-  GISelKnownBits &get(MachineFunction &MF);
+  GISelValueTracking &get(MachineFunction &MF);
   void getAnalysisUsage(AnalysisUsage &AU) const override;
   bool runOnMachineFunction(MachineFunction &MF) override;
   void releaseMemory() override { Info.reset(); }
 };
 } // namespace llvm
 
-#endif // LLVM_CODEGEN_GLOBALISEL_GISELKNOWNBITS_H
+#endif // LLVM_CODEGEN_GLOBALISEL_GISELVALUETRACKING_H

llvm/include/llvm/CodeGen/GlobalISel/InstructionSelect.h

@@ -21,7 +21,7 @@
 namespace llvm {
 
 class InstructionSelector;
-class GISelKnownBits;
+class GISelValueTracking;
 class BlockFrequencyInfo;
 class ProfileSummaryInfo;
 
@@ -62,7 +62,7 @@ class InstructionSelect : public MachineFunctionPass {
   class MIIteratorMaintainer;
 
   InstructionSelector *ISel = nullptr;
-  GISelKnownBits *KB = nullptr;
+  GISelValueTracking *VT = nullptr;
   BlockFrequencyInfo *BFI = nullptr;
   ProfileSummaryInfo *PSI = nullptr;
 

llvm/include/llvm/CodeGen/GlobalISel/LegalizationArtifactCombiner.h

@@ -36,7 +36,7 @@ class LegalizationArtifactCombiner {
   MachineIRBuilder &Builder;
   MachineRegisterInfo &MRI;
   const LegalizerInfo &LI;
-  GISelKnownBits *KB;
+  GISelValueTracking *VT;
 
   static bool isArtifactCast(unsigned Opc) {
     switch (Opc) {
@@ -53,8 +53,8 @@ class LegalizationArtifactCombiner {
 public:
   LegalizationArtifactCombiner(MachineIRBuilder &B, MachineRegisterInfo &MRI,
                                const LegalizerInfo &LI,
-                               GISelKnownBits *KB = nullptr)
-      : Builder(B), MRI(MRI), LI(LI), KB(KB) {}
+                               GISelValueTracking *VT = nullptr)
+      : Builder(B), MRI(MRI), LI(LI), VT(VT) {}
 
   bool tryCombineAnyExt(MachineInstr &MI,
                         SmallVectorImpl<MachineInstr *> &DeadInsts,
@@ -151,7 +151,7 @@ class LegalizationArtifactCombiner {
       // OptLevel results in significant compile-time and O0 code-size
       // improvements. Inserting unnecessary instructions between boolean defs
       // and uses hinders a lot of folding during ISel.
-      if (KB && (KB->getKnownZeroes(AndSrc) | ExtMaskVal).isAllOnes()) {
+      if (VT && (VT->getKnownZeroes(AndSrc) | ExtMaskVal).isAllOnes()) {
         replaceRegOrBuildCopy(DstReg, AndSrc, MRI, Builder, UpdatedDefs,
                               Observer);
       } else {
@@ -214,7 +214,7 @@ class LegalizationArtifactCombiner {
         TruncSrc = Builder.buildAnyExtOrTrunc(DstTy, TruncSrc).getReg(0);
       // Elide G_SEXT_INREG if possible. This is similar to eliding G_AND in
       // tryCombineZExt. Refer to the comment in tryCombineZExt for rationale.
-      if (KB && KB->computeNumSignBits(TruncSrc) >
+      if (VT && VT->computeNumSignBits(TruncSrc) >
                     DstTy.getScalarSizeInBits() - SizeInBits)
         replaceRegOrBuildCopy(DstReg, TruncSrc, MRI, Builder, UpdatedDefs,
                               Observer);

llvm/include/llvm/CodeGen/GlobalISel/Legalizer.h

@@ -22,7 +22,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/CodeGen/GlobalISel/GISelKnownBits.h"
+#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 
@@ -77,7 +77,7 @@ class Legalizer : public MachineFunctionPass {
   legalizeMachineFunction(MachineFunction &MF, const LegalizerInfo &LI,
                           ArrayRef<GISelChangeObserver *> AuxObservers,
                           LostDebugLocObserver &LocObserver,
-                          MachineIRBuilder &MIRBuilder, GISelKnownBits *KB);
+                          MachineIRBuilder &MIRBuilder, GISelValueTracking *VT);
 };
 } // End namespace llvm.
 

llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h

@@ -21,7 +21,7 @@
 #define LLVM_CODEGEN_GLOBALISEL_LEGALIZERHELPER_H
 
 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
-#include "llvm/CodeGen/GlobalISel/GISelKnownBits.h"
+#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
 #include "llvm/CodeGen/RuntimeLibcallUtil.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
@@ -58,7 +58,7 @@ class LegalizerHelper {
   MachineRegisterInfo &MRI;
   const LegalizerInfo &LI;
   const TargetLowering &TLI;
-  GISelKnownBits *KB;
+  GISelValueTracking *VT;
 
 public:
   enum LegalizeResult {
@@ -77,13 +77,13 @@ class LegalizerHelper {
   /// Expose LegalizerInfo so the clients can re-use.
   const LegalizerInfo &getLegalizerInfo() const { return LI; }
   const TargetLowering &getTargetLowering() const { return TLI; }
-  GISelKnownBits *getKnownBits() const { return KB; }
+  GISelValueTracking *getValueTracking() const { return VT; }
 
   LegalizerHelper(MachineFunction &MF, GISelChangeObserver &Observer,
                   MachineIRBuilder &B);
   LegalizerHelper(MachineFunction &MF, const LegalizerInfo &LI,
                   GISelChangeObserver &Observer, MachineIRBuilder &B,
-                  GISelKnownBits *KB = nullptr);
+                  GISelValueTracking *VT = nullptr);
 
   /// Replace \p MI by a sequence of legal instructions that can implement the
   /// same operation. Note that this means \p MI may be deleted, so any iterator

llvm/include/llvm/CodeGen/GlobalISel/Utils.h

@@ -31,7 +31,7 @@ class AnalysisUsage;
 class LostDebugLocObserver;
 class MachineBasicBlock;
 class BlockFrequencyInfo;
-class GISelKnownBits;
+class GISelValueTracking;
 class MachineFunction;
 class MachineInstr;
 class MachineIRBuilder;
@@ -331,7 +331,7 @@ ConstantFoldICmp(unsigned Pred, const Register Op1, const Register Op2,
 /// from computeKnownBits in that it doesn't necessarily determine which bit is
 /// set.
 bool isKnownToBeAPowerOfTwo(Register Val, const MachineRegisterInfo &MRI,
-                            GISelKnownBits *KnownBits = nullptr);
+                            GISelValueTracking *ValueTracking = nullptr);
 
 /// Returns true if \p Val can be assumed to never be a NaN. If \p SNaN is true,
 /// this returns if \p Val can be assumed to never be a signaling NaN.