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
f15cad360901b4cad3955b8da53d24a882e0e46f
swift-mirror/test/SILOptimizer/cowarray_opt.sil

1322 lines
62 KiB
Plaintext
Raw Blame History

// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all -cowarray-opt %s | %FileCheck %s
sil_stage canonical
import Builtin
import Swift
/////////////
// Utility //
/////////////
struct ArrayIntBuffer {
var storage : Builtin.NativeObject
}
struct MyArray<T> {
var buffer : ArrayIntBuffer
}
struct MyStruct {
}
class MyArrayContainer<T> {
var array: MyArray<T>
init()
deinit
}
struct Container {
var array: MyArray<MyStruct>
}
struct ContainerContainer {
var container: Container
}
sil [_semantics "array.make_mutable"] @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
sil [_semantics "array.get_count"] @guaranteed_array_get_count : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
sil [_semantics "array.get_capacity"] @guaranteed_array_get_capacity : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
sil [_semantics "array.mutate_unknown"] @array_unknown_mutate : $@convention(method) (@inout MyArray<MyStruct>) -> ()
// An unknown user
sil @unknown : $@convention(thin) () -> ()
///////////
// Tests //
///////////
// CHECK-LABEL: sil @simple_hoist
// CHECK: bb0([[ARRAY:%[0-9]+]]
// CHECK: [[FUN:%[0-9]+]] = function_ref @array_make_mutable
// CHECK: apply [[FUN]]([[ARRAY]]
// CHECK: bb1
// CHECK-NOT: array_make_mutable
// CHECK-NOT: apply [[FUN]]
sil @simple_hoist : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
debug_value_addr %0 : $*MyArray<MyStruct>
%2 = load %0 : $*MyArray<MyStruct>
br bb1
bb1:
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @hoist_ignoring_paired_retain_release_and_hoist
// CHECK: bb0(
// CHECK-NOT: br bb
// CHECK: [[MM:%.*]] = function_ref @array_make_mutable
// CHECK-NOT: br bb
// CHECK: apply [[MM]]
// CHECK: br bb1
// CHECK: bb1:
// CHECK-NOT: apply
// CHECK: cond_br {{.*}}, bb1
sil @hoist_ignoring_paired_retain_release_and_hoist : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
%2 = load %0 : $*MyArray<MyStruct>
br bb1
bb1:
retain_value %2 : $MyArray<MyStruct>
%3 = load %1 : $*Builtin.Int1
%4 = load %0 : $*MyArray<MyStruct>
release_value %2 : $MyArray<MyStruct>
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br %3, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @hoist_blocked_by_unpaired_retain_release_1
// CHECK: bb0(
// CHECK-NOT: apply
// CHECK: bb1:
// CHECK: retain_value
// CHECK: [[MM:%.*]] = function_ref @array_make_mutable
// CHECK: apply [[MM]]
// CHECK: cond_br {{.*}}, bb1
sil @hoist_blocked_by_unpaired_retain_release_1 : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
%2 = load %0 : $*MyArray<MyStruct>
br bb1
bb1:
retain_value %2 : $MyArray<MyStruct>
%3 = load %1 : $*Builtin.Int1
%4 = load %0 : $*MyArray<MyStruct>
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br %3, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @hoist_blocked_by_unpaired_retain_release_2
// CHECK: bb0(
// CHECK-NOT: apply
// CHECK: bb1:
// CHECK: retain_value
// CHECK: [[MM:%.*]] = function_ref @array_make_mutable
// CHECK: apply [[MM]]
// CHECK: cond_br {{.*}}, bb1
sil @hoist_blocked_by_unpaired_retain_release_2 : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
br bb1
bb1:
%10 = load %0 : $*MyArray<MyStruct>
%11 = load %0 : $*MyArray<MyStruct>
%8 = struct_extract %10 : $MyArray<MyStruct>, #MyArray.buffer
%9 = struct_extract %11 : $MyArray<MyStruct>, #MyArray.buffer
retain_value %8 : $ArrayIntBuffer
retain_value %9 : $ArrayIntBuffer
release_value %9 : $ArrayIntBuffer
%3 = load %1 : $*Builtin.Int1
%4 = load %0 : $*MyArray<MyStruct>
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br %3, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @hoist_not_blocked_by_unpaired_release
// CHECK: bb0(
// CHECK-NOT: br bb
// CHECK: [[MM:%.*]] = function_ref @array_make_mutable
// CHECK-NOT: br bb
// CHECK: apply [[MM]]
// CHECK: br bb1
// CHECK: bb1:
// CHECK-NOT: apply
// CHECK: cond_br {{.*}}, bb1
sil @hoist_not_blocked_by_unpaired_release : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
%2 = load %0 : $*MyArray<MyStruct>
br bb1
bb1:
%3 = load %1 : $*Builtin.Int1
%4 = load %0 : $*MyArray<MyStruct>
release_value %2 : $MyArray<MyStruct>
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br %3, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @cow_should_ignore_mark_dependence_addrproj_use : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
// CHECK: bb0(
// CHECK-NOT: br bb
// CHECK: [[MM:%.*]] = function_ref @array_make_mutable
// CHECK-NOT: br bb
// CHECK: apply [[MM]]
// CHECK: br bb1
// CHECK: bb1:
// CHECK-NOT: apply
// CHECK: cond_br {{.*}}, bb1
sil @cow_should_ignore_mark_dependence_addrproj_use : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
%999 = struct_element_addr %0 : $*MyArray<MyStruct>, #MyArray.buffer
%9999 = struct_element_addr %999 : $*ArrayIntBuffer, #ArrayIntBuffer.storage
%99999 = load %9999 : $*Builtin.NativeObject
%2 = load %0 : $*MyArray<MyStruct>
br bb1
bb1:
retain_value %2 : $MyArray<MyStruct>
%3 = load %1 : $*Builtin.Int1
%4 = load %0 : $*MyArray<MyStruct>
release_value %2 : $MyArray<MyStruct>
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
mark_dependence %1 : $*Builtin.Int1 on %99999 : $Builtin.NativeObject
cond_br %3, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @cow_should_ignore_mark_dependence_value : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
// CHECK: bb0(
// CHECK-NOT: br bb
// CHECK: [[MM:%.*]] = function_ref @array_make_mutable
// CHECK-NOT: br bb
// CHECK: apply [[MM]]
// CHECK: br bb1
// CHECK: bb1:
// CHECK-NOT: apply
// CHECK: cond_br {{.*}}, bb1
sil @cow_should_ignore_mark_dependence_value : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
%2 = load %0 : $*MyArray<MyStruct>
br bb1
bb1:
retain_value %2 : $MyArray<MyStruct>
%3 = load %1 : $*Builtin.Int1
%4 = load %0 : $*MyArray<MyStruct>
release_value %2 : $MyArray<MyStruct>
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
mark_dependence %1 : $*Builtin.Int1 on %2 : $MyArray<MyStruct>
cond_br %3, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @cow_should_ignore_enum : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
// CHECK: bb0(
// CHECK-NOT: br bb
// CHECK: [[MM:%.*]] = function_ref @array_make_mutable
// CHECK-NOT: br bb
// CHECK: apply [[MM]]
// CHECK: br bb1
// CHECK: bb1:
// CHECK-NOT: apply
// CHECK: cond_br {{.*}}, bb1
sil @cow_should_ignore_enum : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
%2 = load %0 : $*MyArray<MyStruct>
br bb1
bb1:
retain_value %2 : $MyArray<MyStruct>
%3 = load %1 : $*Builtin.Int1
%4 = load %0 : $*MyArray<MyStruct>
release_value %2 : $MyArray<MyStruct>
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%8 = enum $Optional<MyArray<MyStruct>>, #Optional.some!enumelt.1, %2 : $MyArray<MyStruct>
mark_dependence %1 : $*Builtin.Int1 on %8 : $Optional<MyArray<MyStruct>>
cond_br %3, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @cow_should_ignore_guaranteed_semantic_call_sequence : $@convention(thin) (@guaranteed MyArrayContainer<MyStruct>, Builtin.NativeObject) -> () {
// CHECK: bb0
// CHECK: [[F:%.*]] = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
// CHECK: apply [[F]](
// CHECK: bb1:
// CHECK: bb2:
// CHECK-NOT: apply [[F]](
// CHECK: bb3:
// CHECK: bb4:
// CHECK-NOT: apply [[F]](
// CHECK: bb5:
// CHECK: bb6:
// CHECK-NOT: apply [[F]](
// CHECK: bb7:
// CHECK: bb8:
// CHECK-NOT: apply [[F]](
// CHECK: bb9:
sil @cow_should_ignore_guaranteed_semantic_call_sequence : $@convention(thin) (@guaranteed MyArrayContainer<MyStruct>, Builtin.NativeObject) -> () {
bb0(%0 : $MyArrayContainer<MyStruct>, %00 : $Builtin.NativeObject):
%1 = ref_element_addr %0 : $MyArrayContainer<MyStruct>, #MyArrayContainer.array
%2 = load %1 : $*MyArray<MyStruct>
%3 = function_ref @guaranteed_array_get_count : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
%4 = function_ref @guaranteed_array_get_capacity : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
%5 = function_ref @unknown : $@convention(thin) () -> ()
%6 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
br bb1
bb1:
// Simple case. This should hoist.
retain_value %2 : $MyArray<MyStruct>
apply %3(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
apply %4(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
release_value %2 : $MyArray<MyStruct>
apply %6(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb1, bb2
bb2:
br bb3
bb3:
// Failure case b/c of use in between release and call.
retain_value %2 : $MyArray<MyStruct>
apply %3(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
apply %4(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
fix_lifetime %0 : $MyArrayContainer<MyStruct>
release_value %2 : $MyArray<MyStruct>
apply %6(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb4, bb3
bb4:
br bb5
bb5:
// Failure case b/c of use in between calls.
retain_value %2 : $MyArray<MyStruct>
apply %3(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
fix_lifetime %0 : $MyArrayContainer<MyStruct>
apply %4(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
release_value %2 : $MyArray<MyStruct>
apply %6(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb5, bb6
bb6:
br bb7
bb7:
// Failure b/c use is in between apply and retain.
retain_value %2 : $MyArray<MyStruct>
fix_lifetime %0 : $MyArrayContainer<MyStruct>
apply %3(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
apply %4(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
release_value %2 : $MyArray<MyStruct>
apply %6(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb7, bb8
bb8:
br bb9
bb9:
// Failure b/c of release_value
retain_value %00 : $Builtin.NativeObject
retain_value %2 : $MyArray<MyStruct>
apply %3(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
apply %4(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
release_value %00 : $Builtin.NativeObject
release_value %2 : $MyArray<MyStruct>
apply %6(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb9, bb10
bb10:
%7 = tuple()
return %7 : $()
}
// CHECK: sil @cow_handle_array_address_load
// CHECK: bb0({{.*}}):
// CHECK: apply
// CHECK: br bb1
// CHECK: bb1:
// CHECK-NOT: apply
// CHECK: bb2
sil @cow_handle_array_address_load : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
%2 = load %0 : $*MyArray<MyStruct>
%3 = struct_element_addr %0 : $*MyArray<MyStruct>, #MyArray.buffer
%4 = struct_element_addr %3 : $*ArrayIntBuffer, #ArrayIntBuffer.storage
br bb1
bb1:
%6 = load %4 : $*Builtin.NativeObject
strong_retain %6 : $Builtin.NativeObject
%8 = load %1 : $*Builtin.Int1
strong_release %6 : $Builtin.NativeObject
%10 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%11 = apply %10(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%12 = enum $Optional<MyArray<MyStruct>>, #Optional.some!enumelt.1, %2 : $MyArray<MyStruct>
%13 = mark_dependence %1 : $*Builtin.Int1 on %12 : $Optional<MyArray<MyStruct>>
cond_br %8, bb1, bb2
bb2:
%15 = tuple ()
return %15 : $()
}
// CHECK-LABEL: sil @cow_type_based_hoisting_retain_release_matching : $@convention(thin) (@guaranteed MyArrayContainer<MyStruct>, Builtin.NativeObject) -> () {
// CHECK: bb0
// CHECK: [[F:%.*]] = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
// CHECK-NOT: apply [[F]](
// CHECK: bb1:
// CHECK: apply [[F]](
// CHECK: bb2:
// CHECK-NOT: apply [[F]](
// CHECK: bb3:
// CHECK: apply [[F]](
// CHECK: bb4:
sil @cow_type_based_hoisting_retain_release_matching : $@convention(thin) (@guaranteed MyArrayContainer<MyStruct>, Builtin.NativeObject) -> () {
bb0(%0 : $MyArrayContainer<MyStruct>, %00 : $Builtin.NativeObject):
%1 = ref_element_addr %0 : $MyArrayContainer<MyStruct>, #MyArrayContainer.array
%2 = load %1 : $*MyArray<MyStruct>
%3 = function_ref @guaranteed_array_get_count : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
%4 = function_ref @guaranteed_array_get_capacity : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
%5 = function_ref @unknown : $@convention(thin) () -> ()
%6 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%7 = function_ref @array_unknown_mutate : $@convention(method) (@inout MyArray<MyStruct>) -> ()
br bb1
bb1:
retain_value %2 : $MyArray<MyStruct>
retain_value %00 : $Builtin.NativeObject
release_value %00: $Builtin.NativeObject
apply %3(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
apply %4(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
release_value %2 : $MyArray<MyStruct>
apply %6(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb1, bb2
bb2:
br bb3
bb3:
retain_value %2 : $MyArray<MyStruct>
apply %7(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
apply %3(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
apply %4(%2) : $@convention(method) (@guaranteed MyArray<MyStruct>) -> Int
release_value %2 : $MyArray<MyStruct>
apply %6(%1) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb3, bb4
bb4:
%8 = tuple()
return %8 : $()
}
struct _MyBridgeStorage {
var rawValue : Builtin.BridgeObject
}
struct _My2dArrayBuffer<T> {
var _storage : _MyBridgeStorage
}
struct My2dArray<T> {
var _buffer : _My2dArrayBuffer<T>
}
struct MyInt {
@sil_stored var _value: Builtin.Int64
init(_ value: Int16)
}
sil [_semantics "array.check_subscript"] @checkSubscript : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
sil [_semantics "array.check_subscript"] @checkSubscript2 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
sil [_semantics "array.make_mutable"] @makeMutable : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
sil [_semantics "array.get_element_address"] @getElementAddress : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
sil [_semantics "array.make_mutable"] @makeMutable2 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
sil [_semantics "array.get_element_address"] @getElementAddress2 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
// Check hoisting of uniqueness checks in a 2D array loop.
// CHECK-LABEL: sil @hoist2DArray
// CHECK: bb0
// CHECK: cond_br undef, bb2, bb1
// CHECK: bb1
// CHECK: [[CS:%.*]] = function_ref @checkSubscript
// CHECK: [[MM:%.*]] = function_ref @makeMutable
// CHECK: apply [[MM]]
// CHECK: br bb3
// CHECK: bb2
// CHECK: return
// CHECK: bb3:
// CHECK: cond_br undef, bb5, bb4
// CHECK: bb4:
// CHECK: [[CS2:%.*]] = function_ref @checkSubscript2
// CHECK: [[GEA:%.*]] = function_ref @getElementAddress
// CHECK: [[MM2:%.*]] = function_ref @makeMutable2
// CHECK: [[GEA2:%.*]] = function_ref @getElementAddress2
// CHECK: strong_retain
// CHECK: apply [[CS]]
// CHECK: strong_release
// CHECK: strong_retain
// CHECK: [[ADDR:%.*]] = apply [[GEA]]
// CHECK: strong_release
// CHECK: [[SE:%.*]] = struct_extract [[ADDR]]
// CHECK: [[PTA:%.*]] = pointer_to_address [[SE]]
// CHECK: [[MD:%.*]] = mark_dependence [[PTA]]
// CHECK: apply [[MM2]]([[MD]]
// CHECK: br bb6
// CHECK: bb5:
// CHECK: cond_br undef, bb2, bb3
// CHECK: bb6
// CHECK: strong_retain
// CHECK: apply [[CS2]]
// CHECK: strong_release
// CHECK: strong_retain
// CHECK: apply [[GEA2]]
// CHECK: strong_release
// CHECK-NOT: apply
// CHECK: cond_br
sil @hoist2DArray : $@convention(thin) (@inout My2dArray<My2dArray<MyInt>>) -> () {
bb0(%0 : $*My2dArray<My2dArray<MyInt>>):
%1 = integer_literal $Builtin.Int64, 0
%2 = struct $MyInt (%1 : $Builtin.Int64)
%3 = integer_literal $Builtin.Int1, -1
cond_br undef, bb2, bb1
bb1:
%5 = integer_literal $Builtin.Int64, 1
%6 = integer_literal $Builtin.Int1, 0
%7 = function_ref @checkSubscript : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
br bb3
bb2:
%9 = tuple ()
return %9 : $()
bb3:
cond_br undef, bb5, bb4
bb4:
%12 = function_ref @checkSubscript2 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
%13 = function_ref @makeMutable : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%14 = struct $Bool (%3 : $Builtin.Int1)
%15 = function_ref @getElementAddress : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%16 = struct_element_addr %0 : $*My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%17 = struct_element_addr %16 : $*_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%18 = struct_element_addr %17 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%19 = function_ref @makeMutable2 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%20 = function_ref @getElementAddress2 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
br bb6(%1 : $Builtin.Int64)
bb5:
cond_br undef, bb2, bb3
bb6(%23 : $Builtin.Int64):
%24 = struct $MyInt (%23 : $Builtin.Int64)
%25 = builtin "sadd_with_overflow_Int64"(%23 : $Builtin.Int64, %5 : $Builtin.Int64, %6 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%26 = tuple_extract %25 : $(Builtin.Int64, Builtin.Int1), 0
%27 = apply %13(%0) : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%28 = load %0 : $*My2dArray<My2dArray<MyInt>>
%29 = struct_extract %28 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%30 = struct_extract %29 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%31 = struct_extract %30 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %31 : $Builtin.BridgeObject
%33 = apply %7(%2, %14, %28) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
strong_release %31 : $Builtin.BridgeObject
%35 = load %0 : $*My2dArray<My2dArray<MyInt>>
%36 = struct_extract %35 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%37 = struct_extract %36 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%38 = struct_extract %37 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %38 : $Builtin.BridgeObject
%40 = apply %15(%2, %35) : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
strong_release %38 : $Builtin.BridgeObject
%42 = load %18 : $*Builtin.BridgeObject
%43 = unchecked_ref_cast %42 : $Builtin.BridgeObject to $Builtin.NativeObject
%44 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %43 : $Builtin.NativeObject
%45 = struct_extract %40 : $UnsafeMutablePointer<My2dArray<MyInt>>, #UnsafeMutablePointer._rawValue
%46 = pointer_to_address %45 : $Builtin.RawPointer to [strict] $*My2dArray<MyInt>
%47 = mark_dependence %46 : $*My2dArray<MyInt> on %44 : $Optional<Builtin.NativeObject>
%48 = apply %19(%47) : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%49 = load %47 : $*My2dArray<MyInt>
%50 = struct_extract %49 : $My2dArray<MyInt>, #My2dArray._buffer
%51 = struct_extract %50 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%52 = struct_extract %51 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %52 : $Builtin.BridgeObject
%54 = apply %12(%24, %14, %49) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
strong_release %52 : $Builtin.BridgeObject
%56 = load %47 : $*My2dArray<MyInt>
%57 = struct_extract %56 : $My2dArray<MyInt>, #My2dArray._buffer
%58 = struct_extract %57 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%59 = struct_extract %58 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %59 : $Builtin.BridgeObject
%61 = apply %20(%24, %56) : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
strong_release %59 : $Builtin.BridgeObject
%63 = struct_element_addr %47 : $*My2dArray<MyInt>, #My2dArray._buffer
%64 = struct_element_addr %63 : $*_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%65 = struct_element_addr %64 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%66 = load %65 : $*Builtin.BridgeObject
%67 = unchecked_ref_cast %66 : $Builtin.BridgeObject to $Builtin.NativeObject
%68 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %67 : $Builtin.NativeObject
%69 = struct_extract %61 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
%70 = pointer_to_address %69 : $Builtin.RawPointer to [strict] $*MyInt
%71 = mark_dependence %70 : $*MyInt on %68 : $Optional<Builtin.NativeObject>
store %24 to %71 : $*MyInt
cond_br undef, bb5, bb6(%26 : $Builtin.Int64)
}
// CHECK-LABEL: sil @dont_hoist_because_release_2DArray
// CHECK: bb0
// CHECK: cond_br undef, bb2, bb1
// CHECK: bb1
// CHECK: br bb3
// CHECK: bb2
// CHECK: return
// CHECK: bb3:
// CHECK: cond_br undef, bb5, bb4
// CHECK: bb4:
// CHECK-NOT: apply
// CHECK: br bb6
sil @dont_hoist_because_release_2DArray : $@convention(thin) (@inout My2dArray<My2dArray<MyInt>>) -> () {
bb0(%0 : $*My2dArray<My2dArray<MyInt>>):
%1 = integer_literal $Builtin.Int64, 0
%2 = struct $MyInt (%1 : $Builtin.Int64)
%3 = integer_literal $Builtin.Int1, -1
cond_br undef, bb2, bb1
bb1:
%5 = integer_literal $Builtin.Int64, 1
%6 = integer_literal $Builtin.Int1, 0
%7 = function_ref @checkSubscript : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
br bb3
bb2:
%9 = tuple ()
return %9 : $()
bb3:
cond_br undef, bb5, bb4
bb4:
%12 = function_ref @checkSubscript2 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
%13 = function_ref @makeMutable : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%14 = struct $Bool (%3 : $Builtin.Int1)
%15 = function_ref @getElementAddress : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%16 = struct_element_addr %0 : $*My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%17 = struct_element_addr %16 : $*_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%18 = struct_element_addr %17 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%19 = function_ref @makeMutable2 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%20 = function_ref @getElementAddress2 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
br bb6(%1 : $Builtin.Int64)
bb5:
cond_br undef, bb2, bb3
bb6(%23 : $Builtin.Int64):
%24 = struct $MyInt (%23 : $Builtin.Int64)
%25 = builtin "sadd_with_overflow_Int64"(%23 : $Builtin.Int64, %5 : $Builtin.Int64, %6 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%26 = tuple_extract %25 : $(Builtin.Int64, Builtin.Int1), 0
%27 = apply %13(%0) : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%28 = load %0 : $*My2dArray<My2dArray<MyInt>>
%29 = struct_extract %28 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%30 = struct_extract %29 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%31 = struct_extract %30 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %31 : $Builtin.BridgeObject
%33 = apply %7(%2, %14, %28) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
strong_release %31 : $Builtin.BridgeObject
%35 = load %0 : $*My2dArray<My2dArray<MyInt>>
%36 = struct_extract %35 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%37 = struct_extract %36 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%38 = struct_extract %37 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %38 : $Builtin.BridgeObject
%40 = apply %15(%2, %35) : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
strong_release %38 : $Builtin.BridgeObject
%42 = load %18 : $*Builtin.BridgeObject
%43 = unchecked_ref_cast %42 : $Builtin.BridgeObject to $Builtin.NativeObject
%44 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %43 : $Builtin.NativeObject
%45 = struct_extract %40 : $UnsafeMutablePointer<My2dArray<MyInt>>, #UnsafeMutablePointer._rawValue
%46 = pointer_to_address %45 : $Builtin.RawPointer to [strict] $*My2dArray<MyInt>
%47 = mark_dependence %46 : $*My2dArray<MyInt> on %44 : $Optional<Builtin.NativeObject>
%48 = apply %19(%47) : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%49 = load %47 : $*My2dArray<MyInt>
%50 = struct_extract %49 : $My2dArray<MyInt>, #My2dArray._buffer
%51 = struct_extract %50 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%52 = struct_extract %51 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %52 : $Builtin.BridgeObject
%54 = apply %12(%24, %14, %49) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
strong_release %52 : $Builtin.BridgeObject
%56 = load %47 : $*My2dArray<MyInt>
%57 = struct_extract %56 : $My2dArray<MyInt>, #My2dArray._buffer
%58 = struct_extract %57 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%59 = struct_extract %58 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %59 : $Builtin.BridgeObject
%61 = apply %20(%24, %56) : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
strong_release %59 : $Builtin.BridgeObject
%63 = struct_element_addr %47 : $*My2dArray<MyInt>, #My2dArray._buffer
%64 = struct_element_addr %63 : $*_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%65 = struct_element_addr %64 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%66 = load %65 : $*Builtin.BridgeObject
%67 = unchecked_ref_cast %66 : $Builtin.BridgeObject to $Builtin.NativeObject
%68 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %67 : $Builtin.NativeObject
%69 = struct_extract %61 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
%70 = pointer_to_address %69 : $Builtin.RawPointer to [strict] $*MyInt
%71 = mark_dependence %70 : $*MyInt on %68 : $Optional<Builtin.NativeObject>
store %24 to %71 : $*MyInt
release_value %28 : $My2dArray<My2dArray<MyInt>>
cond_br undef, bb5, bb6(%26 : $Builtin.Int64)
}
// CHECK-LABEL: sil @dont_hoist_because_retain_2DArray
// CHECK: bb0
// CHECK: cond_br undef, bb2, bb1
// CHECK: bb1
// CHECK: br bb3
// CHECK: bb2
// CHECK: return
// CHECK: bb3:
// CHECK: cond_br undef, bb5, bb4
// CHECK: bb4:
// CHECK-NOT: apply
// CHECK: br bb6
sil @dont_hoist_because_retain_2DArray : $@convention(thin) (@inout My2dArray<My2dArray<MyInt>>) -> () {
bb0(%0 : $*My2dArray<My2dArray<MyInt>>):
%1 = integer_literal $Builtin.Int64, 0
%2 = struct $MyInt (%1 : $Builtin.Int64)
%3 = integer_literal $Builtin.Int1, -1
cond_br undef, bb2, bb1
bb1:
%5 = integer_literal $Builtin.Int64, 1
%6 = integer_literal $Builtin.Int1, 0
%7 = function_ref @checkSubscript : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
br bb3
bb2:
%9 = tuple ()
return %9 : $()
bb3:
cond_br undef, bb5, bb4
bb4:
%12 = function_ref @checkSubscript2 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
%13 = function_ref @makeMutable : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%14 = struct $Bool (%3 : $Builtin.Int1)
%15 = function_ref @getElementAddress : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%16 = struct_element_addr %0 : $*My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%17 = struct_element_addr %16 : $*_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%18 = struct_element_addr %17 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%19 = function_ref @makeMutable2 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%20 = function_ref @getElementAddress2 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
br bb6(%1 : $Builtin.Int64)
bb5:
cond_br undef, bb2, bb3
bb6(%23 : $Builtin.Int64):
%24 = struct $MyInt (%23 : $Builtin.Int64)
%25 = builtin "sadd_with_overflow_Int64"(%23 : $Builtin.Int64, %5 : $Builtin.Int64, %6 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%26 = tuple_extract %25 : $(Builtin.Int64, Builtin.Int1), 0
%27 = apply %13(%0) : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%28 = load %0 : $*My2dArray<My2dArray<MyInt>>
%29 = struct_extract %28 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%30 = struct_extract %29 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%31 = struct_extract %30 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %31 : $Builtin.BridgeObject
%33 = apply %7(%2, %14, %28) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
strong_release %31 : $Builtin.BridgeObject
%35 = load %0 : $*My2dArray<My2dArray<MyInt>>
%36 = struct_extract %35 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%37 = struct_extract %36 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%38 = struct_extract %37 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %38 : $Builtin.BridgeObject
%40 = apply %15(%2, %35) : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
strong_release %38 : $Builtin.BridgeObject
%42 = load %18 : $*Builtin.BridgeObject
%43 = unchecked_ref_cast %42 : $Builtin.BridgeObject to $Builtin.NativeObject
%44 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %43 : $Builtin.NativeObject
%45 = struct_extract %40 : $UnsafeMutablePointer<My2dArray<MyInt>>, #UnsafeMutablePointer._rawValue
%46 = pointer_to_address %45 : $Builtin.RawPointer to [strict] $*My2dArray<MyInt>
%47 = mark_dependence %46 : $*My2dArray<MyInt> on %44 : $Optional<Builtin.NativeObject>
%48 = apply %19(%47) : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%49 = load %47 : $*My2dArray<MyInt>
%50 = struct_extract %49 : $My2dArray<MyInt>, #My2dArray._buffer
%51 = struct_extract %50 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%52 = struct_extract %51 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %52 : $Builtin.BridgeObject
%54 = apply %12(%24, %14, %49) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
strong_release %52 : $Builtin.BridgeObject
%56 = load %47 : $*My2dArray<MyInt>
%57 = struct_extract %56 : $My2dArray<MyInt>, #My2dArray._buffer
%58 = struct_extract %57 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%59 = struct_extract %58 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %59 : $Builtin.BridgeObject
%61 = apply %20(%24, %56) : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
strong_release %59 : $Builtin.BridgeObject
%63 = struct_element_addr %47 : $*My2dArray<MyInt>, #My2dArray._buffer
%64 = struct_element_addr %63 : $*_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%65 = struct_element_addr %64 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%66 = load %65 : $*Builtin.BridgeObject
%67 = unchecked_ref_cast %66 : $Builtin.BridgeObject to $Builtin.NativeObject
%68 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %67 : $Builtin.NativeObject
%69 = struct_extract %61 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
%70 = pointer_to_address %69 : $Builtin.RawPointer to [strict] $*MyInt
%71 = mark_dependence %70 : $*MyInt on %68 : $Optional<Builtin.NativeObject>
store %24 to %71 : $*MyInt
retain_value %28 : $My2dArray<My2dArray<MyInt>>
cond_br undef, bb5, bb6(%26 : $Builtin.Int64)
}
// CHECK-LABEL: sil @dont_hoist_because_store_2DArray
// CHECK: bb0
// CHECK: cond_br undef, bb2, bb1
// CHECK: bb1
// CHECK: br bb3
// CHECK: bb2
// CHECK: return
// CHECK: bb3:
// CHECK: cond_br undef, bb5, bb4
// CHECK: bb4:
// CHECK-NOT: apply
// CHECK: br bb6
sil @dont_hoist_because_store_2DArray : $@convention(thin) (@inout My2dArray<My2dArray<MyInt>>, @inout My2dArray<My2dArray<MyInt>>) -> () {
bb0(%0 : $*My2dArray<My2dArray<MyInt>>, %100: $*My2dArray<My2dArray<MyInt>>):
%1 = integer_literal $Builtin.Int64, 0
%2 = struct $MyInt (%1 : $Builtin.Int64)
%3 = integer_literal $Builtin.Int1, -1
cond_br undef, bb2, bb1
bb1:
%5 = integer_literal $Builtin.Int64, 1
%6 = integer_literal $Builtin.Int1, 0
%7 = function_ref @checkSubscript : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
br bb3
bb2:
%9 = tuple ()
return %9 : $()
bb3:
cond_br undef, bb5, bb4
bb4:
%12 = function_ref @checkSubscript2 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
%13 = function_ref @makeMutable : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%14 = struct $Bool (%3 : $Builtin.Int1)
%15 = function_ref @getElementAddress : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%16 = struct_element_addr %0 : $*My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%17 = struct_element_addr %16 : $*_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%18 = struct_element_addr %17 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%19 = function_ref @makeMutable2 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%20 = function_ref @getElementAddress2 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
br bb6(%1 : $Builtin.Int64)
bb5:
cond_br undef, bb2, bb3
bb6(%23 : $Builtin.Int64):
%24 = struct $MyInt (%23 : $Builtin.Int64)
%25 = builtin "sadd_with_overflow_Int64"(%23 : $Builtin.Int64, %5 : $Builtin.Int64, %6 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%26 = tuple_extract %25 : $(Builtin.Int64, Builtin.Int1), 0
%27 = apply %13(%0) : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%28 = load %0 : $*My2dArray<My2dArray<MyInt>>
%29 = struct_extract %28 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%30 = struct_extract %29 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%31 = struct_extract %30 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %31 : $Builtin.BridgeObject
%33 = apply %7(%2, %14, %28) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
strong_release %31 : $Builtin.BridgeObject
%35 = load %0 : $*My2dArray<My2dArray<MyInt>>
%36 = struct_extract %35 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%37 = struct_extract %36 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%38 = struct_extract %37 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %38 : $Builtin.BridgeObject
%40 = apply %15(%2, %35) : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
strong_release %38 : $Builtin.BridgeObject
%42 = load %18 : $*Builtin.BridgeObject
%43 = unchecked_ref_cast %42 : $Builtin.BridgeObject to $Builtin.NativeObject
%44 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %43 : $Builtin.NativeObject
%45 = struct_extract %40 : $UnsafeMutablePointer<My2dArray<MyInt>>, #UnsafeMutablePointer._rawValue
%46 = pointer_to_address %45 : $Builtin.RawPointer to [strict] $*My2dArray<MyInt>
%47 = mark_dependence %46 : $*My2dArray<MyInt> on %44 : $Optional<Builtin.NativeObject>
%48 = apply %19(%47) : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%49 = load %47 : $*My2dArray<MyInt>
%50 = struct_extract %49 : $My2dArray<MyInt>, #My2dArray._buffer
%51 = struct_extract %50 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%52 = struct_extract %51 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %52 : $Builtin.BridgeObject
%54 = apply %12(%24, %14, %49) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
strong_release %52 : $Builtin.BridgeObject
%56 = load %47 : $*My2dArray<MyInt>
%57 = struct_extract %56 : $My2dArray<MyInt>, #My2dArray._buffer
%58 = struct_extract %57 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%59 = struct_extract %58 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %59 : $Builtin.BridgeObject
%61 = apply %20(%24, %56) : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
strong_release %59 : $Builtin.BridgeObject
%63 = struct_element_addr %47 : $*My2dArray<MyInt>, #My2dArray._buffer
%64 = struct_element_addr %63 : $*_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%65 = struct_element_addr %64 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%66 = load %65 : $*Builtin.BridgeObject
%67 = unchecked_ref_cast %66 : $Builtin.BridgeObject to $Builtin.NativeObject
%68 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %67 : $Builtin.NativeObject
%69 = struct_extract %61 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
%70 = pointer_to_address %69 : $Builtin.RawPointer to [strict] $*MyInt
%71 = mark_dependence %70 : $*MyInt on %68 : $Optional<Builtin.NativeObject>
store %24 to %71 : $*MyInt
%72 = load %100: $*My2dArray<My2dArray<MyInt>>
store %72 to %0: $*My2dArray<My2dArray<MyInt>>
cond_br undef, bb5, bb6(%26 : $Builtin.Int64)
}
// CHECK-LABEL: sil @dont_hoist_because_apply_2DArray
// CHECK: bb0
// CHECK: cond_br undef, bb2, bb1
// CHECK: bb1
// CHECK: br bb3
// CHECK: bb2
// CHECK: return
// CHECK: bb3:
// CHECK: cond_br undef, bb5, bb4
// CHECK: bb4:
// CHECK-NOT: apply
// CHECK: br bb6
sil @dont_hoist_because_apply_2DArray : $@convention(thin) (@inout My2dArray<My2dArray<MyInt>>, @inout My2dArray<My2dArray<MyInt>>) -> () {
bb0(%0 : $*My2dArray<My2dArray<MyInt>>, %100: $*My2dArray<My2dArray<MyInt>>):
%1 = integer_literal $Builtin.Int64, 0
%2 = struct $MyInt (%1 : $Builtin.Int64)
%3 = integer_literal $Builtin.Int1, -1
cond_br undef, bb2, bb1
bb1:
%5 = integer_literal $Builtin.Int64, 1
%6 = integer_literal $Builtin.Int1, 0
%7 = function_ref @checkSubscript : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
br bb3
bb2:
%9 = tuple ()
return %9 : $()
bb3:
cond_br undef, bb5, bb4
bb4:
%12 = function_ref @checkSubscript2 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
%13 = function_ref @makeMutable : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%14 = struct $Bool (%3 : $Builtin.Int1)
%15 = function_ref @getElementAddress : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%16 = struct_element_addr %0 : $*My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%17 = struct_element_addr %16 : $*_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%18 = struct_element_addr %17 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%19 = function_ref @makeMutable2 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%20 = function_ref @getElementAddress2 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
br bb6(%1 : $Builtin.Int64)
bb5:
cond_br undef, bb2, bb3
bb6(%23 : $Builtin.Int64):
%24 = struct $MyInt (%23 : $Builtin.Int64)
%25 = builtin "sadd_with_overflow_Int64"(%23 : $Builtin.Int64, %5 : $Builtin.Int64, %6 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%26 = tuple_extract %25 : $(Builtin.Int64, Builtin.Int1), 0
%27 = apply %13(%0) : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%28 = load %0 : $*My2dArray<My2dArray<MyInt>>
%29 = struct_extract %28 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%30 = struct_extract %29 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%31 = struct_extract %30 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %31 : $Builtin.BridgeObject
%33 = apply %7(%2, %14, %28) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> ()
strong_release %31 : $Builtin.BridgeObject
%35 = load %0 : $*My2dArray<My2dArray<MyInt>>
%36 = struct_extract %35 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%37 = struct_extract %36 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%38 = struct_extract %37 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %38 : $Builtin.BridgeObject
%40 = apply %15(%2, %35) : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
strong_release %38 : $Builtin.BridgeObject
%42 = load %18 : $*Builtin.BridgeObject
%43 = unchecked_ref_cast %42 : $Builtin.BridgeObject to $Builtin.NativeObject
%44 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %43 : $Builtin.NativeObject
%45 = struct_extract %40 : $UnsafeMutablePointer<My2dArray<MyInt>>, #UnsafeMutablePointer._rawValue
%46 = pointer_to_address %45 : $Builtin.RawPointer to [strict] $*My2dArray<MyInt>
%47 = mark_dependence %46 : $*My2dArray<MyInt> on %44 : $Optional<Builtin.NativeObject>
%48 = apply %19(%47) : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%49 = load %47 : $*My2dArray<MyInt>
%50 = struct_extract %49 : $My2dArray<MyInt>, #My2dArray._buffer
%51 = struct_extract %50 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%52 = struct_extract %51 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %52 : $Builtin.BridgeObject
%54 = apply %12(%24, %14, %49) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> ()
strong_release %52 : $Builtin.BridgeObject
%56 = load %47 : $*My2dArray<MyInt>
%57 = struct_extract %56 : $My2dArray<MyInt>, #My2dArray._buffer
%58 = struct_extract %57 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%59 = struct_extract %58 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_retain %59 : $Builtin.BridgeObject
%61 = apply %20(%24, %56) : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
strong_release %59 : $Builtin.BridgeObject
%63 = struct_element_addr %47 : $*My2dArray<MyInt>, #My2dArray._buffer
%64 = struct_element_addr %63 : $*_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%65 = struct_element_addr %64 : $*_MyBridgeStorage, #_MyBridgeStorage.rawValue
%66 = load %65 : $*Builtin.BridgeObject
%67 = unchecked_ref_cast %66 : $Builtin.BridgeObject to $Builtin.NativeObject
%68 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %67 : $Builtin.NativeObject
%69 = struct_extract %61 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
%70 = pointer_to_address %69 : $Builtin.RawPointer to [strict] $*MyInt
%71 = mark_dependence %70 : $*MyInt on %68 : $Optional<Builtin.NativeObject>
store %24 to %71 : $*MyInt
%72 = function_ref @unknown : $@convention(thin) () -> ()
%73 = apply %72() : $@convention(thin) () -> ()
cond_br undef, bb5, bb6(%26 : $Builtin.Int64)
}
// CHECK-LABEL: sil @hoist_projections
// CHECK: bb0([[CONTAINER:%[0-9]+]]
// CHECK: [[CONTAINER2:%.*]] = struct_element_addr [[CONTAINER]] : $*ContainerContainer
// CHECK: [[ARRAY:%.*]] = struct_element_addr [[CONTAINER2]] : $*Container,
// CHECK: [[FUN:%[0-9]+]] = function_ref @array_make_mutable
// CHECK: apply [[FUN]]([[ARRAY]]
// CHECK: bb1
// CHECK-NOT: array_make_mutable
// CHECK-NOT: apply [[FUN]]
sil @hoist_projections : $@convention(thin) (@inout ContainerContainer, @inout Builtin.Int1) -> () {
bb0(%0 : $*ContainerContainer, %1 : $*Builtin.Int1):
br bb1
bb1:
%2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
br bb3(%2 : $*Container)
bb3(%3: $*Container):
%4 = struct_element_addr %3 : $*Container, #Container.array
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%4) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// We don't support hoisting non-unary projections yet.
// CHECK-LABEL: sil @dont_hoist_non_unary_projections
// CHECK-NOT: index_addr
// CHECK: bb2({{.*}}):
// CHECK: index_addr
sil @dont_hoist_non_unary_projections : $@convention(thin) (@inout ContainerContainer, @inout Builtin.Int1) -> () {
bb0(%0 : $*ContainerContainer, %1 : $*Builtin.Int1):
br bb1
bb1:
%2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
br bb2(%2 : $*Container)
bb2(%3: $*Container):
%i = integer_literal $Builtin.Int32, 0
%3i = index_addr %3 : $*Container, %i : $Builtin.Int32
%4 = struct_element_addr %3i : $*Container, #Container.array
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%4) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb1, bb3
bb3:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @hoist_projections2
// CHECK: bb0([[CONTAINER:%[0-9]+]]
// CHECK: [[CONTAINER2:%.*]] = struct_element_addr [[CONTAINER]] : $*ContainerContainer
// CHECK: [[ARRAY:%.*]] = struct_element_addr [[CONTAINER2]] : $*Container,
// CHECK: [[FUN:%[0-9]+]] = function_ref @array_make_mutable
// CHECK: apply [[FUN]]([[ARRAY]]
// CHECK: bb1
// CHECK-NOT: array_make_mutable
// CHECK-NOT: apply [[FUN]]
sil @hoist_projections2 : $@convention(thin) (@inout ContainerContainer, @inout Builtin.Int1) -> () {
bb0(%0 : $*ContainerContainer, %1 : $*Builtin.Int1):
br bb1
bb1:
%2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
%3 = struct_element_addr %2 : $*Container, #Container.array
br bb3(%3 : $*MyArray<MyStruct>)
bb3(%4 : $*MyArray<MyStruct>):
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%4) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
// CHECK-LABEL: sil @hoist_projections3
// CHECK: bb0([[CONTAINER:%[0-9]+]]
// CHECK: [[CONTAINER2:%.*]] = struct_element_addr [[CONTAINER]] : $*ContainerContainer
// CHECK: [[ARRAY:%.*]] = struct_element_addr [[CONTAINER2]] : $*Container,
// CHECK: [[FUN:%[0-9]+]] = function_ref @array_make_mutable
// CHECK: apply [[FUN]]([[ARRAY]]
// CHECK: bb1
// CHECK-NOT: array_make_mutable
// CHECK-NOT: apply [[FUN]]
sil @hoist_projections3 : $@convention(thin) (@inout ContainerContainer, @inout Builtin.Int1) -> () {
bb0(%0 : $*ContainerContainer, %1 : $*Builtin.Int1):
br bb1
bb1:
%2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
%3 = struct_element_addr %2 : $*Container, #Container.array
%5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
%6 = apply %5(%3) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
cond_br undef, bb1, bb2
bb2:
%7 = tuple()
return %7 : $()
}
sil [_semantics "array.props.isNativeTypeChecked"] @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed My2dArray<My2dArray<MyInt>>) -> Bool
sil [_semantics "array.check_subscript"] @checkSubscript3 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> _DependenceToken
sil [_semantics "array.get_element"] @getElement3 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<My2dArray<MyInt>>) -> @out My2dArray<MyInt>
sil [_semantics "array.props.isNativeTypeChecked"] @hoistableIsNativeTypeChecked2 : $@convention(method) (@guaranteed My2dArray<MyInt>) -> Bool
sil [_semantics "array.check_subscript"] @checkSubscript4 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> _DependenceToken
sil [_semantics "array.get_element"] @getElement4 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<MyInt>) -> @out MyInt
sil [_semantics "array.make_mutable"] @makeMutable3 : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
sil [_semantics "array.get_element_address"] @getElementAddress3 : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
sil [_semantics "array.make_mutable"] @makeMutable4 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
sil [_semantics "array.get_element_address"] @getElementAddress4 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
// CHECK-LABEL: sil @hoist2DArray_2
// CHECK: bb0
// CHECK: apply {{.*}} : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
// CHECK: apply {{.*}} : $@convention(method) (@inout My2dArray<MyInt>) -> ()
// CHECK: br bb2
// CHECK: bb1
// CHECK: return
// CHECK: bb2
// CHECK-NOT: apply {{.*}} : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
// CHECK-NOT: apply {{.*}} : $@convention(method) (@inout My2dArray<MyInt>) -> ()
// CHECK: cond_br
sil @hoist2DArray_2 : $@convention(thin) (@inout My2dArray<My2dArray<MyInt>>, MyInt) -> () {
bb0(%0 : $*My2dArray<My2dArray<MyInt>>, %1 : $MyInt):
%4 = integer_literal $Builtin.Int64, 0
%5 = integer_literal $Builtin.Int64, 1024
%6 = integer_literal $Builtin.Int64, 1
%7 = integer_literal $Builtin.Int1, 0
%9 = function_ref @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed My2dArray<My2dArray<MyInt>>) -> Bool
%10 = function_ref @checkSubscript3 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> _DependenceToken
%11 = function_ref @getElement3 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<My2dArray<MyInt>>) -> @out My2dArray<MyInt>
%12 = function_ref @hoistableIsNativeTypeChecked2 : $@convention(method) (@guaranteed My2dArray<MyInt>) -> Bool
%13 = function_ref @checkSubscript4 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> _DependenceToken
%14 = function_ref @getElement4 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<MyInt>) -> @out MyInt
%15 = integer_literal $Builtin.Int1, -1
%18 = function_ref @makeMutable3 : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%20 = struct $Bool (%15 : $Builtin.Int1)
%21 = function_ref @getElementAddress3 : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%22 = function_ref @makeMutable4 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%23 = function_ref @getElementAddress4 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
br bb2(%4 : $Builtin.Int64)
bb1:
%25 = tuple ()
return %25 : $()
bb2(%27 : $Builtin.Int64):
%28 = struct $MyInt (%27 : $Builtin.Int64)
%29 = builtin "sadd_with_overflow_Int64"(%27 : $Builtin.Int64, %6 : $Builtin.Int64, %7 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%30 = tuple_extract %29 : $(Builtin.Int64, Builtin.Int1), 0
%32 = load %0 : $*My2dArray<My2dArray<MyInt>>
%33 = alloc_stack $My2dArray<MyInt>
%35 = apply %9(%32) : $@convention(method) (@guaranteed My2dArray<My2dArray<MyInt>>) -> Bool
%37 = apply %10(%1, %35, %32) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> _DependenceToken
%39 = apply %11(%33, %1, %35, %37, %32) : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<My2dArray<MyInt>>) -> @out My2dArray<MyInt>
%40 = load %33 : $*My2dArray<MyInt>
%41 = alloc_stack $MyInt
%44 = apply %12(%40) : $@convention(method) (@guaranteed My2dArray<MyInt>) -> Bool
%46 = apply %13(%28, %44, %40) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> _DependenceToken
%48 = apply %14(%41, %28, %44, %46, %40) : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<MyInt>) -> @out MyInt
%49 = struct_extract %40 : $My2dArray<MyInt>, #My2dArray._buffer
%50 = struct_extract %49 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%51 = struct_extract %50 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_release %51 : $Builtin.BridgeObject
%53 = struct_element_addr %41 : $*MyInt, #MyInt._value
%54 = load %53 : $*Builtin.Int64
%55 = builtin "sadd_with_overflow_Int64"(%54 : $Builtin.Int64, %6 : $Builtin.Int64, %15 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%56 = tuple_extract %55 : $(Builtin.Int64, Builtin.Int1), 0
%57 = tuple_extract %55 : $(Builtin.Int64, Builtin.Int1), 1
cond_fail %57 : $Builtin.Int1
%59 = struct $MyInt (%56 : $Builtin.Int64)
%60 = apply %18(%0) : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%61 = load %0 : $*My2dArray<My2dArray<MyInt>>
%63 = apply %21(%1, %61) : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%65 = struct_extract %61 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%66 = struct_extract %65 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%67 = struct_extract %66 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
%72 = unchecked_ref_cast %67 : $Builtin.BridgeObject to $Builtin.NativeObject
%73 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %72 : $Builtin.NativeObject
%74 = struct_extract %63 : $UnsafeMutablePointer<My2dArray<MyInt>>, #UnsafeMutablePointer._rawValue
%75 = pointer_to_address %74 : $Builtin.RawPointer to [strict] $*My2dArray<MyInt>
%76 = mark_dependence %75 : $*My2dArray<MyInt> on %73 : $Optional<Builtin.NativeObject>
%79 = apply %22(%76) : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%80 = load %76 : $*My2dArray<MyInt>
%83 = apply %13(%28, %20, %80) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> _DependenceToken
%84 = apply %23(%28, %80) : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
%86 = struct_extract %80 : $My2dArray<MyInt>, #My2dArray._buffer
%87 = struct_extract %86 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%88 = struct_extract %87 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
%93 = unchecked_ref_cast %88 : $Builtin.BridgeObject to $Builtin.NativeObject
%94 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %93 : $Builtin.NativeObject
%95 = struct_extract %84 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
%96 = pointer_to_address %95 : $Builtin.RawPointer to [strict] $*MyInt
%97 = mark_dependence %96 : $*MyInt on %94 : $Optional<Builtin.NativeObject>
store %59 to %97 : $*MyInt
dealloc_stack %41 : $*MyInt
dealloc_stack %33 : $*My2dArray<MyInt>
%101 = builtin "cmp_eq_Int64"(%30 : $Builtin.Int64, %5 : $Builtin.Int64) : $Builtin.Int1
cond_br %101, bb1, bb2(%30 : $Builtin.Int64)
}
sil [_semantics "array.get_element"] @getElement5 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<My2dArray<MyInt>>) -> @owned My2dArray<MyInt>
sil [_semantics "array.get_element"] @getElement6 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<MyInt>) -> MyInt
// CHECK-LABEL: sil @hoist2DArray_with_get_element_returning_direct_result
// CHECK: bb0
// CHECK: apply {{.*}} : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
// CHECK: apply {{.*}} : $@convention(method) (@inout My2dArray<MyInt>) -> ()
// CHECK: br bb2
// CHECK: bb1
// CHECK: return
// CHECK: bb2
// CHECK-NOT: apply {{.*}} : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
// CHECK-NOT: apply {{.*}} : $@convention(method) (@inout My2dArray<MyInt>) -> ()
// CHECK: cond_br
sil @hoist2DArray_with_get_element_returning_direct_result : $@convention(thin) (@inout My2dArray<My2dArray<MyInt>>, MyInt) -> () {
bb0(%0 : $*My2dArray<My2dArray<MyInt>>, %1 : $MyInt):
%4 = integer_literal $Builtin.Int64, 0
%5 = integer_literal $Builtin.Int64, 1024
%6 = integer_literal $Builtin.Int64, 1
%7 = integer_literal $Builtin.Int1, 0
%9 = function_ref @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed My2dArray<My2dArray<MyInt>>) -> Bool
%10 = function_ref @checkSubscript3 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> _DependenceToken
%11 = function_ref @getElement5 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<My2dArray<MyInt>>) -> @owned My2dArray<MyInt>
%12 = function_ref @hoistableIsNativeTypeChecked2 : $@convention(method) (@guaranteed My2dArray<MyInt>) -> Bool
%13 = function_ref @checkSubscript4 : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> _DependenceToken
%14 = function_ref @getElement6 : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<MyInt>) -> MyInt
%15 = integer_literal $Builtin.Int1, -1
%18 = function_ref @makeMutable3 : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%20 = struct $Bool (%15 : $Builtin.Int1)
%21 = function_ref @getElementAddress3 : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%22 = function_ref @makeMutable4 : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%23 = function_ref @getElementAddress4 : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
br bb2(%4 : $Builtin.Int64)
bb1:
%25 = tuple ()
return %25 : $()
bb2(%27 : $Builtin.Int64):
%28 = struct $MyInt (%27 : $Builtin.Int64)
%29 = builtin "sadd_with_overflow_Int64"(%27 : $Builtin.Int64, %6 : $Builtin.Int64, %7 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%30 = tuple_extract %29 : $(Builtin.Int64, Builtin.Int1), 0
%32 = load %0 : $*My2dArray<My2dArray<MyInt>>
%35 = apply %9(%32) : $@convention(method) (@guaranteed My2dArray<My2dArray<MyInt>>) -> Bool
%37 = apply %10(%1, %35, %32) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<My2dArray<MyInt>>) -> _DependenceToken
%40 = apply %11(%1, %35, %37, %32) : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<My2dArray<MyInt>>) -> @owned My2dArray<MyInt>
%44 = apply %12(%40) : $@convention(method) (@guaranteed My2dArray<MyInt>) -> Bool
%46 = apply %13(%28, %44, %40) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> _DependenceToken
%48 = apply %14(%28, %44, %46, %40) : $@convention(method) (MyInt, Bool, _DependenceToken, @guaranteed My2dArray<MyInt>) -> MyInt
%49 = struct_extract %40 : $My2dArray<MyInt>, #My2dArray._buffer
%50 = struct_extract %49 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%51 = struct_extract %50 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
strong_release %51 : $Builtin.BridgeObject
%54 = struct_extract %48 : $MyInt, #MyInt._value
%55 = builtin "sadd_with_overflow_Int64"(%54 : $Builtin.Int64, %6 : $Builtin.Int64, %15 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
%56 = tuple_extract %55 : $(Builtin.Int64, Builtin.Int1), 0
%57 = tuple_extract %55 : $(Builtin.Int64, Builtin.Int1), 1
cond_fail %57 : $Builtin.Int1
%59 = struct $MyInt (%56 : $Builtin.Int64)
%60 = apply %18(%0) : $@convention(method) (@inout My2dArray<My2dArray<MyInt>>) -> ()
%61 = load %0 : $*My2dArray<My2dArray<MyInt>>
%63 = apply %21(%1, %61) : $@convention(method) (MyInt, @guaranteed My2dArray<My2dArray<MyInt>>) -> UnsafeMutablePointer<My2dArray<MyInt>>
%65 = struct_extract %61 : $My2dArray<My2dArray<MyInt>>, #My2dArray._buffer
%66 = struct_extract %65 : $_My2dArrayBuffer<My2dArray<MyInt>>, #_My2dArrayBuffer._storage
%67 = struct_extract %66 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
%72 = unchecked_ref_cast %67 : $Builtin.BridgeObject to $Builtin.NativeObject
%73 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %72 : $Builtin.NativeObject
%74 = struct_extract %63 : $UnsafeMutablePointer<My2dArray<MyInt>>, #UnsafeMutablePointer._rawValue
%75 = pointer_to_address %74 : $Builtin.RawPointer to [strict] $*My2dArray<MyInt>
%76 = mark_dependence %75 : $*My2dArray<MyInt> on %73 : $Optional<Builtin.NativeObject>
%79 = apply %22(%76) : $@convention(method) (@inout My2dArray<MyInt>) -> ()
%80 = load %76 : $*My2dArray<MyInt>
%83 = apply %13(%28, %20, %80) : $@convention(method) (MyInt, Bool, @guaranteed My2dArray<MyInt>) -> _DependenceToken
%84 = apply %23(%28, %80) : $@convention(method) (MyInt, @guaranteed My2dArray<MyInt>) -> UnsafeMutablePointer<MyInt>
%86 = struct_extract %80 : $My2dArray<MyInt>, #My2dArray._buffer
%87 = struct_extract %86 : $_My2dArrayBuffer<MyInt>, #_My2dArrayBuffer._storage
%88 = struct_extract %87 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
%93 = unchecked_ref_cast %88 : $Builtin.BridgeObject to $Builtin.NativeObject
%94 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %93 : $Builtin.NativeObject
%95 = struct_extract %84 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
%96 = pointer_to_address %95 : $Builtin.RawPointer to [strict] $*MyInt
%97 = mark_dependence %96 : $*MyInt on %94 : $Optional<Builtin.NativeObject>
store %59 to %97 : $*MyInt
%101 = builtin "cmp_eq_Int64"(%30 : $Builtin.Int64, %5 : $Builtin.Int64) : $Builtin.Int1
cond_br %101, bb1, bb2(%30 : $Builtin.Int64)
}
Reference in New Issue View Git Blame Copy Permalink