CheckedCastBrJumpThreading test cases.

Author: atrick

test/SILOptimizer/simplify_cfg_checkcast.sil

@@ -1,7 +1,7 @@
 // RUN: %target-sil-opt -enable-sil-verify-all %s -jumpthread-simplify-cfg -enable-ossa-simplify-cfg -enable-ossa-rewriteterminator | %FileCheck %s
 // RUN: %target-sil-opt -enable-sil-verify-all %s -jumpthread-simplify-cfg -enable-ossa-simplify-cfg -enable-ossa-rewriteterminator -debug-only=sil-simplify-cfg 2>&1 | %FileCheck %s --check-prefix=CHECK-TRACE
 //
-// REQUIRES: EnableOSSASimplifyCFG
+// REQUIRES!!!: EnableOSSASimplifyCFG
 
 // FIXME: When OSSA optimization is complete, convert XCHECK to CHECK lines
 
@@ -46,6 +46,8 @@ class Final : Derived {
 sil [ossa] @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
 sil [ossa] @_TFC3ccb4Base6middlefS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
 
+sil @get_base : $@convention(thin) () -> @owned Base
+
 // CHECK-LABEL: sil [ossa] @redundant_checked_cast_br
 sil [ossa] @redundant_checked_cast_br : $@convention(method) (@guaranteed Base) -> () {
 bb0(%0 : @guaranteed $Base):
@@ -324,6 +326,7 @@ bb5(%2a : @guaranteed $Base):
   br bb6
 
 bb6:
+  dealloc_ref %a : $Base
   dealloc_stack_ref %a : $Base
   %r = tuple()
   return %r : $()
@@ -402,7 +405,7 @@ bb0(%0 : @guaranteed $Klass):
   %4 = copy_value %3 : $Klass
   checked_cast_br %3 : $Klass to OtherKlass, bb1, bb2
 
-bb1(%5 : $OtherKlass):
+bb1(%5 : @owned $OtherKlass):
   destroy_value %5 : $OtherKlass
   %6 = integer_literal $Builtin.Int1, -1
   br bb3(%6 : $Builtin.Int1)
@@ -428,19 +431,20 @@ bb6:
 bb7(%16 : @owned $Klass):
   checked_cast_br %16 : $Klass to OtherKlass, bb9, bb8
 
-bb8(%18 : $Klass):
+bb8(%18 : @owned $Klass):
   destroy_value %18 : $Klass
   br bb4
 
-bb9(%20 : $OtherKlass):
+bb9(%20 : @owned $OtherKlass):
   return %20 : $OtherKlass
 
 bb10(%22 : $Builtin.Int64):
   %23 = apply %1() : $@convention(thin) () -> @owned Klass
   %24 = copy_value %23 : $Klass
   checked_cast_br %23 : $Klass to OtherKlass, bb11, bb12
 
-bb11(%25 : $OtherKlass):
+bb11(%25 : @owned $OtherKlass):
+  destroy_value %25 : $OtherKlass
   %26 = integer_literal $Builtin.Int1, -1
   br bb13(%26 : $Builtin.Int1)
 
@@ -465,3 +469,215 @@ bb16:
 bb17:
   br bb10(undef : $Builtin.Int64)
 }
+
+// =============================================================================
+// Test OSSA lifetime fixup after removing redundant checked_cast_br
+
+// Replace an owned result with a guaranteed value on the success path.
+// Introduce a copy for the new lifetime.
+//
+// CHECK-LABEL: sil [ossa] @redundant_checked_cast_br_rauw_guaranteed_to_owned_success : $@convention(method) (@owned Base) -> () {
+// CHECK: bb0(%0 : @owned $Base):
+// CHECK:   [[BORROW:%.*]] = begin_borrow %0 : $Base
+// CHECK:   checked_cast_br [exact] [[BORROW]]  : $Base to Base, bb1, bb2
+// CHECK: bb1([[EXACT:%.*]] : @guaranteed $Base):
+// CHECK-NEXT:   [[NEWCP:%.*]] = copy_value [[EXACT]] : $Base
+// CHECK-NEXT:   [[OLDCP:%.*]] = copy_value [[EXACT]] : $Base
+// CHECK-NEXT:   end_borrow
+// CHECK:   destroy_value [[OLDCP]] : $Base
+// CHECK:   apply %{{.*}}([[NEWCP]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   destroy_value [[NEWCP]] : $Base
+// CHECK:   br bb3
+// CHECK: bb2([[INEXACT:%.*]] : @guaranteed $Base):
+// CHECK:   apply %{{.*}}([[INEXACT]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   end_borrow %1 : $Base
+// CHECK:   br bb3
+// CHECK: bb3:
+// CHECK:   destroy_value %0 : $Base
+// CHECK-LABEL: } // end sil function 'redundant_checked_cast_br_rauw_guaranteed_to_owned_success'
+sil [ossa] @redundant_checked_cast_br_rauw_guaranteed_to_owned_success : $@convention(method) (@owned Base) -> () {
+bb0(%0 : @owned $Base):
+  %borrow = begin_borrow %0 : $Base
+  %1 = class_method %0 : $Base, #Base.middle : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
+  checked_cast_br [exact] %borrow : $Base to Base, bb1, bb6
+
+bb1(%5 : @guaranteed $Base):
+  %6 = copy_value %5 : $Base
+  end_borrow %borrow : $Base
+  %7 = class_method %0 : $Base, #Base.inner : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
+  checked_cast_br [exact] %6 : $Base to Base, bb2, bb4
+
+bb2(%9 : @owned $Base):
+  %10 = function_ref @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
+  %11 = apply %10(%9) : $@convention(method) (@guaranteed Base) -> ()
+  destroy_value %9 : $Base
+  br bb3
+
+bb3:
+  %13 = tuple ()
+  br bb5(%13 : $())
+
+bb4(%defaultBB2 : @owned $Base):
+  %15 = apply %7(%defaultBB2) : $@convention(method) (@guaranteed Base) -> ()
+  destroy_value %defaultBB2 : $Base
+  br bb3
+
+bb5(%17 : $()):
+  br bb7
+
+bb6(%defaultBB0 : @guaranteed $Base):
+  %19 = apply %1(%defaultBB0) : $@convention(method) (@guaranteed Base) -> ()
+  end_borrow %borrow : $Base
+  br bb7
+
+bb7:
+  destroy_value %0 : $Base
+  %3 = tuple ()
+  return %3 : $()
+}
+
+// Replace an owned result with a guaranteed value on the merged path.
+// Introduce a copy for the new lifetime.
+// Simplify down to a single diamond.
+//
+// TODO: Simplify some of the obvisouly dead copy/destroy/borrows
+// on-the-fly after each simplify-cfg. Possible using CanonicalizeOSSALifetime.
+//
+// CHECK-LABEL: sil [ossa] @redundant_checked_cast_br_rauw_guaranteed_to_owned_merge : $@convention(method) (@owned Base) -> () {
+// CHECK: bb0(%0 : @owned $Base):
+// CHECK:   [[BORROW:%.*]] = begin_borrow %0 : $Base
+// CHECK:   checked_cast_br [exact] [[BORROW]] : $Base to Base, bb1, bb3
+// CHECK: bb1([[ARG1:%.*]] : @guaranteed $Base):
+// CHECK:   [[NEWCOPY1:%.*]] = copy_value [[ARG1]] : $Base
+// CHECK:   apply %{{.*}}([[ARG1]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   [[OLDCOPY:%.*]] = copy_value [[BORROW]] : $Base
+// CHECK:   end_borrow [[BORROW]] : $Base
+// CHECK:   destroy_value [[OLDCOPY]] : $Base
+// CHECK:   apply %{{.*}}([[NEWCOPY1]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   destroy_value [[NEWCOPY1]] : $Base
+// CHECK:   br bb2
+// CHECK: bb2:
+// CHECK:   destroy_value %0 : $Base
+// CHECK:   return
+// CHECK: bb3([[ARG3:%.*]] : @guaranteed $Base):
+// CHECK:   apply %1([[ARG3]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   [[NEWCOPY3:%.*]] = copy_value [[BORROW]] : $Base
+// CHECK:   end_borrow [[BORROW]] : $Base
+// CHECK:   apply %{{.*}}([[NEWCOPY3]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   destroy_value [[NEWCOPY3]] : $Base
+// CHECK:   br bb2
+// CHECK-LABEL: } // end sil function 'redundant_checked_cast_br_rauw_guaranteed_to_owned_merge'
+sil [ossa] @redundant_checked_cast_br_rauw_guaranteed_to_owned_merge : $@convention(method) (@owned Base) -> () {
+bb0(%0 : @owned $Base):
+  %m = class_method %0 : $Base, #Base.inner : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
+  %f = function_ref @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
+  %1 = begin_borrow %0 : $Base
+  checked_cast_br [exact] %1 : $Base to Base, bb1, bb2
+
+bb1(%4 : @guaranteed $Base):
+  %5 = apply %f(%4) : $@convention(method) (@guaranteed Base) -> ()
+  br bb3
+
+bb2(%7 : @guaranteed $Base):
+  %8 = apply %m(%7) : $@convention(method) (@guaranteed Base) -> ()
+  br bb3
+
+bb3:
+  %11 = copy_value %1 : $Base
+  end_borrow %1 : $Base
+  checked_cast_br [exact] %11 : $Base to Base, bb4, bb5
+
+bb4(%14 : @owned $Base):
+  %15 = apply %f(%14) : $@convention(method) (@guaranteed Base) -> ()
+  destroy_value %14 : $Base
+  br bb6
+
+bb5(%20 : @owned $Base):
+  %21 = apply %m(%20) : $@convention(method) (@guaranteed Base) -> ()
+  destroy_value %20 : $Base
+  br bb6
+
+bb6:
+  destroy_value %0 : $Base
+  %27 = tuple ()
+  return %27 : $()
+}
+
+// Replace an owned result with a guaranteed value on the merged path.
+//
+// The merged path has an unknown predecessor, where the merged value
+// is produced by an apply.
+//
+// Clone the success path, introducing a copy on it.
+//
+// CHECK-LABEL: sil [ossa] @redundant_checked_cast_br_rauw_guaranteed_to_owned_mergecopy : $@convention(method) (@owned Base) -> () {
+// CHECK: bb0(%0 : @owned $Base):
+// CHECK:   [[BORROW:%.*]] = begin_borrow %0 : $Base
+// CHECK:   checked_cast_br [exact] [[BORROW]] : $Base to Base, bb1, bb2
+// CHECK: bb1([[ARG1:%.*]] : @guaranteed $Base):
+// CHECK:   [[CP1:%.*]] = copy_value [[ARG1]] : $Base
+// CHECK:   apply %2([[ARG1]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   end_borrow [[BORROW]] : $Base
+// CHECK:   br bb4([[CP1]] : $Base)
+// CHECK: bb2([[ARG2:%.*]] : @guaranteed $Base):
+// CHECK:   apply %{{.*}}([[ARG2]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   [[RESULT:%.*]] = apply %{{.*}}() : $@convention(thin) () -> @owned Base
+// CHECK:   end_borrow [[BORROW]] : $Base
+// CHECK:   checked_cast_br [exact] %13 : $Base to Base, bb3, bb5
+// CHECK: bb3([[ARG3:%.*]] : @owned $Base):
+// CHECK:   br bb4(%16 : $Base)
+// CHECK: bb4([[ARG4:%.*]] : @owned $Base):
+// CHECK:   apply %{{.*}}([[ARG4]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   destroy_value [[ARG4]] : $Base
+// CHECK:   br bb6
+// CHECK: bb5([[ARG5:%.*]] : @owned $Base):
+// CHECK:   apply %{{.*}}([[ARG5]]) : $@convention(method) (@guaranteed Base) -> ()
+// CHECK:   destroy_value [[ARG5]] : $Base
+// CHECK:   br bb6
+// CHECK: bb6:
+// CHECK:   destroy_value %0 : $Base
+// CHECK:   return
+// CHECK-LABEL: } // end sil function 'redundant_checked_cast_br_rauw_guaranteed_to_owned_mergecopy'
+sil [ossa] @redundant_checked_cast_br_rauw_guaranteed_to_owned_mergecopy : $@convention(method) (@owned Base) -> () {
+bb0(%0 : @owned $Base):
+  %1 = class_method %0 : $Base, #Base.inner : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
+
+  %2 = function_ref @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
+  %f = function_ref @get_base : $@convention(thin) () -> @owned Base
+  %3 = begin_borrow %0 : $Base
+  checked_cast_br [exact] %3 : $Base to Base, bb1, bb2
+
+bb1(%6 : @guaranteed $Base):
+  %7 = apply %2(%6) : $@convention(method) (@guaranteed Base) -> ()
+  %8 = copy_value %6 : $Base
+  br bb3(%8 : $Base)
+
+bb2(%9 : @guaranteed $Base):
+  %10 = apply %1(%9) : $@convention(method) (@guaranteed Base) -> ()
+  %11 = apply %f() : $@convention(thin) () -> @owned Base
+  br bb3(%11 : $Base)
+
+bb3(%12 : @owned $Base):
+  end_borrow %3 : $Base
+  checked_cast_br [exact] %12 : $Base to Base, bb6, bb7
+
+bb6(%16 : @owned $Base):
+  %17 = apply %2(%16) : $@convention(method) (@guaranteed Base) -> ()
+  destroy_value %16 : $Base
+  br bb8
+
+bb7(%20 : @owned $Base):
+  %21 = apply %1(%20) : $@convention(method) (@guaranteed Base) -> ()
+  destroy_value %20 : $Base
+  br bb8
+
+bb8:
+  destroy_value %0 : $Base
+  %25 = tuple ()
+  return %25 : $()
+}
+
+//!!!TODO: test replacing a guaranteed value with an ownedvalue
+// test borrowOverValue->borrowCopyOverScope path
+
+//!!!TODO: test prepareUnowned paths