GenericSpecializer: support specializing typed throws

This means to support specializing functions with indirect error results.
Also, when specializing (and the concrete error type is loadable), convert the indirect error to a direct error.

rdar://118532113

Author: eeckstein

include/swift/SILOptimizer/Utils/GenericCloner.h

@@ -43,6 +43,7 @@ class GenericCloner
   llvm::SmallVector<AllocStackInst *, 8> AllocStacks;
   llvm::SmallVector<StoreBorrowInst *, 8> StoreBorrowsToCleanup;
   AllocStackInst *ReturnValueAddr = nullptr;
+  AllocStackInst *ErrorValueAddr = nullptr;
 
 public:
   friend class SILCloner<GenericCloner>;

include/swift/SILOptimizer/Utils/Generics.h

@@ -88,6 +88,8 @@ class ReabstractionInfo {
   /// See `droppedMetatypeArgs`.
   bool dropMetatypeArgs = false;
 
+  bool hasIndirectErrorResult = false;
+
   /// The first NumResults bits in Conversions refer to formal indirect
   /// out-parameters.
   unsigned NumFormalIndirectResults = 0;
@@ -190,6 +192,8 @@ class ReabstractionInfo {
   void finishPartialSpecializationPreparation(
       FunctionSignaturePartialSpecializer &FSPS);
 
+  TypeCategory handleReturnAndError(SILResultInfo RI, unsigned argIdx);
+
 public:
   ReabstractionInfo(SILModule &M) : M(&M) {}
 
@@ -227,7 +231,12 @@ class ReabstractionInfo {
   }
 
   unsigned param2ArgIndex(unsigned ParamIdx) const  {
-    return ParamIdx + NumFormalIndirectResults;
+    return ParamIdx + NumFormalIndirectResults + (hasIndirectErrorResult ? 1: 0);
+  }
+
+  unsigned indirectErrorIndex() const {
+    assert(hasIndirectErrorResult);
+    return NumFormalIndirectResults;
   }
 
   /// Returns true if the specialized function needs an alternative mangling.
@@ -255,6 +264,10 @@ class ReabstractionInfo {
     return ConvertIndirectToDirect && Conversions.test(ResultIdx);
   }
 
+  bool isErrorResultConverted() const {
+    return ConvertIndirectToDirect && Conversions.test(indirectErrorIndex());
+  }
+
   /// Gets the total number of original function arguments.
   unsigned getNumArguments() const { return Conversions.size(); }
 

lib/SILOptimizer/Utils/GenericCloner.cpp

@@ -62,6 +62,7 @@ SILFunction *GenericCloner::createDeclaration(
 void GenericCloner::populateCloned() {
   assert(AllocStacks.empty() && "Stale cloner state.");
   assert(!ReturnValueAddr && "Stale cloner state.");
+  assert(!ErrorValueAddr && "Stale cloner state.");
 
   SILFunction *Cloned = getCloned();
   // Create arguments for the entry block.
@@ -95,17 +96,33 @@ void GenericCloner::populateCloned() {
         return false;
 
       if (ArgIdx < origConv.getSILArgIndexOfFirstParam()) {
-        // Handle result arguments.
-        unsigned formalIdx =
-            origConv.getIndirectFormalResultIndexForSILArg(ArgIdx);
-        if (ReInfo.isFormalResultConverted(formalIdx)) {
-          // This result is converted from indirect to direct. The return inst
-          // needs to load the value from the alloc_stack. See below.
-          createAllocStack();
-          assert(!ReturnValueAddr);
-          ReturnValueAddr = ASI;
-          entryArgs.push_back(ASI);
-          return true;
+        if (ArgIdx < origConv.getNumIndirectSILResults()) {
+          // Handle result arguments.
+          unsigned formalIdx =
+              origConv.getIndirectFormalResultIndexForSILArg(ArgIdx);
+          if (ReInfo.isFormalResultConverted(formalIdx)) {
+            // This result is converted from indirect to direct. The return inst
+            // needs to load the value from the alloc_stack. See below.
+            createAllocStack();
+            assert(!ReturnValueAddr);
+            ReturnValueAddr = ASI;
+            entryArgs.push_back(ASI);
+            return true;
+          }
+        } else {
+          assert(origConv.getNumIndirectSILErrorResults() == 1 &&
+                 "only a single indirect error result is supported");
+          assert(ArgIdx == origConv.getNumIndirectSILResults());
+
+          if (ReInfo.isErrorResultConverted()) {
+            // This error result is converted from indirect to direct. The throw
+            // instruction needs to load the value from the alloc_stack. See below.
+            createAllocStack();
+            assert(!ErrorValueAddr);
+            ErrorValueAddr = ASI;
+            entryArgs.push_back(ASI);
+            return true;
+          }
         }
       } else if (ReInfo.isDroppedMetatypeArg(ArgIdx)) {
         // Replace the metatype argument with an `metatype` instruction in the
@@ -195,6 +212,17 @@ void GenericCloner::visitTerminator(SILBasicBlock *BB) {
       getBuilder().createReturn(RI->getLoc(), ReturnValue);
       return;
     }
+  } else if (isa<ThrowAddrInst>(OrigTermInst) && ErrorValueAddr) {
+      // The result is converted from indirect to direct. We have to load the
+      // returned value from the alloc_stack.
+      SILValue errorValue = getBuilder().emitLoadValueOperation(
+            ErrorValueAddr->getLoc(), ErrorValueAddr,
+            LoadOwnershipQualifier::Take);
+      for (AllocStackInst *ASI : reverse(AllocStacks)) {
+        getBuilder().createDeallocStack(ASI->getLoc(), ASI);
+      }
+      getBuilder().createThrow(OrigTermInst->getLoc(), errorValue);
+      return;
   } else if (OrigTermInst->isFunctionExiting()) {
     for (AllocStackInst *ASI : reverse(AllocStacks)) {
       getBuilder().createDeallocStack(ASI->getLoc(), ASI);