[FuncSpec][NFC] Sink cast into function.

[labrinea]

Summary

Before looking up a value in the map of known constants we attempt
to dynamically cast it. The code looks cleaner if we move the cast
inside findConstantFor(), where the look up happens.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

for (BasicBlock *SuccBB : successors(BB))
       if (Solver.isBlockExecutable(SuccBB) &&
           SuccBB->getUniquePredecessor() == BB)
         WorkList.push_back(SuccBB);
   }
   return Bonus;
 }
 
 static Constant *findConstantFor(Value *V, ConstMap &KnownConstants) {
+  if (auto *C = dyn_cast<Constant>(V))
+    return C;
   if (auto It = KnownConstants.find(V); It != KnownConstants.end())
     return It->second;
   return nullptr;
 }
 
 Cost InstCostVisitor::getUserBonus(Instruction *User, Value *Use, Constant *C) {
   // Cache the iterator before visiting.
   LastVisited = KnownConstants.insert({Use, C}).first;
Constant *InstCostVisitor::visitCallBase(CallBase &I) {
   if (!F || !canConstantFoldCallTo(&I, F))
     return nullptr;
 
   SmallVector<Constant *, 8> Operands;
   Operands.reserve(I.getNumOperands());
 
   for (unsigned Idx = 0, E = I.getNumOperands() - 1; Idx != E; ++Idx) {
     Value *V = I.getOperand(Idx);
-    auto *C = dyn_cast<Constant>(V);
-    if (!C)
-      C = findConstantFor(V, KnownConstants);
+    Constant *C = findConstantFor(V, KnownConstants);
     if (!C)
       return nullptr;
     Operands.push_back(C);
   }
 
   auto Ops = ArrayRef(Operands.begin(), Operands.end());
   return ConstantFoldCall(&I, F, Ops);
 }
 
 Constant *InstCostVisitor::visitLoadInst(LoadInst &I) {
   if (isa<ConstantPointerNull>(LastVisited->second))
     return nullptr;
   return ConstantFoldLoadFromConstPtr(LastVisited->second, I.getType(), DL);
 }
 
 Constant *InstCostVisitor::visitGetElementPtrInst(GetElementPtrInst &I) {
   SmallVector<Constant *, 8> Operands;
   Operands.reserve(I.getNumOperands());
 
   for (unsigned Idx = 0, E = I.getNumOperands(); Idx != E; ++Idx) {
     Value *V = I.getOperand(Idx);
-    auto *C = dyn_cast<Constant>(V);
-    if (!C)
-      C = findConstantFor(V, KnownConstants);
+    Constant *C = findConstantFor(V, KnownConstants);
     if (!C)
       return nullptr;
     Operands.push_back(C);
   }
 
   auto Ops = ArrayRef(Operands.begin(), Operands.end());
   return ConstantFoldInstOperands(&I, Ops, DL);
 }
 
 Constant *InstCostVisitor::visitSelectInst(SelectInst &I) {
   if (I.getCondition() != LastVisited->first)
     return nullptr;
 
   Value *V = LastVisited->second->isZeroValue() ? I.getFalseValue()
                                                 : I.getTrueValue();
-  auto *C = dyn_cast<Constant>(V);
-  if (!C)
-    C = findConstantFor(V, KnownConstants);
+  Constant *C = findConstantFor(V, KnownConstants);
   return C;
 }
 
 Constant *InstCostVisitor::visitCastInst(CastInst &I) {
   return ConstantFoldCastOperand(I.getOpcode(), LastVisited->second,
                                  I.getType(), DL);
 }
 
 Constant *InstCostVisitor::visitCmpInst(CmpInst &I) {
   bool Swap = I.getOperand(1) == LastVisited->first;
   Value *V = Swap ? I.getOperand(0) : I.getOperand(1);
-  auto *Other = dyn_cast<Constant>(V);
-  if (!Other)
-    Other = findConstantFor(V, KnownConstants);
-
+  Constant *Other = findConstantFor(V, KnownConstants);
   if (!Other)
     return nullptr;
 
   Constant *Const = LastVisited->second;
   return Swap ?
         ConstantFoldCompareInstOperands(I.getPredicate(), Other, Const, DL)
       : ConstantFoldCompareInstOperands(I.getPredicate(), Const, Other, DL);
 }
 
 Constant *InstCostVisitor::visitUnaryOperator(UnaryOperator &I) {
   return ConstantFoldUnaryOpOperand(I.getOpcode(), LastVisited->second, DL);
 }
 
 Constant *InstCostVisitor::visitBinaryOperator(BinaryOperator &I) {
   bool Swap = I.getOperand(1) == LastVisited->first;
   Value *V = Swap ? I.getOperand(0) : I.getOperand(1);
-  auto *Other = dyn_cast<Constant>(V);
-  if (!Other)
-    Other = findConstantFor(V, KnownConstants);
-
+  Constant *Other = findConstantFor(V, KnownConstants);
   if (!Other)
     return nullptr;
 
   Constant *Const = LastVisited->second;
   return dyn_cast_or_null<Constant>(Swap ?
         simplifyBinOp(I.getOpcode(), Other, Const, SimplifyQuery(DL))
       : simplifyBinOp(I.getOpcode(), Const, Other, SimplifyQuery(DL)));
 }