[InlineCost] Consider the default branch when calculating cost

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

@@ -65,7 +65,8 @@ class TargetTransformInfoImplBase {
     (void)PSI;
     (void)BFI;
     JTSize = 0;
-    return SI.getNumCases();
+    bool HasDefault = !SI.defaultDestUndefined();
+    return SI.getNumCases() + HasDefault;
   }
 
   unsigned getInliningThresholdMultiplier() const { return 1; }

llvm/include/llvm/CodeGen/BasicTTIImpl.h

@@ -446,6 +446,7 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
     /// inline cost heuristic, but it's a generic cost model to be used in other
     /// places (e.g., in loop unrolling).
     unsigned N = SI.getNumCases();
+    bool HasDefault = !SI.defaultDestUndefined();
     const TargetLoweringBase *TLI = getTLI();
     const DataLayout &DL = this->getDataLayout();
 
@@ -454,7 +455,7 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
 
     // Early exit if both a jump table and bit test are not allowed.
     if (N < 1 || (!IsJTAllowed && DL.getIndexSizeInBits(0u) < N))
-      return N;
+      return N + HasDefault;
 
     APInt MaxCaseVal = SI.case_begin()->getCaseValue()->getValue();
     APInt MinCaseVal = MaxCaseVal;
@@ -474,23 +475,23 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
 
       if (TLI->isSuitableForBitTests(Dests.size(), N, MinCaseVal, MaxCaseVal,
                                      DL))
-        return 1;
+        return 1 + HasDefault;
     }
 
     // Check if suitable for a jump table.
     if (IsJTAllowed) {
       if (N < 2 || N < TLI->getMinimumJumpTableEntries())
-        return N;
+        return N + HasDefault;
       uint64_t Range =
           (MaxCaseVal - MinCaseVal)
               .getLimitedValue(std::numeric_limits<uint64_t>::max() - 1) + 1;
       // Check whether a range of clusters is dense enough for a jump table
       if (TLI->isSuitableForJumpTable(&SI, N, Range, PSI, BFI)) {
         JumpTableSize = Range;
-        return 1;
+        return 1 + HasDefault;
       }
     }
-    return N;
+    return N + HasDefault;
   }
 
   bool shouldBuildLookupTables() {

llvm/include/llvm/IR/Instructions.h

@@ -49,6 +49,7 @@ class DataLayout;
 class StringRef;
 class Type;
 class Value;
+class UnreachableInst;
 
 //===----------------------------------------------------------------------===//
 //                                AllocaInst Class
@@ -3505,6 +3506,12 @@ class SwitchInst : public Instruction {
     return cast<BasicBlock>(getOperand(1));
   }
 
+  /// Returns true if the default branch must result in immediate undefined
+  /// behavior, false otherwise.
+  bool defaultDestUndefined() const {
+    return isa<UnreachableInst>(getDefaultDest()->getFirstNonPHIOrDbg());
+  }
+
   void setDefaultDest(BasicBlock *DefaultCase) {
     setOperand(1, reinterpret_cast<Value*>(DefaultCase));
   }

llvm/lib/Analysis/InlineCost.cpp

@@ -707,8 +707,9 @@ class InlineCostCallAnalyzer final : public CallAnalyzer {
     if (JumpTableSize) {
       int64_t JTCost =
           static_cast<int64_t>(JumpTableSize) * InstrCost + 4 * InstrCost;
-
       addCost(JTCost);
+      if (NumCaseCluster > 1)
+        addCost((NumCaseCluster - 1) * 2 * InstrCost);
       return;
     }
 
@@ -1238,6 +1239,9 @@ class InlineCostFeaturesAnalyzer final : public CallAnalyzer {
       int64_t JTCost = static_cast<int64_t>(JumpTableSize) * InstrCost +
                        JTCostMultiplier * InstrCost;
       increment(InlineCostFeatureIndex::jump_table_penalty, JTCost);
+      if (NumCaseCluster > 1)
+        increment(InlineCostFeatureIndex::case_cluster_penalty,
+                  (NumCaseCluster - 1) * CaseClusterCostMultiplier * InstrCost);
       return;
     }