mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
d84847ac9d
* Allow normal function results of @yield_once coroutines * Address review comments * Workaround LLVM coroutine codegen problem: it assumes that unwind path never returns. This is not true to Swift coroutines as unwind path should end with error result.
551 lines
24 KiB
Plaintext
551 lines
24 KiB
Plaintext
// RUN: %target-sil-opt -enable-copy-propagation=requested-passes-only -enable-lexical-lifetimes=false %s -allocbox-to-stack -sil-deadfuncelim | %FileCheck %s
|
|
|
|
sil_stage canonical
|
|
|
|
import Builtin
|
|
import Swift
|
|
import SwiftShims
|
|
|
|
|
|
sil hidden [noinline] [ossa] [Onone] @$blackhole : $@convention(thin) <T> (@in_guaranteed T) -> () {
|
|
bb0(%0 : $*T):
|
|
%2 = tuple ()
|
|
return %2 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testapply :
|
|
// CHECK-NOT: alloc_box
|
|
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
|
|
// CHECK-LABEL: } // end sil function '$testapply'
|
|
sil [noinline] [ossa] @$testapply : $@convention(thin) () -> () {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int64 }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int64 (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int64
|
|
%5 = function_ref @$testapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%6 = apply %5(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
destroy_value %0 : ${ var Int64 }
|
|
%8 = tuple ()
|
|
return %8 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = begin_access [read] [dynamic] %1 : $*Int64
|
|
%4 = load [trivial] %3 : $*Int64
|
|
end_access %3 : $*Int64
|
|
%6 = alloc_stack $Int64
|
|
store %4 to [trivial] %6 : $*Int64
|
|
%8 = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%9 = apply %8<Int64>(%6) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
dealloc_stack %6 : $*Int64
|
|
%11 = tuple ()
|
|
return %11 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = function_ref @$testapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%4 = apply %3(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%5 = tuple ()
|
|
return %5 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testtryapply :
|
|
// CHECK-NOT: alloc_box
|
|
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
|
|
// CHECK-LABEL: } // end sil function '$testtryapply'
|
|
sil [noinline] [ossa] @$testtryapply : $@convention(thin) () -> @error any Error {
|
|
bb0:
|
|
%1 = alloc_box ${ var Int64 }, var, name "x"
|
|
%2 = project_box %1 : ${ var Int64 }, 0
|
|
%3 = integer_literal $Builtin.Int64, 0
|
|
%4 = struct $Int64 (%3 : $Builtin.Int64)
|
|
store %4 to [trivial] %2 : $*Int64
|
|
%6 = function_ref @$testtryapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> @error any Error
|
|
try_apply %6(%1) : $@convention(thin) (@guaranteed { var Int64 }) -> @error any Error, normal bb1, error bb2
|
|
bb1(%8 : $()):
|
|
destroy_value %1 : ${ var Int64 }
|
|
%10 = tuple ()
|
|
return %10 : $()
|
|
bb2(%12 : $Error):
|
|
destroy_value %1 : ${ var Int64 }
|
|
throw %12 : $Error
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testtryapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> @error any Error {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%2 = project_box %0 : ${ var Int64 }, 0
|
|
%4 = begin_access [read] [dynamic] %2 : $*Int64
|
|
%5 = load [trivial] %4 : $*Int64
|
|
end_access %4 : $*Int64
|
|
%7 = alloc_stack $Int64
|
|
store %5 to [trivial] %7 : $*Int64
|
|
%9 = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%10 = apply %9<Int64>(%7) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
dealloc_stack %7 : $*Int64
|
|
%12 = tuple ()
|
|
return %12 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testtryapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> @error any Error {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%2 = project_box %0 : ${ var Int64 }, 0
|
|
%4 = function_ref @$testtryapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> @error any Error
|
|
try_apply %4(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> @error any Error, normal bb1, error bb2
|
|
bb1(%6 : $()):
|
|
%7 = tuple ()
|
|
return %7 : $()
|
|
bb2(%9 : $Error):
|
|
throw %9 : $Error
|
|
}
|
|
|
|
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testpartialapply :
|
|
// CHECK-NOT: alloc_box
|
|
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
|
|
// CHECK-LABEL: } // end sil function '$testpartialapply'
|
|
sil [noinline] [ossa] @$testpartialapply : $@convention(thin) () -> () {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int64 }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int64 (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int64
|
|
%5 = function_ref @$testpartialapplyclosure : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%6 = apply %5(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
destroy_value %0 : ${ var Int64 }
|
|
%8 = tuple ()
|
|
return %8 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testpartialapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = begin_access [read] [dynamic] %1 : $*Int64
|
|
%4 = load [trivial] %3 : $*Int64
|
|
end_access %3 : $*Int64
|
|
%6 = alloc_stack $Int64
|
|
store %4 to [trivial] %6 : $*Int64
|
|
%8 = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%9 = apply %8<Int64>(%6) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
dealloc_stack %6 : $*Int64
|
|
%11 = tuple ()
|
|
return %11 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testpartialapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = function_ref @$testpartialapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%4 = apply %3(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%5 = tuple ()
|
|
return %5 : $()
|
|
}
|
|
|
|
sil private [ossa] @$testpartialapplyclosure : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = function_ref @$testpartialapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%4 = apply %3(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%5 = tuple ()
|
|
return %5 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testtwoboxes :
|
|
// CHECK-NOT: alloc_box
|
|
// CHECK: [[STK1:%.*]] = alloc_stack $Int64, var, name "x"
|
|
// CHECK: [[STK2:%.*]] = alloc_stack $Int64, var, name "y"
|
|
// CHECK-LABEL: } // end sil function '$testtwoboxes'
|
|
sil [noinline] [ossa] @$testtwoboxes : $@convention(thin) () -> () {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int64 }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int64 (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int64
|
|
%5 = alloc_box ${ var Int64 }, var, name "y"
|
|
%6 = project_box %5 : ${ var Int64 }, 0
|
|
%7 = integer_literal $Builtin.Int64, 0
|
|
%8 = struct $Int64 (%7 : $Builtin.Int64)
|
|
store %8 to [trivial] %6 : $*Int64
|
|
%10 = function_ref @$testtwoboxesbas : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> ()
|
|
%11 = apply %10(%0, %5) : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> ()
|
|
destroy_value %5 : ${ var Int64 }
|
|
destroy_value %0 : ${ var Int64 }
|
|
%14 = tuple ()
|
|
return %14 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testtwoboxesbar : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }, %1 : @guaranteed ${ var Int64 }):
|
|
%2 = project_box %0 : ${ var Int64 }, 0
|
|
%4 = project_box %1 : ${ var Int64 }, 0
|
|
%6 = begin_access [read] [dynamic] %2 : $*Int64
|
|
%7 = load [trivial] %6 : $*Int64
|
|
end_access %6 : $*Int64
|
|
%9 = alloc_stack $Int64
|
|
store %7 to [trivial] %9 : $*Int64
|
|
%11 = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%12 = apply %11<Int64>(%9) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
dealloc_stack %9 : $*Int64
|
|
%14 = begin_access [read] [dynamic] %4 : $*Int64
|
|
%15 = load [trivial] %14 : $*Int64
|
|
end_access %14 : $*Int64
|
|
%17 = alloc_stack $Int64
|
|
store %15 to [trivial] %17 : $*Int64
|
|
%19 = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%20 = apply %19<Int64>(%17) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
dealloc_stack %17 : $*Int64
|
|
%22 = tuple ()
|
|
return %22 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testtwoboxesbas : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }, %1 : @guaranteed ${ var Int64 }):
|
|
%2 = project_box %0 : ${ var Int64 }, 0
|
|
%4 = project_box %1 : ${ var Int64 }, 0
|
|
%6 = function_ref @$testtwoboxesbar : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> ()
|
|
%7 = apply %6(%0, %1) : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> ()
|
|
%8 = tuple ()
|
|
return %8 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testboxescapes :
|
|
// CHECK: alloc_box ${ var Int64 }, var, name "x"
|
|
// CHECK-LABEL: } // end sil function '$testboxescapes'
|
|
sil [noinline] [ossa] @$testboxescapes : $@convention(thin) () -> @owned @callee_guaranteed () -> () {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int64 }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int64 (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int64
|
|
%5 = function_ref @$testboxescapesbas : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> ()
|
|
%6 = apply %5(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> ()
|
|
destroy_value %0 : ${ var Int64 }
|
|
return %6 : $@callee_guaranteed () -> ()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testboxescapesbar : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = function_ref @$testboxescapesclosure : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%copy = copy_value %0 : ${ var Int64 }
|
|
%5 = partial_apply [callee_guaranteed] %3(%copy) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
return %5 : $@callee_guaranteed () -> ()
|
|
}
|
|
|
|
sil private [ossa] @$testboxescapesclosure : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = load [trivial] %1 : $*Int64
|
|
%4 = tuple ()
|
|
return %4 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testboxescapesbas : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = function_ref @$testboxescapesbar : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> ()
|
|
%4 = apply %3(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> ()
|
|
return %4 : $@callee_guaranteed () -> ()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testrecur :
|
|
// CHECK: alloc_box ${ var Int64 }, var, name "x"
|
|
// CHECK-LABEL: } // end sil function '$testrecur'
|
|
sil [noinline] [ossa] @$testrecur : $@convention(thin) () -> () {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int64 }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int64 (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int64
|
|
%5 = function_ref @$testrecurbas : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%6 = apply %5(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%7 = function_ref @$testrecurbar : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%8 = apply %7(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
destroy_value %0 : ${ var Int64 }
|
|
%10 = tuple ()
|
|
return %10 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testrecurbar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = begin_access [read] [dynamic] %1 : $*Int64
|
|
%4 = load [trivial] %3 : $*Int64
|
|
end_access %3 : $*Int64
|
|
%6 = alloc_stack $Int64
|
|
store %4 to [trivial] %6 : $*Int64
|
|
%8 = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%9 = apply %8<Int64>(%6) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
dealloc_stack %6 : $*Int64
|
|
%11 = function_ref @$testrecurbas : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%12 = apply %11(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%13 = tuple ()
|
|
return %13 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testrecurbas : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = function_ref @$testrecurbar : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%4 = apply %3(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%5 = tuple ()
|
|
return %5 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testbeginapply :
|
|
// CHECK-NOT: alloc_box
|
|
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
|
|
// CHECK-LABEL: } // end sil function '$testbeginapply'
|
|
sil [noinline] [ossa] @$testbeginapply : $@convention(thin) () -> () {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int64 }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int64 (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int64
|
|
%5 = function_ref @$testbeginapplybas : $@yield_once @convention(thin) (@guaranteed { var Int64 }) -> @yields ()
|
|
(%addr, %token) = begin_apply %5(%0) : $@yield_once @convention(thin) (@guaranteed { var Int64 }) -> @yields ()
|
|
end_apply %token as $()
|
|
destroy_value %0 : ${ var Int64 }
|
|
%8 = tuple ()
|
|
return %8 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testbeginapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = begin_access [read] [dynamic] %1 : $*Int64
|
|
%4 = load [trivial] %3 : $*Int64
|
|
end_access %3 : $*Int64
|
|
%6 = alloc_stack $Int64
|
|
store %4 to [trivial] %6 : $*Int64
|
|
%8 = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%9 = apply %8<Int64>(%6) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
dealloc_stack %6 : $*Int64
|
|
%11 = tuple ()
|
|
return %11 : $()
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testbeginapplybas : $@yield_once @convention(thin) (@guaranteed { var Int64 }) -> @yields () {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%3 = function_ref @$testbeginapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%4 = apply %3(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
|
|
%5 = tuple ()
|
|
yield %5 : $(), resume bb1, unwind bb2
|
|
bb1:
|
|
%rv = tuple()
|
|
return %rv : $()
|
|
bb2:
|
|
unwind
|
|
}
|
|
|
|
struct Int {
|
|
var _value: Builtin.Int64
|
|
}
|
|
|
|
// Test to make sure AppliesToSpecialize in AllocBoxToStack is populated correctly when there are common function calls for multiple allox_boxes.
|
|
// Order of function calls constructed in PromotedOperands: bar common bas common.
|
|
// AppliesToSpecialize should have the order: bar bas common.
|
|
// Only then, the functions get specialized correctly, and we won't see an assert in checkNoPromotedBoxInApply.
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testdfs1 :
|
|
// CHECK-NOT: alloc_box ${ var Int64 }, var, name "x"
|
|
// CHECK-NOT: alloc_box ${ var Int64 }, var, name "y"
|
|
// CHECK-LABEL:} // end sil function '$testdfs1'
|
|
sil [noinline] [ossa] @$testdfs1 : $@convention(thin) () -> Int64 {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int64 }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int64 (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int64
|
|
%5 = alloc_box ${ var Int64 }, var, name "y"
|
|
%6 = project_box %5 : ${ var Int64 }, 0
|
|
%7 = integer_literal $Builtin.Int64, 0
|
|
%8 = struct $Int64 (%7 : $Builtin.Int64)
|
|
store %8 to [trivial] %6 : $*Int64
|
|
%10 = function_ref @$testdfs1common : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> Int64
|
|
%11 = apply %10(%0, %5) : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> Int64
|
|
destroy_value %5 : ${ var Int64 }
|
|
destroy_value %0 : ${ var Int64 }
|
|
return %11 : $Int64
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs1common : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> Int64 {
|
|
bb0(%0 : @guaranteed ${ var Int64 }, %1 : @guaranteed ${ var Int64 }):
|
|
%proj1 = project_box %0 : ${ var Int64 }, 0
|
|
%proj2 = project_box %1 : ${ var Int64 }, 0
|
|
%barfunc = function_ref @$testdfs1bar : $@convention(thin) (@guaranteed { var Int64 }) -> Int64
|
|
%res1 = apply %barfunc(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> Int64
|
|
%basfunc = function_ref @$testdfs1bas : $@convention(thin) (@guaranteed { var Int64 }) -> Int64
|
|
%res2 = apply %basfunc(%1) : $@convention(thin) (@guaranteed { var Int64 }) -> Int64
|
|
%func = function_ref @$blackhole : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%tmp1 = apply %func<Int64>(%proj1) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%tmp2 = apply %func<Int64>(%proj2) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
|
|
%res = load [trivial] %proj1 : $*Int64
|
|
return %res : $Int64
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs1bar : $@convention(thin) (@guaranteed { var Int64 }) -> Int64 {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%4 = load [trivial] %1 : $*Int64
|
|
return %4 : $Int64
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs1bas : $@convention(thin) (@guaranteed { var Int64 }) -> Int64 {
|
|
bb0(%0 : @guaranteed ${ var Int64 }):
|
|
%1 = project_box %0 : ${ var Int64 }, 0
|
|
%4 = load [trivial] %1 : $*Int64
|
|
return %4 : $Int64
|
|
}
|
|
|
|
// Test to make sure we don't optimize the case when we have an inner common function call for multiple boxes.
|
|
// We don't optimize this case now, because we don't have additional logic to correctly construct AppliesToSpecialize
|
|
// Order of function calls constructed in PromotedOperands: bar innercommon local1 bas innercommon local2
|
|
// AppliesToSpecialize should have the order: bar bas innercommon local1 local2
|
|
// Since we don't maintain any tree like data structure with more info on the call tree, this is not possible to construct today
|
|
// CHECK-LABEL: sil [noinline] [ossa] @$testdfs2 :
|
|
// CHECK: alloc_box ${ var Int }, var, name "x"
|
|
// CHECK: alloc_box ${ var Int }, var, name "y"
|
|
// CHECK-LABEL:} // end sil function '$testdfs2'
|
|
sil [noinline] [ossa] @$testdfs2 : $@convention(thin) () -> Int {
|
|
bb0:
|
|
%0 = alloc_box ${ var Int }, var, name "x"
|
|
%1 = project_box %0 : ${ var Int }, 0
|
|
%2 = integer_literal $Builtin.Int64, 0
|
|
%3 = struct $Int (%2 : $Builtin.Int64)
|
|
store %3 to [trivial] %1 : $*Int
|
|
%5 = alloc_box ${ var Int }, var, name "y"
|
|
%6 = project_box %5 : ${ var Int }, 0
|
|
%7 = integer_literal $Builtin.Int64, 0
|
|
%8 = struct $Int (%7 : $Builtin.Int64)
|
|
store %8 to [trivial] %6 : $*Int
|
|
%10 = function_ref @$testdfs2local1 : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
%11 = apply %10(%0, %5) : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
%12 = function_ref @$testdfs2local2 : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
%13 = apply %12(%0, %5) : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
%14 = struct_extract %11 : $Int, #Int._value
|
|
%15 = struct_extract %13 : $Int, #Int._value
|
|
%16 = integer_literal $Builtin.Int1, -1
|
|
%17 = builtin "sadd_with_overflow_Int64"(%14 : $Builtin.Int64, %15 : $Builtin.Int64, %16 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
|
|
(%18, %19) = destructure_tuple %17 : $(Builtin.Int64, Builtin.Int1)
|
|
cond_fail %19 : $Builtin.Int1, "arithmetic overflow"
|
|
%21 = struct $Int (%18 : $Builtin.Int64)
|
|
destroy_value %5 : ${ var Int }
|
|
destroy_value %0 : ${ var Int }
|
|
return %21 : $Int
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs2bar : $@convention(thin) (@guaranteed { var Int }) -> Int {
|
|
bb0(%0 : @guaranteed ${ var Int }):
|
|
%1 = project_box %0 : ${ var Int }, 0
|
|
%4 = load [trivial] %1 : $*Int
|
|
return %4 : $Int
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs2bas : $@convention(thin) (@guaranteed { var Int }) -> Int {
|
|
bb0(%0 : @guaranteed ${ var Int }):
|
|
%1 = project_box %0 : ${ var Int }, 0
|
|
%4 = load [trivial] %1 : $*Int
|
|
return %4 : $Int
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs2innercommon : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int {
|
|
bb0(%0 : @guaranteed ${ var Int }, %1 : @guaranteed ${ var Int }):
|
|
%2 = project_box %0 : ${ var Int }, 0
|
|
%4 = project_box %1 : ${ var Int }, 0
|
|
%8 = function_ref @$testdfs2bar : $@convention(thin) (@guaranteed { var Int }) -> Int
|
|
%9 = apply %8(%0) : $@convention(thin) (@guaranteed { var Int }) -> Int
|
|
%11 = function_ref @$testdfs2bas : $@convention(thin) (@guaranteed { var Int }) -> Int
|
|
%12 = apply %11(%1) : $@convention(thin) (@guaranteed { var Int }) -> Int
|
|
return %12 : $Int
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs2local1 : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int {
|
|
bb0(%0 : @guaranteed ${ var Int }, %1 : @guaranteed ${ var Int }):
|
|
%2 = project_box %0 : ${ var Int }, 0
|
|
%4 = project_box %1 : ${ var Int }, 0
|
|
%7 = function_ref @$testdfs2innercommon : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
%8 = apply %7(%0, %1) : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
return %8 : $Int
|
|
}
|
|
|
|
sil private [noinline] [ossa] @$testdfs2local2 : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int {
|
|
bb0(%0 : @guaranteed ${ var Int }, %1 : @guaranteed ${ var Int }):
|
|
%2 = project_box %0 : ${ var Int }, 0
|
|
%4 = project_box %1 : ${ var Int }, 0
|
|
%7 = function_ref @$testdfs2innercommon : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
%8 = apply %7(%0, %1) : $@convention(thin) (@guaranteed { var Int }, @guaranteed { var Int }) -> Int
|
|
return %8 : $Int
|
|
}
|
|
|
|
class C {}
|
|
|
|
sil @getC : $@convention(thin) () -> (@owned C)
|
|
|
|
sil [ossa] @borrow_c_box : $@convention(thin) (@guaranteed { var C }) -> () {
|
|
entry(%box : @guaranteed ${var C}):
|
|
%retval = tuple ()
|
|
return %retval : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [ossa] @test_copy_applied : {{.*}} {
|
|
// CHECK: [[CLOSURE:%[^,]+]] = partial_apply
|
|
// CHECK: [[COPY:%[^,]+]] = copy_value [[CLOSURE]]
|
|
// CHECK: destroy_value [[CLOSURE]]
|
|
// CHECK: apply [[COPY]]()
|
|
// CHECK: destroy_addr
|
|
// CHECK: dealloc_stack
|
|
// CHECK-LABEL: } // end sil function 'test_copy_applied'
|
|
sil [ossa] @test_copy_applied : $@convention(thin) () -> () {
|
|
bb0:
|
|
%box = alloc_box ${ var C }, var, name "x"
|
|
%addr = project_box %box : ${ var C }, 0
|
|
%getC = function_ref @getC : $@convention(thin) () -> (@owned C)
|
|
%c = apply %getC() : $@convention(thin) () -> (@owned C)
|
|
store %c to [init] %addr : $*C
|
|
|
|
%borrow_int_box = function_ref @borrow_c_box : $@convention(thin) (@guaranteed { var C }) -> ()
|
|
%closure = partial_apply [callee_guaranteed] %borrow_int_box(%box) : $@convention(thin) (@guaranteed { var C }) -> ()
|
|
%copy = copy_value %closure : $@callee_guaranteed () -> ()
|
|
destroy_value %closure : $@callee_guaranteed () -> ()
|
|
apply %copy() : $@callee_guaranteed () -> ()
|
|
destroy_value %copy : $@callee_guaranteed () -> ()
|
|
%retval = tuple ()
|
|
return %retval : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [ossa] @test_move_applied : {{.*}} {
|
|
// CHECK: [[CLOSURE:%[^,]+]] = partial_apply
|
|
// CHECK: [[MOVE:%[^,]+]] = move_value [[CLOSURE]]
|
|
// CHECK: apply [[MOVE]]()
|
|
// CHECK: destroy_addr
|
|
// CHECK: dealloc_stack
|
|
// CHECK-LABEL: } // end sil function 'test_move_applied'
|
|
sil [ossa] @test_move_applied : $@convention(thin) () -> () {
|
|
bb0:
|
|
%box = alloc_box ${ var C }, var, name "x"
|
|
%addr = project_box %box : ${ var C }, 0
|
|
%getC = function_ref @getC : $@convention(thin) () -> (@owned C)
|
|
%c = apply %getC() : $@convention(thin) () -> (@owned C)
|
|
store %c to [init] %addr : $*C
|
|
|
|
%borrow_int_box = function_ref @borrow_c_box : $@convention(thin) (@guaranteed { var C }) -> ()
|
|
%closure = partial_apply [callee_guaranteed] %borrow_int_box(%box) : $@convention(thin) (@guaranteed { var C }) -> ()
|
|
%move = move_value %closure : $@callee_guaranteed () -> ()
|
|
apply %move() : $@callee_guaranteed () -> ()
|
|
destroy_value %move : $@callee_guaranteed () -> ()
|
|
%retval = tuple ()
|
|
return %retval : $()
|
|
}
|