Revert "[Inliner] Add a helper around SimplifiedValues.lookup. NFCI (llvm#118646)"

This reverts commit e6bd00c.

Author: Florian Hahn

llvm/lib/Analysis/InlineCost.cpp

@@ -422,14 +422,6 @@ class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
     return It->second;
   }
 
-  /// Use a value in its given form directly if possible, otherwise try looking
-  /// for it in SimplifiedValues.
-  template <typename T> T *getDirectOrSimplifiedValue(Value *V) const {
-    if (auto *Direct = dyn_cast<T>(V))
-      return Direct;
-    return dyn_cast_if_present<T>(SimplifiedValues.lookup(V));
-  }
-
   // Custom simplification helper routines.
   bool isAllocaDerivedArg(Value *V);
   void disableSROAForArg(AllocaInst *SROAArg);
@@ -1443,8 +1435,10 @@ bool CallAnalyzer::accumulateGEPOffset(GEPOperator &GEP, APInt &Offset) {
 
   for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP);
        GTI != GTE; ++GTI) {
-    ConstantInt *OpC =
-        getDirectOrSimplifiedValue<ConstantInt>(GTI.getOperand());
+    ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
+    if (!OpC)
+      if (Constant *SimpleOp = SimplifiedValues.lookup(GTI.getOperand()))
+        OpC = dyn_cast<ConstantInt>(SimpleOp);
     if (!OpC)
       return false;
     if (OpC->isZero())
@@ -1558,7 +1552,9 @@ bool CallAnalyzer::visitPHI(PHINode &I) {
     if (&I == V)
       continue;
 
-    Constant *C = getDirectOrSimplifiedValue<Constant>(V);
+    Constant *C = dyn_cast<Constant>(V);
+    if (!C)
+      C = SimplifiedValues.lookup(V);
 
     std::pair<Value *, APInt> BaseAndOffset = {nullptr, ZeroOffset};
     if (!C && CheckSROA)
@@ -1643,7 +1639,7 @@ bool CallAnalyzer::visitGetElementPtr(GetElementPtrInst &I) {
   // Lambda to check whether a GEP's indices are all constant.
   auto IsGEPOffsetConstant = [&](GetElementPtrInst &GEP) {
     for (const Use &Op : GEP.indices())
-      if (!getDirectOrSimplifiedValue<Constant>(Op))
+      if (!isa<Constant>(Op) && !SimplifiedValues.lookup(Op))
         return false;
     return true;
   };
@@ -1670,7 +1666,9 @@ bool CallAnalyzer::visitGetElementPtr(GetElementPtrInst &I) {
 bool CallAnalyzer::simplifyInstruction(Instruction &I) {
   SmallVector<Constant *> COps;
   for (Value *Op : I.operands()) {
-    Constant *COp = getDirectOrSimplifiedValue<Constant>(Op);
+    Constant *COp = dyn_cast<Constant>(Op);
+    if (!COp)
+      COp = SimplifiedValues.lookup(Op);
     if (!COp)
       return false;
     COps.push_back(COp);
@@ -1693,7 +1691,10 @@ bool CallAnalyzer::simplifyInstruction(Instruction &I) {
 /// llvm.is.constant would evaluate.
 bool CallAnalyzer::simplifyIntrinsicCallIsConstant(CallBase &CB) {
   Value *Arg = CB.getArgOperand(0);
-  auto *C = getDirectOrSimplifiedValue<Constant>(Arg);
+  auto *C = dyn_cast<Constant>(Arg);
+
+  if (!C)
+    C = dyn_cast_or_null<Constant>(SimplifiedValues.lookup(Arg));
 
   Type *RT = CB.getFunctionType()->getReturnType();
   SimplifiedValues[&CB] = ConstantInt::get(RT, C ? 1 : 0);
@@ -2125,8 +2126,12 @@ bool CallAnalyzer::visitSub(BinaryOperator &I) {
 
 bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
   Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
-  Constant *CLHS = getDirectOrSimplifiedValue<Constant>(LHS);
-  Constant *CRHS = getDirectOrSimplifiedValue<Constant>(RHS);
+  Constant *CLHS = dyn_cast<Constant>(LHS);
+  if (!CLHS)
+    CLHS = SimplifiedValues.lookup(LHS);
+  Constant *CRHS = dyn_cast<Constant>(RHS);
+  if (!CRHS)
+    CRHS = SimplifiedValues.lookup(RHS);
 
   Value *SimpleV = nullptr;
   if (auto FI = dyn_cast<FPMathOperator>(&I))
@@ -2160,7 +2165,9 @@ bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
 
 bool CallAnalyzer::visitFNeg(UnaryOperator &I) {
   Value *Op = I.getOperand(0);
-  Constant *COp = getDirectOrSimplifiedValue<Constant>(Op);
+  Constant *COp = dyn_cast<Constant>(Op);
+  if (!COp)
+    COp = SimplifiedValues.lookup(Op);
 
   Value *SimpleV = simplifyFNegInst(
       COp ? COp : Op, cast<FPMathOperator>(I).getFastMathFlags(), DL);
@@ -2248,7 +2255,9 @@ bool CallAnalyzer::simplifyCallSite(Function *F, CallBase &Call) {
   SmallVector<Constant *, 4> ConstantArgs;
   ConstantArgs.reserve(Call.arg_size());
   for (Value *I : Call.args()) {
-    Constant *C = getDirectOrSimplifiedValue<Constant>(I);
+    Constant *C = dyn_cast<Constant>(I);
+    if (!C)
+      C = dyn_cast_or_null<Constant>(SimplifiedValues.lookup(I));
     if (!C)
       return false; // This argument doesn't map to a constant.
 
@@ -2279,9 +2288,14 @@ bool CallAnalyzer::isLoweredToCall(Function *F, CallBase &Call) {
     // platforms whose headers redirect memcpy to __memcpy_chk (e.g. Darwin), as
     // other platforms use memcpy intrinsics, which are already exempt from the
     // call penalty.
-    auto *LenOp = getDirectOrSimplifiedValue<ConstantInt>(Call.getOperand(2));
-    auto *ObjSizeOp =
-        getDirectOrSimplifiedValue<ConstantInt>(Call.getOperand(3));
+    auto *LenOp = dyn_cast<ConstantInt>(Call.getOperand(2));
+    if (!LenOp)
+      LenOp = dyn_cast_or_null<ConstantInt>(
+          SimplifiedValues.lookup(Call.getOperand(2)));
+    auto *ObjSizeOp = dyn_cast<ConstantInt>(Call.getOperand(3));
+    if (!ObjSizeOp)
+      ObjSizeOp = dyn_cast_or_null<ConstantInt>(
+          SimplifiedValues.lookup(Call.getOperand(3)));
     if (LenOp && ObjSizeOp &&
         LenOp->getLimitedValue() <= ObjSizeOp->getLimitedValue()) {
       return false;
@@ -2397,18 +2411,23 @@ bool CallAnalyzer::visitBranchInst(BranchInst &BI) {
   // shouldn't exist at all, but handling them makes the behavior of the
   // inliner more regular and predictable. Interestingly, conditional branches
   // which will fold away are also free.
-  return BI.isUnconditional() ||
-         getDirectOrSimplifiedValue<ConstantInt>(BI.getCondition()) ||
-         BI.getMetadata(LLVMContext::MD_make_implicit);
+  return BI.isUnconditional() || isa<ConstantInt>(BI.getCondition()) ||
+         BI.getMetadata(LLVMContext::MD_make_implicit) ||
+         isa_and_nonnull<ConstantInt>(
+             SimplifiedValues.lookup(BI.getCondition()));
 }
 
 bool CallAnalyzer::visitSelectInst(SelectInst &SI) {
   bool CheckSROA = SI.getType()->isPointerTy();
   Value *TrueVal = SI.getTrueValue();
   Value *FalseVal = SI.getFalseValue();
 
-  Constant *TrueC = getDirectOrSimplifiedValue<Constant>(TrueVal);
-  Constant *FalseC = getDirectOrSimplifiedValue<Constant>(FalseVal);
+  Constant *TrueC = dyn_cast<Constant>(TrueVal);
+  if (!TrueC)
+    TrueC = SimplifiedValues.lookup(TrueVal);
+  Constant *FalseC = dyn_cast<Constant>(FalseVal);
+  if (!FalseC)
+    FalseC = SimplifiedValues.lookup(FalseVal);
   Constant *CondC =
       dyn_cast_or_null<Constant>(SimplifiedValues.lookup(SI.getCondition()));
 
@@ -2478,8 +2497,11 @@ bool CallAnalyzer::visitSelectInst(SelectInst &SI) {
 bool CallAnalyzer::visitSwitchInst(SwitchInst &SI) {
   // We model unconditional switches as free, see the comments on handling
   // branches.
-  if (getDirectOrSimplifiedValue<ConstantInt>(SI.getCondition()))
+  if (isa<ConstantInt>(SI.getCondition()))
     return true;
+  if (Value *V = SimplifiedValues.lookup(SI.getCondition()))
+    if (isa<ConstantInt>(V))
+      return true;
 
   // Assume the most general case where the switch is lowered into
   // either a jump table, bit test, or a balanced binary tree consisting of