Refactor code computing switch instruction cost. NFC.

[chandlerc]

There's nothing wrong with this code, but this is a refactoring that I think only makes sense in the context where you need it. As-is, it seems like unnecessarily more layers with no real benefit. Let's look at this in the end-state patch?

lib/Analysis/InlineCost.cpp

return BI.isUnconditional() || isa<ConstantInt>(BI.getCondition()) ||
              SimplifiedValues.lookup(BI.getCondition()));
 }
 
 bool CallAnalyzer::visitSwitchInst(SwitchInst &SI) {
   // We model unconditional switches as free, see the comments on handling
   // branches.
   if (isa<ConstantInt>(SI.getCondition()))
     return true;
-  if (Value *V = SimplifiedValues.lookup(SI.getCondition()))
-    if (isa<ConstantInt>(V))
-      return true;
 
-  // Otherwise, we need to accumulate a cost proportional to the number of
+  // Lambda to compute the cost of switch instruction.
+  auto SwitchInstCost = [](SwitchInst &SI) {
+    // We need to compute a cost proportional to the number of
     // distinct successor blocks. This fan-out in the CFG cannot be represented
     // for free even if we can represent the core switch as a jumptable that
     // takes a single instruction.
     //
     // NB: We convert large switches which are just used to initialize large phi
     // nodes to lookup tables instead in simplify-cfg, so this shouldn't prevent
     // inlining those. It will prevent inlining in cases where the optimization
     // does not (yet) fire.
     SmallPtrSet<BasicBlock *, 8> SuccessorBlocks;
     SuccessorBlocks.insert(SI.getDefaultDest());
     for (auto I = SI.case_begin(), E = SI.case_end(); I != E; ++I)
       SuccessorBlocks.insert(I.getCaseSuccessor());
+
     // Add cost corresponding to the number of distinct destinations. The first
     // we model as free because of fallthrough.
-  Cost += (SuccessorBlocks.size() - 1) * InlineConstants::InstrCost;
+    return (SuccessorBlocks.size() - 1) * InlineConstants::InstrCost;
+  };
+
+  if (Value *V = SimplifiedValues.lookup(SI.getCondition()))
+    if (isa<ConstantInt>(V))
+      return true;
+
+  Cost += SwitchInstCost(SI);
   return false;
 }
 
 bool CallAnalyzer::visitIndirectBrInst(IndirectBrInst &IBI) {
   // We never want to inline functions that contain an indirectbr.  This is
   // incorrect because all the blockaddress's (in static global initializers
   // for example) would be referring to the original function, and this
   // indirect jump would jump from the inlined copy of the function into the