Merge pull request #29784 from eeckstein/inline-generic-curry-thunks

Inliner: inline generic thunks which return a partial_apply.

Author: eeckstein

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -526,6 +526,15 @@ bool SILPerformanceInliner::isProfitableToInline(
   return true;
 }
 
+static bool returnsClosure(SILFunction *F) {
+  for (SILBasicBlock &BB : *F) {
+    if (auto *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
+      return isa<PartialApplyInst>(RI->getOperand());
+    }
+  }
+  return false;
+}
+
 /// Checks if a given generic apply should be inlined unconditionally, i.e.
 /// without any complex analysis using e.g. a cost model.
 /// It returns true if a function should be inlined.
@@ -570,6 +579,13 @@ static Optional<bool> shouldInlineGeneric(FullApplySite AI) {
     return None;
   }
 
+  // The returned partial_apply of a thunk is most likely being optimized away
+  // if inlined. Because some thunks cannot be specialized (e.g. if an opened
+  // existential is in the subsitution list), we inline such thunks also in case
+  // they are generic.
+  if (Callee->isThunk() && returnsClosure(Callee))
+    return true;
+
   // All other generic functions should not be inlined if this kind of inlining
   // is disabled.
   if (!EnableSILInliningOfGenerics)

lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp

@@ -556,49 +556,6 @@ static bool calleeIsSelfRecursive(SILFunction *Callee) {
   return false;
 }
 
-// Returns true if the callee contains a partial apply instruction,
-// whose substitutions list would contain opened existentials after
-// inlining.
-static bool calleeHasPartialApplyWithOpenedExistentials(FullApplySite AI) {
-  if (!AI.hasSubstitutions())
-    return false;
-
-  SILFunction *Callee = AI.getReferencedFunctionOrNull();
-  assert(Callee && "Trying to optimize a dynamic function?!");
-
-  auto SubsMap = AI.getSubstitutionMap();
-
-  // Bail if there are no open existentials in the list of substitutions.
-  bool HasNoOpenedExistentials = true;
-  for (auto Replacement : SubsMap.getReplacementTypes()) {
-    if (Replacement->hasOpenedExistential()) {
-      HasNoOpenedExistentials = false;
-      break;
-    }
-  }
-
-  if (HasNoOpenedExistentials)
-    return false;
-
-  for (auto &BB : *Callee) {
-    for (auto &I : BB) {
-      if (auto PAI = dyn_cast<PartialApplyInst>(&I)) {
-        if (!PAI->hasSubstitutions())
-          continue;
-
-        // Check if any of substitutions would contain open existentials
-        // after inlining.
-        auto PAISubMap = PAI->getSubstitutionMap();
-        PAISubMap = PAISubMap.subst(SubsMap);
-        if (PAISubMap.hasOpenedExistential())
-          return true;
-      }
-    }
-  }
-
-  return false;
-}
-
 // Returns true if a given apply site should be skipped during the
 // early inlining pass.
 //
@@ -781,12 +738,6 @@ SILFunction *swift::getEligibleFunction(FullApplySite AI,
       return nullptr;
   }
 
-  // IRGen cannot handle partial_applies containing opened_existentials
-  // in its substitutions list.
-  if (calleeHasPartialApplyWithOpenedExistentials(AI)) {
-    return nullptr;
-  }
-
   return Callee;
 }
 

test/SILOptimizer/curry-thunk-elimination.swift

@@ -0,0 +1,45 @@
+// RUN: %target-swift-frontend  -primary-file %s -O -sil-verify-all -module-name=test -emit-sil | %FileCheck %s
+
+// Also do an end-to-end test to check all components, including IRGen.
+// RUN: %empty-directory(%t) 
+// RUN: %target-build-swift -O %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck --check-prefix=CHECK-OUTPUT %s
+
+// REQUIRES: executable_test,swift_stdlib_no_asserts,optimized_stdlib
+
+protocol P {
+    func foo() throws -> Int
+}
+
+struct S: P {
+    var a: Int
+    var b: Int
+    var c: Int
+    var d: Int
+
+    func foo() throws -> Int {
+        return a + b + c + d
+    }
+}
+
+func callClosure<R>(_ body: () throws -> R) rethrows -> R {
+    try body()
+}
+
+// Check that the optimizer can eliminat all calls to thunks and directly
+// try_apply's the witness method.
+
+// CHECK-LABEL: sil hidden [noinline] @$s4test6testitySiSgAA1P_pF
+// CHECK:   [[METHOD:%[0-9]+]] = witness_method $@opened{{.*}} #P.foo
+// CHECK:   try_apply [[METHOD]]<@opened
+// CHECK: // end sil function '$s4test6testitySiSgAA1P_pF'
+@inline(never)
+func testit(_ p: P) -> Int? {
+    return try? callClosure(p.foo)
+}
+
+let p: P = S(a: 1, b: 2, c: 3, d: 4)
+
+// CHECK-OUTPUT: 10
+print(testit(p)!)
+