mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
ab35362056
The new instruction exists only to be used in tests. The idea is to specify tests that ought to be run "in the context" of the containing function.
126 lines
4.9 KiB
Plaintext
126 lines
4.9 KiB
Plaintext
// RUN: %target-sil-opt -enable-sil-verify-all -inline %s | %FileCheck %s
|
|
|
|
// Check cloning of instructions.
|
|
|
|
sil_stage canonical
|
|
|
|
import Builtin
|
|
|
|
class X {
|
|
}
|
|
|
|
sil [always_inline] @callee_alloc_ref_stack : $@convention(thin) () -> () {
|
|
bb0:
|
|
%0 = alloc_ref [stack] $X
|
|
dealloc_stack_ref %0 : $X
|
|
%r = tuple ()
|
|
return %r : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil @caller_alloc_ref_stack : $@convention(thin) () -> ()
|
|
// CHECK: [[X:%[0-9]+]] = alloc_ref [stack] $X
|
|
// CHECK: dealloc_stack_ref [[X]] : $X
|
|
sil @caller_alloc_ref_stack : $@convention(thin) () -> () {
|
|
bb0:
|
|
%0 = function_ref @callee_alloc_ref_stack : $@convention(thin) () -> ()
|
|
%1 = apply %0() : $@convention(thin) () -> ()
|
|
%2 = tuple ()
|
|
return %2 : $()
|
|
}
|
|
|
|
sil [ossa] [always_inline] @callee_begin_borrow_lexical : $@convention(thin) () -> () {
|
|
%instance = alloc_ref $X
|
|
%guaranteed_c = begin_borrow [lexical] %instance : $X
|
|
end_borrow %guaranteed_c : $X
|
|
destroy_value %instance : $X
|
|
%res = tuple ()
|
|
return %res : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [ossa] @caller_begin_borrow_lexical
|
|
// CHECK: begin_borrow [lexical]
|
|
// CHECK-LABEL: } // end sil function 'caller_begin_borrow_lexical'
|
|
sil [ossa] @caller_begin_borrow_lexical : $@convention(thin) () -> () {
|
|
%callee_begin_borrow_lexical = function_ref @callee_begin_borrow_lexical : $@convention(thin) () -> ()
|
|
%res = apply %callee_begin_borrow_lexical() : $@convention(thin) () -> ()
|
|
return %res : $()
|
|
}
|
|
|
|
sil [ossa] @callee_alloc_stack : $@convention(thin) () -> () {
|
|
%instance = alloc_stack $Builtin.NativeObject
|
|
dealloc_stack %instance : $*Builtin.NativeObject
|
|
%instance2 = alloc_stack [dynamic_lifetime] $Builtin.NativeObject
|
|
dealloc_stack %instance2 : $*Builtin.NativeObject
|
|
%instance3 = alloc_stack [lexical] $Builtin.NativeObject
|
|
dealloc_stack %instance3 : $*Builtin.NativeObject
|
|
%instance4 = alloc_stack [dynamic_lifetime] [lexical] $Builtin.NativeObject
|
|
dealloc_stack %instance4 : $*Builtin.NativeObject
|
|
%res = tuple ()
|
|
return %res : $()
|
|
}
|
|
|
|
// CHECK-LABEL: sil [ossa] @caller_alloc_stack_lexical
|
|
// CHECK: alloc_stack
|
|
// CHECK: alloc_stack [dynamic_lifetime]
|
|
// CHECK: alloc_stack [lexical]
|
|
// CHECK: alloc_stack [dynamic_lifetime] [lexical]
|
|
// CHECK-LABEL: } // end sil function 'caller_alloc_stack_lexical'
|
|
sil [ossa] @caller_alloc_stack_lexical : $@convention(thin) () -> () {
|
|
%callee_alloc_stack = function_ref @callee_alloc_stack : $@convention(thin) () -> ()
|
|
%res = apply %callee_alloc_stack() : $@convention(thin) () -> ()
|
|
return %res : $()
|
|
}
|
|
|
|
sil [ossa] @callee_move_value : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
|
|
entry(%0 : @owned $Builtin.NativeObject):
|
|
%1 = move_value %0 : $Builtin.NativeObject
|
|
%2 = move_value [allows_diagnostics] %1 : $Builtin.NativeObject
|
|
%3 = move_value [lexical] %2 : $Builtin.NativeObject
|
|
%4 = move_value [allows_diagnostics] [lexical] %3 : $Builtin.NativeObject
|
|
return %4 : $Builtin.NativeObject
|
|
}
|
|
|
|
// CHECK-LABEL: sil [ossa] @caller_move_value {{.*}} {
|
|
// CHECK: {{bb[0-9]+}}([[REGISTER_0:%[^,]+]] :
|
|
// CHECK: [[REGISTER_1:%[^,]+]] = move_value [[REGISTER_0]]
|
|
// CHECK: [[REGISTER_2:%[^,]+]] = move_value [allows_diagnostics] [[REGISTER_1]]
|
|
// CHECK: [[REGISTER_3:%[^,]+]] = move_value [lexical] [[REGISTER_2]]
|
|
// CHECK: [[REGISTER_4:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_3]]
|
|
// CHECK: return [[REGISTER_4]]
|
|
// CHECK-LABEL: } // end sil function 'caller_move_value'
|
|
sil [ossa] @caller_move_value : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
|
|
entry(%0 : @owned $Builtin.NativeObject):
|
|
%callee_move_value = function_ref @callee_move_value : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject
|
|
%res = apply %callee_move_value(%0) : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject
|
|
return %res : $Builtin.NativeObject
|
|
}
|
|
|
|
sil [ossa] @callee_debug_value : $@convention(thin) (@owned X) -> @owned X {
|
|
entry(%0 : @owned $X):
|
|
debug_value [trace] %0 : $X
|
|
return %0 : $X
|
|
}
|
|
|
|
sil [ossa] @caller_debug_value : $@convention(thin) (@owned X) -> @owned X {
|
|
entry(%0 : @owned $X):
|
|
%callee_debug_value = function_ref @callee_debug_value : $@convention(thin) (@owned X) -> @owned X
|
|
%res = apply %callee_debug_value(%0) : $@convention(thin) (@owned X) -> @owned X
|
|
return %res : $X
|
|
}
|
|
|
|
// CHECK-LABEL: sil [ossa] @caller_test_specification : {{.*}} {
|
|
// CHECK: test_specification "foo bar baz"
|
|
// CHECK-LABEL: } // end sil function 'caller_test_specification'
|
|
sil [always_inline] [ossa] @callee_test_specification : $@convention(thin) () -> () {
|
|
entry:
|
|
test_specification "foo bar baz"
|
|
%retval = tuple ()
|
|
return %retval : $()
|
|
}
|
|
|
|
sil [ossa] @caller_test_specification : $@convention(thin) () -> () {
|
|
%callee = function_ref @callee_test_specification : $@convention(thin) () -> ()
|
|
%retval = apply %callee() : $@convention(thin) () -> ()
|
|
return %retval : $()
|
|
}
|