Re-apply dc65f70 with some changes.

The underlying type of Int varies depending on platform, so use Int32
explicitly in this test now since the data size is immaterial for the
test.

Also allow for very limited self recursion rather than none, which
provides for a balance between performance and code bloat since inlining
can remove overhead and expose other opportunities for optimization.

Author: rudkx

lib/SILPasses/IPO/PerformanceInliner.cpp

@@ -542,6 +542,25 @@ bool SILPerformanceInliner::hasInliningCycle(SILFunction *Caller,
   return InlinedBefore;
 }
 
+// Return true if the callee does few (or no) self-recursive calls.
+static bool calleeHasMinimalSelfRecursion(SILFunction *Callee) {
+  int countSelfRecursiveCalls = 0;
+
+  for (auto &BB : *Callee) {
+    for (auto &I : BB) {
+      if (auto Apply = FullApplySite::isa(&I)) {
+        if (Apply.getCalleeFunction() == Callee)
+          ++countSelfRecursiveCalls;
+
+        if (countSelfRecursiveCalls > 2)
+          return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 // Returns the callee of an apply_inst if it is basically inlinable.
 SILFunction *SILPerformanceInliner::getEligibleFunction(FullApplySite AI) {
 
@@ -624,6 +643,17 @@ SILFunction *SILPerformanceInliner::getEligibleFunction(FullApplySite AI) {
           Callee->getName() << ".\n");
     return nullptr;
   }
+
+  // Inlining self-recursive functions into other functions can result
+  // in excessive code duplication since we run the inliner multiple
+  // times in our pipeline, so we only do it for callees with few
+  // self-recursive calls.
+  if (calleeHasMinimalSelfRecursion(Callee)) {
+    DEBUG(llvm::dbgs() << "        FAIL: Callee is self-recursive in "
+                       << Callee->getName() << ".\n");
+    return nullptr;
+  }
+
   DEBUG(llvm::dbgs() << "        Eligible callee: " <<
         Callee->getName() << "\n");
 

test/SILPasses/inline_recursive.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -primary-file %s  -parse-as-library -emit-sil -O | FileCheck %s
 
-private func recFunc(x: Int) -> Int {
+private func recFunc(x: Int32) -> Int32 {
   if x > 0 {
     return recFunc(x - 1)
   }
@@ -9,11 +9,31 @@ private func recFunc(x: Int) -> Int {
 
 //CHECK-LABEL: sil {{.*}}callit
 // CHECK: bb0:
-// CHECK-NEXT: integer_literal {{.*}}, 0
+// CHECK-NEXT: integer_literal $Builtin.Int32, 0
 // CHECK-NEXT: struct
 // CHECK-NEXT: return
 
-func callit() -> Int {
+func callit() -> Int32 {
   return recFunc(3)
 }
 
+private func recFuncManyCalls(x: Int32) -> Int32 {
+  if x > 4 {
+    return recFuncManyCalls(x - 1)
+    + recFuncManyCalls(x - 2)
+    + recFuncManyCalls(x - 3)
+    + recFuncManyCalls(x - 4)
+    + recFuncManyCalls(x - 5)
+  }
+  return 0
+}
+
+// CHECK-LABEL: sil hidden {{.*}}callother
+// CHECK: bb0:
+// CHECK: [[FN:%.*]] = function_ref {{.*}}recFuncManyCalls
+// CHECK: [[APPLY:%.*]] = apply [[FN]]
+// CHECK-NOT: apply
+// CHECK: return [[APPLY]]
+func callother() -> Int32 {
+  return recFuncManyCalls(10)
+}