[SILInliner] Mark alloc_stacks lexical.

When inlining a function to which an alloc_stack is passed (via any
convention that's not all of mutating, exclusive, and inout), mark the
alloc_stack as lexical.  Otherwise, destroy_addrs could be hoisted
through the inlined function in a way inconsistent with how they were
hoisted through the callee prior to inlining.

Author: nate-chandler

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -15,6 +15,8 @@
 #include "swift/SILOptimizer/Utils/SILInliner.h"
 #include "swift/AST/Builtins.h"
 #include "swift/AST/DiagnosticsSIL.h"
+#include "swift/Basic/Defer.h"
+#include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/PrettyStackTrace.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILInstruction.h"
@@ -433,17 +435,44 @@ void SILInlineCloner::cloneInline(ArrayRef<SILValue> AppliedArgs) {
   auto calleeConv = getCalleeFunction()->getConventions();
   for (auto p : llvm::enumerate(AppliedArgs)) {
     SILValue callArg = p.value();
+    SWIFT_DEFER { entryArgs.push_back(callArg); };
     unsigned idx = p.index();
     if (idx >= calleeConv.getSILArgIndexOfFirstParam()) {
-      // Insert begin/end borrow for guaranteed arguments.
-      if (calleeConv.getParamInfoForSILArg(idx).isGuaranteed()) {
-        if (SILValue newValue = borrowFunctionArgument(callArg, Apply)) {
-          callArg = newValue;
-          borrowedArgs[idx] = true;
+      auto paramInfo = calleeConv.getParamInfoForSILArg(idx);
+      if (callArg->getType().isAddress()) {
+        // If lexical lifetimes are enabled, any alloc_stacks in the caller that
+        // are passed to the callee being inlined (except mutating exclusive
+        // accesses) need to be promoted to be lexical.  Otherwise,
+        // destroy_addrs could be hoisted through the body of the newly inlined
+        // function without regard to the deinit barriers it contains.
+        //
+        // TODO: [begin_borrow_addr] Instead of marking the alloc_stack as a
+        //       whole lexical, just mark the inlined range lexical via
+        //       begin_borrow_addr [lexical]/end_borrow_addr just as is done
+        //       with values.
+        auto &module = Apply.getFunction()->getModule();
+        auto enableLexicalLifetimes =
+            module.getASTContext().SILOpts.supportsLexicalLifetimes(module);
+        if (!enableLexicalLifetimes)
+          continue;
+
+        // Exclusive mutating accesses don't entail a lexical scope.
+        if (paramInfo.getConvention() == ParameterConvention::Indirect_Inout)
+          continue;
+
+        auto storage = AccessStorageWithBase::compute(callArg);
+        if (auto *asi = dyn_cast<AllocStackInst>(storage.base))
+          asi->setIsLexical();
+      } else {
+        // Insert begin/end borrow for guaranteed arguments.
+        if (paramInfo.isGuaranteed()) {
+          if (SILValue newValue = borrowFunctionArgument(callArg, Apply)) {
+            callArg = newValue;
+            borrowedArgs[idx] = true;
+          }
         }
       }
     }
-    entryArgs.push_back(callArg);
   }
 
   // Create the return block and set ReturnToBB for use in visitTerminator

test/SILGen/copy_operator.swift

@@ -37,7 +37,7 @@ class Klass {}
 // CHECK-SIL-LABEL: sil @$s8moveonly7useCopyyAA5KlassCADF : $@convention(thin) (@guaranteed Klass) -> @owned Klass {
 // CHECK-SIL: bb0([[ARG:%.*]] : $Klass):
 // CHECK-SIL-NEXT: debug_value
-// CHECK-SIL-NEXT: [[INPUT:%.*]] = alloc_stack $Klass
+// CHECK-SIL-NEXT: [[INPUT:%.*]] = alloc_stack [lexical] $Klass
 // CHECK-SIL-NEXT: store [[ARG]] to [[INPUT]]
 // CHECK-SIL-NEXT: [[VALUE:%[0-9][0-9]*]] = load [[INPUT]]{{.*}}
 // CHECK-SIL-NEXT: strong_retain [[VALUE]]
@@ -78,7 +78,7 @@ public func useCopy(_ k: Klass) -> Klass {
 // CHECK-SIL-LABEL: sil @$s8moveonly7useCopyyxxRlzClF : $@convention(thin) <T where T : AnyObject> (@guaranteed T) -> @owned T {
 // CHECK-SIL: bb0([[ARG:%.*]] :
 // CHECK-SIL-NEXT: debug_value
-// CHECK-SIL-NEXT: [[INPUT_TO_BE_ELIMINATED:%.*]] = alloc_stack $T
+// CHECK-SIL-NEXT: [[INPUT_TO_BE_ELIMINATED:%.*]] = alloc_stack [lexical] $T
 // CHECK-SIL-NEXT: store [[ARG]] to [[INPUT]] : $*T
 // CHECK-SIL-NEXT: [[VALUE:%.*]] = load [[INPUT]] : $*T
 // CHECK-SIL-NEXT: strong_retain [[VALUE]]

test/SILOptimizer/inline_lifetime.sil

@@ -130,6 +130,20 @@ bb0(%instance : $*T):
   return %retval : $()
 }
 
+// CHECK-LABEL: sil [ossa] @caller_allocstack_callee_inguaranteed : $@convention(thin) <T> () -> () {
+// CHECK:         alloc_stack [lexical]
+// CHECK-LABEL: } // end sil function 'caller_allocstack_callee_inguaranteed'
+sil [ossa] @caller_allocstack_callee_inguaranteed : $@convention(thin) <T> () -> () {
+bb0:
+  %addr = alloc_stack $T
+  apply undef<T>(%addr) : $@convention(thin) <τ_0_0> () -> @out τ_0_0
+  %callee_inguaranteed = function_ref @callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> ()
+  %retval = apply %callee_inguaranteed<T>(%addr) : $@convention(thin) <T> (@in_guaranteed T) -> ()
+  destroy_addr %addr : $*T
+  dealloc_stack %addr : $*T
+  return %retval : $()
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // begin_apply
 ////////////////////////////////////////////////////////////////////////////////

test/SILOptimizer/specialize_dynamic_self.swift

@@ -11,7 +11,7 @@ extension P {
 
 class C<T> : P {
   // CHECK-LABEL: sil shared [noinline] @$s23specialize_dynamic_self1CC11returnsSelfACyxGXDyFSi_Tg5 : $@convention(method) (@guaranteed C<Int>) -> @owned C<Int>
-  // CHECK: [[RESULT:%.*]] = alloc_stack $C<Int>
+  // CHECK: [[RESULT:%.*]] = alloc_stack [lexical] $C<Int>
   // CHECK: [[FN:%.*]] = function_ref @$s23specialize_dynamic_self1PPAAE7method1yyF : $@convention(method) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
   // CHECK: apply [[FN]]<@dynamic_self C<Int>>([[RESULT]]) : $@convention(method) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
   // CHECK: return %0 : $C<Int>