| // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -I %S/Inputs/abi %s -emit-ir -enable-large-loadable-types | %FileCheck %s |
| |
| // UNSUPPORTED: resilient_stdlib |
| |
| // REQUIRES: CPU=x86_64 |
| |
| // REQUIRES: OS=macosx |
| |
| sil_stage canonical |
| import c_layout |
| import Builtin |
| import Swift |
| |
| struct BigTempStruct<T> { |
| var i0 : Int32 |
| var i1 : Int32 |
| var i2 : Int32 |
| var i3 : Int32 |
| var i4 : Int32 |
| var i5 : Int32 |
| var i6 : Int32 |
| var i7 : Int32 |
| var i8 : Int32 |
| } |
| |
| public struct BigStruct { |
| var i0 : Int32 = 0 |
| var i1 : Int32 = 1 |
| var i2 : Int32 = 2 |
| var i3 : Int32 = 3 |
| var i4 : Int32 = 4 |
| var i5 : Int32 = 5 |
| var i6 : Int32 = 6 |
| var i7 : Int32 = 7 |
| var i8 : Int32 = 8 |
| } |
| |
| public struct BigBigStruct { |
| var s : BigStruct |
| } |
| |
| // CHECK-LABEL: define{{( protected)?}} swiftcc void @testBitfieldInBlock |
| // CHECK: call void {{%.*}}(%TSC11BitfieldOneV* noalias nocapture sret {{%.*}}, %objc_block* {{%.*}}, %TSC11BitfieldOneV* byval align 8 {{%.*}}) |
| sil @testBitfieldInBlock : $@convention(thin) (@owned @convention(block) (BitfieldOne) -> BitfieldOne, BitfieldOne) -> BitfieldOne { |
| entry(%b : $@convention(block) (BitfieldOne) -> BitfieldOne, %x : $BitfieldOne): |
| %r = apply %b(%x) : $@convention(block) (BitfieldOne) -> BitfieldOne |
| return %r : $BitfieldOne |
| } |
| |
| // CHECK-LABEL: define{{( protected)?}} swiftcc void @testTupleExtract |
| // CHECK: call void {{%.*}}(%TSC11BitfieldOneV* noalias nocapture sret {{%.*}}, %objc_block* {{%.*}}, %TSC11BitfieldOneV* byval align 8 {{%.*}}) |
| sil @testTupleExtract : $@convention(thin) (@owned (BitfieldOne, @convention(block) (BitfieldOne) -> BitfieldOne), BitfieldOne) -> BitfieldOne { |
| entry(%b : $(BitfieldOne, @convention(block) (BitfieldOne) -> (BitfieldOne)), %x : $BitfieldOne): |
| %a = tuple_extract %b : $(BitfieldOne, @convention(block) (BitfieldOne) -> (BitfieldOne)), 1 |
| %r = apply %a(%x) : $@convention(block) (BitfieldOne) -> BitfieldOne |
| return %r : $BitfieldOne |
| } |
| |
| // CHECK-LABEL: define{{( protected)?}} swiftcc void @testBigTempStruct(%T22big_types_corner_cases13BigTempStructV* noalias nocapture sret, %swift.bridge*, %swift.type* %Element) #0 { |
| // CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases13BigTempStructV |
| // CHECK: call swiftcc void @testBigTempStruct(%T22big_types_corner_cases13BigTempStructV* noalias nocapture sret [[ALLOC]], %swift.bridge* %1, %swift.type* %Element) |
| // CHECK: ret void |
| sil @testBigTempStruct : $@convention(method) <Element> (@guaranteed _ArrayBuffer<Element>) -> @owned BigTempStruct<Element> { |
| bb0(%0 : $_ArrayBuffer<Element>): |
| // function_ref specialized _ArrayBuffer.subscript.getter |
| %4 = function_ref @testBigTempStruct : $@convention(method) <τ_0_0> (@guaranteed _ArrayBuffer<τ_0_0>) -> @owned BigTempStruct<τ_0_0> |
| %9 = apply %4<Element>(%0) : $@convention(method) <τ_0_0> (@guaranteed _ArrayBuffer<τ_0_0>) -> @owned BigTempStruct<τ_0_0> |
| return %9 : $BigTempStruct<Element> |
| } |
| |
| // CHECK-LABEL: define{{( protected)?}} swiftcc void @testTryApply(%T22big_types_corner_cases9BigStructV* noalias nocapture sret, i8*, %swift.refcounted*, %swift.refcounted* swiftself, %swift.error** swifterror) #0 { |
| // CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases9BigStructV |
| // CHECK: call swiftcc void {{.*}}(%T22big_types_corner_cases9BigStructV* noalias nocapture sret [[ALLOC]] |
| // CHECK: ret void |
| sil @testTryApply : $@convention(thin)(() -> (@owned BigStruct, @error Error)) -> (@owned BigStruct, @error Error) { |
| bb0(%0 : $() -> (@owned BigStruct, @error Error)): |
| try_apply %0() : $() -> (@owned BigStruct, @error Error), normal bb1, error bb2 |
| |
| bb1(%ret : $BigStruct): |
| %s = struct $BigBigStruct (%ret : $BigStruct) |
| return %ret : $BigStruct |
| |
| bb2(%err : $Error): |
| throw %err : $Error |
| } |
| |
| // CHECK-LABEL: define{{( protected)?}} swiftcc i8* @testThinFuncPointer(%swift.type* %"BigTempStruct<Element>", %T22big_types_corner_cases13BigTempStructV* noalias nocapture swiftself dereferenceable({{.*}}) #0 { |
| // CHECK-NEXT: entry |
| // CHECK-NEXT: ret i8* bitcast (i8* (%swift.type*, %T22big_types_corner_cases13BigTempStructV*)* @testThinFuncPointer to i8*) |
| sil @testThinFuncPointer : $@convention(method) <Element> (@guaranteed BigTempStruct<Element>) -> @owned Builtin.RawPointer { |
| bb0(%0 : $BigTempStruct<Element>): |
| // function_ref specialized BigTempStruct.subscript.getter |
| %fref = function_ref @testThinFuncPointer : $@convention(method) <τ_0_0> (@guaranteed BigTempStruct<τ_0_0>) -> @owned Builtin.RawPointer |
| %ret = thin_function_to_pointer %fref : $@convention(method) <τ_0_0> (@guaranteed BigTempStruct<τ_0_0>) -> @owned Builtin.RawPointer to $Builtin.RawPointer |
| return %ret : $Builtin.RawPointer |
| } |
| |
| // CHECK-LABEL: define{{( protected)?}} swiftcc void @testFuncWithModBlockStorageApply({ %objc_block, %swift.function }* nocapture dereferenceable({{.*}}), %T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) #0 { |
| // CHECK: call swiftcc void {{.*}}(%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) %1 |
| // CHECK: ret void |
| sil @testFuncWithModBlockStorageApply : $@convention(thin) (@inout_aliasable @block_storage @callee_owned (@owned BigStruct) -> (), BigStruct) -> () { |
| // %0 // user: %5 |
| // %1 // users: %12, %13, %7 |
| // %2 // user: %20 |
| // %3 // user: %20 |
| // %4 // user: %20 |
| bb0(%0 : $*@block_storage @callee_owned (@owned BigStruct) -> (), %1 : $BigStruct): |
| %proji = project_block_storage %0 : $*@block_storage @callee_owned (@owned BigStruct) -> () // user: %6 |
| %ldi = load %proji : $*@callee_owned (@owned BigStruct) -> () // users: %11, %17, %20 |
| %appi = apply %ldi(%1) : $@callee_owned (@owned BigStruct) -> () |
| %ret = tuple () // user: %22 |
| return %ret : $() // id: %22 |
| } |