---

yaml
---
r: 345577
b: refs/heads/master
c: 615f7b6
h: refs/heads/master
i:
  345575: a8f2cdd

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7818220f84dd95fe0a5057bbb395acc73f1a365d
+refs/heads/master: 615f7b6463721f0e29ccd936a952807282c231d6
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/SILGen/SILGenBuilder.cpp

@@ -971,3 +971,9 @@ void SILGenBuilder::emitDestructureValueOperation(
         return func(index, cloner.clone(subValue));
       });
 }
+
+ManagedValue SILGenBuilder::createProjectBox(SILLocation loc, ManagedValue mv,
+                                             unsigned index) {
+  auto *pbi = SILBuilder::createProjectBox(loc, mv.getValue(), index);
+  return ManagedValue::forUnmanaged(pbi);
+}

trunk/lib/SILGen/SILGenBuilder.h

@@ -417,6 +417,10 @@ class SILGenBuilder : public SILBuilder {
   void emitDestructureValueOperation(
       SILLocation loc, ManagedValue value,
       function_ref<void(unsigned, ManagedValue)> func);
+
+  using SILBuilder::createProjectBox;
+  ManagedValue createProjectBox(SILLocation loc, ManagedValue mv,
+                                unsigned index);
 };
 
 } // namespace Lowering

trunk/lib/SILGen/SILGenDecl.cpp

@@ -889,23 +889,33 @@ void EnumElementPatternInitialization::emitEnumMatch(
 
         // If the payload is indirect, project it out of the box.
         if (eltDecl->isIndirect() || eltDecl->getParentEnum()->isIndirect()) {
-          SILValue boxedValue = SGF.B.createProjectBox(loc, mv.getValue(), 0);
-          auto &boxedTL = SGF.getTypeLowering(boxedValue->getType());
-          // SEMANTIC ARC TODO: Revisit this when the verifier is enabled.
+          ManagedValue boxedValue = SGF.B.createProjectBox(loc, mv, 0);
+          auto &boxedTL = SGF.getTypeLowering(boxedValue.getType());
+
+          // We must treat the boxed value as +0 since it may be shared. Copy it
+          // if nontrivial.
+          //
+          // NOTE: The APIs that we are usinng here will ensure that if we have
+          // a trivial value, the load_borrow will become a load [trivial] and
+          // the copies will be "automagically" elided.
           if (boxedTL.isLoadable() || !SGF.silConv.useLoweredAddresses()) {
             UnenforcedAccess access;
-            SILValue accessAddress =
-              access.beginAccess(SGF, loc, boxedValue, SILAccessKind::Read);
-            boxedValue = boxedTL.emitLoad(SGF.B, loc, accessAddress,
-                                          LoadOwnershipQualifier::Take);
+            SILValue accessAddress = access.beginAccess(
+                SGF, loc, boxedValue.getValue(), SILAccessKind::Read);
+            auto mvAccessAddress = ManagedValue::forUnmanaged(accessAddress);
+            {
+              Scope loadScope(SGF, loc);
+              ManagedValue borrowedVal =
+                  SGF.B.createLoadBorrow(loc, mvAccessAddress);
+              mv = loadScope.popPreservingValue(
+                  borrowedVal.copyUnmanaged(SGF, loc));
+            }
             access.endAccess(SGF);
+          } else {
+            // If we do not have a loadable value, just do a copy of the
+            // boxedValue.
+            mv = boxedValue.copyUnmanaged(SGF, loc);
           }
-          // We must treat the boxed value as +0 since it may be shared. Copy it
-          // if nontrivial.
-          //
-          // TODO: Should be able to hand it off at +0 in some cases.
-          mv = ManagedValue::forUnmanaged(boxedValue);
-          mv = mv.copyUnmanaged(SGF, loc);
         }
 
         // Reabstract to the substituted type, if needed.

trunk/test/SILGen/indirect_enum.swift

@@ -1,5 +1,5 @@
 
-// RUN: %target-swift-emit-silgen -module-name indirect_enum -Xllvm -sil-print-debuginfo %s | %FileCheck %s
+// RUN: %target-swift-emit-silgen -enable-sil-ownership -module-name indirect_enum -Xllvm -sil-print-debuginfo %s | %FileCheck %s
 
 indirect enum TreeA<T> {
   case Nil
@@ -151,7 +151,9 @@ func switchTreeA<T>(_ x: TreeA<T>) {
   // CHECK: bb0([[ARG:%.*]] : @guaranteed $TreeA<T>):
   // --           x +2
   // CHECK:       [[ARG_COPY:%.*]] = copy_value [[ARG]]
-  // CHECK:       switch_enum [[ARG_COPY]] : $TreeA<T>,
+  // CHECK:       [[BORROWED_ARG_COPY:%.*]] = begin_borrow [[ARG_COPY]]
+  // CHECK:       [[ARG_COPY_2:%.*]] = copy_value [[BORROWED_ARG_COPY]]
+  // CHECK:       switch_enum [[ARG_COPY_2]] : $TreeA<T>,
   // CHECK:          case #TreeA.Nil!enumelt: [[NIL_CASE:bb1]],
   // CHECK:          case #TreeA.Leaf!enumelt.1: [[LEAF_CASE:bb2]],
   // CHECK:          case #TreeA.Branch!enumelt.1: [[BRANCH_CASE:bb3]],
@@ -177,13 +179,15 @@ func switchTreeA<T>(_ x: TreeA<T>) {
   // CHECK:       [[TUPLE_ADDR:%.*]] = project_box [[NODE_BOX]]
   // CHECK:       [[TUPLE:%.*]] = load_borrow [[TUPLE_ADDR]]
   // CHECK:       ([[LEFT:%.*]], [[RIGHT:%.*]]) = destructure_tuple [[TUPLE]]
-  // CHECK:       switch_enum [[LEFT]] : $TreeA<T>,
+  // CHECK:       [[LEFT_COPY:%.*]] = copy_value [[LEFT]]
+  // CHECK:       switch_enum [[LEFT_COPY]] : $TreeA<T>,
   // CHECK:          case #TreeA.Leaf!enumelt.1: [[LEAF_CASE_LEFT:bb[0-9]+]],
   // CHECK:          default [[FAIL_LEFT:bb[0-9]+]]
 
   // CHECK:     [[LEAF_CASE_LEFT]]([[LEFT_LEAF_BOX:%.*]] : @owned $<τ_0_0> { var τ_0_0 } <T>):
   // CHECK:       [[LEFT_LEAF_VALUE:%.*]] = project_box [[LEFT_LEAF_BOX]]
-  // CHECK:       switch_enum [[RIGHT]] : $TreeA<T>,
+  // CHECK:       [[RIGHT_COPY:%.*]] = copy_value [[RIGHT]]
+  // CHECK:       switch_enum [[RIGHT_COPY]] : $TreeA<T>,
   // CHECK:          case #TreeA.Leaf!enumelt.1: [[LEAF_CASE_RIGHT:bb[0-9]+]],
   // CHECK:          default [[FAIL_RIGHT:bb[0-9]+]]
 
@@ -195,10 +199,12 @@ func switchTreeA<T>(_ x: TreeA<T>) {
   // CHECK:       destroy_value [[NODE_BOX]]
   // CHECK:       br [[OUTER_CONT]]
 
-  // CHECK:     [[FAIL_RIGHT]]:
+  // CHECK:     [[FAIL_RIGHT]]([[DEFAULT_VAL:%.*]] :
+  // CHECK:       destroy_value [[DEFAULT_VAL]]
   // CHECK:       br [[DEFAULT:bb[0-9]+]]
 
-  // CHECK:     [[FAIL_LEFT]]:
+  // CHECK:     [[FAIL_LEFT]]([[DEFAULT_VAL:%.*]] :
+  // CHECK:       destroy_value [[DEFAULT_VAL]]
   // CHECK:       br [[DEFAULT]]
 
   case .Branch(.Leaf(let x), .Leaf(let y)):
@@ -310,6 +316,27 @@ func switchTreeB<T>(_ x: TreeB<T>) {
   // CHECK:       return
 }
 
+// Make sure that switchTreeInt obeys ownership invariants.
+//
+// CHECK-LABEL: sil hidden @$s13indirect_enum13switchTreeInt{{[_0-9a-zA-Z]*}}F
+func switchTreeInt(_ x: TreeInt) {
+  switch x {
+
+  case .Nil:
+    a()
+
+  case .Leaf(let x):
+    b(x)
+
+  case .Branch(.Leaf(let x), .Leaf(let y)):
+    c(x, y)
+
+  default:
+    d()
+  }
+}
+// CHECK: } // end sil function '$s13indirect_enum13switchTreeInt{{[_0-9a-zA-Z]*}}F'
+
 // CHECK-LABEL: sil hidden @$s13indirect_enum10guardTreeA{{[_0-9a-zA-Z]*}}F
 func guardTreeA<T>(_ tree: TreeA<T>) {
   // CHECK: bb0([[ARG:%.*]] : @guaranteed $TreeA<T>):
@@ -340,8 +367,9 @@ func guardTreeA<T>(_ tree: TreeA<T>) {
     // CHECK:   destroy_value [[ORIGINAL_VALUE]]
     // CHECK: [[YES]]([[BOX:%.*]] : @owned $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
     // CHECK:   [[VALUE_ADDR:%.*]] = project_box [[BOX]]
-    // CHECK:   [[TUPLE:%.*]] = load [take] [[VALUE_ADDR]]
+    // CHECK:   [[TUPLE:%.*]] = load_borrow [[VALUE_ADDR]]
     // CHECK:   [[TUPLE_COPY:%.*]] = copy_value [[TUPLE]]
+    // CHECK:   end_borrow [[TUPLE]]
     // CHECK:   ([[L:%.*]], [[R:%.*]]) = destructure_tuple [[TUPLE_COPY]]
     // CHECK:   destroy_value [[BOX]]
     guard case .Branch(left: let l, right: let r) = tree else { return }
@@ -381,16 +409,16 @@ func guardTreeA<T>(_ tree: TreeA<T>) {
     // CHECK:   destroy_value [[ORIGINAL_VALUE]]
     // CHECK: [[YES]]([[BOX:%.*]] : @owned $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
     // CHECK:   [[VALUE_ADDR:%.*]] = project_box [[BOX]]
-    // CHECK:   [[TUPLE:%.*]] = load [take] [[VALUE_ADDR]]
+    // CHECK:   [[TUPLE:%.*]] = load_borrow [[VALUE_ADDR]]
     // CHECK:   [[TUPLE_COPY:%.*]] = copy_value [[TUPLE]]
+    // CHECK:   end_borrow [[TUPLE]]
     // CHECK:   ([[L:%.*]], [[R:%.*]]) = destructure_tuple [[TUPLE_COPY]]
     // CHECK:   destroy_value [[BOX]]
     // CHECK:   destroy_value [[R]]
     // CHECK:   destroy_value [[L]]
     if case .Branch(left: let l, right: let r) = tree { }
   }
 }
-
 // CHECK-LABEL: sil hidden @$s13indirect_enum10guardTreeB{{[_0-9a-zA-Z]*}}F
 func guardTreeB<T>(_ tree: TreeB<T>) {
   do {
@@ -479,6 +507,25 @@ func guardTreeB<T>(_ tree: TreeB<T>) {
   }
 }
 
+// Just run guardTreeInt through the ownership verifier
+//
+// CHECK-LABEL: sil hidden @$s13indirect_enum12guardTreeInt{{[_0-9a-zA-Z]*}}F
+func guardTreeInt(_ tree: TreeInt) {
+  do {
+    guard case .Nil = tree else { return }
+
+    guard case .Leaf(let x) = tree else { return }
+
+    guard case .Branch(left: let l, right: let r) = tree else { return }
+  }
+
+  do {
+    if case .Nil = tree { }
+    if case .Leaf(let x) = tree { }
+    if case .Branch(left: let l, right: let r) = tree { }
+  }
+}
+
 // SEMANTIC ARC TODO: This test needs to be made far more comprehensive.
 // CHECK-LABEL: sil hidden @$s13indirect_enum35dontDisableCleanupOfIndirectPayloadyyAA010TrivialButG0OF : $@convention(thin) (@guaranteed TrivialButIndirect) -> () {
 func dontDisableCleanupOfIndirectPayload(_ x: TrivialButIndirect) {