averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-21 12:14:44 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
c52affbd68788b51a613ebd37a33dbdd1cc944cd
swift-mirror/test/SILOptimizer/allocboxtostack_localapply.sil
Meghana Gupta 1d4f617fee Extend AllocBoxToStack to handle apply (#31974) 
* Don't always give shared linkage to spl functions

private functions on specialization were being given shared linkage.
Use swift::getSpecializeLinkage to correctly get the linkage for the
specialized function based on the linkage of the original function.

* Extend AllocBoxToStack to handle apply

AllocBoxToStack analyzes the uses of boxes and promotes them to stack if
it is safe to do so. Currently the analysis is limited to only a few known
users including partial_apply.

With this change, the pass also analyzes apply users, where the callee
is a local private function.
The analysis is recursive and bound by a threshold.

Fixes rdar://59070139
2020-06-22 14:50:15 -07:00

352 lines
14 KiB
Plaintext
Raw Blame History

// RUN: %target-sil-opt %s -allocbox-to-stack -sil-deadfuncelim | %FileCheck %s
sil_stage canonical
import Builtin
import Swift
import SwiftShims
sil hidden [noinline] [Onone] @$blackhole : $@convention(thin) <T> (@in_guaranteed T) -> () {
bb0(%0 : $*T):
%2 = tuple ()
return %2 : $()
}
// CHECK-LABEL: sil [noinline] @$testapply :
// CHECK-NOT: alloc_box
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
// CHECK-LABEL: } // end sil function '$testapply'
sil [noinline] @$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 %1 : $*Int64
%5 = function_ref @$testapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> ()
%6 = apply %5(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
strong_release %0 : ${ var Int64 }
%8 = tuple ()
return %8 : $()
}
sil private [noinline] @$testapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ var Int64 }):
%1 = project_box %0 : ${ var Int64 }, 0
%3 = begin_access [read] [dynamic] %1 : $*Int64
%4 = load %3 : $*Int64
end_access %3 : $*Int64
%6 = alloc_stack $Int64
store %4 to %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] @$testapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ 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] @$testtryapply :
// CHECK-NOT: alloc_box
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
// CHECK-LABEL: } // end sil function '$testtryapply'
sil [noinline] @$testtryapply : $@convention(thin) () -> @error 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 %2 : $*Int64
%6 = function_ref @$testtryapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> @error Error
try_apply %6(%1) : $@convention(thin) (@guaranteed { var Int64 }) -> @error Error, normal bb1, error bb2
bb1(%8 : $()):
strong_release %1 : ${ var Int64 }
%10 = tuple ()
return %10 : $()
bb2(%12 : $Error):
strong_release %1 : ${ var Int64 }
throw %12 : $Error
}
sil private [noinline] @$testtryapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> @error Error {
bb0(%0 : ${ var Int64 }):
%2 = project_box %0 : ${ var Int64 }, 0
%4 = begin_access [read] [dynamic] %2 : $*Int64
%5 = load %4 : $*Int64
end_access %4 : $*Int64
%7 = alloc_stack $Int64
store %5 to %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] @$testtryapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> @error Error {
bb0(%0 : ${ var Int64 }):
%2 = project_box %0 : ${ var Int64 }, 0
%4 = function_ref @$testtryapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> @error Error
try_apply %4(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> @error Error, normal bb1, error bb2
bb1(%6 : $()):
%7 = tuple ()
return %7 : $()
bb2(%9 : $Error):
throw %9 : $Error
}
// CHECK-LABEL: sil [noinline] @$testpartialapply :
// CHECK-NOT: alloc_box
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
// CHECK-LABEL: } // end sil function '$testpartialapply'
sil [noinline] @$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 %1 : $*Int64
%5 = function_ref @$testpartialapplyclosure : $@convention(thin) (@guaranteed { var Int64 }) -> ()
%6 = apply %5(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
strong_release %0 : ${ var Int64 }
%8 = tuple ()
return %8 : $()
}
sil private [noinline] @$testpartialapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ var Int64 }):
%1 = project_box %0 : ${ var Int64 }, 0
%3 = begin_access [read] [dynamic] %1 : $*Int64
%4 = load %3 : $*Int64
end_access %3 : $*Int64
%6 = alloc_stack $Int64
store %4 to %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] @$testpartialapplybas : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ 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 @$testpartialapplyclosure : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ 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] @$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] @$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 %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 %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 }) -> ()
strong_release %5 : ${ var Int64 }
strong_release %0 : ${ var Int64 }
%14 = tuple ()
return %14 : $()
}
sil private [noinline] @$testtwoboxesbar : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> () {
bb0(%0 : ${ var Int64 }, %1 : ${ 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 %6 : $*Int64
end_access %6 : $*Int64
%9 = alloc_stack $Int64
store %7 to %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 %14 : $*Int64
end_access %14 : $*Int64
%17 = alloc_stack $Int64
store %15 to %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] @$testtwoboxesbas : $@convention(thin) (@guaranteed { var Int64 }, @guaranteed { var Int64 }) -> () {
bb0(%0 : ${ var Int64 }, %1 : ${ 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] @$testboxescapes :
// CHECK: alloc_box ${ var Int64 }, var, name "x"
// CHECK-LABEL: } // end sil function '$testboxescapes'
sil [noinline] @$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 %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 () -> ()
strong_release %0 : ${ var Int64 }
return %6 : $@callee_guaranteed () -> ()
}
sil private [noinline] @$testboxescapesbar : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> () {
bb0(%0 : ${ var Int64 }):
%1 = project_box %0 : ${ var Int64 }, 0
%3 = function_ref @$testboxescapesclosure : $@convention(thin) (@guaranteed { var Int64 }) -> ()
strong_retain %0 : ${ var Int64 }
%5 = partial_apply [callee_guaranteed] %3(%0) : $@convention(thin) (@guaranteed { var Int64 }) -> ()
return %5 : $@callee_guaranteed () -> ()
}
sil private @$testboxescapesclosure : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ var Int64 }):
%1 = project_box %0 : ${ var Int64 }, 0
%3 = load %1 : $*Int64
%4 = tuple ()
return %4 : $()
}
sil private [noinline] @$testboxescapesbas : $@convention(thin) (@guaranteed { var Int64 }) -> @owned @callee_guaranteed () -> () {
bb0(%0 : ${ 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] @$testrecur :
// CHECK: alloc_box ${ var Int64 }, var, name "x"
// CHECK-LABEL: } // end sil function '$testrecur'
sil [noinline] @$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 %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 }) -> ()
strong_release %0 : ${ var Int64 }
%10 = tuple ()
return %10 : $()
}
sil private [noinline] @$testrecurbar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ var Int64 }):
%1 = project_box %0 : ${ var Int64 }, 0
%3 = begin_access [read] [dynamic] %1 : $*Int64
%4 = load %3 : $*Int64
end_access %3 : $*Int64
%6 = alloc_stack $Int64
store %4 to %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] @$testrecurbas : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ 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] @$testbeginapply :
// CHECK-NOT: alloc_box
// CHECK: [[STK:%.*]] = alloc_stack $Int64, var, name "x"
// CHECK-LABEL: } // end sil function '$testbeginapply'
sil [noinline] @$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 %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
strong_release %0 : ${ var Int64 }
%8 = tuple ()
return %8 : $()
}
sil private [noinline] @$testbeginapplybar : $@convention(thin) (@guaranteed { var Int64 }) -> () {
bb0(%0 : ${ var Int64 }):
%1 = project_box %0 : ${ var Int64 }, 0
%3 = begin_access [read] [dynamic] %1 : $*Int64
%4 = load %3 : $*Int64
end_access %3 : $*Int64
%6 = alloc_stack $Int64
store %4 to %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] @$testbeginapplybas : $@yield_once @convention(thin) (@guaranteed { var Int64 }) -> @yields () {
bb0(%0 : ${ 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
}
Reference in New Issue View Git Blame Copy Permalink