[CallSite removal][SCCP] Use CallBase instead of CallSite. NFC

[mtrofin]

lgtm, some naming nits

llvm/lib/Transforms/Scalar/SCCP.cpp

1134

Nit: here and below, CallBase &CB?

[craig.topper]

llvm/lib/Transforms/Scalar/SCCP.cpp

1134

I was just trying to be consistent with the other visitor functions in the file. But I can change it.

[mtrofin]

llvm/lib/Transforms/Scalar/SCCP.cpp

1134

Ah... I see, looks like some cases use just generic "I", some use acronyms (visitCatchSwitch for example). It's a nit anyway, the patch is good to land.

[craig.topper]

Rename I to CB.

llvm/lib/Transforms/Scalar/SCCP.cpp

 //===- SCCP.cpp - Sparse Conditional Constant Propagation -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueLattice.h"
 #include "llvm/Analysis/ValueLatticeUtils.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/InstrTypes.h"
private:
   // Mark I's users as changed, including AdditionalUsers.
   void markUsersAsChanged(Value *I) {
     // Functions include their arguments in the use-list. Changed function
     // values mean that the result of the function changed. We only need to
     // update the call sites with the new function result and do not have to
     // propagate the call arguments.
     if (isa<Function>(I)) {
       for (User *U : I->users()) {
-        if (auto CS = CallSite(U))
-          handleCallResult(CS);
+        if (auto *CB = dyn_cast<CallBase>(U))
+          handleCallResult(*CB);
       }
     } else {
       for (User *U : I->users())
         if (auto *UI = dyn_cast<Instruction>(U))
           OperandChangedState(UI);
     }
 
     auto Iter = AdditionalUsers.find(I);
     if (Iter != AdditionalUsers.end()) {
       for (User *U : Iter->second)
         if (auto *UI = dyn_cast<Instruction>(U))
           OperandChangedState(UI);
     }
   }
-  void handleCallOverdefined(CallSite CS);
-  void handleCallResult(CallSite CS);
-  void handleCallArguments(CallSite CS);
+  void handleCallOverdefined(CallBase &I);
+  void handleCallResult(CallBase &I);
+  void handleCallArguments(CallBase &I);
 
 private:
   friend class InstVisitor<SCCPSolver>;
 
   // visit implementations - Something changed in this instruction.  Either an
   // operand made a transition, or the instruction is newly executable.  Change
   // the value type of I to reflect these changes if appropriate.
   void visitPHINode(PHINode &I);
private:
 
   // Instructions that cannot be folded away.
 
   void visitStoreInst     (StoreInst &I);
   void visitLoadInst      (LoadInst &I);
   void visitGetElementPtrInst(GetElementPtrInst &I);
 
   void visitCallInst      (CallInst &I) {
-    visitCallSite(&I);
+    visitCallBase(I);
   }
 
   void visitInvokeInst    (InvokeInst &II) {
-    visitCallSite(&II);
+    visitCallBase(II);
     visitTerminator(II);
   }
 
   void visitCallBrInst    (CallBrInst &CBI) {
-    visitCallSite(&CBI);
+    visitCallBase(CBI);
     visitTerminator(CBI);
   }
 
-  void visitCallSite      (CallSite CS);
+  void visitCallBase      (CallBase &I);
   void visitResumeInst    (ResumeInst &I) { /*returns void*/ }
   void visitUnreachableInst(UnreachableInst &I) { /*returns void*/ }
   void visitFenceInst     (FenceInst &I) { /*returns void*/ }
 
   void visitInstruction(Instruction &I) {
     // All the instructions we don't do any special handling for just
     // go to overdefined.
     LLVM_DEBUG(dbgs() << "SCCP: Don't know how to handle: " << I << '\n');
if (Constant *C = ConstantFoldLoadFromConstPtr(Ptr, I.getType(), DL)) {
     return (void)markConstant(IV, &I, C);
   }
 
   // Otherwise we cannot say for certain what value this load will produce.
   // Bail out.
   markOverdefined(IV, &I);
 }
 
-void SCCPSolver::visitCallSite(CallSite CS) {
-  handleCallResult(CS);
-  handleCallArguments(CS);
+void SCCPSolver::visitCallBase(CallBase &I) {
+  handleCallResult(I);
+  handleCallArguments(I);
 }
 
-void SCCPSolver::handleCallOverdefined(CallSite CS) {
-  Function *F = CS.getCalledFunction();
-  Instruction *I = CS.getInstruction();
+void SCCPSolver::handleCallOverdefined(CallBase &I) {
+  Function *F = I.getCalledFunction();
 
   // Void return and not tracking callee, just bail.
-  if (I->getType()->isVoidTy())
+  if (I.getType()->isVoidTy())
     return;
 
   // Otherwise, if we have a single return value case, and if the function is
   // a declaration, maybe we can constant fold it.
-  if (F && F->isDeclaration() && !I->getType()->isStructTy() &&
-      canConstantFoldCallTo(cast<CallBase>(CS.getInstruction()), F)) {
+  if (F && F->isDeclaration() && !I.getType()->isStructTy() &&
+      canConstantFoldCallTo(&I, F)) {
     SmallVector<Constant *, 8> Operands;
-    for (CallSite::arg_iterator AI = CS.arg_begin(), E = CS.arg_end(); AI != E;
-         ++AI) {
+    for (auto AI = I.arg_begin(), E = I.arg_end(); AI != E; ++AI) {
       if (AI->get()->getType()->isStructTy())
-        return markOverdefined(I); // Can't handle struct args.
+        return markOverdefined(&I); // Can't handle struct args.
       ValueLatticeElement State = getValueState(*AI);
 
       if (State.isUnknownOrUndef())
         return; // Operands are not resolved yet.
       if (isOverdefined(State))
-        return (void)markOverdefined(I);
+        return (void)markOverdefined(&I);
       assert(isConstant(State) && "Unknown state!");
       Operands.push_back(getConstant(State));
     }
 
-    if (isOverdefined(getValueState(I)))
-      return (void)markOverdefined(I);
+    if (isOverdefined(getValueState(&I)))
+      return (void)markOverdefined(&I);
 
     // If we can constant fold this, mark the result of the call as a
     // constant.
-    if (Constant *C = ConstantFoldCall(cast<CallBase>(CS.getInstruction()), F,
-                                       Operands, &GetTLI(*F))) {
+    if (Constant *C = ConstantFoldCall(&I, F, Operands, &GetTLI(*F))) {
       // call -> undef.
       if (isa<UndefValue>(C))
         return;
-      return (void)markConstant(I, C);
+      return (void)markConstant(&I, C);
     }
   }
 
   // Otherwise, we don't know anything about this call, mark it overdefined.
-  return (void)markOverdefined(I);
+  return (void)markOverdefined(&I);
 }
 
-void SCCPSolver::handleCallArguments(CallSite CS) {
-  Function *F = CS.getCalledFunction();
+void SCCPSolver::handleCallArguments(CallBase &I) {
+  Function *F = I.getCalledFunction();
   // If this is a local function that doesn't have its address taken, mark its
   // entry block executable and merge in the actual arguments to the call into
   // the formal arguments of the function.
   if (!TrackingIncomingArguments.empty() &&
       TrackingIncomingArguments.count(F)) {
     MarkBlockExecutable(&F->front());
 
     // Propagate information from this call site into the callee.
-    CallSite::arg_iterator CAI = CS.arg_begin();
+    auto CAI = I.arg_begin();
     for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); AI != E;
          ++AI, ++CAI) {
       // If this argument is byval, and if the function is not readonly, there
       // will be an implicit copy formed of the input aggregate.
       if (AI->hasByValAttr() && !F->onlyReadsMemory()) {
         markOverdefined(&*AI);
         continue;
       }
 
       if (auto *STy = dyn_cast<StructType>(AI->getType())) {
         for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
           ValueLatticeElement CallArg = getStructValueState(*CAI, i);
           mergeInValue(getStructValueState(&*AI, i), &*AI, CallArg);
         }
       } else
         mergeInValue(&*AI, getValueState(*CAI),
                      ValueLatticeElement::MergeOptions().setCheckWiden(false));
     }
   }
 }
 
-void SCCPSolver::handleCallResult(CallSite CS) {
-  Function *F = CS.getCalledFunction();
-  Instruction *I = CS.getInstruction();
+void SCCPSolver::handleCallResult(CallBase &I) {
+  Function *F = I.getCalledFunction();
 
-  if (auto *II = dyn_cast<IntrinsicInst>(I)) {
+  if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
     if (II->getIntrinsicID() == Intrinsic::ssa_copy) {
-      if (ValueState[I].isOverdefined())
+      if (ValueState[&I].isOverdefined())
         return;
 
-      Value *CopyOf = I->getOperand(0);
-      auto *PI = getPredicateInfoFor(I);
+      Value *CopyOf = I.getOperand(0);
+      auto *PI = getPredicateInfoFor(&I);
       auto *PBranch = dyn_cast_or_null<PredicateBranch>(PI);
       if (!PI || !PBranch) {
-        mergeInValue(ValueState[I], I, getValueState(CopyOf));
+        mergeInValue(ValueState[&I], &I, getValueState(CopyOf));
         return;
       }
 
       // Everything below relies on the condition being a comparison.
       auto *Cmp = dyn_cast<CmpInst>(PBranch->Condition);
       if (!Cmp) {
-        mergeInValue(ValueState[I], I, getValueState(CopyOf));
+        mergeInValue(ValueState[&I], &I, getValueState(CopyOf));
         return;
       }
 
       Value *CmpOp0 = Cmp->getOperand(0);
       Value *CmpOp1 = Cmp->getOperand(1);
       if (CopyOf != CmpOp0 && CopyOf != CmpOp1) {
-        mergeInValue(ValueState[I], I, getValueState(CopyOf));
+        mergeInValue(ValueState[&I], &I, getValueState(CopyOf));
         return;
       }
 
       auto Pred = Cmp->getPredicate();
       if (CmpOp0 != CopyOf) {
         std::swap(CmpOp0, CmpOp1);
         Pred = Cmp->getSwappedPredicate();
       }
 
       // Wait until CmpOp1 is resolved.
       if (getValueState(CmpOp1).isUnknown()) {
-        addAdditionalUser(CmpOp1, I);
+        addAdditionalUser(CmpOp1, &I);
         return;
       }
 
       if (!PBranch->TrueEdge)
         Pred = CmpInst::getInversePredicate(Pred);
 
       ValueLatticeElement CondVal = getValueState(CmpOp1);
-      ValueLatticeElement &IV = ValueState[I];
+      ValueLatticeElement &IV = ValueState[&I];
       ValueLatticeElement OriginalVal = getValueState(CopyOf);
       if (CondVal.isConstantRange() || OriginalVal.isConstantRange()) {
         auto NewCR =
             ConstantRange::getFull(DL.getTypeSizeInBits(CopyOf->getType()));
 
         // Get the range imposed by the condition.
         if (CondVal.isConstantRange())
           NewCR = ConstantRange::makeAllowedICmpRegion(
               Pred, CondVal.getConstantRange());
 
         // Combine range info for the original value with the new range from the
         // condition.
         auto OriginalCR = OriginalVal.isConstantRange()
                               ? OriginalVal.getConstantRange()
                               : ConstantRange::getFull(
                                     DL.getTypeSizeInBits(CopyOf->getType()));
         NewCR = NewCR.intersectWith(OriginalCR);
 
-        addAdditionalUser(CmpOp1, I);
+        addAdditionalUser(CmpOp1, &I);
         // TODO: Actually filp MayIncludeUndef for the created range to false,
         // once most places in the optimizer respect the branches on
         // undef/poison are UB rule. The reason why the new range cannot be
         // undef is as follows below:
         // The new range is based on a branch condition. That guarantees that
         // neither of the compare operands can be undef in the branch targets,
         // unless we have conditions that are always true/false (e.g. icmp ule
         // i32, %a, i32_max). For the latter overdefined/empty range will be
         // inferred, but the branch will get folded accordingly anyways.
         mergeInValue(
-            IV, I,
+            IV, &I,
             ValueLatticeElement::getRange(NewCR, /*MayIncludeUndef=*/true));
         return;
       } else if (Pred == CmpInst::ICMP_EQ && CondVal.isConstant()) {
         // For non-integer values or integer constant expressions, only
         // propagate equal constants.
-        addAdditionalUser(CmpOp1, I);
-        mergeInValue(IV, I, CondVal);
+        addAdditionalUser(CmpOp1, &I);
+        mergeInValue(IV, &I, CondVal);
         return;
       }
 
-      return (void)mergeInValue(IV, I, getValueState(CopyOf));
+      return (void)mergeInValue(IV, &I, getValueState(CopyOf));
     }
   }
 
   // The common case is that we aren't tracking the callee, either because we
   // are not doing interprocedural analysis or the callee is indirect, or is
   // external.  Handle these cases first.
   if (!F || F->isDeclaration())
-    return handleCallOverdefined(CS);
+    return handleCallOverdefined(I);
 
   // If this is a single/zero retval case, see if we're tracking the function.
   if (auto *STy = dyn_cast<StructType>(F->getReturnType())) {
     if (!MRVFunctionsTracked.count(F))
-      return handleCallOverdefined(CS); // Not tracking this callee.
+      return handleCallOverdefined(I); // Not tracking this callee.
 
     // If we are tracking this callee, propagate the result of the function
     // into this call site.
     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
-      mergeInValue(getStructValueState(I, i), I,
+      mergeInValue(getStructValueState(&I, i), &I,
                    TrackedMultipleRetVals[std::make_pair(F, i)]);
   } else {
     auto TFRVI = TrackedRetVals.find(F);
     if (TFRVI == TrackedRetVals.end())
-      return handleCallOverdefined(CS); // Not tracking this callee.
+      return handleCallOverdefined(I); // Not tracking this callee.
 
     // If so, propagate the return value of the callee into this call result.
-    mergeInValue(I, TFRVI->second);
+    mergeInValue(&I, TFRVI->second);
   }
 }
 
 void SCCPSolver::Solve() {
   // Process the work lists until they are empty!
   while (!BBWorkList.empty() || !InstWorkList.empty() ||
          !OverdefinedInstWorkList.empty()) {
     // Process the overdefined instruction's work list first, which drives other
for (BasicBlock &BB : F) {
     for (Instruction &I : BB) {
       // Look for instructions which produce undef values.
       if (I.getType()->isVoidTy()) continue;
 
       if (auto *STy = dyn_cast<StructType>(I.getType())) {
         // Only a few things that can be structs matter for undef.
 
         // Tracked calls must never be marked overdefined in ResolvedUndefsIn.
-        if (CallSite CS = CallSite(&I))
-          if (Function *F = CS.getCalledFunction())
+        if (auto *CB = dyn_cast<CallBase>(&I))
+          if (Function *F = CB->getCalledFunction())
             if (MRVFunctionsTracked.count(F))
               continue;
 
         // extractvalue and insertvalue don't need to be marked; they are
         // tracked as precisely as their operands.
         if (isa<ExtractValueInst>(I) || isa<InsertValueInst>(I))
           continue;
         // Send the results of everything else to overdefined.  We could be
for (Instruction &I : BB) {
       if (!LV.isUnknownOrUndef())
         continue;
 
       // There are two reasons a call can have an undef result
       // 1. It could be tracked.
       // 2. It could be constant-foldable.
       // Because of the way we solve return values, tracked calls must
       // never be marked overdefined in ResolvedUndefsIn.
-      if (CallSite CS = CallSite(&I))
-        if (Function *F = CS.getCalledFunction())
+      if (auto *CB = dyn_cast<CallBase>(&I))
+        if (Function *F = CB->getCalledFunction())
           if (TrackedRetVals.count(F))
             continue;
 
       if (isa<LoadInst>(I)) {
         // A load here means one of two things: a load of undef from a global,
         // a load from an unknown pointer.  Either way, having it return undef
         // is okay.
         continue;
Const =
         isConstant(IV) ? Solver.getConstant(IV) : UndefValue::get(V->getType());
   }
   assert(Const && "Constant is nullptr here!");
 
   // Replacing `musttail` instructions with constant breaks `musttail` invariant
   // unless the call itself can be removed
   CallInst *CI = dyn_cast<CallInst>(V);
   if (CI && CI->isMustTailCall() && !CI->isSafeToRemove()) {
-    CallSite CS(CI);
-    Function *F = CS.getCalledFunction();
+    Function *F = CI->getCalledFunction();
 
     // Don't zap returns of the callee
     if (F)
       Solver.AddMustTailCallee(F);
 
     LLVM_DEBUG(dbgs() << "  Can\'t treat the result of musttail call : " << *CI
                       << " as a constant\n");
     return false;
assert(
              [&Solver](User *U) {
                if (isa<Instruction>(U) &&
                    !Solver.isBlockExecutable(cast<Instruction>(U)->getParent()))
                  return true;
                // Non-callsite uses are not impacted by zapping. Also, constant
                // uses (like blockaddresses) could stuck around, without being
                // used in the underlying IR, meaning we do not have lattice
                // values for them.
-               if (!CallSite(U))
+               if (!isa<CallBase>(U))
                  return true;
                if (U->getType()->isStructTy()) {
                  return all_of(Solver.getStructLatticeValueFor(U),
                                [](const ValueLatticeElement &LV) {
                                  return !isOverdefined(LV);
                                });
                }
                return !isOverdefined(Solver.getLatticeValueFor(U));