[llvm][NFC][CallSite] Remove CallSite from Evaluator.

[dblaikie]

llvm/lib/Transforms/Utils/Evaluator.cpp

267–269

Looks like this could pass by reference, rather than pointer (since it unconditionally dereferences in the implementation)

282

This one's less clear - up to you if you want to look closer to figure out if it could be reference. (the only issue is whether callers actually need to pass null CB when they pass null F - if they still pass non-null CB when F is null, then CB might as well be a reference)

571

No need for the cast here, since CB is already a CallBase?

[mtrofin]

• -> &

[mtrofin]

Missed a comment. Fixed.

[mtrofin]

llvm/lib/Transforms/Utils/Evaluator.cpp

282

Both members are only used internally, we could make them private.

[craig.topper]

llvm/include/llvm/Transforms/Utils/Evaluator.h

99

Can we change these to SmallVectorImpl<Constant *>& while we're already touching these lines? No point in forcing a specific size on the caller or repeating it.

[mtrofin]

SmallVector -> SmallVectorImpl

[craig.topper]

LGTM

llvm/include/llvm/Transforms/Utils/Evaluator.h

 
 #ifndef LLVM_TRANSFORMS_UTILS_EVALUATOR_H
 #define LLVM_TRANSFORMS_UTILS_EVALUATOR_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallSite.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
 #include <deque>
 #include <memory>
 
 namespace llvm {
 
Constant *getVal(Value *V) {
     return R;
   }
 
   void setVal(Value *V, Constant *C) {
     ValueStack.back()[V] = C;
   }
 
   /// Given call site return callee and list of its formal arguments
-  Function *getCalleeWithFormalArgs(CallSite &CS,
+  Function *getCalleeWithFormalArgs(CallBase *CB,
                                     SmallVector<Constant *, 8> &Formals);
 
   /// Given call site and callee returns list of callee formal argument
   /// values converting them when necessary
-  bool getFormalParams(CallSite &CS, Function *F,
+  bool getFormalParams(CallBase *CB, Function *F,
                        SmallVector<Constant *, 8> &Formals);
 
   /// Casts call result to a type of bitcast call expression
   Constant *castCallResultIfNeeded(Value *CallExpr, Constant *RV);
 
   const DenseMap<Constant*, Constant*> &getMutatedMemory() const {
     return MutatedMemory;
   }
 
   const SmallPtrSetImpl<GlobalVariable*> &getInvariants() const {
     return Invariants;
   }
 
 private:
   Constant *ComputeLoadResult(Constant *P);
 
   /// As we compute SSA register values, we store their contents here. The back
   /// of the deque contains the current function and the stack contains the
   /// values in the calling frames.
   std::deque<DenseMap<Value*, Constant*>> ValueStack;
 
   /// This is used to detect recursion.  In pathological situations we could hit
   /// exponential behavior, but at least there is nothing unbounded.
   SmallVector<Function*, 4> CallStack;
 

llvm/lib/Transforms/Utils/Evaluator.cpp

 
 #include "llvm/Transforms/Utils/Evaluator.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/ConstantFolding.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/GlobalAlias.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
static Function *getFunction(Constant *C) {
 
   if (auto *Alias = dyn_cast<GlobalAlias>(C))
     if (auto *Fn = dyn_cast<Function>(Alias->getAliasee()))
       return Fn;
   return nullptr;
 }
 
 Function *
-Evaluator::getCalleeWithFormalArgs(CallSite &CS,
+Evaluator::getCalleeWithFormalArgs(CallBase *CB,
                                    SmallVector<Constant *, 8> &Formals) {
-  auto *V = CS.getCalledValue();
+  auto *V = CB->getCalledValue();
   if (auto *Fn = getFunction(getVal(V)))
-    return getFormalParams(CS, Fn, Formals) ? Fn : nullptr;
+    return getFormalParams(CB, Fn, Formals) ? Fn : nullptr;
 
   auto *CE = dyn_cast<ConstantExpr>(V);
   if (!CE || CE->getOpcode() != Instruction::BitCast ||
-      !getFormalParams(CS, getFunction(CE->getOperand(0)), Formals))
+      !getFormalParams(CB, getFunction(CE->getOperand(0)), Formals))
     return nullptr;
 
   return dyn_cast<Function>(
       ConstantFoldLoadThroughBitcast(CE, CE->getOperand(0)->getType(), DL));
 }
 
-bool Evaluator::getFormalParams(CallSite &CS, Function *F,
+bool Evaluator::getFormalParams(CallBase *CB, Function *F,
                                 SmallVector<Constant *, 8> &Formals) {
   if (!F)
     return false;
 
   auto *FTy = F->getFunctionType();
-  if (FTy->getNumParams() > CS.getNumArgOperands()) {
+  if (FTy->getNumParams() > CB->getNumArgOperands()) {
     LLVM_DEBUG(dbgs() << "Too few arguments for function.\n");
     return false;
   }
 
-  auto ArgI = CS.arg_begin();
+  auto ArgI = CB->arg_begin();
   for (auto ParI = FTy->param_begin(), ParE = FTy->param_end(); ParI != ParE;
        ++ParI) {
     auto *ArgC = ConstantFoldLoadThroughBitcast(getVal(*ArgI), *ParI, DL);
     if (!ArgC) {
       LLVM_DEBUG(dbgs() << "Can not convert function argument.\n");
       return false;
     }
     Formals.push_back(ArgC);
if (StoreInst *SI = dyn_cast<StoreInst>(CurInst)) {
       Type *Ty = AI->getAllocatedType();
       AllocaTmps.push_back(std::make_unique<GlobalVariable>(
           Ty, false, GlobalValue::InternalLinkage, UndefValue::get(Ty),
           AI->getName(), /*TLMode=*/GlobalValue::NotThreadLocal,
           AI->getType()->getPointerAddressSpace()));
       InstResult = AllocaTmps.back().get();
       LLVM_DEBUG(dbgs() << "Found an alloca. Result: " << *InstResult << "\n");
     } else if (isa<CallInst>(CurInst) || isa<InvokeInst>(CurInst)) {
-      CallSite CS(&*CurInst);
+      CallBase *CB = cast<CallBase>(&*CurInst);
 
       // Debug info can safely be ignored here.
-      if (isa<DbgInfoIntrinsic>(CS.getInstruction())) {
+      if (isa<DbgInfoIntrinsic>(CB)) {
         LLVM_DEBUG(dbgs() << "Ignoring debug info.\n");
         ++CurInst;
         continue;
       }
 
       // Cannot handle inline asm.
-      if (isa<InlineAsm>(CS.getCalledValue())) {
+      if (isa<InlineAsm>(CB->getCalledValue())) {
         LLVM_DEBUG(dbgs() << "Found inline asm, can not evaluate.\n");
         return false;
       }
 
-      if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) {
+      if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CB)) {
         if (MemSetInst *MSI = dyn_cast<MemSetInst>(II)) {
           if (MSI->isVolatile()) {
             LLVM_DEBUG(dbgs() << "Can not optimize a volatile memset "
                               << "intrinsic.\n");
             return false;
           }
           Constant *Ptr = getVal(MSI->getDest());
           Constant *Val = getVal(MSI->getValue());
if (StoreInst *SI = dyn_cast<StoreInst>(CurInst)) {
         }
 
         LLVM_DEBUG(dbgs() << "Unknown intrinsic. Can not evaluate.\n");
         return false;
       }
 
       // Resolve function pointers.
       SmallVector<Constant *, 8> Formals;
-      Function *Callee = getCalleeWithFormalArgs(CS, Formals);
+      Function *Callee = getCalleeWithFormalArgs(CB, Formals);
       if (!Callee || Callee->isInterposable()) {
         LLVM_DEBUG(dbgs() << "Can not resolve function pointer.\n");
         return false;  // Cannot resolve.
       }
 
       if (Callee->isDeclaration()) {
         // If this is a function we can constant fold, do it.
-        if (Constant *C = ConstantFoldCall(cast<CallBase>(CS.getInstruction()),
-                                           Callee, Formals, TLI)) {
-          InstResult = castCallResultIfNeeded(CS.getCalledValue(), C);
+        if (Constant *C =
+                ConstantFoldCall(cast<CallBase>(CB), Callee, Formals, TLI)) {
+          InstResult = castCallResultIfNeeded(CB->getCalledValue(), C);
           if (!InstResult)
             return false;
           LLVM_DEBUG(dbgs() << "Constant folded function call. Result: "
                             << *InstResult << "\n");
         } else {
           LLVM_DEBUG(dbgs() << "Can not constant fold function call.\n");
           return false;
         }
       } else {
         if (Callee->getFunctionType()->isVarArg()) {
           LLVM_DEBUG(dbgs() << "Can not constant fold vararg function call.\n");
           return false;
         }
 
         Constant *RetVal = nullptr;
         // Execute the call, if successful, use the return value.
         ValueStack.emplace_back();
         if (!EvaluateFunction(Callee, RetVal, Formals)) {
           LLVM_DEBUG(dbgs() << "Failed to evaluate function.\n");
           return false;
         }
         ValueStack.pop_back();
-        InstResult = castCallResultIfNeeded(CS.getCalledValue(), RetVal);
+        InstResult = castCallResultIfNeeded(CB->getCalledValue(), RetVal);
         if (RetVal && !InstResult)
           return false;
 
         if (InstResult) {
           LLVM_DEBUG(dbgs() << "Successfully evaluated function. Result: "
                             << *InstResult << "\n\n");
         } else {
           LLVM_DEBUG(dbgs()