[AggresiveInstCombine] Add wrapper calls for `KnownBits` computing

[anton-afanasyev]

Summary

Precommit before AssumptionCache adding: reviews.llvm.org/D109141

[lebedev.ri]

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h

118

same

[lebedev.ri]

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h

111

Ugh. And phab ate my comment yet again.
Let's not add CtxI here, but in a patch that requires it.

[anton-afanasyev]

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h

111

Sure. CtxI isn't used without AC anyway.

[anton-afanasyev]

Use /*CtxI=*/nullptr

llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TRANSFORMS_AGGRESSIVEINSTCOMBINE_COMBINEINTERNAL_H
 #define LLVM_LIB_TRANSFORMS_AGGRESSIVEINSTCOMBINE_COMBINEINTERNAL_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/Support/KnownBits.h"
 
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // TruncInstCombine - looks for expression dags dominated by trunc instructions
 // and for each eligible dag, it will create a reduced bit-width expression and
 // replace the old expression with this new one and remove the old one.
 // Eligible expression dag is such that:
private:
   /// Build an expression dag dominated by the current processed TruncInst and
   /// Check if it is eligible to be reduced to a smaller type.
   ///
   /// \return the scalar version of the new type to be used for the reduced
   ///         expression dag, or nullptr if the expression dag is not eligible
   ///         to be reduced.
   Type *getBestTruncatedType();
 
+  KnownBits computeKnownBits(const Value *V) const {
+    return llvm::computeKnownBits(V, DL, /*Depth=*/0, /*AC=*/nullptr,
+                                  /*CtxI=*/nullptr, &DT);
+  }
+
+  unsigned ComputeNumSignBits(const Value *V) const {
+    return llvm::ComputeNumSignBits(V, DL, /*Depth=*/0, /*AC=*/nullptr,
+                                    /*CtxI=*/nullptr, &DT);
+  }
+
   /// Given a \p V value and a \p SclTy scalar type return the generated reduced
   /// value of \p V based on the type \p SclTy.
   ///
   /// \param V value to be reduced.
   /// \param SclTy scalar version of new type to reduce to.
   /// \return the new reduced value.
   Value *getReducedOperand(Value *V, Type *SclTy);
 

llvm/lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp

Type *TruncInstCombine::getBestTruncatedType() {
   // bits of the value-to-be-shifted are zeros.
   // For `ashr` adjust MinBitWidth so that all potentially truncated
   // bits of the value-to-be-shifted are sign bits (all zeros or ones)
   // and even one (first) untruncated bit is sign bit.
   // Exit early if MinBitWidth is not less than original bitwidth.
   for (auto &Itr : InstInfoMap) {
     Instruction *I = Itr.first;
     if (I->isShift()) {
-      KnownBits KnownRHS = computeKnownBits(I->getOperand(1), DL);
+      KnownBits KnownRHS = computeKnownBits(I->getOperand(1));
       unsigned MinBitWidth = KnownRHS.getMaxValue()
                                  .uadd_sat(APInt(OrigBitWidth, 1))
                                  .getLimitedValue(OrigBitWidth);
       if (MinBitWidth == OrigBitWidth)
         return nullptr;
       if (I->getOpcode() == Instruction::LShr) {
-        KnownBits KnownLHS = computeKnownBits(I->getOperand(0), DL);
+        KnownBits KnownLHS = computeKnownBits(I->getOperand(0));
         MinBitWidth =
             std::max(MinBitWidth, KnownLHS.getMaxValue().getActiveBits());
       }
       if (I->getOpcode() == Instruction::AShr) {
-        unsigned NumSignBits = ComputeNumSignBits(I->getOperand(0), DL);
+        unsigned NumSignBits = ComputeNumSignBits(I->getOperand(0));
         MinBitWidth = std::max(MinBitWidth, OrigBitWidth - NumSignBits + 1);
       }
       if (MinBitWidth >= OrigBitWidth)
         return nullptr;
       Itr.second.MinBitWidth = MinBitWidth;
     }
   }