NFC: add early exit in ModuleSummaryAnalysis

[Prazek]

Summary

Changed this code because it was not very readable.
The one question that I got after changing it is, should we
count calls to intrinsics? We don't add them to caller summary,
so maybe we shouldn't also count them?

[tejohnson]

LGTM thanks for the cleanup.

We should count intrinsic calls towards the instruction count of the function, because they often do translate to real instructions. Could in fact be more than 1. CallAnalyzer::visitCallSite does some analysis based on the type of intrinsic for the inliner, but I hadn't looked into cloning that here - if we unify the inliner and importer cost analysis we would presumably pick that up.

llvm/trunk/lib/Analysis/ModuleSummaryAnalysis.cpp

static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M,
   DenseMap<const Value *, CalleeInfo> CallGraphEdges;
   DenseMap<GlobalValue::GUID, CalleeInfo> IndirectCallEdges;
   DenseSet<const Value *> RefEdges;
   ICallPromotionAnalysis ICallAnalysis;
 
   SmallPtrSet<const User *, 8> Visited;
   for (const BasicBlock &BB : F)
     for (const Instruction &I : BB) {
-      if (!isa<DbgInfoIntrinsic>(I))
-        ++NumInsts;
-
-      if (auto CS = ImmutableCallSite(&I)) {
-        auto *CalledFunction = CS.getCalledFunction();
-        // Check if this is a direct call to a known function.
-        if (CalledFunction) {
-          if (CalledFunction->hasName() && !CalledFunction->isIntrinsic()) {
-            auto ScaledCount = BFI ? BFI->getBlockProfileCount(&BB) : None;
-            auto *CalleeId =
-                M.getValueSymbolTable().lookup(CalledFunction->getName());
-            CallGraphEdges[CalleeId] +=
-                (ScaledCount ? ScaledCount.getValue() : 0);
-          }
-        } else {
-          // Otherwise, check for an indirect call (call to a non-const value
-          // that isn't an inline assembly call).
-          const CallInst *CI = dyn_cast<CallInst>(&I);
-          if (CS.getCalledValue() && !isa<Constant>(CS.getCalledValue()) &&
-              !(CI && CI->isInlineAsm())) {
-            uint32_t NumVals, NumCandidates;
-            uint64_t TotalCount;
-            auto CandidateProfileData =
-                ICallAnalysis.getPromotionCandidatesForInstruction(
-                    &I, NumVals, TotalCount, NumCandidates);
-            for (auto &Candidate : CandidateProfileData)
-              IndirectCallEdges[Candidate.Value] += Candidate.Count;
-          }
-        }
-      }
-      findRefEdges(&I, RefEdges, Visited);
-    }
+      if (isa<DbgInfoIntrinsic>(I))
+        continue;
+      findRefEdges(&I, RefEdges, Visited);
+      auto CS = ImmutableCallSite(&I);
+      if (!CS)
+        continue;
+        // Skip nameless and intrinsics.
+        if (!CalledFunction->hasName() || CalledFunction->isIntrinsic())
+          continue;
+        CallGraphEdges[CalleeId] += (ScaledCount ? ScaledCount.getValue() : 0);
+        const auto *CI = dyn_cast<CallInst>(&I);
+        // Skip inline assembly calls.
+        if (CI && CI->isInlineAsm())
+          continue;
+        // Skip direct calls.
+        if (!CS.getCalledValue() || isa<Constant>(CS.getCalledValue()))
+          continue;
+
 
   GlobalValueSummary::GVFlags Flags(F);
   std::unique_ptr<FunctionSummary> FuncSummary =
       llvm::make_unique<FunctionSummary>(Flags, NumInsts);
   FuncSummary->addCallGraphEdges(CallGraphEdges);
   FuncSummary->addCallGraphEdges(IndirectCallEdges);
   FuncSummary->addRefEdges(RefEdges);
   Index.addGlobalValueSummary(F.getName(), std::move(FuncSummary));