[SIL-opaque] Add @in_guaranteed function argument support.

Temporarily map storage to a fake load_borrow.

Author: atrick

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -425,7 +425,12 @@ struct AddressLoweringState {
 
   AddressLoweringState(SILFunction *function, DominanceInfo *domInfo)
       : function(function), loweredFnConv(getLoweredFnConv(function)),
-        domInfo(domInfo) {}
+        domInfo(domInfo) {
+    for (auto &block : *function) {
+      if (block.getTerminator()->isFunctionExiting())
+        exitingInsts.push_back(block.getTerminator());
+    }
+  }
 
   SILModule *getModule() const { return &function->getModule(); }
 
@@ -489,28 +494,39 @@ static void convertDirectToIndirectFunctionArgs(AddressLoweringState &pass) {
     if (param.isFormalIndirect() && !fnConv.isSILIndirect(param)) {
       SILArgument *arg = pass.function->getArgument(argIdx);
       SILType addrType = arg->getType().getAddressType();
-      LoadInst *loadArg = argBuilder.createTrivialLoadOr(
-          SILValue(arg).getLoc(), SILUndef::get(addrType, *pass.function),
-          LoadOwnershipQualifier::Take);
-
-      arg->replaceAllUsesWith(loadArg);
+      auto loc = SILValue(arg).getLoc();
+      SILValue undefAddress = SILUndef::get(addrType, *pass.function);
+      SingleValueInstruction *load;
+      if (param.isConsumed()) {
+        load = argBuilder.createTrivialLoadOr(loc, undefAddress,
+                                              LoadOwnershipQualifier::Take);
+      } else {
+        load = cast<SingleValueInstruction>(
+            argBuilder.emitLoadBorrowOperation(loc, undefAddress));
+        for (SILInstruction *termInst : pass.exitingInsts) {
+          pass.getBuilder(termInst->getIterator())
+              .createEndBorrow(pass.genLoc(), load);
+        }
+      }
+      arg->replaceAllUsesWith(load);
       assert(!pass.valueStorageMap.contains(arg));
 
       arg = arg->getParent()->replaceFunctionArgument(
           arg->getIndex(), addrType, OwnershipKind::None, arg->getDecl());
 
-      loadArg->setOperand(arg);
+      assert(isa<LoadInst>(load) || isa<LoadBorrowInst>(load));
+      load->setOperand(0, arg);
 
       // Indirect calling convention may be used for loadable types. In that
       // case, generating the argument loads is sufficient.
       if (addrType.isAddressOnly(*pass.function)) {
-        pass.valueStorageMap.insertValue(loadArg, arg);
+        pass.valueStorageMap.insertValue(load, arg);
       }
     }
     ++argIdx;
   }
-  assert(argIdx
-         == fnConv.getSILArgIndexOfFirstParam() + fnConv.getNumSILArguments());
+  assert(argIdx ==
+         fnConv.getSILArgIndexOfFirstParam() + fnConv.getNumSILArguments());
 }
 
 /// Before populating the ValueStorageMap, insert function arguments for any
@@ -575,9 +591,6 @@ class OpaqueValueVisitor {
 /// to valueStorageMap in RPO.
 void OpaqueValueVisitor::mapValueStorage() {
   for (auto *block : postorderInfo.getReversePostOrder()) {
-    if (block->getTerminator()->isFunctionExiting())
-      pass.exitingInsts.push_back(block->getTerminator());
-
     // Opaque function arguments have already been replaced.
     if (block != pass.function->getEntryBlock()) {
       for (auto *arg : block->getArguments()) {

test/SILOptimizer/address_lowering.sil

@@ -272,12 +272,12 @@ bb0(%0 : @owned $C):
 
 sil [ossa] @f044_indirectGuaranteed : $@convention(thin) <T>(@in_guaranteed T) -> ()
 
-// CHECK-LABEL: sil [ossa] @f045_indirectGuaranteedArg : $@convention(thin) <T> (@in T) -> () {
+// CHECK-LABEL: sil [ossa] @f045_indirectGuaranteedCallArg : $@convention(thin) <T> (@in T) -> () {
 // CHECK: bb0(%0 : $*T):
 // CHECK:   apply %{{.*}}<T>(%0) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
 // CHECK:   destroy_addr %0 : $*T
-// CHECK-LABEL: } // end sil function 'f045_indirectGuaranteedArg'
-sil [ossa] @f045_indirectGuaranteedArg : $@convention(thin) <T>(@in T) -> () {
+// CHECK-LABEL: } // end sil function 'f045_indirectGuaranteedCallArg'
+sil [ossa] @f045_indirectGuaranteedCallArg : $@convention(thin) <T>(@in T) -> () {
 bb0(%0 : @owned $T):
   %1 = function_ref @f044_indirectGuaranteed : $@convention(thin) <τ_0_0>(@in_guaranteed τ_0_0) -> ()
   %2 = apply %1<T>(%0) : $@convention(thin) <τ_0_0>(@in_guaranteed τ_0_0) -> ()
@@ -286,6 +286,20 @@ bb0(%0 : @owned $T):
   return %6 : $()
 }
 
+// CHECK-LABEL: sil [ossa] @f046_indirectGuaranteedFunctionArg : $@convention(thin) <T> (@in_guaranteed T) -> () {
+// CHECK: bb0(%0 : $*T):
+// CHECK-NOT: load
+// CHECK: apply %{{.*}}<T>(%0) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
+// CHECK-NOT: end_borrow
+// CHECK-LABEL: } // end sil function 'f046_indirectGuaranteedFunctionArg'
+sil [ossa] @f046_indirectGuaranteedFunctionArg : $@convention(thin) <T>(@in_guaranteed T) -> () {
+bb0(%0 : @guaranteed $T):
+  %1 = function_ref @f044_indirectGuaranteed : $@convention(thin) <τ_0_0>(@in_guaranteed τ_0_0) -> ()
+  %2 = apply %1<T>(%0) : $@convention(thin) <τ_0_0>(@in_guaranteed τ_0_0) -> ()
+  %6 = tuple ()
+  return %6 : $()
+}
+
 // CHECK-LABEL: sil [ossa] @f050_storeinout : $@convention(thin) <T> (@inout T, @inout T, @in T) -> () {
 // CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T):
 // CHECK:   %[[PREV1:.*]] = alloc_stack $T