[NFC] CallGraph related cleanup

[sdmitriev]

Summary

Tidy up some CallGraph-related code in preparation for D82572.

[jdoerfert]

LGTM. I assumed you just commit this TBH ;)

llvm/include/llvm/Analysis/CallGraph.h

public:
   void dump() const;
 };
 
 //===----------------------------------------------------------------------===//
 // GraphTraits specializations for call graphs so that they can be treated as
 // graphs by the generic graph algorithms.
 //
 
-// Provide graph traits for tranversing call graphs using standard graph
+// Provide graph traits for traversing call graphs using standard graph
 // traversals.
 template <> struct GraphTraits<CallGraphNode *> {
   using NodeRef = CallGraphNode *;
   using CGNPairTy = CallGraphNode::CallRecord;
 
   static NodeRef getEntryNode(CallGraphNode *CGN) { return CGN; }
   static CallGraphNode *CGNGetValue(CGNPairTy P) { return P.second; }
 

llvm/lib/Analysis/CallGraphSCCPass.cpp

for (CallGraphSCC::iterator SCCIdx = CurSCC.begin(), E = CurSCC.end();
     // invalidated and removed.
     unsigned NumDirectRemoved = 0, NumIndirectRemoved = 0;
 
     // Get the set of call sites currently in the function.
     for (CallGraphNode::iterator I = CGN->begin(), E = CGN->end(); I != E; ) {
       // If this call site is null, then the function pass deleted the call
       // entirely and the WeakTrackingVH nulled it out.
       auto *Call = dyn_cast_or_null<CallBase>(I->first);
-      if (!I->first ||
+      if (!Call ||
           // If we've already seen this call site, then the FunctionPass RAUW'd
           // one call with another, which resulted in two "uses" in the edge
           // list of the same call.
-          Calls.count(I->first) ||
+          Calls.count(Call) ||
 
           // If the call edge is not from a call or invoke, or it is a
           // instrinsic call, then the function pass RAUW'd a call with
           // another value. This can happen when constant folding happens
           // of well known functions etc.
-          !Call ||
           (Call->getCalledFunction() &&
            Call->getCalledFunction()->isIntrinsic() &&
            Intrinsic::isLeaf(Call->getCalledFunction()->getIntrinsicID()))) {
         assert(!CheckingMode &&
                "CallGraphSCCPass did not update the CallGraph correctly!");
 
         // If this was an indirect call site, count it.
         if (!I->second->getFunction())
for (CallGraphNode::iterator I = CGN->begin(), E = CGN->end(); I != E; ) {
         // iterator checking rejects comparisons of the resultant pointer with
         // end.
         if (WasLast)
           break;
         E = CGN->end();
         continue;
       }
 
-      assert(!Calls.count(I->first) &&
-             "Call site occurs in node multiple times");
+      assert(!Calls.count(Call) && "Call site occurs in node multiple times");
 
       if (Call) {
         Function *Callee = Call->getCalledFunction();
         // Ignore intrinsics because they're not really function calls.
         if (!Callee || !(Callee->isIntrinsic()))
-          Calls.insert(std::make_pair(I->first, I->second));
+          Calls.insert(std::make_pair(Call, I->second));
       }
       ++I;
     }
 
     // Loop over all of the instructions in the function, getting the callsites.
     // Keep track of the number of direct/indirect calls added.
     unsigned NumDirectAdded = 0, NumIndirectAdded = 0;
 

llvm/lib/Transforms/IPO/SyntheticCountsPropagation.cpp

PreservedAnalyses SyntheticCountsPropagation::run(Module &M,
 
   // Edge includes information about the source. Hence ignore the first
   // parameter.
   auto GetCallSiteProfCount = [&](const CallGraphNode *,
                                   const CallGraphNode::CallRecord &Edge) {
     Optional<Scaled64> Res = None;
     if (!Edge.first)
       return Res;
-    assert(isa<Instruction>(Edge.first));
-    CallBase &CB = cast<CallBase>(*Edge.first);
+    CallBase &CB = *cast<CallBase>(Edge.first);
     Function *Caller = CB.getCaller();
     auto &BFI = FAM.getResult<BlockFrequencyAnalysis>(*Caller);
 
     // Now compute the callsite count from relative frequency and
     // entry count:
     BasicBlock *CSBB = CB.getParent();
     Scaled64 EntryFreq(BFI.getEntryFreq(), 0);
     Scaled64 BBCount(BFI.getBlockFreq(CSBB).getFrequency(), 0);