| // RUN: %target-sil-opt -enable-sil-ownership -enable-sil-verify-all %s -definite-init | %FileCheck %s |
| |
| // These are all regression tests to ensure that the memory promotion pass |
| // doesn't crash. |
| |
| import Builtin |
| |
| struct Int { |
| var _value: Builtin.Int64 |
| } |
| |
| // Mixed combination of aggregate load/stores and elements. |
| struct Triple { |
| var a, b, c : Int |
| } |
| |
| // CHECK-LABEL: sil @TripleTest |
| sil @TripleTest : $@convention(method) (Int, @inout Triple) -> Triple { |
| bb0(%0 : @trivial $Int, %1 : @trivial $*Triple): |
| %4 = alloc_box $<τ_0_0> { var τ_0_0 } <Triple> |
| %4a = project_box %4 : $<τ_0_0> { var τ_0_0 } <Triple>, 0 |
| %5 = load [trivial] %1 : $*Triple |
| store %5 to [trivial] %4a : $*Triple |
| %8 = struct_element_addr %4a : $*Triple, #Triple.b |
| store %0 to [trivial] %8 : $*Int |
| %10 = load [trivial] %4a : $*Triple |
| destroy_value %4 : $<τ_0_0> { var τ_0_0 } <Triple> |
| return %10 : $Triple |
| } |
| |
| |
| struct Single { |
| var a : Int |
| } |
| |
| // CHECK-LABEL: sil @SingleTest |
| sil @SingleTest : $@convention(method) (@inout Single, Int) -> Single { |
| bb0(%0 : @trivial $*Single, %1 : @trivial $Int): |
| %4 = alloc_box $<τ_0_0> { var τ_0_0 } <Single> |
| %4a = project_box %4 : $<τ_0_0> { var τ_0_0 } <Single>, 0 |
| %5 = load [trivial] %0 : $*Single |
| store %5 to [trivial] %4a : $*Single |
| |
| %8 = struct_element_addr %4a : $*Single, #Single.a |
| store %1 to [trivial] %8 : $*Int |
| |
| %10 = load [trivial] %4a : $*Single |
| destroy_value %4 : $<τ_0_0> { var τ_0_0 } <Single> |
| return %10 : $Single |
| } |
| |
| class SomeClass {} |
| |
| enum SomeUnion { |
| case x(Int) |
| case y(SomeClass) |
| } |
| |
| sil @getSomeClass : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass |
| sil @getSomeUnion : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion |
| |
| |
| // CHECK-LABEL: sil @test_union_release |
| sil @test_union_release : $@convention(thin) () -> () { |
| bb0: |
| %1 = alloc_box $<τ_0_0> { var τ_0_0 } <SomeUnion> |
| %1a = project_box %1 : $<τ_0_0> { var τ_0_0 } <SomeUnion>, 0 |
| %2 = function_ref @getSomeUnion : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion |
| %3 = metatype $@thin SomeUnion.Type |
| %4 = function_ref @getSomeClass : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass |
| %5 = metatype $@thick SomeClass.Type |
| %6 = apply %4(%5) : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass |
| %7 = apply %2(%6, %3) : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion |
| assign %7 to %1a : $*SomeUnion |
| destroy_value %1 : $<τ_0_0> { var τ_0_0 } <SomeUnion> |
| %10 = tuple () |
| return %10 : $() |
| } |
| |
| public protocol Proto { |
| } |
| |
| protocol Error {} |
| |
| public struct MyErrorType : Error {} |
| |
| public struct NonTrivial { |
| @sil_stored let ptr: Builtin.NativeObject |
| } |
| |
| public struct AStruct { |
| @sil_stored public let name: NonTrivial |
| @sil_stored public let foobar: NonTrivial |
| @sil_stored public let protoType: Proto.Type |
| } |
| |
| sil @mayThrow : $@convention(thin) () -> (@owned NonTrivial, @error Error) |
| |
| // CHECK-LABEL: sil @assign_of_non_primitive_object_element_type |
| sil @assign_of_non_primitive_object_element_type : $@convention(thin) (@thick Proto.Type) -> (@owned AStruct, @error Error) { |
| bb0(%0 : @trivial $@thick Proto.Type): |
| %3 = alloc_stack $AStruct |
| %4 = mark_uninitialized [rootself] %3 : $*AStruct |
| %7 = function_ref @mayThrow : $@convention(thin) () -> (@owned NonTrivial, @error Error) |
| try_apply %7() : $@convention(thin) () -> (@owned NonTrivial, @error Error), normal bb1, error bb3 |
| |
| bb1(%15 : @owned $NonTrivial): |
| %16 = struct_element_addr %4 : $*AStruct, #AStruct.foobar |
| assign %15 to %16 : $*NonTrivial |
| try_apply %7() : $@convention(thin) () -> (@owned NonTrivial, @error Error), normal bb2, error bb4 |
| |
| bb2(%26 : @owned $NonTrivial): |
| %27 = struct_element_addr %4 : $*AStruct, #AStruct.name |
| assign %26 to %27 : $*NonTrivial |
| %29 = struct_element_addr %4 : $*AStruct, #AStruct.protoType |
| assign %0 to %29 : $*@thick Proto.Type |
| %31 = load [copy] %4 : $*AStruct |
| destroy_addr %4 : $*AStruct |
| dealloc_stack %3 : $*AStruct |
| return %31 : $AStruct |
| |
| bb3(%36 : @owned $Error): |
| br bb5(%36 : $Error) |
| |
| bb4(%38 : @owned $Error): |
| br bb5(%38 : $Error) |
| |
| bb5(%40 : @owned $Error): |
| destroy_addr %4 : $*AStruct |
| dealloc_stack %3 : $*AStruct |
| throw %40 : $Error |
| } |
| |