mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
514 lines
20 KiB
Plaintext
514 lines
20 KiB
Plaintext
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all -global-property-opt %s | %FileCheck %s
|
|
|
|
sil_stage canonical
|
|
|
|
import Builtin
|
|
import Swift
|
|
import SwiftShims
|
|
|
|
public class X {
|
|
}
|
|
|
|
|
|
public class Holder {
|
|
init()
|
|
|
|
private var arrFieldNative: [X]
|
|
public var arrFieldPublic: [X]
|
|
private var arrFieldUnknown: [X]
|
|
private var arrFieldEscaped: [X]
|
|
}
|
|
|
|
public struct StructHolder {
|
|
init()
|
|
|
|
private var arrFieldNative: [X]
|
|
public var arrFieldPublic: [X]
|
|
private var arrFieldUnknown: [X]
|
|
private var arrFieldEscaped: [X]
|
|
}
|
|
|
|
struct DepStruct {
|
|
private var depField: [X]
|
|
private var depField2: [X]
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_alloc_stack
|
|
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
|
|
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
|
|
// CHECK: return [[R]]
|
|
sil @test_alloc_stack : $@convention(thin) () -> Bool {
|
|
bb0:
|
|
%1 = alloc_stack $Array<X>
|
|
%3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%4 = apply %3() : $@convention(thin) () -> @owned Array<X>
|
|
store %4 to %1 : $*Array<X>
|
|
|
|
%m1 = function_ref @_array_X_mutate : $@convention(method) (@inout Array<X>) -> ()
|
|
%m2 = apply %m1(%1) : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
%5 = load %1 : $*Array<X>
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%5) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
dealloc_stack %1 : $*Array<X>
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_alloc_stack_escapes
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_alloc_stack_escapes : $@convention(thin) () -> Bool {
|
|
bb0:
|
|
%1 = alloc_stack $Array<X>
|
|
%3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%4 = apply %3() : $@convention(thin) () -> @owned Array<X>
|
|
store %4 to %1 : $*Array<X>
|
|
|
|
%m1 = function_ref @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()
|
|
%m2 = apply %m1(%1) : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
%5 = load %1 : $*Array<X>
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%5) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
dealloc_stack %1 : $*Array<X>
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_alloc_write_unknown
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_alloc_write_unknown : $@convention(thin) (@owned Array<X>) -> Bool {
|
|
bb0(%0 : $Array<X>):
|
|
%1 = alloc_stack $Array<X>
|
|
%3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%4 = apply %3() : $@convention(thin) () -> @owned Array<X>
|
|
store %4 to %1 : $*Array<X>
|
|
|
|
store %0 to %1 : $*Array<X>
|
|
|
|
%5 = load %1 : $*Array<X>
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%5) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
dealloc_stack %1 : $*Array<X>
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_phi
|
|
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
|
|
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
|
|
// CHECK: return [[R]]
|
|
sil @test_phi : $@convention(thin) (Bool) -> Bool {
|
|
bb0(%0 : $Bool):
|
|
%2 = struct_extract %0 : $Bool, #Bool._value
|
|
%3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
cond_br %2, bb1, bb2
|
|
|
|
bb1:
|
|
%4 = apply %3() : $@convention(thin) () -> @owned Array<X>
|
|
br bb3(%4 : $Array<X>)
|
|
|
|
bb2:
|
|
%6 = apply %3() : $@convention(thin) () -> @owned Array<X>
|
|
br bb3(%6 : $Array<X>)
|
|
|
|
bb3(%a1 : $Array<X>):
|
|
%f1 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %f1(%a1) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @negative_test_phi
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @negative_test_phi : $@convention(thin) (Bool, @owned Array<X>) -> Bool {
|
|
bb0(%0 : $Bool, %1 : $Array<X>):
|
|
%2 = struct_extract %0 : $Bool, #Bool._value
|
|
cond_br %2, bb1, bb2
|
|
|
|
bb1:
|
|
%3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%4 = apply %3() : $@convention(thin) () -> @owned Array<X>
|
|
br bb3(%4 : $Array<X>)
|
|
|
|
bb2:
|
|
br bb3(%1 : $Array<X>)
|
|
|
|
bb3(%a1 : $Array<X>):
|
|
%f1 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %f1(%a1) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_tuple
|
|
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
|
|
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
|
|
// CHECK: return [[R]]
|
|
sil @test_tuple : $@convention(thin) () -> Bool {
|
|
bb0:
|
|
%f1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%a1 = apply %f1() : $@convention(thin) () -> @owned Array<X>
|
|
%i1 = integer_literal $Builtin.Int64, 0
|
|
%t1 = tuple (%a1 : $Array<X>, %i1 : $Builtin.Int64)
|
|
|
|
%a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
|
|
%f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %r1 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_tuple_unknown_member
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_tuple_unknown_member : $@convention(thin) (@owned Array<X>) -> Bool {
|
|
bb0(%0 : $Array<X>):
|
|
%i1 = integer_literal $Builtin.Int64, 0
|
|
%t1 = tuple (%0 : $Array<X>, %i1 : $Builtin.Int64)
|
|
|
|
%a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
|
|
%f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %r1 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_unknown_tuple
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_unknown_tuple : $@convention(thin) () -> Bool {
|
|
bb0:
|
|
%f1 = function_ref @provide_tuple : $@convention(thin) () -> @owned (Array<X>, Builtin.Int64)
|
|
%t1 = apply %f1() : $@convention(thin) () -> @owned (Array<X>, Builtin.Int64)
|
|
|
|
%a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
|
|
%f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %r1 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_tuple_member_escapes
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_tuple_member_escapes : $@convention(thin) () -> Bool {
|
|
bb0:
|
|
%s1 = alloc_stack $(Array<X>, Builtin.Int64)
|
|
%a1 = tuple_element_addr %s1 : $*(Array<X>, Builtin.Int64), 0
|
|
%f1 = function_ref @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()
|
|
%x1 = apply %f1(%a1) : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
%t1 = load %s1 : $*(Array<X>, Builtin.Int64)
|
|
%a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
|
|
%f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
dealloc_stack %s1 : $*(Array<X>, Builtin.Int64)
|
|
return %r1 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_tuple_phi
|
|
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
|
|
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
|
|
// CHECK: return [[R]]
|
|
sil @test_tuple_phi : $@convention(thin) (Bool) -> Bool {
|
|
bb0(%0 : $Bool):
|
|
%i1 = integer_literal $Builtin.Int64, 0
|
|
%f1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%2 = struct_extract %0 : $Bool, #Bool._value
|
|
cond_br %2, bb1, bb2
|
|
|
|
bb1:
|
|
%a1 = apply %f1() : $@convention(thin) () -> @owned Array<X>
|
|
%t1 = tuple (%a1 : $Array<X>, %i1 : $Builtin.Int64)
|
|
br bb3(%t1 : $(Array<X>, Builtin.Int64))
|
|
|
|
bb2:
|
|
%a2 = apply %f1() : $@convention(thin) () -> @owned Array<X>
|
|
%t2 = tuple (%a2 : $Array<X>, %i1 : $Builtin.Int64)
|
|
br bb3(%t2 : $(Array<X>, Builtin.Int64))
|
|
|
|
bb3(%t3 : $(Array<X>, Builtin.Int64)):
|
|
%a3 = tuple_extract %t3 : $(Array<X>, Builtin.Int64), 0
|
|
%f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %f2(%a3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_tuple_phi_unknown
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_tuple_phi_unknown : $@convention(thin) (Bool, @owned Array<X>) -> Bool {
|
|
bb0(%0 : $Bool, %1 : $Array<X>):
|
|
%i1 = integer_literal $Builtin.Int64, 0
|
|
%f1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%2 = struct_extract %0 : $Bool, #Bool._value
|
|
cond_br %2, bb1, bb2
|
|
|
|
bb1:
|
|
%a1 = apply %f1() : $@convention(thin) () -> @owned Array<X>
|
|
%t1 = tuple (%a1 : $Array<X>, %i1 : $Builtin.Int64)
|
|
br bb3(%t1 : $(Array<X>, Builtin.Int64))
|
|
|
|
bb2:
|
|
%t2 = tuple (%1 : $Array<X>, %i1 : $Builtin.Int64)
|
|
br bb3(%t2 : $(Array<X>, Builtin.Int64))
|
|
|
|
bb3(%t3 : $(Array<X>, Builtin.Int64)):
|
|
%a2 = tuple_extract %t3 : $(Array<X>, Builtin.Int64), 0
|
|
%f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_arrFieldNative
|
|
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
|
|
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
|
|
// CHECK: return [[R]]
|
|
sil @test_arrFieldNative : $@convention(thin) (@owned Holder) -> Bool {
|
|
bb0(%0 : $Holder):
|
|
%2 = ref_element_addr %0 : $Holder, #Holder.arrFieldNative
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_arrFieldPublic
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_arrFieldPublic : $@convention(thin) (@owned Holder) -> Bool {
|
|
bb0(%0 : $Holder):
|
|
%2 = ref_element_addr %0 : $Holder, #Holder.arrFieldPublic
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_arrFieldUnknown
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_arrFieldUnknown : $@convention(thin) (@owned Holder) -> Bool {
|
|
bb0(%0 : $Holder):
|
|
%2 = ref_element_addr %0 : $Holder, #Holder.arrFieldUnknown
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_arrFieldEscaped
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_arrFieldEscaped : $@convention(thin) (@owned Holder) -> Bool {
|
|
bb0(%0 : $Holder):
|
|
%2 = ref_element_addr %0 : $Holder, #Holder.arrFieldEscaped
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_struct_arrFieldNative
|
|
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
|
|
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
|
|
// CHECK: return [[R]]
|
|
sil @test_struct_arrFieldNative : $@convention(thin) (@inout StructHolder) -> Bool {
|
|
bb0(%0 : $*StructHolder):
|
|
%2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldNative
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_struct_arrFieldPublic
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_struct_arrFieldPublic : $@convention(thin) (@inout StructHolder) -> Bool {
|
|
bb0(%0 : $*StructHolder):
|
|
%2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldPublic
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_struct_arrFieldUnknown
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_struct_arrFieldUnknown : $@convention(thin) (@inout StructHolder) -> Bool {
|
|
bb0(%0 : $*StructHolder):
|
|
%2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldUnknown
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_struct_arrFieldEscaped
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_struct_arrFieldEscaped : $@convention(thin) (@inout StructHolder) -> Bool {
|
|
bb0(%0 : $*StructHolder):
|
|
%2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldEscaped
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %10 : $Bool
|
|
}
|
|
|
|
// CHECK-LABEL: sil @test_dependencies
|
|
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
|
|
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
|
|
// CHECK: return [[R]]
|
|
sil @test_dependencies : $@convention(thin) (@owned Holder, Bool) -> Bool {
|
|
bb0(%0 : $Holder, %1 : $Bool):
|
|
%2 = ref_element_addr %0 : $Holder, #Holder.arrFieldNative
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%i1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%c1 = struct_extract %1 : $Bool, #Bool._value
|
|
cond_br %c1, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3(%3 : $Array<X>)
|
|
|
|
bb2:
|
|
%i2 = apply %i1() : $@convention(thin) () -> @owned Array<X>
|
|
br bb3(%i2 : $Array<X>)
|
|
|
|
bb3(%a1 : $Array<X>):
|
|
|
|
%i3 = apply %i1() : $@convention(thin) () -> @owned Array<X>
|
|
|
|
%f1 = function_ref @_take_struct : $@convention(thin) (@owned DepStruct) -> ()
|
|
%s1 = struct $DepStruct (%a1 : $Array<X>, %i3 : $Array<X>)
|
|
%s2 = apply %f1(%s1) : $@convention(thin) (@owned DepStruct) -> ()
|
|
|
|
%f2 = function_ref @_provide_struct : $@convention(thin) () -> @owned DepStruct
|
|
%s3 = apply %f2() : $@convention(thin) () -> @owned DepStruct
|
|
|
|
%x1 = struct_extract %s3 : $DepStruct, #DepStruct.depField
|
|
|
|
%f3 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%r1 = apply %f3(%x1) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %r1 : $Bool
|
|
}
|
|
|
|
// Check dependency chain: load -> argument -> struct -> extract
|
|
|
|
// CHECK-LABEL: sil @test_dependencies2
|
|
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
|
|
// CHECK: [[R:%[0-9]+]] = apply [[F]]
|
|
// CHECK: return [[R]]
|
|
sil @test_dependencies2 : $@convention(thin) (@owned Holder, Bool) -> Bool {
|
|
bb0(%0 : $Holder, %1 : $Bool):
|
|
%2 = ref_element_addr %0 : $Holder, #Holder.arrFieldUnknown
|
|
%3 = load %2 : $*Array<X>
|
|
|
|
%i1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
%c1 = struct_extract %1 : $Bool, #Bool._value
|
|
cond_br %c1, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3(%3 : $Array<X>)
|
|
|
|
bb2:
|
|
%i2 = apply %i1() : $@convention(thin) () -> @owned Array<X>
|
|
br bb3(%i2 : $Array<X>)
|
|
|
|
bb3(%a1 : $Array<X>):
|
|
|
|
%i3 = apply %i1() : $@convention(thin) () -> @owned Array<X>
|
|
|
|
%f1 = function_ref @_take_struct : $@convention(thin) (@owned DepStruct) -> ()
|
|
%s1 = struct $DepStruct (%i3 : $Array<X>, %a1 : $Array<X>)
|
|
%s2 = apply %f1(%s1) : $@convention(thin) (@owned DepStruct) -> ()
|
|
|
|
%f2 = function_ref @_provide_struct : $@convention(thin) () -> @owned DepStruct
|
|
%s3 = apply %f2() : $@convention(thin) () -> @owned DepStruct
|
|
|
|
%x1 = struct_extract %s3 : $DepStruct, #DepStruct.depField2
|
|
|
|
%f3 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
%r1 = apply %f3(%x1) : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
return %r1 : $Bool
|
|
}
|
|
|
|
sil @setArrayFields : $@convention(thin) (@owned Holder, @inout StructHolder, @owned Array<X>) -> () {
|
|
bb0(%0 : $Holder, %1 : $*StructHolder, %2 : $Array<X>):
|
|
%l1 = integer_literal $Builtin.Word, 0 // user: %3
|
|
%f1 = function_ref @_allocate_uninitialized_X : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
|
|
%f2 = function_ref @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
%c3 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
|
|
%c4 = tuple_extract %c3 : $(Array<X>, Builtin.RawPointer), 0
|
|
%c5 = ref_element_addr %0 : $Holder, #Holder.arrFieldNative
|
|
store %c4 to %c5 : $*Array<X>
|
|
|
|
%c6 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
|
|
%c7 = tuple_extract %c6 : $(Array<X>, Builtin.RawPointer), 0
|
|
%c8 = ref_element_addr %0 : $Holder, #Holder.arrFieldPublic
|
|
store %c7 to %c8 : $*Array<X>
|
|
|
|
%c9 = ref_element_addr %0 : $Holder, #Holder.arrFieldUnknown
|
|
store %2 to %c9 : $*Array<X>
|
|
|
|
%c11 = ref_element_addr %0 : $Holder, #Holder.arrFieldEscaped
|
|
%c12 = apply %f2(%c11) : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
%s3 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
|
|
%s4 = tuple_extract %s3 : $(Array<X>, Builtin.RawPointer), 0
|
|
%s5 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldNative
|
|
store %s4 to %s5 : $*Array<X>
|
|
|
|
%s6 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
|
|
%s7 = tuple_extract %s6 : $(Array<X>, Builtin.RawPointer), 0
|
|
%s8 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldPublic
|
|
store %s7 to %s8 : $*Array<X>
|
|
|
|
%s9 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldUnknown
|
|
store %2 to %s9 : $*Array<X>
|
|
|
|
%s11 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldEscaped
|
|
%s12 = apply %f2(%s11) : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
%t1 = tuple ()
|
|
return %t1 : $()
|
|
}
|
|
|
|
sil [_semantics "array.init"] @_array_X_init : $@convention(thin) () -> @owned Array<X>
|
|
|
|
sil [_semantics "array.mutate_unknown"] @_array_X_mutate : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
sil [_semantics "array.props.isNativeTypeChecked"] @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
|
|
|
|
sil [_semantics "array.uninitialized"] @_allocate_uninitialized_X : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
|
|
|
|
sil @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()
|
|
|
|
sil @_take_struct : $@convention(thin) (@owned DepStruct) -> ()
|
|
|
|
sil @_provide_struct : $@convention(thin) () -> @owned DepStruct
|
|
|
|
sil @provide_tuple : $@convention(thin) () -> @owned (Array<X>, Builtin.Int64)
|
|
|