mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
7cceaff5f3
Type annotations for instruction operands are omitted, e.g. ``` %3 = struct $S(%1, %2) ``` Operand types are redundant anyway and were only used for sanity checking in the SIL parser. But: operand types _are_ printed if the definition of the operand value was not printed yet. This happens: * if the block with the definition appears after the block where the operand's instruction is located * if a block or instruction is printed in isolation, e.g. in a debugger The old behavior can be restored with `-Xllvm -sil-print-types`. This option is added to many existing test files which check for operand types in their check-lines.
212 lines
14 KiB
Swift
212 lines
14 KiB
Swift
// RUN: %target-swift-emit-silgen -Xllvm -sil-print-types %s | %FileCheck %s
|
|
|
|
// CHECK-LABEL: @$s4main14receive_simpleyyxxQpRvzlF : $@convention(thin) <each T> (@pack_guaranteed Pack{repeat each T}) -> () {
|
|
// CHECK: bb0(%0 : $*Pack{repeat each T}):
|
|
// CHECK-NEXT: debug_value
|
|
// CHECK-NEXT: [[RET:%.*]] = tuple ()
|
|
// CHECK-NEXT: return [[RET]] : $()
|
|
func receive_simple<each T>(_ args: repeat each T) {}
|
|
|
|
// CHECK-LABEL: @$s4main20receive_simple_ownedyyxxQpnRvzlF : $@convention(thin) <each T> (@pack_owned Pack{repeat each T}) -> () {
|
|
// CHECK: bb0(%0 : $*Pack{repeat each T}):
|
|
// CHECK-NEXT: debug_value
|
|
// CHECK-NEXT: [[ZERO:%.*]] = integer_literal $Builtin.Word, 0
|
|
// CHECK-NEXT: [[ONE:%.*]] = integer_literal $Builtin.Word, 1
|
|
// CHECK-NEXT: [[LEN:%.*]] = pack_length $Pack{repeat each T}
|
|
// CHECK-NEXT: br bb1([[LEN]] : $Builtin.Word)
|
|
// CHECK: bb1([[LAST_IDX:%.*]] : $Builtin.Word)
|
|
// CHECK-NEXT: [[LAST_IDX_EQ_ZERO:%.*]] = builtin "cmp_eq_Word"([[LAST_IDX]] : $Builtin.Word, [[ZERO]] : $Builtin.Word) : $Builtin.Int1
|
|
// CHECK-NEXT: cond_br [[LAST_IDX_EQ_ZERO]], bb3, bb2
|
|
// CHECK: bb2:
|
|
// CHECK-NEXT: [[IDX:%.*]] = builtin "sub_Word"([[LAST_IDX]] : $Builtin.Word, [[ONE]] : $Builtin.Word) : $Builtin.Word
|
|
// CHECK-NEXT: [[INDEX:%.*]] = dynamic_pack_index [[IDX]] of $Pack{repeat each T}
|
|
// CHECK-NEXT: open_pack_element [[INDEX]] of <each T> at <Pack{repeat each T}>, shape $each T, uuid [[UUID:".*"]]
|
|
// CHECK-NEXT: [[ELT_ADDR:%.*]] = pack_element_get [[INDEX]] of %0 : $*Pack{repeat each T} as $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: destroy_addr [[ELT_ADDR]] : $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: br bb1([[IDX]] : $Builtin.Word)
|
|
// CHECK: bb3:
|
|
// CHECK-NEXT: [[RET:%.*]] = tuple ()
|
|
// CHECK-NEXT: return [[RET]] : $()
|
|
func receive_simple_owned<each T>(_ args: repeat __owned each T) {}
|
|
|
|
// CHECK-LABEL: @$s4main12scalar_test01i1f1sySi_SfSStF
|
|
// CHECK: [[PACK:%.*]] = alloc_pack $Pack{Int, Float, String}
|
|
// Copy i into a temporary and insert that into the pack.
|
|
// CHECK-NEXT: [[INT_TEMP:%.*]] = alloc_stack $Int
|
|
// CHECK-NEXT: store %0 to [trivial] [[INT_TEMP]] : $*Int
|
|
// CHECK-NEXT: [[INT_INDEX:%.*]] = scalar_pack_index 0 of $Pack{Int, Float, String}
|
|
// CHECK-NEXT: pack_element_set [[INT_TEMP]] : $*Int into [[INT_INDEX]] of [[PACK]] : $*Pack{Int, Float, String}
|
|
// Copy f into a temporary and insert that into the pack.
|
|
// CHECK-NEXT: [[FLOAT_TEMP:%.*]] = alloc_stack $Float
|
|
// CHECK-NEXT: store %1 to [trivial] [[FLOAT_TEMP]] : $*Float
|
|
// CHECK-NEXT: [[FLOAT_INDEX:%.*]] = scalar_pack_index 1 of $Pack{Int, Float, String}
|
|
// CHECK-NEXT: pack_element_set [[FLOAT_TEMP]] : $*Float into [[FLOAT_INDEX]] of [[PACK]] : $*Pack{Int, Float, String}
|
|
// Copy s into a temporary and insert that into the pack.
|
|
// TODO: do this with a borrow
|
|
// CHECK-NEXT: [[STRING_TEMP:%.*]] = alloc_stack $String
|
|
// CHECK-NEXT: [[STRING_COPY:%.*]] = copy_value %2 : $String
|
|
// CHECK-NEXT: store [[STRING_COPY]] to [init] [[STRING_TEMP]] : $*String
|
|
// CHECK-NEXT: [[STRING_INDEX:%.*]] = scalar_pack_index 2 of $Pack{Int, Float, String}
|
|
// CHECK-NEXT: pack_element_set [[STRING_TEMP]] : $*String into [[STRING_INDEX]] of [[PACK]] : $*Pack{Int, Float, String}
|
|
// Perform the call.
|
|
// CHECK-NEXT: // function_ref
|
|
// CHECK-NEXT: [[FN:%.*]] = function_ref @$s4main14receive_simpleyyxxQpRvzlF : $@convention(thin) <each τ_0_0> (@pack_guaranteed Pack{repeat each τ_0_0}) -> ()
|
|
// CHECK-NEXT: apply [[FN]]<Pack{Int, Float, String}>([[PACK]])
|
|
// Clean up.
|
|
// CHECK-NEXT: destroy_addr [[STRING_TEMP]] : $*String
|
|
// CHECK-NEXT: dealloc_stack [[STRING_TEMP]] : $*String
|
|
// CHECK-NEXT: dealloc_stack [[FLOAT_TEMP]] : $*Float
|
|
// CHECK-NEXT: dealloc_stack [[INT_TEMP]] : $*Int
|
|
// CHECK-NEXT: dealloc_pack [[PACK]] : $*Pack{Int, Float, String}
|
|
func scalar_test0(i: Int, f: Float, s: String) {
|
|
receive_simple(i, f, s)
|
|
}
|
|
|
|
// CHECK-LABEL: @$s4main12scalar_test11i1f1sySi_SfSStF
|
|
// CHECK: [[PACK:%.*]] = alloc_pack $Pack{Int, Float, String}
|
|
// Copy i into a temporary and insert that into the pack.
|
|
// CHECK-NEXT: [[INT_TEMP:%.*]] = alloc_stack $Int
|
|
// CHECK-NEXT: store %0 to [trivial] [[INT_TEMP]] : $*Int
|
|
// CHECK-NEXT: [[INT_INDEX:%.*]] = scalar_pack_index 0 of $Pack{Int, Float, String}
|
|
// CHECK-NEXT: pack_element_set [[INT_TEMP]] : $*Int into [[INT_INDEX]] of [[PACK]] : $*Pack{Int, Float, String}
|
|
// Copy f into a temporary and insert that into the pack.
|
|
// CHECK-NEXT: [[FLOAT_TEMP:%.*]] = alloc_stack $Float
|
|
// CHECK-NEXT: store %1 to [trivial] [[FLOAT_TEMP]] : $*Float
|
|
// CHECK-NEXT: [[FLOAT_INDEX:%.*]] = scalar_pack_index 1 of $Pack{Int, Float, String}
|
|
// CHECK-NEXT: pack_element_set [[FLOAT_TEMP]] : $*Float into [[FLOAT_INDEX]] of [[PACK]] : $*Pack{Int, Float, String}
|
|
// Copy s into a temporary and insert that into the pack.
|
|
// TODO: do this with a borrow
|
|
// CHECK-NEXT: [[STRING_TEMP:%.*]] = alloc_stack $String
|
|
// CHECK-NEXT: [[STRING_COPY:%.*]] = copy_value %2 : $String
|
|
// CHECK-NEXT: store [[STRING_COPY]] to [init] [[STRING_TEMP]] : $*String
|
|
// CHECK-NEXT: [[STRING_INDEX:%.*]] = scalar_pack_index 2 of $Pack{Int, Float, String}
|
|
// CHECK-NEXT: pack_element_set [[STRING_TEMP]] : $*String into [[STRING_INDEX]] of [[PACK]] : $*Pack{Int, Float, String}
|
|
// Perform the call.
|
|
// CHECK-NEXT: // function_ref
|
|
// CHECK-NEXT: [[FN:%.*]] = function_ref @$s4main20receive_simple_ownedyyxxQpnRvzlF : $@convention(thin) <each τ_0_0> (@pack_owned Pack{repeat each τ_0_0}) -> ()
|
|
// CHECK-NEXT: apply [[FN]]<Pack{Int, Float, String}>([[PACK]])
|
|
// Clean up.
|
|
// CHECK-NEXT: dealloc_stack [[STRING_TEMP]] : $*String
|
|
// CHECK-NEXT: dealloc_stack [[FLOAT_TEMP]] : $*Float
|
|
// CHECK-NEXT: dealloc_stack [[INT_TEMP]] : $*Int
|
|
// CHECK-NEXT: dealloc_pack [[PACK]] : $*Pack{Int, Float, String}
|
|
func scalar_test1(i: Int, f: Float, s: String) {
|
|
receive_simple_owned(i, f, s)
|
|
}
|
|
|
|
// FIXME: this pack should just be forwarded
|
|
// CHECK-LABEL: @$s4main10pack_test04argsyxxQp_tRvzlF
|
|
// CHECK: bb0(%0 : $*Pack{repeat each T}):
|
|
// CHECK: [[PACK:%.*]] = alloc_pack $Pack{repeat each T}
|
|
// CHECK-NEXT: [[TUPLE:%.*]] = alloc_stack $(repeat each T)
|
|
// CHECK-NEXT: [[ZERO:%.*]] = integer_literal $Builtin.Word, 0
|
|
// CHECK-NEXT: [[ONE:%.*]] = integer_literal $Builtin.Word, 1
|
|
// CHECK-NEXT: [[LEN:%.*]] = pack_length $Pack{repeat each T}
|
|
// CHECK-NEXT: br bb1([[ZERO]] : $Builtin.Word)
|
|
// CHECK: bb1([[IDX:%.*]] : $Builtin.Word)
|
|
// CHECK-NEXT: [[IDX_EQ_LEN:%.*]] = builtin "cmp_eq_Word"([[IDX]] : $Builtin.Word, [[LEN]] : $Builtin.Word) : $Builtin.Int1
|
|
// CHECK-NEXT: cond_br [[IDX_EQ_LEN]], bb3, bb2
|
|
// CHECK: bb2:
|
|
// CHECK-NEXT: [[INDEX:%.*]] = dynamic_pack_index [[IDX]] of $Pack{repeat each T}
|
|
// CHECK-NEXT: open_pack_element [[INDEX]] of <each T> at <Pack{repeat each T}>, shape $each T, uuid [[UUID:".*"]]
|
|
// CHECK-NEXT: [[DST_ELT_ADDR:%.*]] = tuple_pack_element_addr [[INDEX]] of [[TUPLE]] : $*(repeat each T) as $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: [[SRC_ELT_ADDR:%.*]] = pack_element_get [[INDEX]] of %0 : $*Pack{repeat each T} as $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: copy_addr [[SRC_ELT_ADDR]] to [init] [[DST_ELT_ADDR]] : $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: pack_element_set [[DST_ELT_ADDR]] : $*@pack_element([[UUID]]) each T into [[INDEX]] of [[PACK]] : $*Pack{repeat each T}
|
|
// CHECK-NEXT: [[NEXT_IDX:%.*]] = builtin "add_Word"([[IDX]] : $Builtin.Word, [[ONE]] : $Builtin.Word) : $Builtin.Word
|
|
// CHECK-NEXT: br bb1([[NEXT_IDX]] : $Builtin.Word)
|
|
// CHECK: bb3:
|
|
// CHECK-NEXT: // function_ref
|
|
// CHECK-NEXT: [[FN:%.*]] = function_ref @$s4main14receive_simpleyyxxQpRvzlF
|
|
// CHECK-NEXT: apply [[FN]]<Pack{repeat each T}>([[PACK]])
|
|
// CHECK-NEXT: destroy_addr [[TUPLE]] : $*(repeat each T)
|
|
// CHECK-NEXT: dealloc_stack [[TUPLE]] : $*(repeat each T)
|
|
// CHECK-NEXT: dealloc_pack [[PACK]] : $*Pack{repeat each T}
|
|
// CHECK-NEXT: [[RET:%.*]] = tuple ()
|
|
// CHECK-NEXT: return [[RET]] : $()
|
|
func pack_test0<each T>(args: repeat each T) {
|
|
receive_simple(repeat each args)
|
|
}
|
|
|
|
// CHECK-LABEL: @$s4main10pack_test14argsyxxQp_tRvzlF
|
|
// CHECK: bb0(%0 : $*Pack{repeat each T}):
|
|
// CHECK: [[PACK:%.*]] = alloc_pack $Pack{repeat each T}
|
|
// CHECK-NEXT: [[TUPLE:%.*]] = alloc_stack $(repeat each T)
|
|
// CHECK-NEXT: [[ZERO:%.*]] = integer_literal $Builtin.Word, 0
|
|
// CHECK-NEXT: [[ONE:%.*]] = integer_literal $Builtin.Word, 1
|
|
// CHECK-NEXT: [[LEN:%.*]] = pack_length $Pack{repeat each T}
|
|
// CHECK-NEXT: br bb1([[ZERO]] : $Builtin.Word)
|
|
// CHECK: bb1([[IDX:%.*]] : $Builtin.Word)
|
|
// CHECK-NEXT: [[IDX_EQ_LEN:%.*]] = builtin "cmp_eq_Word"([[IDX]] : $Builtin.Word, [[LEN]] : $Builtin.Word) : $Builtin.Int1
|
|
// CHECK-NEXT: cond_br [[IDX_EQ_LEN]], bb3, bb2
|
|
// CHECK: bb2:
|
|
// CHECK-NEXT: [[INDEX:%.*]] = dynamic_pack_index [[IDX]] of $Pack{repeat each T}
|
|
// CHECK-NEXT: open_pack_element [[INDEX]] of <each T> at <Pack{repeat each T}>, shape $each T, uuid [[UUID:".*"]]
|
|
// CHECK-NEXT: [[DST_ELT_ADDR:%.*]] = tuple_pack_element_addr [[INDEX]] of [[TUPLE]] : $*(repeat each T) as $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: [[SRC_ELT_ADDR:%.*]] = pack_element_get [[INDEX]] of %0 : $*Pack{repeat each T} as $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: copy_addr [[SRC_ELT_ADDR]] to [init] [[DST_ELT_ADDR]] : $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: pack_element_set [[DST_ELT_ADDR]] : $*@pack_element([[UUID]]) each T into [[INDEX]] of [[PACK]] : $*Pack{repeat each T}
|
|
// CHECK-NEXT: [[NEXT_IDX:%.*]] = builtin "add_Word"([[IDX]] : $Builtin.Word, [[ONE]] : $Builtin.Word) : $Builtin.Word
|
|
// CHECK-NEXT: br bb1([[NEXT_IDX]] : $Builtin.Word)
|
|
// CHECK: bb3:
|
|
// CHECK-NEXT: // function_ref
|
|
// CHECK-NEXT: [[FN:%.*]] = function_ref @$s4main20receive_simple_ownedyyxxQpnRvzlF : $@convention(thin) <each τ_0_0> (@pack_owned Pack{repeat each τ_0_0}) -> ()
|
|
// CHECK-NEXT: apply [[FN]]<Pack{repeat each T}>([[PACK]])
|
|
// CHECK-NEXT: dealloc_stack [[TUPLE]] : $*(repeat each T)
|
|
// CHECK-NEXT: dealloc_pack [[PACK]] : $*Pack{repeat each T}
|
|
// CHECK-NEXT: [[RET:%.*]] = tuple ()
|
|
// CHECK-NEXT: return [[RET]] : $()
|
|
func pack_test1<each T>(args: repeat each T) {
|
|
receive_simple_owned(repeat each args)
|
|
}
|
|
|
|
// CHECK-LABEL: @$s4main10pack_test24args1i1syxxQp_SiSStRvzlF
|
|
// CHECK: bb0(%0 : $*Pack{repeat each T}, %1 : $Int, %2 : @guaranteed $String):
|
|
// CHECK: [[PACK:%.*]] = alloc_pack $Pack{Int, repeat each T, String}
|
|
// Int argument.
|
|
// CHECK-NEXT: [[INT_ADDR:%.*]] = alloc_stack $Int
|
|
// CHECK-NEXT: store %1 to [trivial] [[INT_ADDR]] : $*Int
|
|
// CHECK-NEXT: [[INT_INDEX]] = scalar_pack_index 0 of $Pack{Int, repeat each T, String}
|
|
// CHECK-NEXT: pack_element_set [[INT_ADDR]] : $*Int into [[INT_INDEX]] of [[PACK]] : $*Pack{Int, repeat each T, String}
|
|
// Pack expansion argument.
|
|
// FIXME: the elements of this pack should be borrowed
|
|
// CHECK-NEXT: [[TUPLE:%.*]] = alloc_stack $(repeat each T)
|
|
// CHECK-NEXT: [[ZERO:%.*]] = integer_literal $Builtin.Word, 0
|
|
// CHECK-NEXT: [[ONE:%.*]] = integer_literal $Builtin.Word, 1
|
|
// CHECK-NEXT: [[LEN:%.*]] = pack_length $Pack{repeat each T}
|
|
// CHECK-NEXT: br bb1([[ZERO]] : $Builtin.Word)
|
|
// CHECK: bb1([[IDX:%.*]] : $Builtin.Word)
|
|
// CHECK-NEXT: [[IDX_EQ_LEN:%.*]] = builtin "cmp_eq_Word"([[IDX]] : $Builtin.Word, [[LEN]] : $Builtin.Word) : $Builtin.Int1
|
|
// CHECK-NEXT: cond_br [[IDX_EQ_LEN]], bb3, bb2
|
|
// CHECK: bb2:
|
|
// CHECK-NEXT: [[EXPANSION_INDEX:%.*]] = dynamic_pack_index [[IDX]] of $Pack{repeat each T}
|
|
// CHECK-NEXT: open_pack_element [[EXPANSION_INDEX]] of <each T> at <Pack{repeat each T}>, shape $each T, uuid [[UUID:".*"]]
|
|
// CHECK-NEXT: [[INDEX:%.*]] = pack_pack_index 1, [[EXPANSION_INDEX]] of $Pack{Int, repeat each T, String}
|
|
// CHECK-NEXT: [[DST_ELT_ADDR:%.*]] = tuple_pack_element_addr [[EXPANSION_INDEX]] of [[TUPLE]] : $*(repeat each T) as $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: [[SRC_ELT_ADDR:%.*]] = pack_element_get [[EXPANSION_INDEX]] of %0 : $*Pack{repeat each T} as $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: copy_addr [[SRC_ELT_ADDR]] to [init] [[DST_ELT_ADDR]] : $*@pack_element([[UUID]]) each T
|
|
// CHECK-NEXT: pack_element_set [[DST_ELT_ADDR]] : $*@pack_element([[UUID]]) each T into [[INDEX]] of [[PACK]] : $*Pack{Int, repeat each T, String}
|
|
// CHECK-NEXT: [[NEXT_IDX:%.*]] = builtin "add_Word"([[IDX]] : $Builtin.Word, [[ONE]] : $Builtin.Word) : $Builtin.Word
|
|
// CHECK-NEXT: br bb1([[NEXT_IDX]] : $Builtin.Word)
|
|
// CHECK: bb3:
|
|
// String argument.
|
|
// CHECK-NEXT: [[STRING_ADDR:%.*]] = alloc_stack $String
|
|
// CHECK-NEXT: [[STRING_COPY:%.*]] = copy_value %2 : $String
|
|
// CHECK-NEXT: store [[STRING_COPY]] to [init] [[STRING_ADDR]] : $*String
|
|
// CHECK-NEXT: [[STRING_INDEX:%.*]] = scalar_pack_index 2 of $Pack{Int, repeat each T, String}
|
|
// CHECK-NEXT: pack_element_set [[STRING_ADDR]] : $*String into [[STRING_INDEX]] of [[PACK]] : $*Pack{Int, repeat each T, String}
|
|
// CHECK-NEXT: // function_ref
|
|
// CHECK-NEXT: [[FN:%.*]] = function_ref @$s4main14receive_simpleyyxxQpRvzlF
|
|
// CHECK-NEXT: apply [[FN]]<Pack{Int, repeat each T, String}>([[PACK]])
|
|
// CHECK-NEXT: destroy_addr [[STRING_ADDR]] : $*String
|
|
// CHECK-NEXT: dealloc_stack [[STRING_ADDR]] : $*String
|
|
// CHECK-NEXT: destroy_addr [[TUPLE]] : $*(repeat each T)
|
|
// CHECK-NEXT: dealloc_stack [[TUPLE]] : $*(repeat each T)
|
|
// CHECK-NEXT: dealloc_stack [[INT_ADDR]] : $*Int
|
|
// CHECK-NEXT: dealloc_pack [[PACK]] : $*Pack{Int, repeat each T, String}
|
|
// CHECK-NEXT: [[RET:%.*]] = tuple ()
|
|
// CHECK-NEXT: return [[RET]] : $()
|
|
func pack_test2<each T>(args: repeat each T, i: Int, s: String) {
|
|
receive_simple(i, repeat each args, s)
|
|
}
|