mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +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.
233 lines
7.2 KiB
Plaintext
233 lines
7.2 KiB
Plaintext
// RUN: %target-sil-opt -sil-print-types -enable-sil-verify-all %s -jumpthread-simplify-cfg | %FileCheck %s
|
|
|
|
sil_stage canonical
|
|
|
|
import Builtin
|
|
import Swift
|
|
import SwiftShims
|
|
|
|
// CHECK-LABEL: sil @test_jump_threading
|
|
// CHECK: bb5(%{{[0-9]+}} : $Builtin.Int64):
|
|
// CHECK-NEXT: br bb1
|
|
sil @test_jump_threading : $@convention(thin) (Builtin.Int1) -> () {
|
|
bb0(%0 : $Builtin.Int1):
|
|
cond_br %0, bb2, bb3
|
|
|
|
// Blocks are handled from last to first. Block bb1 is placed here so that its argument
|
|
// is not optimized before jump threading is done in bb2 and bb3.
|
|
bb1(%i4 : $Builtin.Int64):
|
|
%f3 = function_ref @get_condition : $@convention(thin) (Builtin.Int64) -> Builtin.Int1
|
|
%c1 = apply %f3(%i3) : $@convention(thin) (Builtin.Int64) -> Builtin.Int1
|
|
%i5 = integer_literal $Builtin.Int64, 27
|
|
cond_br %c1, bb1(%i5 : $Builtin.Int64), bb5
|
|
|
|
bb2:
|
|
%f1 = function_ref @get_int1 : $@convention(thin) () -> Builtin.Int64
|
|
%i1 = apply %f1() : $@convention(thin) () -> Builtin.Int64
|
|
br bb4(%i1 : $Builtin.Int64)
|
|
|
|
bb3:
|
|
%f2 = function_ref @get_int1 : $@convention(thin) () -> Builtin.Int64
|
|
%i2 = apply %f2() : $@convention(thin) () -> Builtin.Int64
|
|
br bb4(%i2 : $Builtin.Int64)
|
|
|
|
// Jump threading must not be done for this block because the argument %i3 is also
|
|
// used in bb1.
|
|
bb4(%i3 : $Builtin.Int64):
|
|
br bb1(%i3 : $Builtin.Int64)
|
|
|
|
bb5:
|
|
%r1 = tuple ()
|
|
return %r1 : $()
|
|
|
|
}
|
|
|
|
sil @get_int1 : $@convention(thin) () -> Builtin.Int64
|
|
sil @get_int2 : $@convention(thin) () -> Builtin.Int64
|
|
sil @get_condition : $@convention(thin) (Builtin.Int64) -> Builtin.Int1
|
|
|
|
|
|
public final class AA {
|
|
}
|
|
public final class BB {
|
|
@_hasStorage internal weak final var n: BB!
|
|
@_hasStorage internal final var o: AA!
|
|
}
|
|
|
|
// Test that SimplifyCFG does not hang when compiling an infinite loop with switch_enum.
|
|
// CHECK-LABEL: test_infinite_loop
|
|
sil hidden @test_infinite_loop : $@convention(method) (@owned BB) -> () {
|
|
bb0(%0 : $BB):
|
|
%31 = enum $Optional<BB>, #Optional.some!enumelt, %0 : $BB
|
|
br bb4(%31 : $Optional<BB>)
|
|
|
|
bb4(%36 : $Optional<BB>):
|
|
switch_enum %36 : $Optional<BB>, case #Optional.some!enumelt: bb6, default bb5
|
|
|
|
bb5:
|
|
br bb7
|
|
|
|
bb6:
|
|
%39 = unchecked_enum_data %36 : $Optional<BB>, #Optional.some!enumelt
|
|
%40 = ref_element_addr %39 : $BB, #BB.o
|
|
%41 = load %40 : $*Optional<AA>
|
|
release_value %41 : $Optional<AA>
|
|
br bb7
|
|
|
|
bb7:
|
|
switch_enum %36 : $Optional<BB>, case #Optional.none!enumelt: bb8, case #Optional.some!enumelt: bb9
|
|
|
|
bb8:
|
|
br bb4(%36 : $Optional<BB>)
|
|
|
|
bb9:
|
|
%48 = unchecked_enum_data %36 : $Optional<BB>, #Optional.some!enumelt
|
|
%49 = ref_element_addr %48 : $BB, #BB.n
|
|
%50 = load_weak %49 : $*@sil_weak Optional<BB>
|
|
release_value %36 : $Optional<BB>
|
|
switch_enum %50 : $Optional<BB>, case #Optional.some!enumelt: bb11, case #Optional.none!enumelt: bb10
|
|
|
|
bb10:
|
|
br bb4(%50 : $Optional<BB>)
|
|
|
|
bb11:
|
|
%54 = unchecked_enum_data %50 : $Optional<BB>, #Optional.some!enumelt
|
|
%55 = ref_to_raw_pointer %54 : $BB to $Builtin.RawPointer
|
|
%56 = ref_to_raw_pointer %0 : $BB to $Builtin.RawPointer
|
|
%57 = builtin "cmp_eq_RawPointer"(%55 : $Builtin.RawPointer, %56 : $Builtin.RawPointer) : $Builtin.Int1
|
|
cond_br %57, bb13, bb12
|
|
|
|
bb12:
|
|
br bb4(%50 : $Optional<BB>)
|
|
|
|
bb13:
|
|
release_value %50 : $Optional<BB>
|
|
strong_release %0 : $BB
|
|
%65 = tuple ()
|
|
return %65 : $()
|
|
}
|
|
|
|
sil @some_function : $@convention(thin) (AA) -> Optional<AA>
|
|
|
|
// Another test for checking that SimplifyCFG does not hang.
|
|
// CHECK-LABEL: test_other_infinite_loop
|
|
sil hidden @test_other_infinite_loop : $@convention(method) (@owned AA) -> () {
|
|
bb0(%5 : $AA):
|
|
strong_retain %5 : $AA
|
|
%6 = enum $Optional<AA>, #Optional.some!enumelt, %5 : $AA
|
|
br bb1(%6 : $Optional<AA>)
|
|
|
|
bb1(%8 : $Optional<AA>):
|
|
retain_value %8 : $Optional<AA>
|
|
switch_enum %8 : $Optional<AA>, case #Optional.some!enumelt: bb3, default bb2
|
|
|
|
bb2:
|
|
release_value %8 : $Optional<AA>
|
|
br bb6
|
|
|
|
bb3:
|
|
cond_br undef, bb4, bb5
|
|
|
|
bb4:
|
|
%85 = tuple ()
|
|
return %85 : $()
|
|
|
|
bb5:
|
|
br bb6
|
|
|
|
bb6:
|
|
switch_enum %8 : $Optional<AA>, case #Optional.none!enumelt: bb7, default bb8
|
|
|
|
bb7:
|
|
br bb9(%8 : $Optional<AA>)
|
|
|
|
bb8:
|
|
%23 = unchecked_enum_data %8 : $Optional<AA>, #Optional.some!enumelt
|
|
strong_retain %23 : $AA
|
|
%25 = function_ref @some_function : $@convention(thin) (AA) -> Optional<AA>
|
|
%26 = apply %25(%23) : $@convention(thin) (AA) -> Optional<AA>
|
|
strong_release %23 : $AA
|
|
br bb9(%26 : $Optional<AA>)
|
|
|
|
bb9(%29 : $Optional<AA>):
|
|
release_value %8 : $Optional<AA>
|
|
br bb1(%29 : $Optional<AA>)
|
|
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Test jump-threading through a non-pure address producer.
|
|
//
|
|
// BB3 cannot (currently) be cloned because the block cloner does not
|
|
// know how to sink address producers unless they are pure address
|
|
// projections. init_existential_addr is not a pure projection. It's
|
|
// address is transitively used outside bb3 via %17 =
|
|
// tuple_element_addr. Test that cloning is inhibited. If cloning did
|
|
// happen, then it would either need to sink init_existential_addr, or
|
|
// SSA would be incorrectly updated.
|
|
|
|
enum FakeOptional<T> {
|
|
case some(T)
|
|
case none
|
|
}
|
|
|
|
struct S {
|
|
}
|
|
|
|
struct T {
|
|
let s: S
|
|
}
|
|
|
|
class C {
|
|
func method() -> Any
|
|
func f() -> FakeOptional<T>
|
|
}
|
|
|
|
// Make BB3 is not jump-threaded. And init_existential_addr is not cloned
|
|
//
|
|
// CHECK-LABEL: sil hidden @nonPureAddressProducer : $@convention(method) (@guaranteed C) -> @out Any {
|
|
// CHECK: bb0(%0 : $*Any, %1 : $C):
|
|
// CHECK: switch_enum %{{.*}} : $FakeOptional<T>, case #FakeOptional.some!enumelt: bb1, case #FakeOptional.none!enumelt: bb2
|
|
// CHECK: bb3(%{{.*}} : $FakeOptional<Int64>):
|
|
// CHECK: init_existential_addr %0 : $*Any, $(FakeOptional<Int64>, FakeOptional<S>)
|
|
// CHECK: switch_enum %{{.*}} : $FakeOptional<T>, case #FakeOptional.some!enumelt: bb4, case #FakeOptional.none!enumelt: bb6
|
|
// CHECK-LABEL: } // end sil function 'nonPureAddressProducer'
|
|
sil hidden @nonPureAddressProducer : $@convention(method) (@guaranteed C) -> @out Any {
|
|
bb0(%0 : $*Any, %1 : $C):
|
|
%3 = class_method %1 : $C, #C.f : (C) -> () -> FakeOptional<T>, $@convention(method) (@guaranteed C) -> FakeOptional<T>
|
|
%4 = apply %3(%1) : $@convention(method) (@guaranteed C) -> FakeOptional<T>
|
|
switch_enum %4 : $FakeOptional<T>, case #FakeOptional.some!enumelt: bb1, case #FakeOptional.none!enumelt: bb2
|
|
|
|
bb1:
|
|
%7 = integer_literal $Builtin.Int64, 1
|
|
%8 = struct $Int64 (%7 : $Builtin.Int64)
|
|
%9 = enum $FakeOptional<Int64>, #FakeOptional.some!enumelt, %8 : $Int64
|
|
br bb3(%9 : $FakeOptional<Int64>)
|
|
|
|
bb2:
|
|
%11 = enum $FakeOptional<Int64>, #FakeOptional.none!enumelt
|
|
br bb3(%11 : $FakeOptional<Int64>)
|
|
|
|
bb3(%13 : $FakeOptional<Int64>):
|
|
%15 = init_existential_addr %0 : $*Any, $(FakeOptional<Int64>, FakeOptional<S>)
|
|
%16 = tuple_element_addr %15 : $*(FakeOptional<Int64>, FakeOptional<S>), 0
|
|
%17 = tuple_element_addr %15 : $*(FakeOptional<Int64>, FakeOptional<S>), 1
|
|
store %13 to %16 : $*FakeOptional<Int64>
|
|
switch_enum %4 : $FakeOptional<T>, case #FakeOptional.some!enumelt: bb4, case #FakeOptional.none!enumelt: bb6
|
|
|
|
bb4(%20 : $T):
|
|
%21 = struct_extract %20 : $T, #T.s
|
|
%22 = enum $FakeOptional<S>, #FakeOptional.some!enumelt, %21 : $S
|
|
store %22 to %17 : $*FakeOptional<S>
|
|
br bb5
|
|
|
|
bb5:
|
|
%25 = tuple ()
|
|
return %25 : $()
|
|
|
|
bb6:
|
|
%27 = enum $FakeOptional<S>, #FakeOptional.none!enumelt
|
|
store %27 to %17 : $*FakeOptional<S>
|
|
br bb5
|
|
}
|