averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update more IRGen tests for opaque pointers

Browse Source
This commit is contained in:
Dario Rexin
2023-06-07 16:51:21 -07:00
committed by Arnold Schwaighofer
parent 1adf2aeb87
commit 90c11024a4
13 changed files with 536 additions and 721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
test/IRGen/eager-class-initialization-stable-abi.swift
View File

@@ -1,7 +1,6 @@
// RUN: %empty-directory(%t)
// RUN: %build-irgen-test-overlays
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %use_no_opaque_pointers %S/eager-class-initialization.swift -target %target-stable-abi-triple -emit-ir | %FileCheck %S/eager-class-initialization.swift -DINT=i%target-ptrsize --check-prefix=CHECK
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %S/eager-class-initialization.swift -target %target-stable-abi-triple -emit-ir
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %S/eager-class-initialization.swift -target %target-stable-abi-triple -emit-ir | %FileCheck %S/eager-class-initialization.swift -DINT=i%target-ptrsize --check-prefix=CHECK
// REQUIRES: objc_interop
// REQUIRES: swift_stable_abi

7
test/IRGen/eager-class-initialization.swift
View File

@@ -1,7 +1,6 @@
// RUN: %empty-directory(%t)
// RUN: %build-irgen-test-overlays
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %use_no_opaque_pointers %s -emit-ir -target %target-pre-stable-abi-triple | %FileCheck %s -DINT=i%target-ptrsize --check-prefix=CHECK --check-prefix=CHECK-OLD
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -emit-ir -target %target-pre-stable-abi-triple
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -emit-ir -target %target-pre-stable-abi-triple | %FileCheck %s -DINT=i%target-ptrsize --check-prefix=CHECK --check-prefix=CHECK-OLD
// REQUIRES: objc_interop
// UNSUPPORTED: swift_only_stable_abi
@@ -28,8 +27,8 @@ class GenericAncestryWithCustomName : Generic<Double> {}
// CHECK-NEXT: entry:
// CHECK-OLD-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s4main15GenericAncestryCMa"([[INT]] 0)
// CHECK-OLD-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0
// CHECK-OLD-NEXT: call void asm sideeffect "", "r"(%swift.type* [[METADATA]])
// CHECK-OLD-NEXT: call void asm sideeffect "", "r"(ptr [[METADATA]])
// CHECK-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s4main29GenericAncestryWithCustomNameCMa"([[INT]] 0)
// CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0
// CHECK-NEXT: call void asm sideeffect "", "r"(%swift.type* [[METADATA]])
// CHECK-NEXT: call void asm sideeffect "", "r"(ptr [[METADATA]])
// CHECK-NEXT: ret

3
test/IRGen/enum_32_bit.sil
View File

@@ -18,7 +18,6 @@ sil_vtable C {}
sil @$s11enum_32_bit1CCfD : $@convention(thin) (@owned C) -> ()
// CHECK-LABEL: %T11enum_32_bit3FooO = type <{ [4 x i8] }>
enum Foo {
case A(C)
case B
@@ -26,13 +25,11 @@ enum Foo {
@objc protocol ClassExistential {}
// CHECK-LABEL: %T11enum_32_bit3BarO = type <{ [4 x i8] }>
enum Bar {
case A(ClassExistential)
case B
}
// CHECK-LABEL: %T11enum_32_bit3BasO = type <{ [4 x i8] }>
enum Bas {
case A(ClassExistential)
case B(C)

100
test/IRGen/enum_dynamic_multi_payload.sil
View File

@@ -1,5 +1,4 @@
// RUN: %target-swift-frontend %use_no_opaque_pointers -disable-type-layout %s -gnone -emit-ir -I %S/Inputs | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize -DINT=i%target-ptrsize
// RUN: %target-swift-frontend -disable-type-layout %s -gnone -emit-ir -I %S/Inputs
// RUN: %target-swift-frontend -disable-type-layout %s -gnone -emit-ir -I %S/Inputs | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize -DINT=i%target-ptrsize
import Builtin
@@ -42,27 +41,24 @@ entry(%e : $Either<(), ()>):
// CHECK-NEXT: alloca
// CHECK-NEXT: trunc i8 {{.*}} to i1
// CHECK-NEXT: bitcast
// CHECK-NEXT: llvm.lifetime.start
%s = alloc_stack $Either<(), ()>
%l = enum $Either<(), ()>, #Either.Left!enumelt, undef : $()
// CHECK-NEXT: bitcast {{.*}} to i1*
// CHECK-NEXT: store i1 false
store %l to %s : $*Either<(), ()>
%r = enum $Either<(), ()>, #Either.Right!enumelt, undef : $()
// CHECK-NEXT: bitcast {{.*}} to i1*
// CHECK-NEXT: store i1 true
store %r to %s : $*Either<(), ()>
%a = unchecked_enum_data %l : $Either<(), ()>, #Either.Left!enumelt
%b = unchecked_enum_data %r : $Either<(), ()>, #Either.Right!enumelt
// CHECK-NEXT: br i1 {{%.*}}, label %7, label %6
// CHECK: 6:
// CHECK: br label %8
// CHECK: 7:
// CHECK: br label %9
// CHECK-NEXT: br i1 {{%.*}}, label %[[RIGHT_PRE:[0-9]+]], label %[[LEFT_PRE:[0-9]+]]
// CHECK: [[LEFT_PRE]]:
// CHECK: br label [[LEFT:%[0-9]+]]
// CHECK: [[RIGHT_PRE]]:
// CHECK: br label [[RIGHT:%[0-9]+]]
switch_enum %e : $Either<(), ()>,
case #Either.Left!enumelt: left,
case #Either.Right!enumelt: right
@@ -75,7 +71,7 @@ right(%y : $()):
%1 = integer_literal $Builtin.Int8, 1
br next(%1 : $Builtin.Int8)
// CHECK: phi i8 [ 1, %9 ], [ 0, %8 ]
// CHECK: phi i8 [ 1, [[RIGHT]] ], [ 0, [[LEFT]] ]
next(%z : $Builtin.Int8):
dealloc_stack %s : $*Either<(), ()>
return undef : $()
@@ -91,23 +87,18 @@ entry(%e : $EitherOr<(), ()>):
fix_lifetime %e : $EitherOr<(), ()>
// CHECK-NEXT: alloca
// CHECK-NEXT: bitcast
// CHECK-NEXT: llvm.lifetime.start
%s = alloc_stack $EitherOr<(), ()>
// CHECK-NEXT: bitcast {{.*}} to i8*
// CHECK-NEXT: store i8 0
%l = enum $EitherOr<(), ()>, #EitherOr.Left!enumelt, undef : $()
store %l to %s : $*EitherOr<(), ()>
// CHECK-NEXT: bitcast {{.*}} to i8*
// CHECK-NEXT: store i8 1
%r = enum $EitherOr<(), ()>, #EitherOr.Right!enumelt, undef : $()
store %r to %s : $*EitherOr<(), ()>
// CHECK-NEXT: bitcast {{.*}} to i8*
// CHECK-NEXT: store i8 2
%m = enum $EitherOr<(), ()>, #EitherOr.Middle!enumelt
store %m to %s : $*EitherOr<(), ()>
// CHECK-NEXT: bitcast {{.*}} to i8*
// CHECK-NEXT: store i8 3
%k = enum $EitherOr<(), ()>, #EitherOr.Center!enumelt
store %k to %s : $*EitherOr<(), ()>
@@ -265,36 +256,33 @@ entry:
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_inject
// CHECK: ([[EITHER_OR:%swift.opaque]]* noalias nocapture sret({{.*}}) %0, %swift.type* %T)
// CHECK: (ptr noalias nocapture sret({{.*}}) %0, ptr %T)
sil @dynamic_inject : $@convention(thin) <T> () -> @out EitherOr<T, Builtin.Int64> {
entry(%e : $*EitherOr<T, Builtin.Int64>):
// CHECK: call void @swift_storeEnumTagMultiPayload(%swift.opaque* {{%.*}}, %swift.type* [[TYPE:%.*]], i32 0)
// CHECK: call void @swift_storeEnumTagMultiPayload(ptr {{%.*}}, ptr [[TYPE:%.*]], i32 0)
inject_enum_addr %e : $*EitherOr<T, Builtin.Int64>, #EitherOr.Left!enumelt
// CHECK: call void @swift_storeEnumTagMultiPayload(%swift.opaque* {{%.*}}, %swift.type* [[TYPE]], i32 2)
// CHECK: call void @swift_storeEnumTagMultiPayload(ptr {{%.*}}, ptr [[TYPE]], i32 2)
inject_enum_addr %e : $*EitherOr<T, Builtin.Int64>, #EitherOr.Middle!enumelt
// CHECK: call void @swift_storeEnumTagMultiPayload(%swift.opaque* {{%.*}}, %swift.type* [[TYPE]], i32 3)
// CHECK: call void @swift_storeEnumTagMultiPayload(ptr {{%.*}}, ptr [[TYPE]], i32 3)
inject_enum_addr %e : $*EitherOr<T, Builtin.Int64>, #EitherOr.Center!enumelt
// CHECK: call void @swift_storeEnumTagMultiPayload(%swift.opaque* {{%.*}}, %swift.type* [[TYPE]], i32 1)
// CHECK: call void @swift_storeEnumTagMultiPayload(ptr {{%.*}}, ptr [[TYPE]], i32 1)
inject_enum_addr %e : $*EitherOr<T, Builtin.Int64>, #EitherOr.Right!enumelt
return undef : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_project
// CHECK: ([[EITHER_OR]]* noalias nocapture sret({{.*}}) %0, %swift.type* %T)
// CHECK: (ptr noalias nocapture sret({{.*}}) %0, ptr %T)
sil @dynamic_project : $@convention(thin) <T> () -> @out EitherOr<T, Builtin.Int64> {
entry(%e : $*EitherOr<T, Builtin.Int64>):
// CHECK: [[ARG:%.*]] = bitcast %swift.opaque* %0 to %T26enum_dynamic_multi_payload8EitherOrO.0
// CHECK: bitcast %T26enum_dynamic_multi_payload8EitherOrO.0* [[ARG]] to %swift.opaque*
%l = unchecked_take_enum_data_addr %e : $*EitherOr<T, Builtin.Int64>, #EitherOr.Left!enumelt
// CHECK: bitcast %T26enum_dynamic_multi_payload8EitherOrO.0* [[ARG]] to i64*
%r = unchecked_take_enum_data_addr %e : $*EitherOr<T, Builtin.Int64>, #EitherOr.Right!enumelt
return undef : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_switch
// CHECK: ([[EITHER_OR]]* noalias nocapture sret({{.*}}) %0, %swift.type* %T)
// CHECK: (ptr noalias nocapture sret({{.*}}) %0, ptr %T)
sil @dynamic_switch : $@convention(thin) <T> () -> @out EitherOr<T, Builtin.Int64> {
entry(%e : $*EitherOr<T, Builtin.Int64>):
// CHECK: [[TAG:%.*]] = call i32 @swift_getEnumCaseMultiPayload
@@ -335,7 +323,7 @@ next(%x : $Builtin.Int8):
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_value_semantics
// CHECK: ([[EITHER_OR]]* noalias nocapture sret({{.*}}) %0, %T26enum_dynamic_multi_payload8EitherOrO.0* noalias nocapture %1, %swift.type* %T)
// CHECK: (ptr noalias nocapture sret({{.*}}) %0, ptr noalias nocapture %1, ptr %T)
sil @dynamic_value_semantics : $@convention(thin) <T> (@in EitherOr<T, Builtin.Int64>) -> @out EitherOr<T, Builtin.Int64> {
entry(%a : $*EitherOr<T, Builtin.Int64>, %b : $*EitherOr<T, Builtin.Int64>):
// CHECK: [[TAG:%.*]] = call i32 @swift_getEnumCaseMultiPayload
@@ -343,7 +331,9 @@ entry(%a : $*EitherOr<T, Builtin.Int64>, %b : $*EitherOr<T, Builtin.Int64>):
// CHECK: [[COND:%.*]] = icmp ne i32 [[TAG]], 0
// CHECK-NEXT: br i1 [[COND]], label %[[NOOP:[0-9]+]], label %[[LEFT:[0-9]+]]
// CHECK: [[LEFT]]:
// CHECK: call void %destroy(%swift.opaque* noalias {{%.*}}, %swift.type* %T)
// CHECK: [[DESTROYADDR:%[0-9]+]] = getelementptr inbounds ptr, ptr %T.valueWitnesses, i32 1
// CHECK: [[DESTROY:%[0-9]+]] = load ptr, ptr [[DESTROYADDR]]
// CHECK: call void [[DESTROY]](ptr noalias {{%[0-9]+}}, ptr %T)
// CHECK: br label %[[NOOP]]
// CHECK: [[NOOP]]:
destroy_addr %a : $*EitherOr<T, Builtin.Int64>
@@ -353,7 +343,9 @@ entry(%a : $*EitherOr<T, Builtin.Int64>, %b : $*EitherOr<T, Builtin.Int64>):
// CHECK: [[COND:%.*]] = icmp ne i32 [[TAG]], 0
// CHECK-NEXT: br i1 [[COND]], label %[[TRIVIAL:[0-9]+]], label %[[LEFT:[0-9]+]]
// CHECK: [[LEFT]]:
// CHECK: call %swift.opaque* %initializeWithTake(%swift.opaque* noalias {{%.*}}, %swift.type* %T)
// CHECK: [[INITWITHTAKEADDR:%[0-9]+]] = getelementptr inbounds ptr, ptr %T.valueWitnesses, i32 4
// CHECK: [[INITWITHTAKE:%[0-9]+]] = load ptr, ptr [[INITWITHTAKEADDR]]
// CHECK: {{%[0-9]+}} = call ptr [[INITWITHTAKE]](ptr noalias {{%[0-9]+}}, ptr noalias {{%[0-9]+}}, ptr %T)
// CHECK: br label %[[DONE:[0-9]+]]
// CHECK: [[TRIVIAL]]:
// CHECK: call void @llvm.memcpy
@@ -369,7 +361,7 @@ entry(%a : $*EitherOr<T, Builtin.Int64>, %b : $*EitherOr<T, Builtin.Int64>):
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @dynamic_value_semantics2
// CHECK: (%swift.opaque* noalias nocapture sret({{.*}}) %0, %T26enum_dynamic_multi_payload8EitherOrO.1* noalias nocapture %1, %swift.type* %T)
// CHECK: (ptr noalias nocapture sret({{.*}}) %0, ptr noalias nocapture %1, ptr %T)
sil @dynamic_value_semantics2 : $@convention(thin) <T> (@in EitherOr<T, C>) -> @out EitherOr<T, C> {
entry(%a : $*EitherOr<T, C>, %b : $*EitherOr<T, C>):
// CHECK: [[TAG:%.*]] = call i32 @swift_getEnumCaseMultiPayload
@@ -378,10 +370,12 @@ entry(%a : $*EitherOr<T, C>, %b : $*EitherOr<T, C>):
// CHECK-NEXT: i32 1, label %[[RIGHT:[0-9]+]]
// CHECK-NEXT: ]
// CHECK: [[LEFT]]:
// CHECK: call void %destroy(%swift.opaque* noalias {{%.*}}, %swift.type* %T)
// CHECK: [[DESTROYADDR:%[0-9]+]] = getelementptr inbounds ptr, ptr %T.valueWitnesses, i32 1
// CHECK: [[DESTROY:%[0-9]+]] = load ptr, ptr [[DESTROYADDR]]
// CHECK: call void [[DESTROY]](ptr noalias {{%[0-9]+}}, ptr %T)
// CHECK: br label %[[NOOP]]
// CHECK: [[RIGHT]]:
// CHECK: call void {{.*}} @swift_release
// CHECK: call void @swift_release
// CHECK: [[NOOP]]:
destroy_addr %a : $*EitherOr<T, C>
@@ -390,7 +384,9 @@ entry(%a : $*EitherOr<T, C>, %b : $*EitherOr<T, C>):
// CHECK: [[COND:%.*]] = icmp ne i32 [[TAG]], 0
// CHECK-NEXT: br i1 [[COND]], label %[[TRIVIAL:[0-9]+]], label %[[LEFT:[0-9]+]]
// CHECK: [[LEFT]]:
// CHECK: call %swift.opaque* %initializeWithTake(%swift.opaque* noalias {{%.*}}, %swift.type* %T)
// CHECK: [[INITWITHTAKEADDR:%[0-9]+]] = getelementptr inbounds ptr, ptr %T.valueWitnesses, i32 4
// CHECK: [[INITWITHTAKE:%[0-9]+]] = load ptr, ptr [[INITWITHTAKEADDR]]
// CHECK: {{%[0-9]+}} = call ptr [[INITWITHTAKE]](ptr noalias {{%[0-9]+}}, ptr noalias {{%[0-9]+}}, ptr %T)
// CHECK: br label %[[DONE:[0-9]+]]
// CHECK: [[TRIVIAL]]:
// CHECK: call void @llvm.memcpy
@@ -405,10 +401,12 @@ entry(%a : $*EitherOr<T, C>, %b : $*EitherOr<T, C>):
// CHECK-NEXT: i32 1, label %[[RIGHT:[0-9]+]]
// CHECK-NEXT: ]
// CHECK: [[LEFT]]:
// CHECK: call %swift.opaque* %initializeWithCopy(%swift.opaque* noalias {{%.*}}, %swift.type* %T)
// CHECK: [[INITWITHCOPYADDR:%[0-9]+]] = getelementptr inbounds ptr, ptr %T.valueWitnesses, i32 2
// CHECK: [[INITWITHCOPY:%[0-9]+]] = load ptr, ptr [[INITWITHCOPYADDR]]
// CHECK: {{%[0-9]+}} = call ptr [[INITWITHCOPY]](ptr noalias {{%[0-9]+}}, ptr noalias {{%[0-9]+}}, ptr %T)
// CHECK: br label %[[DONE:[0-9]+]]
// CHECK: [[RIGHT]]:
// CHECK: call %swift.refcounted* @swift_retain
// CHECK: call ptr @swift_retain
// CHECK: br label %[[DONE:[0-9]+]]
// CHECK: [[TRIVIAL]]:
// CHECK: call void @llvm.memcpy
@@ -419,35 +417,33 @@ entry(%a : $*EitherOr<T, C>, %b : $*EitherOr<T, C>):
return undef : $()
}
// CHECK: define{{( dllexport)?}}{{( protected)?}} internal %swift.type* @"$s26enum_dynamic_multi_payload8EitherOrOMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) {{.*}} {
// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata
// CHECK: define{{( dllexport)?}}{{( protected)?}} internal ptr @"$s26enum_dynamic_multi_payload8EitherOrOMi"(ptr %0, ptr %1, ptr %2) {{.*}} {
// CHECK: [[METADATA:%.*]] = call ptr @swift_allocateGenericValueMetadata
// CHECK: define{{( protected)?}} internal swiftcc %swift.metadata_response @"$s26enum_dynamic_multi_payload8EitherOrOMr"
// CHECK-SAME: (%swift.type* [[METADATA:%.*]], i8* %0, i8** %1) {{.*}} {
// CHECK-SAME: (ptr [[METADATA:%.*]], ptr %0, ptr %1) {{.*}} {
// CHECK: [[BUF:%.*]] = alloca [2 x i8**]
// CHECK: [[BUF:%.*]] = alloca [2 x ptr]
// CHECK: [[BUF0:%.*]] = getelementptr {{.*}} [[BUF]], i32 0, i32 0
// CHECK: [[T0:%.*]] = call{{( tail)?}} swiftcc %swift.metadata_response @swift_checkMetadataState([[INT]] 319, %swift.type* %T)
// CHECK: [[T0:%.*]] = call{{( tail)?}} swiftcc %swift.metadata_response @swift_checkMetadataState([[INT]] 319, ptr %T)
// CHECK-NEXT: [[T_CHECKED:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: [[T_STATUS:%.*]] = extractvalue %swift.metadata_response [[T0]], 1
// CHECK-NEXT: [[T_OK:%.*]] = icmp ule [[INT]] [[T_STATUS]], 63
// CHECK-NEXT: br i1 [[T_OK]],
// CHECK: [[T0:%.*]] = bitcast %swift.type* [[T_CHECKED]] to i8***
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8**, i8*** [[T0]]
// CHECK-NEXT: [[VALUE_WITNESSES:%.*]] = load i8**, i8*** [[T1]]
// CHECK-NEXT: [[LAYOUT:%.*]] = getelementptr inbounds i8*, i8** [[VALUE_WITNESSES]], i32 8
// CHECK-NEXT: store i8** [[LAYOUT]], {{.*}} [[BUF0]]
// CHECK: [[T1:%.*]] = getelementptr inbounds ptr, ptr [[T_CHECKED]]
// CHECK-NEXT: [[VALUE_WITNESSES:%.*]] = load ptr, ptr [[T1]]
// CHECK-NEXT: [[LAYOUT:%.*]] = getelementptr inbounds ptr, ptr [[VALUE_WITNESSES]], i32 8
// CHECK-NEXT: store ptr [[LAYOUT]], {{.*}} [[BUF0]]
// CHECK: [[BUF1:%.*]] = getelementptr {{.*}} [[BUF]], i32 0, i32 1
// CHECK: [[T0:%.*]] = call{{( tail)?}} swiftcc %swift.metadata_response @swift_checkMetadataState([[INT]] 319, %swift.type* %U)
// CHECK: [[T0:%.*]] = call{{( tail)?}} swiftcc %swift.metadata_response @swift_checkMetadataState([[INT]] 319, ptr %U)
// CHECK-NEXT: [[U_CHECKED:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: [[U_STATUS:%.*]] = extractvalue %swift.metadata_response [[T0]], 1
// CHECK-NEXT: [[U_OK:%.*]] = icmp ule [[INT]] [[U_STATUS]], 63
// CHECK-NEXT: br i1 [[U_OK]],
// CHECK: [[T0:%.*]] = bitcast %swift.type* [[U_CHECKED]] to i8***
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8**, i8*** [[T0]]
// CHECK-NEXT: [[VALUE_WITNESSES:%.*]] = load i8**, i8*** [[T1]]
// CHECK-NEXT: [[LAYOUT:%.*]] = getelementptr inbounds i8*, i8** [[VALUE_WITNESSES]], i32 8
// CHECK-NEXT: store i8** [[LAYOUT]], {{.*}} [[BUF1]]
// CHECK: [[T1:%.*]] = getelementptr inbounds ptr, ptr [[U_CHECKED]]
// CHECK-NEXT: [[VALUE_WITNESSES:%.*]] = load ptr, ptr [[T1]]
// CHECK-NEXT: [[LAYOUT:%.*]] = getelementptr inbounds ptr, ptr [[VALUE_WITNESSES]], i32 8
// CHECK-NEXT: store ptr [[LAYOUT]], {{.*}} [[BUF1]]
// CHECK: call void @swift_initEnumMetadataMultiPayload(%swift.type* [[METADATA]], {{i(32|64)}} 0, {{i(32|64)}} 2, i8*** [[BUF0]])
// CHECK: call void @swift_initEnumMetadataMultiPayload(ptr [[METADATA]], {{i(32|64)}} 0, {{i(32|64)}} 2, ptr [[BUF0]])

239
test/IRGen/enum_resilience.swift
View File

@@ -3,13 +3,10 @@
// RUN: %{python} %utils/chex.py < %s > %t/enum_resilience.swift
// RUN: %target-swift-frontend -emit-module -enable-library-evolution -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -emit-module -enable-library-evolution -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend %use_no_opaque_pointers -disable-type-layout -emit-ir -enable-library-evolution -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift | %FileCheck %t/enum_resilience.swift --check-prefix=ENUM_RES
// RUN: %target-swift-frontend -disable-type-layout -emit-ir -enable-library-evolution -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
// RUN: %target-swift-frontend %use_no_opaque_pointers -disable-type-layout -emit-ir -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift | %FileCheck %t/enum_resilience.swift --check-prefix=ENUM_NOT_RES
// RUN: %target-swift-frontend -disable-type-layout -emit-ir -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
// RUN: %target-swift-frontend -disable-type-layout -emit-ir -enable-library-evolution -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift | %FileCheck %t/enum_resilience.swift --check-prefix=ENUM_RES
// RUN: %target-swift-frontend -disable-type-layout -emit-ir -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift | %FileCheck %t/enum_resilience.swift --check-prefix=ENUM_NOT_RES
// RUN: %target-swift-frontend -emit-module -enable-library-evolution -emit-module-path=%t/resilient_enum.swiftmodule -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
// RUN: %target-swift-frontend %use_no_opaque_pointers -disable-type-layout -module-name enum_resilience -I %t -emit-ir -enable-library-evolution %s | %FileCheck %t/enum_resilience.swift -DINT=i%target-ptrsize --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize --check-prefix=CHECK-%target-cpu
// RUN: %target-swift-frontend -disable-type-layout -module-name enum_resilience -I %t -emit-ir -enable-library-evolution %s
// RUN: %target-swift-frontend -disable-type-layout -module-name enum_resilience -I %t -emit-ir -enable-library-evolution %s | %FileCheck %t/enum_resilience.swift -DINT=i%target-ptrsize --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize --check-prefix=CHECK-%target-cpu
// RUN: %target-swift-frontend -module-name enum_resilience -I %t -emit-ir -enable-library-evolution -O %s
import resilient_enum
@@ -25,31 +22,15 @@ import resilient_struct
// ENUM_NOT_RES-NOT: @"$s14resilient_enum6MediumO5PaperyA2CmFWC" =
// ENUM_NOT_RES-NOT: @"$s14resilient_enum6MediumO6CanvasyA2CmFWC" =
// CHECK: %T15enum_resilience5ClassC = type <{ %swift.refcounted }>
// CHECK: %T15enum_resilience9ReferenceV = type <{ %T15enum_resilience5ClassC* }>
// CHECK: %T15enum_resilience9ReferenceV = type <{ ptr }>
// Public fixed layout struct contains a public resilient struct,
// cannot use spare bits
// CHECK: %T15enum_resilience6EitherO = type <{ [[REFERENCE_TYPE:\[(4|8) x i8\]]], [1 x i8] }>
// Public resilient struct contains a public resilient struct,
// can use spare bits
// CHECK: %T15enum_resilience15ResilientEitherO = type <{ [[REFERENCE_TYPE]] }>
// Internal fixed layout struct contains a public resilient struct,
// can use spare bits
// CHECK: %T15enum_resilience14InternalEitherO = type <{ [[REFERENCE_TYPE]] }>
// Public fixed layout struct contains a fixed layout struct,
// can use spare bits
// CHECK: %T15enum_resilience10EitherFastO = type <{ [[REFERENCE_TYPE]] }>
// CHECK: @"$s15enum_resilience24EnumWithResilientPayloadOMl" =
// CHECK-SAME: internal global { %swift.type*, i8* } zeroinitializer, align
// CHECK-SAME: internal global { ptr, ptr } zeroinitializer, align
// CHECK: @"$s15enum_resilience24EnumWithResilientPayloadOMn" = {{.*}}constant
// 0x00010052
@@ -91,41 +72,37 @@ enum InternalEither {
case Right(ReferenceFast)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25functionWithResilientEnumy010resilient_A06MediumOAEF"(%swift.opaque* noalias nocapture sret({{.*}}) %0, %swift.opaque* noalias nocapture %1)
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25functionWithResilientEnumy010resilient_A06MediumOAEF"(ptr noalias nocapture sret({{.*}}) %0, ptr noalias nocapture %1)
public func functionWithResilientEnum(_ m: Medium) -> Medium {
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum6MediumOMa"([[INT]] 0)
// CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METADATA]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// This is copying the +0 argument to be used as a return value.
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK-NEXT: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]]
// CHECK-arm64e-NEXT: ptrtoint i8** [[WITNESS_ADDR]] to i64
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 2
// CHECK-NEXT: [[WITNESS_FN:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK-arm64e-NEXT: ptrtoint ptr [[WITNESS_ADDR]] to i64
// CHECK-arm64e-NEXT: call i64 @llvm.ptrauth.blend
// CHECK-NEXT: call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias %0, %swift.opaque* noalias %1, %swift.type* [[METADATA]])
// CHECK-NEXT: call ptr [[WITNESS_FN]](ptr noalias %0, ptr noalias %1, ptr [[METADATA]])
// CHECK-NEXT: ret void
return m
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience33functionWithIndirectResilientEnumy010resilient_A00E8ApproachOAEF"(%swift.opaque* noalias nocapture sret({{.*}}) %0, %swift.opaque* noalias nocapture %1)
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience33functionWithIndirectResilientEnumy010resilient_A00E8ApproachOAEF"(ptr noalias nocapture sret({{.*}}) %0, ptr noalias nocapture %1)
public func functionWithIndirectResilientEnum(_ ia: IndirectApproach) -> IndirectApproach {
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum16IndirectApproachOMa"([[INT]] 0)
// CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METADATA]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// This is copying the +0 argument into the return slot.
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK-NEXT: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]]
// CHECK-arm64e-NEXT: ptrtoint i8** [[WITNESS_ADDR]] to i64
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 2
// CHECK-NEXT: [[WITNESS_FN:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK-arm64e-NEXT: ptrtoint ptr [[WITNESS_ADDR]] to i64
// CHECK-arm64e-NEXT: call i64 @llvm.ptrauth.blend
// CHECK-NEXT: call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias %0, %swift.opaque* noalias %1, %swift.type* [[METADATA]])
// CHECK-NEXT: call ptr [[WITNESS_FN]](ptr noalias %0, ptr noalias %1, ptr [[METADATA]])
// CHECK-NEXT: ret void
return ia
@@ -133,21 +110,19 @@ public func functionWithIndirectResilientEnum(_ ia: IndirectApproach) -> Indirec
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience31constructResilientEnumNoPayload010resilient_A06MediumOyF"
public func constructResilientEnumNoPayload() -> Medium {
// CHECK: [[TAG:%.*]] = load i32, i32* @"$s14resilient_enum6MediumO5PaperyA2CmFWC"
// CHECK: [[TAG:%.*]] = load i32, ptr @"$s14resilient_enum6MediumO5PaperyA2CmFWC"
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum6MediumOMa"([[INT]] 0)
// CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METADATA]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK-16-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 16
// CHECK-32-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 14
// CHECK-64-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 13
// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK-NEXT: [[WITNESS_FN:%.*]] = bitcast i8* [[WITNESS]]
// CHECK-arm64e-NEXT: ptrtoint i8** [[WITNESS_ADDR]] to i64
// CHECK-16-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 16
// CHECK-32-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 14
// CHECK-64-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 13
// CHECK-NEXT: [[WITNESS_FN:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK-arm64e-NEXT: ptrtoint ptr [[WITNESS_ADDR]] to i64
// CHECK-arm64e-NEXT: call i64 @llvm.ptrauth.blend
// CHECK-NEXT: call void [[WITNESS_FN]](%swift.opaque* noalias %0, i32 [[TAG]], %swift.type* [[METADATA]])
// CHECK-NEXT: call void [[WITNESS_FN]](ptr noalias %0, i32 [[TAG]], ptr [[METADATA]])
// CHECK-NEXT: ret void
return Medium.Paper
@@ -157,91 +132,78 @@ public func constructResilientEnumNoPayload() -> Medium {
public func constructResilientEnumPayload(_ s: Size) -> Medium {
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s16resilient_struct4SizeVMa"([[INT]] 0)
// CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK-NEXT: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METADATA]], [[INT]] -1
// CHECK-NEXT: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 8
// CHECK-NEXT: [[WITNESS_FOR_SIZE:%size]] = load [[INT]], [[INT]]* [[WITNESS_ADDR]]
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 8
// CHECK-NEXT: [[WITNESS_FOR_SIZE:%size]] = load [[INT]], ptr [[WITNESS_ADDR]]
// CHECK-NEXT: [[ALLOCA:%.*]] = alloca i8, {{.*}} [[WITNESS_FOR_SIZE]], align 16
// CHECK-NEXT: call void @llvm.lifetime.start.p0i8({{(i32|i64)}} -1, i8* [[ALLOCA]])
// CHECK-NEXT: [[ENUM_STORAGE:%.*]] = bitcast i8* [[ALLOCA]] to %swift.opaque*
// CHECK-NEXT: call void @llvm.lifetime.start.p0({{(i32|i64)}} -1, ptr [[ALLOCA]])
// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK-NEXT: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]] to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*
// CHECK-arm64e-NEXT: ptrtoint i8** [[WITNESS_ADDR]] to i64
// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 2
// CHECK-NEXT: [[WITNESS:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK-arm64e-NEXT: ptrtoint ptr [[WITNESS_ADDR]] to i64
// CHECK-arm64e-NEXT: call i64 @llvm.ptrauth.blend
// CHECK-NEXT: call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias [[ENUM_STORAGE]], %swift.opaque* noalias %1, %swift.type* [[METADATA]])
// CHECK-NEXT: call ptr [[WITNESS]](ptr noalias [[ALLOCA]], ptr noalias %1, ptr [[METADATA]])
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 4
// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK-NEXT: [[WITNESS_FN:%initializeWithTake]] = bitcast i8* [[WITNESS]] to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*
// CHECK-arm64e-NEXT: ptrtoint i8** [[WITNESS_ADDR]] to i64
// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 4
// CHECK-NEXT: [[WITNESS:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK-arm64e-NEXT: ptrtoint ptr [[WITNESS_ADDR]] to i64
// CHECK-arm64e-NEXT: call i64 @llvm.ptrauth.blend
// CHECK-NEXT: call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias %0, %swift.opaque* noalias [[ENUM_STORAGE]], %swift.type* [[METADATA]])
// CHECK-NEXT: call ptr [[WITNESS]](ptr noalias %0, ptr noalias [[ALLOCA]], ptr [[METADATA]])
// CHECK-NEXT: [[TAG:%.*]] = load i32, i32* @"$s14resilient_enum6MediumO8PostcardyAC0A7_struct4SizeVcACmFWC"
// CHECK-NEXT: [[TAG:%.*]] = load i32, ptr @"$s14resilient_enum6MediumO8PostcardyAC0A7_struct4SizeVcACmFWC"
// CHECK-NEXT: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum6MediumOMa"([[INT]] 0)
// CHECK-NEXT: [[METADATA2:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: [[METADATA_ADDR2:%.*]] = bitcast %swift.type* [[METADATA2]] to i8***
// CHECK-NEXT: [[VWT_ADDR2:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR2]], [[INT]] -1
// CHECK-NEXT: [[VWT2:%.*]] = load i8**, i8*** [[VWT_ADDR2]]
// CHECK-NEXT: [[VWT_ADDR2:%.*]] = getelementptr inbounds ptr, ptr [[METADATA2]], [[INT]] -1
// CHECK-NEXT: [[VWT2:%.*]] = load ptr, ptr [[VWT_ADDR2]]
// CHECK-16-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT2]], i32 16
// CHECK-32-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT2]], i32 14
// CHECK-64-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT2]], i32 13
// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK-NEXT: [[WITNESS_FN:%destructiveInjectEnumTag]] = bitcast i8* [[WITNESS]]
// CHECK-arm64e-NEXT: ptrtoint i8** [[WITNESS_ADDR]] to i64
// CHECK-16-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT2]], i32 16
// CHECK-32-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT2]], i32 14
// CHECK-64-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT2]], i32 13
// CHECK-NEXT: [[WITNESS_FN:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK-arm64e-NEXT: ptrtoint ptr [[WITNESS_ADDR]] to i64
// CHECK-arm64e-NEXT: call i64 @llvm.ptrauth.blend
// CHECK-NEXT: call void [[WITNESS_FN]](%swift.opaque* noalias %0, i32 [[TAG]], %swift.type* [[METADATA2]])
// CHECK-NEXT: [[STORAGE_ALLOCA:%.*]] = bitcast %swift.opaque* [[ENUM_STORAGE]] to i8*
// CHECK-NEXT: call void @llvm.lifetime.end.p0i8({{(i32|i64)}} -1, i8* [[STORAGE_ALLOCA]])
// CHECK-NEXT: call void [[WITNESS_FN]](ptr noalias %0, i32 [[TAG]], ptr [[METADATA2]])
// CHECK-NEXT: call void @llvm.lifetime.end.p0({{(i32|i64)}} -1, ptr [[ALLOCA]])
// CHECK-NEXT: ret void
return Medium.Postcard(s)
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i32|i64}} @"$s15enum_resilience19resilientSwitchTestySi0c1_A06MediumOF"(%swift.opaque* noalias nocapture %0)
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc {{i32|i64}} @"$s15enum_resilience19resilientSwitchTestySi0c1_A06MediumOF"(ptr noalias nocapture %0)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s14resilient_enum6MediumOMa"([[INT]] 0)
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT]] -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METADATA]], [[INT]] -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 8
// CHECK: [[WITNESS_FOR_SIZE:%size]] = load [[INT]], [[INT]]* [[WITNESS_ADDR]]
// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 8
// CHECK: [[WITNESS_FOR_SIZE:%size]] = load [[INT]], ptr [[WITNESS_ADDR]]
// CHECK: [[ALLOCA:%.*]] = alloca i8, {{.*}} [[WITNESS_FOR_SIZE]], align 16
// CHECK: [[ALLOCA:%.*]] = alloca i8, {{.*}} [[WITNESS_FOR_SIZE]], align 16
// CHECK: [[ENUM_STORAGE:%.*]] = bitcast i8* [[ALLOCA]] to %swift.opaque*
// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
// CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]]
// CHECK: [[ENUM_COPY:%.*]] = call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias [[ENUM_STORAGE]], %swift.opaque* noalias %0, %swift.type* [[METADATA]])
// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 2
// CHECK: [[WITNESS_FN:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK: [[ENUM_COPY:%.*]] = call ptr [[WITNESS_FN]](ptr noalias [[ALLOCA]], ptr noalias %0, ptr [[METADATA]])
// CHECK-16-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 14
// CHECK-32-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 12
// CHECK-64-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 11
// CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
// CHECK: [[WITNESS_FN:%getEnumTag]] = bitcast i8* [[WITNESS]]
// CHECK: [[TAG:%.*]] = call i32 [[WITNESS_FN]](%swift.opaque* noalias [[ENUM_STORAGE]], %swift.type* [[METADATA]])
// CHECK-16-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 14
// CHECK-32-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 12
// CHECK-64-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 11
// CHECK: [[WITNESS_FN:%.*]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK: [[TAG:%.*]] = call i32 [[WITNESS_FN]](ptr noalias [[ALLOCA]], ptr [[METADATA]])
// CHECK: [[PAMPHLET_CASE_TAG:%.*]] = load i32, i32* @"$s14resilient_enum6MediumO8PamphletyA2CcACmFWC"
// CHECK: [[PAMPHLET_CASE_TAG:%.*]] = load i32, ptr @"$s14resilient_enum6MediumO8PamphletyA2CcACmFWC"
// CHECK: [[PAMPHLET_CASE:%.*]] = icmp eq i32 [[TAG]], [[PAMPHLET_CASE_TAG]]
// CHECK: br i1 [[PAMPHLET_CASE]], label %[[PAMPHLET_CASE_LABEL:.*]], label %[[PAPER_CHECK:.*]]
// CHECK: [[PAPER_CHECK]]:
// CHECK: [[PAPER_CASE_TAG:%.*]] = load i32, i32* @"$s14resilient_enum6MediumO5PaperyA2CmFWC"
// CHECK: [[PAPER_CASE_TAG:%.*]] = load i32, ptr @"$s14resilient_enum6MediumO5PaperyA2CmFWC"
// CHECK: [[PAPER_CASE:%.*]] = icmp eq i32 [[TAG]], [[PAPER_CASE_TAG]]
// CHECK: br i1 [[PAPER_CASE]], label %[[PAPER_CASE_LABEL:.*]], label %[[CANVAS_CHECK:.*]]
// CHECK: [[CANVAS_CHECK]]:
// CHECK: [[CANVAS_CASE_TAG:%.*]] = load i32, i32* @"$s14resilient_enum6MediumO6CanvasyA2CmFWC"
// CHECK: [[CANVAS_CASE_TAG:%.*]] = load i32, ptr @"$s14resilient_enum6MediumO6CanvasyA2CmFWC"
// CHECK: [[CANVAS_CASE:%.*]] = icmp eq i32 [[TAG]], [[CANVAS_CASE_TAG]]
// CHECK: br i1 [[CANVAS_CASE]], label %[[CANVAS_CASE_LABEL:.*]], label %[[DEFAULT_CASE:.*]]
@@ -278,18 +240,17 @@ public func resilientSwitchTest(_ m: Medium) -> Int {
public func reabstraction<T>(_ f: (Medium) -> T) {}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25resilientEnumPartialApplyyySi0c1_A06MediumOXEF"(i8* %0, %swift.opaque* %1)
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience25resilientEnumPartialApplyyySi0c1_A06MediumOXEF"(ptr %0, ptr %1)
public func resilientEnumPartialApply(_ f: (Medium) -> Int) {
// CHECK: [[STACKALLOC:%.*]] = alloca i8
// CHECK: [[CONTEXT:%.*]] = bitcast i8* [[STACKALLOC]] to %swift.opaque*
// CHECK: call swiftcc void @"$s15enum_resilience13reabstractionyyx010resilient_A06MediumOXElF"(i8* bitcast ({{.*}} @"$s14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA{{(\.ptrauth)?}}" to i8*), %swift.opaque* [[CONTEXT:%.*]], %swift.type* @"$sSiN")
// CHECK: call swiftcc void @"$s15enum_resilience13reabstractionyyx010resilient_A06MediumOXElF"(ptr @"$s14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA{{(\.ptrauth)?}}", ptr [[CONTEXT:%.*]], ptr @"$sSiN")
reabstraction(f)
// CHECK: ret void
}
// CHECK-LABEL: define internal swiftcc void @"$s14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA"(%TSi* noalias nocapture sret({{.*}}) %0, %swift.opaque* noalias nocapture %1, %swift.refcounted* swiftself %2)
// CHECK-LABEL: define internal swiftcc void @"$s14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA"(ptr noalias nocapture sret({{.*}}) %0, ptr noalias nocapture %1, ptr swiftself %2)
// Enums with resilient payloads from a different resilience domain
@@ -303,10 +264,10 @@ public enum EnumWithResilientPayload {
// Make sure we call a function to access metadata of enums with
// resilient layout.
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s15enum_resilience20getResilientEnumTypeypXpyF"()
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc ptr @"$s15enum_resilience20getResilientEnumTypeypXpyF"()
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s15enum_resilience24EnumWithResilientPayloadOMa"([[INT]] 0)
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-NEXT: ret %swift.type* [[METADATA]]
// CHECK-NEXT: ret ptr [[METADATA]]
public func getResilientEnumType() -> Any.Type {
return EnumWithResilientPayload.self
@@ -314,20 +275,20 @@ public func getResilientEnumType() -> Any.Type {
// Public metadata accessor for our resilient enum
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.metadata_response @"$s15enum_resilience24EnumWithResilientPayloadOMa"(
// CHECK: [[LOAD_METADATA:%.*]] = load %swift.type*, %swift.type** getelementptr inbounds ({ %swift.type*, i8* }, { %swift.type*, i8* }* @"$s15enum_resilience24EnumWithResilientPayloadOMl", i32 0, i32 0), align
// CHECK-NEXT: [[COND:%.*]] = icmp eq %swift.type* [[LOAD_METADATA]], null
// CHECK: [[LOAD_METADATA:%.*]] = load ptr, ptr @"$s15enum_resilience24EnumWithResilientPayloadOMl", align
// CHECK-NEXT: [[COND:%.*]] = icmp eq ptr [[LOAD_METADATA]], null
// CHECK-NEXT: br i1 [[COND]], label %cacheIsNull, label %cont
// CHECK: cacheIsNull:
// CHECK-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @swift_getSingletonMetadata([[INT]] %0, %swift.type_descriptor* bitcast ({{.*}} @"$s15enum_resilience24EnumWithResilientPayloadOMn" to %swift.type_descriptor*))
// CHECK-NEXT: [[RESPONSE:%.*]] = call swiftcc %swift.metadata_response @swift_getSingletonMetadata([[INT]] %0, ptr @"$s15enum_resilience24EnumWithResilientPayloadOMn")
// CHECK-NEXT: [[RESPONSE_METADATA:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 0
// CHECK-NEXT: [[RESPONSE_STATE:%.*]] = extractvalue %swift.metadata_response [[RESPONSE]], 1
// CHECK-NEXT: br label %cont
// CHECK: cont:
// CHECK-NEXT: [[RESULT_METADATA:%.*]] = phi %swift.type* [ [[LOAD_METADATA]], %entry ], [ [[RESPONSE_METADATA]], %cacheIsNull ]
// CHECK-NEXT: [[RESULT_METADATA:%.*]] = phi ptr [ [[LOAD_METADATA]], %entry ], [ [[RESPONSE_METADATA]], %cacheIsNull ]
// CHECK-NEXT: [[RESULT_STATE:%.*]] = phi [[INT]] [ 0, %entry ], [ [[RESPONSE_STATE]], %cacheIsNull ]
// CHECK-NEXT: [[T0:%.*]] = insertvalue %swift.metadata_response undef, %swift.type* [[RESULT_METADATA]], 0
// CHECK-NEXT: [[T0:%.*]] = insertvalue %swift.metadata_response undef, ptr [[RESULT_METADATA]], 0
// CHECK-NEXT: [[T1:%.*]] = insertvalue %swift.metadata_response [[T0]], [[INT]] [[RESULT_STATE]], 1
// CHECK-NEXT: ret %swift.metadata_response [[T1]]
@@ -335,24 +296,24 @@ public func getResilientEnumType() -> Any.Type {
// from metadata -- make sure we can do that
extension ResilientMultiPayloadGenericEnum {
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %swift.type* @"$s14resilient_enum32ResilientMultiPayloadGenericEnumO0B11_resilienceE16getTypeParameterxmyF"(%swift.type* %"ResilientMultiPayloadGenericEnum<T>", %swift.opaque* noalias nocapture swiftself %0)
// CHECK: [[METADATA:%.*]] = bitcast %swift.type* %"ResilientMultiPayloadGenericEnum<T>" to %swift.type**
// CHECK-NEXT: [[T_ADDR:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[METADATA]], [[INT]] 2
// CHECK-NEXT: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]]
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc ptr @"$s14resilient_enum32ResilientMultiPayloadGenericEnumO0B11_resilienceE16getTypeParameterxmyF"(ptr %"ResilientMultiPayloadGenericEnum<T>", ptr noalias nocapture swiftself %0)
// CHECK: [[T_ADDR:%.*]] = getelementptr inbounds ptr, ptr %"ResilientMultiPayloadGenericEnum<T>", [[INT]] 2
// CHECK-NEXT: [[T:%.*]] = load ptr, ptr [[T_ADDR]]
public func getTypeParameter() -> T.Type {
return T.self
}
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience39constructExhaustiveWithResilientMembers010resilient_A011SimpleShapeOyF"(%swift.opaque* noalias nocapture sret({{.*}}) %0)
// CHECK: [[ARG:%.*]] = bitcast %swift.opaque* %0 to %T14resilient_enum11SimpleShapeO*
// CHECK: [[BUFFER:%.*]] = bitcast %T14resilient_enum11SimpleShapeO* [[ARG]] to %swift.opaque*
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s15enum_resilience39constructExhaustiveWithResilientMembers010resilient_A011SimpleShapeOyF"(ptr noalias nocapture sret({{.*}}) %0)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s16resilient_struct4SizeVMa"([[INT]] 0)
// CHECK-NEXT: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK: [[STORE_TAG:%.*]] = bitcast i8* {{%.+}} to void (%swift.opaque*, i32, i32, %swift.type*)*
// CHECK-arm64e-NEXT: ptrtoint i8** {{.*}} to i64
// CHECK-arm64e-NEXT: ptrtoint ptr {{.*}} to i64
// CHECK-arm64e-NEXT: call i64 @llvm.ptrauth.blend
// CHECK-NEXT: call void [[STORE_TAG]](%swift.opaque* noalias [[BUFFER]], i32 1, i32 1, %swift.type* [[METADATA]])
// CHECK-NEXT: [[WITNESSTABLE_ADDR:%[0-9]+]] = getelementptr inbounds ptr, ptr [[METADATA]], i64 -1
// CHECK-NEXT: %.valueWitnesses = load ptr, ptr [[WITNESSTABLE_ADDR]]
// CHECK-NEXT: [[WITNESS_ADDR:%[0-9]+]] = getelementptr inbounds ptr, ptr %.valueWitnesses, i32 7
// CHECK-NEXT: [[WITNESS_FN:%[0-9]+]] = load ptr, ptr [[WITNESS_ADDR]]
// CHECK-NEXT: call void [[WITNESS_FN]](ptr noalias %0, i32 1, i32 1, ptr [[METADATA]])
// CHECK-NEXT: ret void
// CHECK-NEXT: {{^}$}}
public func constructExhaustiveWithResilientMembers() -> SimpleShape {
@@ -366,7 +327,7 @@ public func constructFullyFixed() -> FullyFixedLayout {
return .noPayload
}
// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s15enum_resilience24EnumWithResilientPayloadOMr"(%swift.type* %0, i8* %1, i8** %2)
// CHECK-LABEL: define internal swiftcc %swift.metadata_response @"$s15enum_resilience24EnumWithResilientPayloadOMr"(ptr %0, ptr %1, ptr %2)
// CHECK: [[TUPLE_LAYOUT:%.*]] = alloca %swift.full_type_layout
// CHECK: [[SIZE_RESPONSE:%.*]] = call swiftcc %swift.metadata_response @"$s16resilient_struct4SizeVMa"([[INT]] 319)
// CHECK-NEXT: [[SIZE_METADATA:%.*]] = extractvalue %swift.metadata_response [[SIZE_RESPONSE]], 0
@@ -374,19 +335,17 @@ public func constructFullyFixed() -> FullyFixedLayout {
// CHECK-NEXT: [[T0:%.*]] = icmp ule [[INT]] [[SIZE_STATE]], 63
// CHECK-NEXT: br i1 [[T0]], label %[[SATISFIED1:.*]], label
// CHECK: [[SATISFIED1]]:
// CHECK-NEXT: [[T0:%.*]] = bitcast %swift.type* [[SIZE_METADATA]] to i8***
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8**, i8*** [[T0]], [[INT]] -1
// CHECK-NEXT: [[SIZE_VWT:%.*]] = load i8**, i8*** [[T1]],
// CHECK-NEXT: [[SIZE_LAYOUT_1:%.*]] = getelementptr inbounds i8*, i8** [[SIZE_VWT]], i32 8
// CHECK-NEXT: store i8** [[SIZE_LAYOUT_1]],
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds ptr, ptr [[SIZE_METADATA]], [[INT]] -1
// CHECK-NEXT: [[SIZE_VWT:%.*]] = load ptr, ptr [[T1]],
// CHECK-NEXT: [[SIZE_LAYOUT_1:%.*]] = getelementptr inbounds ptr, ptr [[SIZE_VWT]], i32 8
// CHECK-NEXT: store ptr [[SIZE_LAYOUT_1]],
// CHECK-NEXT: getelementptr
// CHECK-NEXT: [[SIZE_LAYOUT_2:%.*]] = getelementptr inbounds i8*, i8** [[SIZE_VWT]], i32 8
// CHECK-NEXT: [[SIZE_LAYOUT_3:%.*]] = getelementptr inbounds i8*, i8** [[SIZE_VWT]], i32 8
// CHECK-NEXT: call swiftcc [[INT]] @swift_getTupleTypeLayout2(%swift.full_type_layout* [[TUPLE_LAYOUT]], i8** [[SIZE_LAYOUT_2]], i8** [[SIZE_LAYOUT_3]])
// CHECK-NEXT: [[T0:%.*]] = bitcast %swift.full_type_layout* [[TUPLE_LAYOUT]] to i8**
// CHECK-NEXT: store i8** [[T0]],
// CHECK-NEXT: [[SIZE_LAYOUT_2:%.*]] = getelementptr inbounds ptr, ptr [[SIZE_VWT]], i32 8
// CHECK-NEXT: [[SIZE_LAYOUT_3:%.*]] = getelementptr inbounds ptr, ptr [[SIZE_VWT]], i32 8
// CHECK-NEXT: call swiftcc [[INT]] @swift_getTupleTypeLayout2(ptr [[TUPLE_LAYOUT]], ptr [[SIZE_LAYOUT_2]], ptr [[SIZE_LAYOUT_3]])
// CHECK-NEXT: store ptr [[TUPLE_LAYOUT]],
// CHECK: call void @swift_initEnumMetadataMultiPayload
// CHECK: phi %swift.type* [ [[SIZE_METADATA]], %entry ], [ null, %[[SATISFIED1]] ]
// CHECK: phi ptr [ [[SIZE_METADATA]], %entry ], [ null, %[[SATISFIED1]] ]
// CHECK: phi [[INT]] [ 63, %entry ], [ 0, %[[SATISFIED1]] ]
@@ -398,5 +357,5 @@ private enum ProtGenEnumWithSize<T: Prot> {
case c2(s2: Size)
}
// CHECK-LABEL: define linkonce_odr hidden %T15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLO* @"$s15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLOyxGAA0C0RzlWOh"(%T15enum_resilience19ProtGenEnumWithSize
// CHECK: ret %T15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLO* %0
// CHECK-LABEL: define linkonce_odr hidden ptr @"$s15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLOyxGAA0C0RzlWOh"(ptr
// CHECK: ret ptr %0

10
test/IRGen/enum_switch_singleton_enum_in_optional.sil
View File

@@ -1,5 +1,4 @@
// RUN: %target-swift-frontend %use_no_opaque_pointers -emit-ir %s | %FileCheck %s
// RUN: %target-swift-frontend -emit-ir %s
// RUN: %target-swift-frontend -emit-ir %s | %FileCheck %s
sil_stage canonical
enum Optional<T> { case some(T), none }
@@ -15,10 +14,9 @@ enum AnEnum {
}
// CHECK-LABEL: define {{.*}} @switch_singleton_enum_in_optional
// CHECK: [[CAST:%.*]] = bitcast {{.*}} %0 to { [[WORD:i[0-9]+]], [[WORD]], [[WORD]], [[WORD]], [[WORD]], [[WORD]] }*
// CHECK: [[GEP:%.*]] = getelementptr {{.*}} %1, i32 0, i32 0
// CHECK: [[FIRSTWORD:%.*]] = load [[WORD]], [[WORD]]* [[GEP]]
// CHECK: [[TEST:%.*]] = icmp eq [[WORD]] [[FIRSTWORD]], 0
// CHECK: [[GEP:%.*]] = getelementptr inbounds {{.*}}, ptr %0, i32 0, i32 0
// CHECK: [[FIRSTWORD:%.*]] = load {{.*}}, ptr [[GEP]]
// CHECK: [[TEST:%.*]] = icmp eq {{.*}} [[FIRSTWORD]], 0
// CHECK: br i1 [[TEST]]
sil public @switch_singleton_enum_in_optional :
$@convention(thin) (@in Optional<AnEnum>) -> () {

114
test/IRGen/errors.sil
View File

@@ -1,7 +1,6 @@
// XFAIL: CPU=powerpc64le
// XFAIL: CPU=s390x
// RUN: %target-swift-frontend %use_no_opaque_pointers -primary-file %s -emit-ir | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime --check-prefix=CHECK-%target-cpu --check-prefix=CHECK-%target-ptrsize
// RUN: %target-swift-frontend -primary-file %s -emit-ir
// RUN: %target-swift-frontend -primary-file %s -emit-ir | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime --check-prefix=CHECK-%target-cpu --check-prefix=CHECK-%target-ptrsize
sil_stage canonical
@@ -16,40 +15,40 @@ entry:
unreachable
}
// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** %1) {{.*}} {
// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64_32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr %1) {{.*}} {
// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64_32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @does_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
sil @does_throw : $@convention(thin) () -> @error Error {
// CHECK: [[T0:%.*]] = call swiftcc %swift.error* @create_error()
// CHECK: [[T0:%.*]] = call swiftcc ptr @create_error()
%0 = function_ref @create_error : $@convention(thin) () -> @owned Error
%1 = apply %0() : $@convention(thin) () -> @owned Error
// CHECK-NEXT: store %swift.error* [[T0]], %swift.error** %1,
// CHECK-NEXT: store ptr [[T0]], ptr %1,
// CHECK-NEXT: call swiftcc void @swift_willThrow
// CHECK-NEXT: store %swift.error* null, %swift.error** %1,
// CHECK-NEXT: store %swift.error* [[T0]], %swift.error** %1,
// CHECK-NEXT: store ptr null, ptr %1,
// CHECK-NEXT: store ptr [[T0]], ptr %1,
// CHECK-NEXT: ret void
builtin "willThrow"(%1 : $Error) : $()
throw %1 : $Error
}
// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** %1) {{.*}} {
// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-arm64_32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(%swift.refcounted* swiftself %0, %swift.error** swifterror %1) {{.*}} {
// CHECK-LABEL-i386: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr %1) {{.*}} {
// CHECK-LABEL-x86_64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-armv7: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-armv7s: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-armv7k: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-aarch64: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64e: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
// CHECK-LABEL-arm64_32: define{{( dllexport)?}}{{( protected)?}} swiftcc void @doesnt_throw(ptr swiftself %0, ptr swifterror %1) {{.*}} {
sil @doesnt_throw : $@convention(thin) () -> @error Error {
// We don't have to do anything here because the caller always
// zeroes the error slot before a call.
@@ -61,44 +60,44 @@ sil @doesnt_throw : $@convention(thin) () -> @error Error {
sil @try_apply_helper : $@convention(thin) (@owned AnyObject) -> (@owned AnyObject, @error Error)
// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(%objc_object* %0)
// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(%swift.refcounted* %0)
// CHECK-objc-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(ptr %0)
// CHECK-native-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @try_apply(ptr %0)
sil @try_apply : $@convention(thin) (@owned AnyObject) -> () {
entry(%0 : $AnyObject):
// CHECK-i386: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]]%swift.error*, align
// CHECK-x86_64: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-armv7: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-armv7s: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-armv7k: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-arm64: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-arm64e: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-aarch64: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-arm64_32: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-powerpc64le: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] %swift.error*, align
// CHECK-NEXT: store %swift.error* null, %swift.error** [[ERRORSLOT]], align
// CHECK-i386: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]]ptr, align
// CHECK-x86_64: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-armv7: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-armv7s: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-armv7k: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-arm64: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-arm64e: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-aarch64: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-arm64_32: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-powerpc64le: [[ERRORSLOT:%.*]] = alloca [[SWIFTERROR:.*]] ptr, align
// CHECK-NEXT: store ptr null, ptr [[ERRORSLOT]], align
// CHECK-objc-NEXT: [[RESULT:%.*]] = call swiftcc %objc_object* @try_apply_helper(%objc_object* %0, %swift.refcounted* swiftself undef, %swift.error** noalias nocapture [[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) [[ERRORSLOT]])
// CHECK-native-NEXT: [[RESULT:%.*]] = call swiftcc %swift.refcounted* @try_apply_helper(%swift.refcounted* %0, %swift.refcounted* swiftself undef, %swift.error** noalias nocapture [[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) [[ERRORSLOT]])
// CHECK-NEXT: [[ERR:%.*]] = load %swift.error*, %swift.error** [[ERRORSLOT]], align
// CHECK-NEXT: [[T0:%.*]] = icmp ne %swift.error* [[ERR]], null
// CHECK-objc-NEXT: [[RESULT:%.*]] = call swiftcc ptr @try_apply_helper(ptr %0, ptr swiftself undef, ptr noalias nocapture [[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) [[ERRORSLOT]])
// CHECK-native-NEXT: [[RESULT:%.*]] = call swiftcc ptr @try_apply_helper(ptr %0, ptr swiftself undef, ptr noalias nocapture [[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) [[ERRORSLOT]])
// CHECK-NEXT: [[ERR:%.*]] = load ptr, ptr [[ERRORSLOT]], align
// CHECK-NEXT: [[T0:%.*]] = icmp ne ptr [[ERR]], null
// CHECK-NEXT: br i1 [[T0]],
%1 = function_ref @try_apply_helper : $@convention(thin) (@owned AnyObject) -> (@owned AnyObject, @error Error)
try_apply %1(%0) : $@convention(thin) (@owned AnyObject) -> (@owned AnyObject, @error Error),
normal bb1, error bb2
// CHECK-objc: [[T0:%.*]] = phi %objc_object* [ [[RESULT]],
// CHECK-objc-NEXT: call void @swift_unknownObjectRelease(%objc_object* [[T0]])
// CHECK-native: [[T0:%.*]] = phi %swift.refcounted* [ [[RESULT]],
// CHECK-native-NEXT: call void @swift_release(%swift.refcounted* [[T0]])
// CHECK-objc: [[T0:%.*]] = phi ptr [ [[RESULT]],
// CHECK-objc-NEXT: call void @swift_unknownObjectRelease(ptr [[T0]])
// CHECK-native: [[T0:%.*]] = phi ptr [ [[RESULT]],
// CHECK-native-NEXT: call void @swift_release(ptr [[T0]])
// CHECK-NEXT: br label [[CONT:%[0-9]+]]
bb1(%2 : $AnyObject):
strong_release %2 : $AnyObject
br bb3
// CHECK: [[T0:%.*]] = phi %swift.error* [ [[ERR]],
// CHECK-NEXT: store %swift.error* null, %swift.error** [[ERRORSLOT]], align
// CHECK-objc-NEXT: call void @swift_errorRelease(%swift.error* [[T0]])
// CHECK-native-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%swift.error*)*)(%swift.error* [[T0]])
// CHECK: [[T0:%.*]] = phi ptr [ [[ERR]],
// CHECK-NEXT: store ptr null, ptr [[ERRORSLOT]], align
// CHECK-objc-NEXT: call void @swift_errorRelease(ptr [[T0]])
// CHECK-native-NEXT: call void @swift_release(ptr [[T0]])
// CHECK-NEXT: br label [[CONT]]
bb2(%3 : $Error):
release_value %3 : $Error
@@ -113,8 +112,8 @@ enum ColorError : Error {
}
// CHECK-LABEL: TestCallToWillThrowCallBack
// CHECK: call swiftcc void @swift_willThrow(i8* swiftself undef, %swift.error** noalias nocapture readonly [[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) %2)
// CHECK: store %swift.error* %0
// CHECK: call swiftcc void @swift_willThrow(ptr swiftself undef, ptr noalias nocapture readonly [[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) %2)
// CHECK: store ptr %0
// CHECK: ret i64 undef
sil hidden @TestCallToWillThrowCallBack : $@convention(thin) (@owned Error) -> (Int64, @error Error) {
bb0(%0 : $Error):
@@ -124,12 +123,11 @@ bb0(%0 : $Error):
// rdar://21084084 - Partial application of throwing functions.
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_single(%T6errors1AC* %0)
// CHECK: insertvalue { i8*, %swift.refcounted* } { i8* bitcast ({{.*}}* @"$s27partial_apply_single_helperTA{{(\.ptrauth)?}}" to i8*), %swift.refcounted* undef },
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc { ptr, ptr } @partial_apply_single(ptr %0)
// CHECK: insertvalue { ptr, ptr } { ptr @"$s27partial_apply_single_helperTA{{(\.ptrauth)?}}", ptr undef },
// CHECK: define internal swiftcc void @"$s27partial_apply_single_helperTA"(%swift.refcounted* swiftself %0, %swift.error** noalias nocapture{{( )?}}[[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) %1)
// CHECK: [[T0:%.*]] = bitcast %swift.refcounted* {{%.*}} to %T6errors1AC*
// CHECK-NEXT: tail call swiftcc void @partial_apply_single_helper(%T6errors1AC* [[T0]], %swift.refcounted* swiftself undef, %swift.error** noalias nocapture{{( )?}}[[SWIFTERROR]]{{( )?}}dereferenceable({{.}}){{( )?}}{{%.*}})
// CHECK: define internal swiftcc void @"$s27partial_apply_single_helperTA"(ptr swiftself %0, ptr noalias nocapture{{( )?}}[[SWIFTERROR]]{{( )?}}dereferenceable({{.}}) %1)
// CHECK: tail call swiftcc void @partial_apply_single_helper(ptr {{%.*}}, ptr swiftself undef, ptr noalias nocapture{{( )?}}[[SWIFTERROR]]{{( )?}}dereferenceable({{.}}){{( )?}}{{%.*}})
// CHECK-NEXT: ret void
sil @partial_apply_single : $@convention(thin) (@owned A) -> @callee_owned () -> @error Error {
entry(%0 : $A):

40
test/IRGen/exact_self_class_metadata_peephole.swift
View File

@@ -1,7 +1,5 @@
// RUN: %target-swift-frontend %use_no_opaque_pointers -emit-ir %s | %FileCheck %s --check-prefix=CHECK --check-prefix=ONONE
// RUN: %target-swift-frontend -emit-ir %s
// RUN: %target-swift-frontend %use_no_opaque_pointers -O -disable-llvm-optzns -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-ir %s | %FileCheck %s --check-prefix=CHECK --check-prefix=O
// RUN: %target-swift-frontend -O -disable-llvm-optzns -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-ir %s
// RUN: %target-swift-frontend -emit-ir %s | %FileCheck %s --check-prefix=CHECK --check-prefix=ONONE
// RUN: %target-swift-frontend -O -disable-llvm-optzns -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-ir %s | %FileCheck %s --check-prefix=CHECK --check-prefix=O
@_silgen_name("useMetadata")
func useMetadata<T>(_: T.Type)
@@ -16,7 +14,7 @@ private class PrivateEffectivelyFinal<T, U, V> {
}
// CHECK-LABEL: define {{.*}}PrivateEffectivelyFinal{{.*}}cfC
// CHECK: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK: call {{.*}}@swift_allocObject(ptr %0
}
// The class is not final and has subclasses, so we can only peephole
@@ -32,16 +30,16 @@ private class PrivateNonfinal<T, U, V> {
final func butts() {
// CHECK: [[INSTANTIATED_TYPE_RESPONSE:%.*]] = call {{.*}} @{{.*}}15PrivateNonfinal{{.*}}Ma
// CHECK-NEXT: [[INSTANTIATED_TYPE:%.*]] = extractvalue {{.*}} [[INSTANTIATED_TYPE_RESPONSE]]
// CHECK-NEXT: call {{.*}} @useMetadata(%swift.type* [[INSTANTIATED_TYPE]], %swift.type* [[INSTANTIATED_TYPE]])
// CHECK-NEXT: call {{.*}} @useMetadata(ptr [[INSTANTIATED_TYPE]], ptr [[INSTANTIATED_TYPE]])
useMetadata(PrivateNonfinal<T, U, V>.self)
// CHECK: [[INSTANTIATED_TYPE_RESPONSE:%.*]] = call {{.*}} @{{.*}}15PrivateNonfinal{{.*}}Ma
// CHECK-NEXT: [[INSTANTIATED_TYPE:%.*]] = extractvalue {{.*}} [[INSTANTIATED_TYPE_RESPONSE]]
// CHECK-NEXT: call {{.*}} @useMetadata(%swift.type* [[INSTANTIATED_TYPE]], %swift.type* [[INSTANTIATED_TYPE]])
// CHECK-NEXT: call {{.*}} @useMetadata(ptr [[INSTANTIATED_TYPE]], ptr [[INSTANTIATED_TYPE]])
useMetadata(PrivateNonfinal<Int, String, V>.self)
}
// CHECK-LABEL: define {{.*}}15PrivateNonfinal{{.*}}cfC
// CHECK: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK: call {{.*}}@swift_allocObject(ptr %0
}
// TODO: Although this is not explicitly final, class hierarchy analysis
@@ -49,7 +47,7 @@ private class PrivateNonfinal<T, U, V> {
// subclasses.
private class PrivateNonfinalSubclass: PrivateNonfinal<Int, String, Float> {
// CHECK-O-LABEL: define {{.*}}PrivateNonfinalSubclass{{.*}}cfC
// CHECK-O: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK-O: call {{.*}}@swift_allocObject(ptr %0
@inline(never)
final func borts() {
@@ -57,7 +55,7 @@ private class PrivateNonfinalSubclass: PrivateNonfinal<Int, String, Float> {
}
// CHECK-ONONE-LABEL: define {{.*}}PrivateNonfinalSubclass{{.*}}cfC
// CHECK-ONONE: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK-ONONE: call {{.*}}@swift_allocObject(ptr %0
}
final private class FinalPrivateNonfinalSubclass<U>: PrivateNonfinal<U, String, Float> {
@@ -65,26 +63,25 @@ final private class FinalPrivateNonfinalSubclass<U>: PrivateNonfinal<U, String,
// FinalPrivateNonfinalSubclass<U> from the self argument.
// CHECK-O-LABEL: define {{.*}}FinalPrivateNonfinalSubclass{{.*}}cfC"
// CHECK-O: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK-O: call {{.*}}@swift_allocObject(ptr %0
// CHECK-LABEL: define {{.*}}FinalPrivateNonfinalSubclass{{.*}}burts
@inline(never)
final func burts() {
// CHECK: [[TYPE_GEP:%.*]] = bitcast {{.*}} %0
// CHECK: [[TYPE:%.*]] = load {{.*}} [[TYPE_GEP]]
// CHECK: call {{.*}} @useMetadata(%swift.type* [[TYPE]], %swift.type* [[TYPE]])
// CHECK: [[TYPE:%.*]] = load {{.*}} %0
// CHECK: call {{.*}} @useMetadata(ptr [[TYPE]], ptr [[TYPE]])
useMetadata(FinalPrivateNonfinalSubclass<U>.self)
// CHECK: [[INSTANTIATED_TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}}FinalPrivateNonfinalSubclass
// CHECK: call {{.*}} @useMetadata(%swift.type* [[INSTANTIATED_TYPE]], %swift.type* [[INSTANTIATED_TYPE]])
// CHECK: call {{.*}} @useMetadata(ptr [[INSTANTIATED_TYPE]], ptr [[INSTANTIATED_TYPE]])
useMetadata(FinalPrivateNonfinalSubclass<Int>.self)
}
// CHECK-ONONE-LABEL: define {{.*}}FinalPrivateNonfinalSubclass{{.*}}cfC"
// CHECK-ONONE: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK-ONONE: call {{.*}}@swift_allocObject(ptr %0
}
// CHECK-O-LABEL: define {{.*}}FinalPrivateNonfinalSubclass{{.*}}cfC"
// CHECK-O: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK-O: call {{.*}}@swift_allocObject(ptr %0
final private class PrivateFinal<T, U, V> {
// The class is final, so we can always form metadata for
@@ -92,17 +89,16 @@ final private class PrivateFinal<T, U, V> {
// CHECK-LABEL: define {{.*}}PrivateFinal{{.*}}butts
func butts() {
// CHECK: [[TYPE_GEP:%.*]] = bitcast {{.*}} %0
// CHECK: [[TYPE:%.*]] = load {{.*}} [[TYPE_GEP]]
// CHECK: call {{.*}} @useMetadata(%swift.type* [[TYPE]], %swift.type* [[TYPE]])
// CHECK: [[TYPE:%.*]] = load {{.*}} %0
// CHECK: call {{.*}} @useMetadata(ptr [[TYPE]], ptr [[TYPE]])
useMetadata(PrivateFinal<T, U, V>.self)
// CHECK: [[INSTANTIATED_TYPE:%.*]] = call {{.*}} @__swift_instantiateConcreteTypeFromMangledName{{.*}}({{.*}}PrivateFinal
// CHECK: call {{.*}} @useMetadata(%swift.type* [[INSTANTIATED_TYPE]], %swift.type* [[INSTANTIATED_TYPE]])
// CHECK: call {{.*}} @useMetadata(ptr [[INSTANTIATED_TYPE]], ptr [[INSTANTIATED_TYPE]])
useMetadata(PrivateFinal<Int, String, Float>.self)
}
// CHECK-LABEL: define {{.*}}PrivateFinal{{.*}}cfC"
// CHECK: call {{.*}}@swift_allocObject(%swift.type* %0
// CHECK: call {{.*}}@swift_allocObject(ptr %0
}
public func useStuff<T, U, V>(_: T, _: U, _: V) {

35
test/IRGen/exclusivity.sil
View File

@@ -1,5 +1,4 @@
// RUN: %target-swift-frontend %use_no_opaque_pointers %s -swift-version 4 -emit-ir -enforce-exclusivity=checked | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s
// RUN: %target-swift-frontend %s -swift-version 4 -emit-ir -enforce-exclusivity=checked
// RUN: %target-swift-frontend %s -swift-version 4 -emit-ir -enforce-exclusivity=checked | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s
sil_stage canonical
@@ -19,41 +18,35 @@ bb0(%0 : $A):
// CHECK: [[SCRATCH0:%.*]] = alloca [[BUFFER_T:\[.* x i8\]]],
// CHECK: [[SCRATCH1:%.*]] = alloca [[BUFFER_T:\[.* x i8\]]],
// CHECK: [[PROP:%.*]] = getelementptr inbounds [[C:%T11exclusivity1AC]], %T11exclusivity1AC* %0, i32 0, i32 1
// CHECK: [[PROP:%.*]] = getelementptr inbounds [[C:%T11exclusivity1AC]], ptr %0, i32 0, i32 1
%3 = ref_element_addr %0 : $A, #A.x
// CHECK: [[T0:%.*]] = bitcast [[BUFFER_T]]* [[SCRATCH0]] to i8*
// CHECK: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[T0]])
// CHECK: [[T0:%.*]] = bitcast [[INT:%TSi]]* [[PROP]] to i8*
// CHECK: call void @swift_beginAccess(i8* [[T0]], [[BUFFER_T]]* [[SCRATCH0]], [[SIZE_T:i32|i64]] 32, i8* null)
// CHECK: call void @llvm.lifetime.start.p0(i64 -1, ptr [[SCRATCH0]])
// CHECK: call void @swift_beginAccess(ptr [[PROP]], ptr [[SCRATCH0]], [[SIZE_T:i32|i64]] 32, ptr null)
%4 = begin_access [read] [dynamic] %3 : $*Int
// CHECK: [[T0:%.*]] = getelementptr inbounds [[INT]], [[INT]]* %1, i32 0, i32 0
// CHECK: load {{.*}}* [[T0]]
// CHECK: [[T0:%.*]] = getelementptr inbounds [[INT:%TSi]], ptr %1, i32 0, i32 0
// CHECK: load i64, ptr [[T0]]
%5 = load %4 : $*Int
// CHECK: call void @swift_endAccess([[BUFFER_T]]* [[SCRATCH0]])
// CHECK: [[T0:%.*]] = bitcast [[BUFFER_T]]* [[SCRATCH0]] to i8*
// CHECK: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[T0]])
// CHECK: call void @swift_endAccess(ptr [[SCRATCH0]])
// CHECK: call void @llvm.lifetime.end.p0(i64 -1, ptr [[SCRATCH0]])
end_access %4 : $*Int
%9 = function_ref @changeInt : $@convention(thin) (@inout Int) -> ()
// CHECK: [[PROP:%.*]] = getelementptr inbounds [[C:%T11exclusivity1AC]], %T11exclusivity1AC* %0, i32 0, i32 1
// CHECK: [[PROP:%.*]] = getelementptr inbounds [[C:%T11exclusivity1AC]], ptr %0, i32 0, i32 1
%11 = ref_element_addr %0 : $A, #A.x
// CHECK: [[T0:%.*]] = bitcast [[BUFFER_T]]* [[SCRATCH1]] to i8*
// CHECK: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[T0]])
// CHECK: [[T0:%.*]] = bitcast [[INT:%TSi]]* [[PROP]] to i8*
// CHECK: call void @swift_beginAccess(i8* [[T0]], [[BUFFER_T]]* [[SCRATCH1]], [[SIZE_T:i32|i64]] 33, i8* null)
// CHECK: call void @llvm.lifetime.start.p0(i64 -1, ptr [[SCRATCH1]])
// CHECK: call void @swift_beginAccess(ptr [[PROP]], ptr [[SCRATCH1]], [[SIZE_T:i32|i64]] 33, ptr null)
%12 = begin_access [modify] [dynamic] %11 : $*Int
// CHECK: call {{.*}} @changeInt([[INT]]*{{.*}} [[PROP]])
// CHECK: call {{.*}} @changeInt(ptr{{.*}} [[PROP]])
%13 = apply %9(%12) : $@convention(thin) (@inout Int) -> ()
// CHECK: call void @swift_endAccess([[BUFFER_T]]* [[SCRATCH1]])
// CHECK: [[T0:%.*]] = bitcast [[BUFFER_T]]* [[SCRATCH1]] to i8*
// CHECK: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[T0]])
// CHECK: call void @swift_endAccess(ptr [[SCRATCH1]])
// CHECK: call void @llvm.lifetime.end.p0(i64 -1, ptr [[SCRATCH1]])
end_access %12 : $*Int
strong_release %0 : $A
return %5 : $Int

51
test/IRGen/existential_shape_metadata.swift
View File

@@ -1,8 +1,7 @@
// RUN: %target-swift-frontend %use_no_opaque_pointers -emit-ir %s -swift-version 5 -disable-availability-checking | %IRGenFileCheck %s
// RUN: %target-swift-frontend -emit-ir %s -swift-version 5 -disable-availability-checking
// RUN: %target-swift-frontend -emit-ir %s -swift-version 5 -disable-availability-checking | %IRGenFileCheck %s
// CHECK-LABEL: @"$sl26existential_shape_metadata2Q0_px1TRts_XPXGMq" = linkonce_odr hidden constant
// CHECK-SAME: { i32 {{.*}}sub ([[INT]] ptrtoint (i8** @{{[0-9]+}} to [[INT]])
// CHECK-SAME: { i32 {{.*}}sub ([[INT]] ptrtoint (ptr @{{[0-9]+}} to [[INT]])
// CHECK-SAME: i32 6400,
// CHECK-SAME: i32 {{.*}} @"flat unique 26existential_shape_metadata2Q0_px1TAaBPRts_XP"
// CHECK-SAME: i16 2, i16 2, i16 3, i16 0,
@@ -38,50 +37,44 @@ private struct C {}
// CHECK-LABEL: define{{.*}} @"$s26existential_shape_metadata12testConcrete
public func testConcrete() -> Any.Type {
// CHECK: [[METADATA:%.*]] = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* @"$s26existential_shape_metadata2Q0_pSi1TAaBPRts_XPMD")
// CHECK: ret %swift.type* [[METADATA]]
// CHECK: [[METADATA:%.*]] = call ptr @__swift_instantiateConcreteTypeFromMangledName(ptr @"$s26existential_shape_metadata2Q0_pSi1TAaBPRts_XPMD")
// CHECK: ret ptr [[METADATA]]
return (any Q0<Int>).self
}
// Still the same shape with an application of a dependent type.
// CHECK-LABEL: define{{.*}} @"$s26existential_shape_metadata13testDependent
public func testDependent<T>(t: T.Type) -> Any.Type {
// CHECK: [[ARGS:%.*]] = alloca [1 x i8*], align
// CHECK: [[T0:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[ARGS]], i32 0, i32 0
// CHECK: [[T1:%.*]] = bitcast %swift.type* %T to i8*
// CHECK: store i8* [[T1]], i8** [[T0]], align
// CHECK: [[T0:%.*]] = bitcast [1 x i8*]* [[ARGS]] to i8**
// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getExtendedExistentialTypeMetadata({{.*}}@"$sl26existential_shape_metadata2Q0_px1TRts_XPXGMq{{(\.ptrauth)?}}" to i8*), i8** [[T0]])
// CHECK: ret %swift.type* [[METADATA]]
// CHECK: [[ARGS:%.*]] = alloca [1 x ptr], align
// CHECK: [[T0:%.*]] = getelementptr inbounds [1 x ptr], ptr [[ARGS]], i32 0, i32 0
// CHECK: store ptr %T, ptr [[T0]], align
// CHECK: [[METADATA:%.*]] = call ptr @swift_getExtendedExistentialTypeMetadata(ptr @"$sl26existential_shape_metadata2Q0_px1TRts_XPXGMq{{(\.ptrauth)?}}", ptr [[ARGS]])
// CHECK: ret ptr [[METADATA]]
return (any Q0<T>).self
}
// Still the same shape with an application of a complex type.
// CHECK-LABEL: define{{.*}} @"$s26existential_shape_metadata22testComplexApplication
public func testComplexApplication<T>(t: T.Type) -> Any.Type {
// CHECK: [[ARGS:%.*]] = alloca [1 x i8*], align
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s26existential_shape_metadata1BVMa"([[INT]] 255, %swift.type* %T)
// CHECK: [[ARGS:%.*]] = alloca [1 x ptr], align
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @"$s26existential_shape_metadata1BVMa"([[INT]] 255, ptr %T)
// CHECK: [[B_T:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK: [[T0:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[ARGS]], i32 0, i32 0
// CHECK: [[T1:%.*]] = bitcast %swift.type* [[B_T]] to i8*
// CHECK: store i8* [[T1]], i8** [[T0]], align
// CHECK: [[T0:%.*]] = bitcast [1 x i8*]* [[ARGS]] to i8**
// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getExtendedExistentialTypeMetadata({{.*}}@"$sl26existential_shape_metadata2Q0_px1TRts_XPXGMq{{(\.ptrauth)?}}" to i8*), i8** [[T0]])
// CHECK: ret %swift.type* [[METADATA]]
// CHECK: [[T0:%.*]] = getelementptr inbounds [1 x ptr], ptr [[ARGS]], i32 0, i32 0
// CHECK: store ptr [[B_T]], ptr [[T0]], align
// CHECK: [[METADATA:%.*]] = call ptr @swift_getExtendedExistentialTypeMetadata(ptr @"$sl26existential_shape_metadata2Q0_px1TRts_XPXGMq{{(\.ptrauth)?}}", ptr [[ARGS]])
// CHECK: ret ptr [[METADATA]]
return (any Q0<B<T>>).self
}
// Private protocols make the shape private and unique.
// CHECK-LABEL: define{{.*}} @"$s26existential_shape_metadata12test_private
public func test_private<T>(t: T.Type) -> Any.Type {
// CHECK: [[ARGS:%.*]] = alloca [1 x i8*], align
// CHECK: [[T0:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[ARGS]], i32 0, i32 0
// CHECK: [[T1:%.*]] = bitcast %swift.type* %T to i8*
// CHECK: store i8* [[T1]], i8** [[T0]], align
// CHECK: [[T0:%.*]] = bitcast [1 x i8*]* [[ARGS]] to i8**
// CHECK: [[ARGS:%.*]] = alloca [1 x ptr], align
// CHECK: [[T0:%.*]] = getelementptr inbounds [1 x ptr], ptr [[ARGS]], i32 0, i32 0
// CHECK: store ptr %T, ptr [[T0]], align
// FIXME: this should be unique?
// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getExtendedExistentialTypeMetadata_unique({{.*}}@"$sl26existential_shape_metadata2R033_881A0B6978EB4286E7CFF1E27030ACACLL_px1TRts_XPXG{{(\.ptrauth)?}}" to i8*), i8** [[T0]])
// CHECK: ret %swift.type* [[METADATA]]
// CHECK: [[METADATA:%.*]] = call ptr @swift_getExtendedExistentialTypeMetadata_unique(ptr @"$sl26existential_shape_metadata2R033_881A0B6978EB4286E7CFF1E27030ACACLL_px1TRts_XPXG{{(\.ptrauth)?}}", ptr [[ARGS]])
// CHECK: ret ptr [[METADATA]]
return (any R0<T>).self
}
@@ -89,7 +82,7 @@ public func test_private<T>(t: T.Type) -> Any.Type {
// change anything: the shape is still public.
// CHECK-LABEL: define{{.*}} @"$s26existential_shape_metadata23test_privateApplication
public func test_privateApplication<T>(t: T.Type) -> Any.Type {
// CHECK: [[METADATA:%.*]] = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* @"$s26existential_shape_metadata2Q0_pAA1C33_881A0B6978EB4286E7CFF1E27030ACACLLV1TAaBPRts_XPMD")
// CHECK: ret %swift.type* [[METADATA]]
// CHECK: [[METADATA:%.*]] = call ptr @__swift_instantiateConcreteTypeFromMangledName(ptr @"$s26existential_shape_metadata2Q0_pAA1C33_881A0B6978EB4286E7CFF1E27030ACACLLV1TAaBPRts_XPMD")
// CHECK: ret ptr [[METADATA]]
return (any Q0<C>).self
}

444
test/IRGen/existentials_opaque_boxed.sil
View File

@@ -1,5 +1,4 @@
// RUN: %target-swift-frontend %use_no_opaque_pointers -disable-type-layout %s -emit-ir | %FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-%target-ptrsize -DINT=i%target-ptrsize
// RUN: %target-swift-frontend -disable-type-layout %s -emit-ir
// RUN: %target-swift-frontend -disable-type-layout %s -emit-ir | %FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-%target-ptrsize -DINT=i%target-ptrsize
sil_stage canonical
@@ -26,9 +25,7 @@ struct NonFixed<T> : Existential, OtherExistential {
// CHECK-LABEL: define {{.*}} @test_init_existential_non_fixed
// CHECK: [[CONTAINER:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[BITCAST:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]] to %__opaque_existential_type_1*
// CHECK: [[CALL:%.*]] = call %swift.opaque* @__swift_allocate_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BITCAST]])
// CHECK: [[INIT_EXIST_ADDR:%.*]] = bitcast %swift.opaque* [[CALL]] to %T25existentials_opaque_boxed8NonFixedV*
// CHECK: [[CALL:%.*]] = call ptr @__swift_allocate_boxed_opaque_existential_1(ptr [[CONTAINER]])
sil @test_init_existential_non_fixed : $@convention(thin) <T> (@in T) -> () {
entry(%0 : $*T):
@@ -48,38 +45,33 @@ entry(%0 : $*T):
return %t : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_allocate_boxed_opaque_existential_1(%__opaque_existential_type_1* %0)
// CHECK: [[METATYPE_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 1
// CHECK: [[METATYPE:%.*]] = load %swift.type*, %swift.type** [[METATYPE_ADDR]]
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[METATYPE]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, i32* [[FLAGS_ADDR]]
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden ptr @__swift_allocate_boxed_opaque_existential_1(ptr %0)
// CHECK: [[METATYPE_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 1
// CHECK: [[METATYPE:%.*]] = load ptr, ptr [[METATYPE_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METATYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, ptr [[FLAGS_ADDR]]
// CHECK: [[ISNOTINLINE:%.*]] = and i32 [[FLAGS]], 131072
// CHECK: [[ISINLINE:%.*]] = icmp eq i32 [[ISNOTINLINE]], 0
// CHECK: [[EXISTENTIAL_BUFFER:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 0
// CHECK: [[EXISTENTIAL_BUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[EXISTENTIAL_BUFFER]] to %swift.opaque*
// CHECK: [[EXISTENTIAL_BUFFER:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 0
// CHECK: br i1 [[ISINLINE]], label %done, label %allocateBox
//
// CHECK:done:
// CHECK: ret %swift.opaque* [[EXISTENTIAL_BUFFER_OPAQUE]]
// CHECK: ret ptr [[EXISTENTIAL_BUFFER]]
//
// CHECK:allocateBox:
// CHECK: [[CALL:%.*]] = call swiftcc { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* [[METATYPE]])
// CHECK: [[BOX:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[CALL]], 0
// CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[CALL]], 1
// CHECK: [[ADDR_IN_BUFFER:%.*]] = bitcast [{{(24|12)}} x i8]* [[EXISTENTIAL_BUFFER]] to %swift.refcounted**
// CHECK: store %swift.refcounted* [[BOX]], %swift.refcounted** [[ADDR_IN_BUFFER]]
// CHECK: ret %swift.opaque* [[ADDR]]
// CHECK: [[CALL:%.*]] = call swiftcc { ptr, ptr } @swift_allocBox(ptr [[METATYPE]])
// CHECK: [[BOX:%.*]] = extractvalue { ptr, ptr } [[CALL]], 0
// CHECK: [[ADDR:%.*]] = extractvalue { ptr, ptr } [[CALL]], 1
// CHECK: store ptr [[BOX]], ptr [[EXISTENTIAL_BUFFER]]
// CHECK: ret ptr [[ADDR]]
// CHECK-LABEL: define {{.*}} @test_init_existential_fixed
// CHECK: [[CONTAINER:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// The first inline buffer reference is from the emitOpaqueExistentialContainerInit call.
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[INIT_EXIST_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[INLINEBUFFER]] to %T25existentials_opaque_boxed5FixedV*
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr [[CONTAINER]], i32 0, i32 0
sil @test_init_existential_fixed : $@convention(thin) () -> () {
entry:
%exist_container = alloc_stack $Existential
@@ -100,14 +92,11 @@ entry:
// CHECK-LABEL: define {{.*}} @test_init_existential_fixed_not_inline()
// CHECK: [[CONTAINER:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata, i32 0, i32 2), {{(i64 48|i32 40)}}, {{(i64|i32)}} 7)
// CHECK: [[BOX_ADDR:%.*]] = bitcast %swift.refcounted* [[BOX]] to <{ %swift.refcounted{{(, \[4 x i8\])?}}, [32 x i8] }>*
// CHECK: [[VALUE_ADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted{{(, \[4 x i8\])?}}, [32 x i8] }>, <{ %swift.refcounted{{(, \[4 x i8\])?}}, [32 x i8] }>* [[BOX_ADDR]], i32 0, i32 {{(1|2)}}
// CHECK: [[INIT_EXIST_ADDR:%.*]] = bitcast [32 x i8]* [[VALUE_ADDR]] to %T25existentials_opaque_boxed14NotInlineFixedV*
// CHECK: [[INLINEBUFFER_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[INLINEBUFFER]] to %swift.refcounted**
// CHECK: store %swift.refcounted* [[BOX]], %swift.refcounted** [[INLINEBUFFER_ADDR]]
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr [[CONTAINER]], i32 0, i32 0
// CHECK: [[BOX:%.*]] = call noalias ptr @swift_allocObject(ptr getelementptr inbounds (%swift.full_boxmetadata, ptr @metadata, i32 0, i32 2), {{(i64 48|i32 40)}}, {{(i64|i32)}} 7)
// CHECK: [[VALUE_ADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted{{(, \[4 x i8\])?}}, [32 x i8] }>, ptr [[BOX]], i32 0, i32 {{(1|2)}}
// CHECK: store ptr [[BOX]], ptr [[INLINEBUFFER]]
// CHECK: ret void
sil @test_init_existential_fixed_not_inline : $@convention(thin) () -> () {
entry:
@@ -129,8 +118,7 @@ entry:
// CHECK-LABEL: define {{.*}} @test_deinit_existential
// CHECK: [[CONTAINER:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[BITCAST:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]] to %__opaque_existential_type_1*
// CHECK: call void @__swift_deallocate_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BITCAST]])
// CHECK: call void @__swift_deallocate_boxed_opaque_existential_1(ptr [[CONTAINER]])
// CHECK: ret void
sil @test_deinit_existential : $@convention(thin) () -> () {
entry:
@@ -150,15 +138,13 @@ entry:
return %t : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_deallocate_boxed_opaque_existential_1(%__opaque_existential_type_1* %0)
// CHECK: [[META_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 1
// CHECK: [[META:%.*]] = load %swift.type*, %swift.type** [[META_ADDR]]
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[META]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** %3, {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, i32* [[FLAGS_ADDR]]
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_deallocate_boxed_opaque_existential_1(ptr %0)
// CHECK: [[META_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 1
// CHECK: [[META:%.*]] = load ptr, ptr [[META_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr %2, {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, ptr [[FLAGS_ADDR]]
// CHECK: [[ISNOTINLINE:%.*]] = and i32 [[FLAGS]], 131072
// CHECK: [[ISINLINE:%.*]] = icmp eq i32 [[ISNOTINLINE]], 0
// CHECK: br i1 [[ISINLINE]], label %done, label %deallocateBox
@@ -167,15 +153,12 @@ entry:
// CHECK: ret void
// CHECK: deallocateBox:
// CHECK: [[BUFFER:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 0
// CHECK: [[REFERENCE_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[BUFFER]] to %swift.refcounted**
// CHECK: [[REFERENCE:%.*]] = load %swift.refcounted*, %swift.refcounted** [[REFERENCE_ADDR]]
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[META]] to i8***
// CHECK: [[VWT_ADDR2:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT2:%.*]] = load i8**, i8*** [[VWT_ADDR2]]
// CHECK: [[VWT2_CAST:%.*]] = bitcast i8** [[VWT2]] to %swift.vwtable*
// CHECK: [[SIZE2_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT2_CAST]], i32 0, i32 8
// CHECK: [[SIZE:%.*]] = load [[INT]], [[INT]]* [[SIZE2_ADDR]]
// CHECK: [[BUFFER:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 0
// CHECK: [[REFERENCE:%.*]] = load ptr, ptr [[BUFFER]]
// CHECK: [[VWT_ADDR2:%.*]] = getelementptr inbounds ptr, ptr [[META]], {{(i64|i32)}} -1
// CHECK: [[VWT2:%.*]] = load ptr, ptr [[VWT_ADDR2]]
// CHECK: [[SIZE2_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT2]], i32 0, i32 8
// CHECK: [[SIZE:%.*]] = load [[INT]], ptr [[SIZE2_ADDR]]
// CHECK-64:[[T0:%.*]] = zext i32 [[FLAGS]] to i64
// CHECK-64:[[ALIGNMASK:%.*]] = and i64 [[T0]], 255
// CHECK-32:[[ALIGNMASK:%.*]] = and i32 [[FLAGS]], 255
@@ -186,17 +169,15 @@ entry:
// CHECK: [[ALIGNEDSTART:%.*]] = and {{(i64|i32)}} [[HEADERSIZEPLUSALIGN]], [[NOTALIGNMASK]]
// CHECK: [[HEAPSIZE:%.*]] = add {{(i64|i32)}} [[ALIGNEDSTART]], [[SIZE]]
// CHECK: [[ALIGNMASK_ATLEASTPOINTER:%.*]] = or {{(i64|i32)}} [[ALIGNMASK]], {{(7|3)}}
// CHECK: [[PTR:%.*]] = bitcast %swift.refcounted* [[REFERENCE]] to i8*
// CHECK: call void @swift_slowDealloc(i8* [[PTR]], {{(i64|i32)}} [[HEAPSIZE]], {{(i64|i32)}} [[ALIGNMASK_ATLEASTPOINTER]])
// CHECK: call void @swift_slowDealloc(ptr [[REFERENCE]], {{(i64|i32)}} [[HEAPSIZE]], {{(i64|i32)}} [[ALIGNMASK_ATLEASTPOINTER]])
// CHECK: ret void
// CHECK-LABEL: define {{.*}} @test_open_existential_addr_immutable(%T25existentials_opaque_boxed11ExistentialP*
// CHECK: [[META_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 1
// CHECK: [[METATYPE:%.*]] = load %swift.type*, %swift.type** [[META_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 2
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[BUFFER:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* %0 to %__opaque_existential_type_1
// CHECK: [[VALUE_ADDR:%.*]] = call %swift.opaque* @__swift_project_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BUFFER]], %swift.type* [[METATYPE]])
// CHECK-LABEL: define {{.*}} @test_open_existential_addr_immutable(ptr
// CHECK: [[META_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %0, i32 0, i32 1
// CHECK: [[METATYPE:%.*]] = load ptr, ptr [[META_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %0, i32 0, i32 2
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VALUE_ADDR:%.*]] = call ptr @__swift_project_boxed_opaque_existential_1(ptr %0, ptr [[METATYPE]])
// CHECK: ret void
sil @test_open_existential_addr_immutable :$@convention(thin) (@in Existential) -> () {
bb0(%0 : $*Existential):
@@ -205,24 +186,20 @@ bb0(%0 : $*Existential):
return %t : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_project_boxed_opaque_existential_1(%__opaque_existential_type_1* %0, %swift.type* %1)
// CHECK: [[CAST:%.*]] = bitcast %swift.type* %1 to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, i32* [[FLAGS_ADDR]]
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden ptr @__swift_project_boxed_opaque_existential_1(ptr %0, ptr %1)
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr %1, {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, ptr [[FLAGS_ADDR]]
// CHECK: [[ISNOTINLINE:%.*]] = and i32 [[FLAGS]], 131072
// CHECK: [[ISINLINE:%.*]] = icmp eq i32 [[ISNOTINLINE]], 0
// CHECK: [[VALUEADDRINLINE:%.*]] = bitcast %__opaque_existential_type_1* %0 to %swift.opaque*
// CHECK: br i1 [[ISINLINE]], label %done, label %boxed
//
// CHECK: done:
// CHECK: ret %swift.opaque* [[VALUEADDRINLINE]]
// CHECK: ret ptr %0
//
// CHECK: boxed:
// CHECK: [[REFADDR:%.*]] = bitcast %__opaque_existential_type_1* %0 to %swift.refcounted**
// CHECK: [[REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[REFADDR]]
// CHECK: [[REF:%.*]] = load ptr, ptr %0
// CHECK-64:[[T0:%.*]] = zext i32 [[FLAGS]] to i64
// CHECK-64:[[ALIGNMASK:%.*]] = and i64 [[T0]], 255
// CHECK-32:[[ALIGNMASK:%.*]] = and i32 [[FLAGS]], 255
@@ -231,19 +208,16 @@ bb0(%0 : $*Existential):
// CHECK: [[HEADERSIZEPLUSALIGN:%.*]] = add {{(i64 16|i32 8)}}, [[ALIGNMASK]]
// CHECK: [[NOTALIGNMASK:%.*]] = xor {{(i64|i32)}} [[ALIGNMASK]], -1
// CHECK: [[ALIGNEDSTART:%.*]] = and {{(i64|i32)}} [[HEADERSIZEPLUSALIGN]], [[NOTALIGNMASK]]
// CHECK: [[HEAPOBJ:%.*]] = bitcast %swift.refcounted* %9 to i8*
// CHECK: [[STARTOFVALUE:%.*]] = getelementptr inbounds i8, i8* [[HEAPOBJ]], {{(i64|i32)}} [[ALIGNEDSTART]]
// CHECK: [[VALUEADDRBOXED:%.*]] = bitcast i8* [[STARTOFVALUE]] to %swift.opaque*
// CHECK: ret %swift.opaque* [[VALUEADDRBOXED]]
// CHECK: [[STARTOFVALUE:%.*]] = getelementptr inbounds i8, ptr %5, {{(i64|i32)}} [[ALIGNEDSTART]]
// CHECK: ret ptr [[STARTOFVALUE]]
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} {{.*}} @test_open_existential_addr_mutable
// CHECK: [[META_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 1
// CHECK: [[METATYPE:%.*]] = load %swift.type*, %swift.type** [[META_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 2
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[BUFFER:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* %0 to %__opaque_existential_type_1
// CHECK: [[VALUE_ADDR:%.*]] = call %swift.opaque* @__swift_mutable_project_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BUFFER]], %swift.type* [[METATYPE]])
// CHECK: [[META_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %0, i32 0, i32 1
// CHECK: [[METATYPE:%.*]] = load ptr, ptr [[META_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %0, i32 0, i32 2
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VALUE_ADDR:%.*]] = call ptr @__swift_mutable_project_boxed_opaque_existential_1(ptr %0, ptr [[METATYPE]])
// CHECK: ret void
sil @test_open_existential_addr_mutable :$@convention(thin) (@in Existential) -> () {
bb0(%0 : $*Existential):
@@ -252,20 +226,17 @@ bb0(%0 : $*Existential):
return %t : $()
}
// CHECK: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden %swift.opaque* @__swift_mutable_project_boxed_opaque_existential_1(%__opaque_existential_type_1* %0, %swift.type* %1)
// CHECK: [[CAST:%.*]] = bitcast %swift.type* %1 to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, i32* [[FLAGS_ADDR]]
// CHECK: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden ptr @__swift_mutable_project_boxed_opaque_existential_1(ptr %0, ptr %1)
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr %1, {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, ptr [[FLAGS_ADDR]]
// CHECK: [[ISNOTINLINE:%.*]] = and i32 [[FLAGS]], 131072
// CHECK: [[ISINLINE:%.*]] = icmp eq i32 [[ISNOTINLINE]], 0
// CHECK: [[VALUEADDRINLINE:%.*]] = bitcast %__opaque_existential_type_1* %0 to %swift.opaque*
// CHECK: br i1 [[ISINLINE]], label %done, label %boxed
//
// CHECK: done:
// CHECK: ret %swift.opaque* [[VALUEADDRINLINE]]
// CHECK: ret ptr %0
// CHECK: boxed:
// CHECK-64:[[T0:%.*]] = zext i32 [[FLAGS]] to i64
@@ -273,16 +244,14 @@ bb0(%0 : $*Existential):
// CHECK-32:[[ALIGNMASK:%.*]] = and i32 [[FLAGS]], 255
// CHECK-16:[[T0:%.*]] = trunc i32 [[FLAGS]] to i16
// CHECK-16:[[ALIGNMASK:%.*]] = and i16 [[T0]], 255
// CHECK: [[OPAQUE_ADDR:%.*]] = bitcast %__opaque_existential_type_1* %0 to %swift.opaque*
// CHECK: [[REFANDADDR:%.*]] = call swiftcc { %swift.refcounted*, %swift.opaque* } @swift_makeBoxUnique(%swift.opaque* [[OPAQUE_ADDR]], %swift.type* %1, {{(i64|i32)}} [[ALIGNMASK]])
// CHECK: [[REF:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[REFANDADDR]], 0
// CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[REFANDADDR]], 1
// CHECK: ret %swift.opaque* [[ADDR]]
// CHECK: [[REFANDADDR:%.*]] = call swiftcc { ptr, ptr } @swift_makeBoxUnique(ptr %0, ptr %1, {{(i64|i32)}} [[ALIGNMASK]])
// CHECK: [[REF:%.*]] = extractvalue { ptr, ptr } [[REFANDADDR]], 0
// CHECK: [[ADDR:%.*]] = extractvalue { ptr, ptr } [[REFANDADDR]], 1
// CHECK: ret ptr [[ADDR]]
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_destroy_existential_addr(%T25existentials_opaque_boxed11ExistentialP*
// CHECK: [[BITCAST:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* %0 to %__opaque_existential_type_1
// CHECK: call void @__swift_destroy_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BITCAST]])
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_destroy_existential_addr(ptr
// CHECK: call void @__swift_destroy_boxed_opaque_existential_1(ptr %0)
// CHECK: ret void
sil @test_destroy_existential_addr :$@convention(thin) (@in Existential) -> () {
bb0(%0 : $*Existential):
@@ -298,42 +267,34 @@ bb0(%0 : $*OtherExistential):
return %t : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_destroy_boxed_opaque_existential_1(%__opaque_existential_type_1* %0)
// CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 1
// CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]]
// CHECK: [[BUFFER_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 0
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, i32* [[FLAGS_ADDR]]
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_destroy_boxed_opaque_existential_1(ptr %0)
// CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 1
// CHECK: [[METADATA:%.*]] = load ptr, ptr [[METADATA_ADDR]]
// CHECK: [[BUFFER_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 0
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METADATA]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, ptr [[FLAGS_ADDR]]
// CHECK: [[ISNOTINLINE:%.*]] = and i32 [[FLAGS]], 131072
// CHECK: [[ISINLINE:%.*]] = icmp eq i32 [[ISNOTINLINE]], 0
// CHECK: br i1 [[ISINLINE]], label %inline, label %outline
//
// CHECK: inline:
// CHECK: [[OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[BUFFER_ADDR]] to %swift.opaque*
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 1
// CHECK: [[VW:%.*]] = load i8*, i8** [[VW_ADDR]]
// CHECK: [[DESTROY:%.*]] = bitcast i8* [[VW]] to void (%swift.opaque*, %swift.type*)*
// CHECK: call void [[DESTROY]](%swift.opaque* noalias [[OPAQUE]], %swift.type* [[METADATA]])
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[METADATA]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 1
// CHECK: [[VW:%.*]] = load ptr, ptr [[VW_ADDR]]
// CHECK: call void [[VW]](ptr noalias [[BUFFER_ADDR]], ptr [[METADATA]])
// CHECK: ret void
//
// CHECK: outline:
// CHECK: [[REFERENCE_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[BUFFER_ADDR]] to %swift.refcounted**
// CHECK: [[REFERENCE:%.*]] = load %swift.refcounted*, %swift.refcounted** [[REFERENCE_ADDR]]
// CHECK: call void @swift_release(%swift.refcounted* [[REFERENCE]])
// CHECK: [[REFERENCE:%.*]] = load ptr, ptr [[BUFFER_ADDR]]
// CHECK: call void @swift_release(ptr [[REFERENCE]])
// CHECK: ret void
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_assignWithCopy_existential_addr(%T25existentials_opaque_boxed11ExistentialP*
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_assignWithCopy_existential_addr(ptr
// CHECK: [[ALLOCA:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[DST:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* [[ALLOCA]] to %__opaque_existential_type_1
// CHECK: [[SRC:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* %0 to %__opaque_existential_type_1
// CHECK: call void @__swift_assign_boxed_opaque_existential_1(%__opaque_existential_type_1* [[DST]], %__opaque_existential_type_1* [[SRC]])
// CHECK: call void @__swift_assign_boxed_opaque_existential_1(ptr [[ALLOCA]], ptr %0)
// CHECK: ret void
// CHECK:}
sil @test_assignWithCopy_existential_addr : $@convention(thin) (@in Existential) -> () {
@@ -354,158 +315,125 @@ bb0(%0 : $*OtherExistential):
return %t : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_assign_boxed_opaque_existential_1(%__opaque_existential_type_1* %0, %__opaque_existential_type_1* %1)
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} linkonce_odr hidden void @__swift_assign_boxed_opaque_existential_1(ptr %0, ptr %1)
// CHECK: [[TMPBUFFER:%.*]] = alloca [{{(24|12)}} x i8]
// CHECK: [[SELFASSIGN:%.*]] = icmp eq %__opaque_existential_type_1* %0, %1
// CHECK: [[SELFASSIGN:%.*]] = icmp eq ptr %0, %1
// CHECK: br i1 [[SELFASSIGN]], label %done, label %cont
//
// CHECK: cont:
// CHECK: [[DEST_BUFFERADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 0
// CHECK: [[SRC_BUFFERADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %1, i32 0, i32 0
// CHECK: [[DEST_TYPEADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 1
// CHECK: [[DEST_TYPE:%.*]] = load %swift.type*, %swift.type** [[DEST_TYPEADDR]]
// CHECK: [[SRC_TYPEADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %1, i32 0, i32 1
// CHECK: [[SRC_TYPE:%.*]] = load %swift.type*, %swift.type** [[SRC_TYPEADDR]]
// CHECK: [[ISSAME:%.*]] = icmp eq %swift.type* [[DEST_TYPE]], [[SRC_TYPE]]
// CHECK: [[DEST_BUFFERADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 0
// CHECK: [[SRC_BUFFERADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %1, i32 0, i32 0
// CHECK: [[DEST_TYPEADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 1
// CHECK: [[DEST_TYPE:%.*]] = load ptr, ptr [[DEST_TYPEADDR]]
// CHECK: [[SRC_TYPEADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %1, i32 0, i32 1
// CHECK: [[SRC_TYPE:%.*]] = load ptr, ptr [[SRC_TYPEADDR]]
// CHECK: [[ISSAME:%.*]] = icmp eq ptr [[DEST_TYPE]], [[SRC_TYPE]]
// CHECK: br i1 [[ISSAME]], label %match, label %no-match
//
// CHECK: match:
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[DEST_TYPE]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VWT_CAST:%.*]] = bitcast i8** [[VWT]] to %swift.vwtable*
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[VWT_CAST]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, i32* [[FLAGS_ADDR]]
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[DEST_TYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[VWT]], i32 0, i32 10
// CHECK: [[FLAGS:%.*]] = load i32, ptr [[FLAGS_ADDR]]
// CHECK: [[ISNOTINLINE:%.*]] = and i32 [[FLAGS]], 131072
// CHECK: [[ISINLINE:%.*]] = icmp eq i32 [[ISNOTINLINE]], 0
// CHECK: br i1 [[ISINLINE]], label %match-inline, label %match-outline
//
// CHECK: match-inline:
// CHECK: [[DEST_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.opaque*
// CHECK: [[SRC_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.opaque*
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[DEST_TYPE]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 3
// CHECK: [[VW:%.*]] = load i8*, i8** [[VW_ADDR]]
// CHECK: [[ASSIGNWITHCOPY:%.*]] = bitcast i8* [[VW]] to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*
// CHECK: call %swift.opaque* [[ASSIGNWITHCOPY]](%swift.opaque* [[DEST_OPAQUE]], %swift.opaque* [[SRC_OPAQUE]], %swift.type* [[DEST_TYPE]])
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[DEST_TYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 3
// CHECK: [[VW:%.*]] = load ptr, ptr [[VW_ADDR]]
// CHECK: call ptr [[VW]](ptr [[DEST_BUFFERADDR]], ptr [[SRC_BUFFERADDR]], ptr [[DEST_TYPE]])
// CHECK: br label %done
//
// CHECK: match-outline:
// CHECK: [[DEST_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[DEST_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[DEST_REFADDR]]
// CHECK: [[SRC_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[SRC_REFADDR]]
// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[SRC_REF]])
// CHECK: call void @swift_release(%swift.refcounted* [[DEST_REF]])
// CHECK: store %swift.refcounted* [[SRC_REF]], %swift.refcounted** [[DEST_REFADDR]]
// CHECK: [[DEST_REF:%.*]] = load ptr, ptr [[DEST_BUFFERADDR]]
// CHECK: [[SRC_REF:%.*]] = load ptr, ptr [[SRC_BUFFERADDR]]
// CHECK: call ptr @swift_retain(ptr returned [[SRC_REF]])
// CHECK: call void @swift_release(ptr [[DEST_REF]])
// CHECK: store ptr [[SRC_REF]], ptr [[DEST_BUFFERADDR]]
// CHECK: br label %done
// CHECK: no-match:
// CHECK: store %swift.type* [[SRC_TYPE]], %swift.type** [[DEST_TYPEADDR]]
// CHECK: [[DEST_PWT_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %0, i32 0, i32 2
// CHECK: [[SRC_PWT_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, %__opaque_existential_type_1* %1, i32 0, i32 2
// CHECK: [[SRC_PTW:%.*]] = load i8**, i8*** [[SRC_PWT_ADDR]]
// CHECK: store i8** [[SRC_PTW]], i8*** [[DEST_PWT_ADDR]]
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[DEST_TYPE]] to i8***
// CHECK: [[DEST_VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[DEST_VWT:%.*]] = load i8**, i8*** [[DEST_VWT_ADDR]]
// CHECK: [[DEST_VWT_CAST:%.*]] = bitcast i8** [[DEST_VWT]] to %swift.vwtable*
// CHECK: [[DEST_FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[DEST_VWT_CAST]], i32 0, i32 10
// CHECK: [[DEST_FLAGS:%.*]] = load i32, i32* [[DEST_FLAGS_ADDR]]
// CHECK: store ptr [[SRC_TYPE]], ptr [[DEST_TYPEADDR]]
// CHECK: [[DEST_PWT_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %0, i32 0, i32 2
// CHECK: [[SRC_PWT_ADDR:%.*]] = getelementptr inbounds %__opaque_existential_type_1, ptr %1, i32 0, i32 2
// CHECK: [[SRC_PTW:%.*]] = load ptr, ptr [[SRC_PWT_ADDR]]
// CHECK: store ptr [[SRC_PTW]], ptr [[DEST_PWT_ADDR]]
// CHECK: [[DEST_VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[DEST_TYPE]], {{(i64|i32)}} -1
// CHECK: [[DEST_VWT:%.*]] = load ptr, ptr [[DEST_VWT_ADDR]]
// CHECK: [[DEST_FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[DEST_VWT]], i32 0, i32 10
// CHECK: [[DEST_FLAGS:%.*]] = load i32, ptr [[DEST_FLAGS_ADDR]]
// CHECK: [[DEST_ISNOTINLINE:%.*]] = and i32 [[DEST_FLAGS]], 131072
// CHECK: [[DEST_ISINLINE:%.*]] = icmp eq i32 [[DEST_ISNOTINLINE]], 0
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[SRC_TYPE]] to i8***
// CHECK: [[SRC_VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[SRC_VWT:%.*]] = load i8**, i8*** [[SRC_VWT_ADDR]]
// CHECK: [[SRC_VWT_CAST:%.*]] = bitcast i8** [[SRC_VWT]] to %swift.vwtable*
// CHECK: [[SRC_FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, %swift.vwtable* [[SRC_VWT_CAST]], i32 0, i32 10
// CHECK: [[SRC_FLAGS:%.*]] = load i32, i32* [[SRC_FLAGS_ADDR]]
// CHECK: [[SRC_VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[SRC_TYPE]], {{(i64|i32)}} -1
// CHECK: [[SRC_VWT:%.*]] = load ptr, ptr [[SRC_VWT_ADDR]]
// CHECK: [[SRC_FLAGS_ADDR:%.*]] = getelementptr inbounds %swift.vwtable, ptr [[SRC_VWT]], i32 0, i32 10
// CHECK: [[SRC_FLAGS:%.*]] = load i32, ptr [[SRC_FLAGS_ADDR]]
// CHECK: [[SRC_ISNOTINLINE:%.*]] = and i32 [[SRC_FLAGS]], 131072
// CHECK: [[SRC_ISINLINE:%.*]] = icmp eq i32 [[SRC_ISNOTINLINE]], 0
// CHECK: br i1 [[DEST_ISINLINE]], label %dest-inline, label %dest-outline
//
// CHECK: dest-inline:
// CHECK: [[TMPBUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[TMPBUFFER]] to %swift.opaque*
// CHECK: [[DESTBUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.opaque*
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[DEST_TYPE]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 4
// CHECK: [[VW:%.*]] = load i8*, i8** [[VW_ADDR]]
// CHECK: [[INITWITHTAKE:%.*]] = bitcast i8* [[VW]] to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*
// CHECK: call %swift.opaque* [[INITWITHTAKE]](%swift.opaque* noalias [[TMPBUFFER_OPAQUE]], %swift.opaque* noalias [[DESTBUFFER_OPAQUE]], %swift.type* [[DEST_TYPE]])
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[DEST_TYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 4
// CHECK: [[VW:%.*]] = load ptr, ptr [[VW_ADDR]]
// CHECK: call ptr [[VW]](ptr noalias [[TMPBUFFER]], ptr noalias [[DEST_BUFFERADDR]], ptr [[DEST_TYPE]])
// CHECK: br i1 [[SRC_ISINLINE]], label %dest-inline-src-inline, label %dest-inline-src-outline
//
// CHECK: dest-inline-src-inline:
// CHECK: [[DESTBUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.opaque*
// CHECK: [[SRCBUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.opaque*
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[SRC_TYPE]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
// CHECK: [[VW:%.*]] = load i8*, i8** [[VW_ADDR]]
// CHECK: [[INITWITHCOPY:%.*]] = bitcast i8* [[VW]] to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*
// CHECK: call %swift.opaque* [[INITWITHCOPY]](%swift.opaque* noalias [[DESTBUFFER_OPAQUE]], %swift.opaque* noalias [[SRCBUFFER_OPAQUE]], %swift.type* [[SRC_TYPE]])
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[SRC_TYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 2
// CHECK: [[VW:%.*]] = load ptr, ptr [[VW_ADDR]]
// CHECK: call ptr [[VW]](ptr noalias [[DEST_BUFFERADDR]], ptr noalias [[SRC_BUFFERADDR]], ptr [[SRC_TYPE]])
// CHECK: br label %dest-inline-cont
//
// CHECK: dest-inline-src-outline:
// CHECK: [[DEST_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[SRC_REFADDR]]
// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[SRC_REF]])
// CHECK: store %swift.refcounted* [[SRC_REF]], %swift.refcounted** [[DEST_REFADDR]]
// CHECK: [[SRC_REF:%.*]] = load ptr, ptr [[SRC_BUFFERADDR]]
// CHECK: call ptr @swift_retain(ptr returned [[SRC_REF]])
// CHECK: store ptr [[SRC_REF]], ptr [[DEST_BUFFERADDR]]
// CHECK: br label %dest-inline-cont
//
// CHECK: dest-inline-cont:
// CHECK: [[TMPBUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[TMPBUFFER]] to %swift.opaque*
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[DEST_TYPE]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 1
// CHECK: [[VW:%.*]] = load i8*, i8** [[VW_ADDR]]
// CHECK: [[DESTROY:%.*]] = bitcast i8* [[VW]] to void (%swift.opaque*, %swift.type*)*
// CHECK: call void [[DESTROY]](%swift.opaque* noalias [[TMPBUFFER_OPAQUE]], %swift.type* [[DEST_TYPE]])
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[DEST_TYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 1
// CHECK: [[VW:%.*]] = load ptr, ptr [[VW_ADDR]]
// CHECK: call void [[VW]](ptr noalias [[TMPBUFFER]], ptr [[DEST_TYPE]])
// CHECK: br label %done
//
// CHECK: dest-outline:
// CHECK: [[DEST_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[DEST_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[DEST_REFADDR]]
// CHECK: [[DEST_REF:%.*]] = load ptr, ptr [[DEST_BUFFERADDR]]
// CHECK: br i1 [[SRC_ISINLINE]], label %dest-outline-src-inline, label %dest-outline-src-outline
//
// CHECK: dest-outline-src-inline:
// CHECK: [[DESTBUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.opaque*
// CHECK: [[SRCBUFFER_OPAQUE:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.opaque*
// CHECK: [[CAST:%.*]] = bitcast %swift.type* [[SRC_TYPE]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
// CHECK: [[VW:%.*]] = load i8*, i8** [[VW_ADDR]]
// CHECK: [[INITWITHCOPY:%.*]] = bitcast i8* [[VW]] to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*
// CHECK: call %swift.opaque* [[INITWITHCOPY]](%swift.opaque* noalias [[DESTBUFFER_OPAQUE]], %swift.opaque* noalias [[SRCBUFFER_OPAQUE]], %swift.type* [[SRC_TYPE]])
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[SRC_TYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VW_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 2
// CHECK: [[VW:%.*]] = load ptr, ptr [[VW_ADDR]]
// CHECK: call ptr [[VW]](ptr noalias [[DEST_BUFFERADDR]], ptr noalias [[SRC_BUFFERADDR]], ptr [[SRC_TYPE]])
// CHECK: br label %dest-outline-cont
//
// CHECK: dest-outline-src-outline:
// CHECK: [[DEST_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[SRC_REFADDR]]
// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[SRC_REF]])
// CHECK: store %swift.refcounted* [[SRC_REF]], %swift.refcounted** [[DEST_REFADDR]]
// CHECK: [[SRC_REF:%.*]] = load ptr, ptr [[SRC_BUFFERADDR]]
// CHECK: call ptr @swift_retain(ptr returned [[SRC_REF]])
// CHECK: store ptr [[SRC_REF]], ptr [[DEST_BUFFERADDR]]
// CHECK: br label %dest-outline-cont
//
// CHECK: dest-outline-cont:
// CHECK: call void @swift_release(%swift.refcounted* [[DEST_REF]])
// CHECK: call void @swift_release(ptr [[DEST_REF]])
// CHECK: br label %done
//
// CHECK: done:
// CHECK: ret void
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_assignWithTake_existential_addr(%T25existentials_opaque_boxed11ExistentialP*
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_assignWithTake_existential_addr(ptr
// CHECK: [[ALLOCA:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[BITCAST:%.*]] = bitcast %T25existentials_opaque_boxed11ExistentialP* [[ALLOCA]] to %__opaque_existential_type_1
// CHECK: call void @__swift_destroy_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BITCAST]])
// CHECK: call %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOb"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* [[ALLOCA]])
// CHECK: call void @__swift_destroy_boxed_opaque_existential_1(ptr [[ALLOCA]])
// CHECK: call ptr @"$s25existentials_opaque_boxed11Existential_pWOb"(ptr %0, ptr [[ALLOCA]])
// CHECK: ret void
sil @test_assignWithTake_existential_addr : $@convention(thin) (@in Existential) -> () {
bb0(%0 : $*Existential):
@@ -525,15 +453,13 @@ bb0(%0 : $*OtherExistential):
return %t : $()
}
// CHECK-LABEL: define linkonce_odr hidden %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOb"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* %1)
// CHECK: %2 = bitcast %T25existentials_opaque_boxed11ExistentialP* %1 to i8*
// CHECK: %3 = bitcast %T25existentials_opaque_boxed11ExistentialP* %0 to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.{{(i64|i32)}}(i8* align {{(8|4)}} %2, i8* align {{(8|4)}} %3, {{(i64 40|i32 20)}}, i1 false)
// CHECK: ret %T25existentials_opaque_boxed11ExistentialP* %1
// CHECK-LABEL: define linkonce_odr hidden ptr @"$s25existentials_opaque_boxed11Existential_pWOb"(ptr %0, ptr %1)
// CHECK: call void @llvm.memcpy.p0.p0.{{(i64|i32)}}(ptr align {{(8|4)}} %1, ptr align {{(8|4)}} %0, {{(i64 40|i32 20)}}, i1 false)
// CHECK: ret ptr %1
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_initWithTake_existential_addr(%T25existentials_opaque_boxed11ExistentialP*
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_initWithTake_existential_addr(ptr
// CHECK: [[LOCAL:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: call %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOb"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* [[LOCAL]])
// CHECK: call ptr @"$s25existentials_opaque_boxed11Existential_pWOb"(ptr %0, ptr [[LOCAL]])
// CHECK: ret void
sil @test_initWithTake_existential_addr : $@convention(thin) (@in Existential) -> () {
bb0(%0 : $*Existential):
@@ -553,28 +479,26 @@ bb0(%0 : $*OtherExistential):
return %t : $()
}
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_initWithCopy_existential_addr(%T25existentials_opaque_boxed11ExistentialP*
// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @test_initWithCopy_existential_addr(ptr
// CHECK: [[LOCAL:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: call %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOc"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* [[LOCAL]])
// CHECK: call ptr @"$s25existentials_opaque_boxed11Existential_pWOc"(ptr %0, ptr [[LOCAL]])
// CHECK: ret void
// CHECK-LABEL: define linkonce_odr hidden %T25existentials_opaque_boxed11ExistentialP* @"$s25existentials_opaque_boxed11Existential_pWOc"(%T25existentials_opaque_boxed11ExistentialP* %0, %T25existentials_opaque_boxed11ExistentialP* %1)
// CHECK: [[TYPE_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 1
// CHECK: [[ARG_TYPE:%.*]] = load %swift.type*, %swift.type** [[TYPE_ADDR]]
// CHECK: [[LOCAL_TYPE_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %1, i32 0, i32 1
// CHECK: store %swift.type* [[ARG_TYPE]], %swift.type** [[LOCAL_TYPE_ADDR]]
// CHECK: [[PWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 2
// CHECK: [[PWT:%.*]] = load i8**, i8*** [[PWT_ADDR]]
// CHECK: [[LOCAL_PWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %1, i32 0, i32 2
// CHECK: store i8** [[PWT]], i8*** [[LOCAL_PWT_ADDR]]
// CHECK: [[BUFFER_ARG_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %0, i32 0, i32 0
// CHECK: [[BUFFER_LOCAL_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* %1, i32 0, i32 0
// CHECK: [[CAST_ADDR:%.*]] = bitcast %swift.type* [[ARG_TYPE]] to i8***
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[CAST_ADDR]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
// CHECK: [[VW:%.*]] = load i8*, i8** [[VWT]]
// CHECK: [[INITWITHCOPYBUFFER:%.*]] = bitcast i8* [[VW]]
// CHECK: call %swift.opaque* [[INITWITHCOPYBUFFER]]({{.*}} noalias [[BUFFER_LOCAL_ADDR]], {{.*}} noalias [[BUFFER_ARG_ADDR]], %swift.type* [[ARG_TYPE]])
// CHECK: ret %T25existentials_opaque_boxed11ExistentialP* %1
// CHECK-LABEL: define linkonce_odr hidden ptr @"$s25existentials_opaque_boxed11Existential_pWOc"(ptr %0, ptr %1)
// CHECK: [[TYPE_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %0, i32 0, i32 1
// CHECK: [[ARG_TYPE:%.*]] = load ptr, ptr [[TYPE_ADDR]]
// CHECK: [[LOCAL_TYPE_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %1, i32 0, i32 1
// CHECK: store ptr [[ARG_TYPE]], ptr [[LOCAL_TYPE_ADDR]]
// CHECK: [[PWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %0, i32 0, i32 2
// CHECK: [[PWT:%.*]] = load ptr, ptr [[PWT_ADDR]]
// CHECK: [[LOCAL_PWT_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %1, i32 0, i32 2
// CHECK: store ptr [[PWT]], ptr [[LOCAL_PWT_ADDR]]
// CHECK: [[BUFFER_ARG_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %0, i32 0, i32 0
// CHECK: [[BUFFER_LOCAL_ADDR:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr %1, i32 0, i32 0
// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[ARG_TYPE]], {{(i64|i32)}} -1
// CHECK: [[VWT:%.*]] = load ptr, ptr [[VWT_ADDR]]
// CHECK: [[VW:%.*]] = load ptr, ptr [[VWT]]
// CHECK: call ptr [[VW]]({{.*}} noalias [[BUFFER_LOCAL_ADDR]], {{.*}} noalias [[BUFFER_ARG_ADDR]], ptr [[ARG_TYPE]])
// CHECK: ret ptr %1
sil @test_initWithCopy_existential_addr : $@convention(thin) (@in Existential) -> () {
bb0(%0 : $*Existential):
%s = alloc_stack $Existential
@@ -602,15 +526,11 @@ struct FixedOveralign : Existential {
// CHECK-LABEL: define {{.*}} @test_init_existential_fixed_align_not_inline()
// CHECK: [[CONTAINER:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata.4, i32 0, i32 2), {{(i64|i32)}} 32, {{(i64|i32)}} 15)
// CHECK-64: [[BOX_ADDR:%.*]] = bitcast %swift.refcounted* [[BOX]] to [[BOX_TYPE:<{ %swift.refcounted, \[16 x i8\] }>]]*
// CHECK-32: [[BOX_ADDR:%.*]] = bitcast %swift.refcounted* [[BOX]] to [[BOX_TYPE:<{ %swift.refcounted, \[8 x i8\], \[16 x i8\] }>]]*
// CHECK: [[VALUE_ADDR:%.*]] = getelementptr inbounds [[BOX_TYPE]], [[BOX_TYPE]]* [[BOX_ADDR]], i32 0, i32 {{(1|2)}}
// CHECK: [[INIT_EXIST_ADDR:%.*]] = bitcast [16 x i8]* [[VALUE_ADDR]] to %T25existentials_opaque_boxed14FixedOveralignV*
// CHECK: [[INLINEBUFFER_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[INLINEBUFFER]] to %swift.refcounted**
// CHECK: store %swift.refcounted* [[BOX]], %swift.refcounted** [[INLINEBUFFER_ADDR]]
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, ptr [[CONTAINER]], i32 0, i32 0
// CHECK: [[BOX:%.*]] = call noalias ptr @swift_allocObject(ptr getelementptr inbounds (%swift.full_boxmetadata, ptr @metadata.4, i32 0, i32 2), {{(i64|i32)}} 32, {{(i64|i32)}} 15)
// CHECK: [[VALUE_ADDR:%.*]] = getelementptr inbounds {{.*}}, ptr [[BOX]], i32 0, i32 {{(1|2)}}
// CHECK: store ptr [[BOX]], ptr [[INLINEBUFFER]]
// CHECK: ret void
sil @test_init_existential_fixed_align_not_inline : $@convention(thin) () -> () {
entry:

93
test/IRGen/generic_metatypes.swift
View File

@@ -1,15 +1,15 @@
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-apple-macosx10.9 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target i386-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-apple-tvos9.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target i386-apple-watchos2.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-unknown-linux-gnu -disable-objc-interop -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-apple-macosx10.9 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target i386-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-apple-tvos9.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target i386-apple-watchos2.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target x86_64-unknown-linux-gnu -disable-objc-interop -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target armv7-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target arm64-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target arm64-apple-tvos9.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -disable-generic-metadata-prespecialization -module-name generic_metatypes -target armv7k-apple-watchos2.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target armv7-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target arm64-apple-ios7.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target arm64-apple-tvos9.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -disable-generic-metadata-prespecialization -module-name generic_metatypes -target armv7k-apple-watchos2.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// REQUIRES: CODEGENERATOR=X86
// REQUIRES: CODEGENERATOR=ARM
@@ -23,25 +23,25 @@ public func type<T, Metatype>(of value: T) -> Metatype {
never()
}
// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture %0, %swift.type* [[TYPE:%.*]])
// CHECK: define hidden swiftcc ptr [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](ptr noalias nocapture %0, ptr [[TYPE:%.*]])
func genericTypeof<T>(_ x: T) -> T.Type {
// CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* {{.*}}, %swift.type* [[TYPE]], i1 false)
// CHECK: ret %swift.type* [[METATYPE]]
// CHECK: [[METATYPE:%.*]] = call ptr @swift_getDynamicType(ptr {{.*}}, ptr [[TYPE]], i1 false)
// CHECK: ret ptr [[METATYPE]]
return type(of: x)
}
struct Foo {}
class Bar {}
// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC* %0) {{.*}} {
// CHECK-LABEL: define hidden swiftcc ptr @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(ptr %0) {{.*}} {
func remapToSubstitutedMetatypes(_ x: Foo, y: Bar)
-> (Foo.Type, Bar.Type)
{
// CHECK: call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture undef, %swift.type* {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}})
// CHECK: call swiftcc ptr [[GENERIC_TYPEOF]](ptr noalias nocapture undef, ptr {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}})
// CHECK: [[BAR_REQUEST:%.*]] = call {{.*}}@"$s17generic_metatypes3BarCMa"
// CHECK: [[BAR:%.*]] = extractvalue {{.*}} [[BAR_REQUEST]]
// CHECK: [[BAR_META:%.*]] = call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture {{%.*}}, %swift.type* [[BAR]])
// CHECK: ret %swift.type* [[BAR_META]]
// CHECK: [[BAR_META:%.*]] = call swiftcc ptr [[GENERIC_TYPEOF]](ptr noalias nocapture {{%.*}}, ptr [[BAR]])
// CHECK: ret ptr [[BAR_META]]
return (genericTypeof(x), genericTypeof(y))
}
@@ -50,7 +50,7 @@ func remapToSubstitutedMetatypes(_ x: Foo, y: Bar)
func remapToGenericMetatypes() {
// CHECK: [[BAR_REQUEST:%.*]] = call {{.*}}@"$s17generic_metatypes3BarCMa"
// CHECK: [[BAR:%.*]] = extractvalue {{.*}} [[BAR_REQUEST]]
// CHECK: call swiftcc void @"$s17generic_metatypes0A9Metatypes{{.*}}"(%swift.type* {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} %swift.type* [[BAR]], %swift.type* {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} %swift.type* [[BAR]])
// CHECK: call swiftcc void @"$s17generic_metatypes0A9Metatypes{{.*}}"(ptr {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} ptr [[BAR]], ptr {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} ptr [[BAR]])
genericMetatypes(Foo.self, Bar.self)
}
@@ -58,36 +58,35 @@ func genericMetatypes<T, U>(_ t: T.Type, _ u: U.Type) {}
protocol Bas {}
// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}}) %0)
// CHECK: define hidden swiftcc { ptr, ptr } @"$s17generic_metatypes14protocolTypeof{{.*}}"(ptr noalias nocapture dereferenceable({{.*}}) %0)
func protocolTypeof(_ x: Bas) -> Bas.Type {
// CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X:%.*]], i32 0, i32 1
// CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]]
// CHECK: [[BUFFER:%.*]] = bitcast %T17generic_metatypes3BasP* [[X]] to %__opaque_existential_type_1*
// CHECK: [[VALUE_ADDR:%.*]] = call %swift.opaque* @__swift_project_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BUFFER]], %swift.type* [[METADATA]])
// CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* [[VALUE_ADDR]], %swift.type* [[METADATA]], i1 true)
// CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* %0, i32 0, i32 2
// CHECK: [[WTABLE:%.*]] = load i8**, i8*** [[WTABLE_ADDR]]
// CHECK-NOT: call void @__swift_destroy_boxed_opaque_existential_1(%T17generic_metatypes3BasP* %0)
// CHECK: [[T0:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* [[METATYPE]], 0
// CHECK: [[T1:%.*]] = insertvalue { %swift.type*, i8** } [[T0]], i8** [[WTABLE]], 1
// CHECK: ret { %swift.type*, i8** } [[T1]]
// CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, ptr [[X:%.*]], i32 0, i32 1
// CHECK: [[METADATA:%.*]] = load ptr, ptr [[METADATA_ADDR]]
// CHECK: [[VALUE_ADDR:%.*]] = call ptr @__swift_project_boxed_opaque_existential_1(ptr [[X]], ptr [[METADATA]])
// CHECK: [[METATYPE:%.*]] = call ptr @swift_getDynamicType(ptr [[VALUE_ADDR]], ptr [[METADATA]], i1 true)
// CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, ptr %0, i32 0, i32 2
// CHECK: [[WTABLE:%.*]] = load ptr, ptr [[WTABLE_ADDR]]
// CHECK-NOT: call void @__swift_destroy_boxed_opaque_existential_1(ptr %0)
// CHECK: [[T0:%.*]] = insertvalue { ptr, ptr } undef, ptr [[METATYPE]], 0
// CHECK: [[T1:%.*]] = insertvalue { ptr, ptr } [[T0]], ptr [[WTABLE]], 1
// CHECK: ret { ptr, ptr } [[T1]]
return type(of: x)
}
struct Zim : Bas {}
class Zang : Bas {}
// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA3ZimVmF"() #0
// CHECK-LABEL: define hidden swiftcc { ptr, ptr } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA3ZimVmF"() #0
func metatypeErasure(_ z: Zim.Type) -> Bas.Type {
// CHECK: ret { %swift.type*, i8** } {{.*}} @"$s17generic_metatypes3ZimVMf", {{.*}} @"$s17generic_metatypes3ZimVAA3BasAAWP"
// CHECK: ret { ptr, ptr } {{.*}} @"$s17generic_metatypes3ZimVMf", {{.*}} @"$s17generic_metatypes3ZimVAA3BasAAWP"
return z
}
// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type* %0)
// CHECK-LABEL: define hidden swiftcc { ptr, ptr } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(ptr %0)
func metatypeErasure(_ z: Zang.Type) -> Bas.Type {
// CHECK: [[RET:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* %0, 0
// CHECK: [[RET2:%.*]] = insertvalue { %swift.type*, i8** } [[RET]], i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"$s17generic_metatypes4ZangCAA3BasAAWP", i32 0, i32 0), 1
// CHECK: ret { %swift.type*, i8** } [[RET2]]
// CHECK: [[RET:%.*]] = insertvalue { ptr, ptr } undef, ptr %0, 0
// CHECK: [[RET2:%.*]] = insertvalue { ptr, ptr } [[RET]], ptr @"$s17generic_metatypes4ZangCAA3BasAAWP", 1
// CHECK: ret { ptr, ptr } [[RET2]]
return z
}
@@ -118,30 +117,24 @@ func makeGenericMetatypes() {
}
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes6OneArgVMa"
// CHECK-SAME: ([[INT]] %0, %swift.type* %1)
// CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* undef, i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes6OneArgVMn" {{.*}})
// CHECK-SAME: ([[INT]] %0, ptr %1)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, ptr %1, ptr undef, ptr undef, ptr @"$s17generic_metatypes6OneArgVMn")
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes7TwoArgsVMa"
// CHECK-SAME: ([[INT]] %0, %swift.type* %1, %swift.type* %2)
// CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1
// CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* [[BITCAST_2]], i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes7TwoArgsVMn" {{.*}})
// CHECK-SAME: ([[INT]] %0, ptr %1, ptr %2)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, ptr %1, ptr %2, ptr undef, ptr @"$s17generic_metatypes7TwoArgsVMn")
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes9ThreeArgsVMa"
// CHECK-SAME: ({{i[0-9]+}} %0, %swift.type* %1, %swift.type* %2, %swift.type* %3)
// CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1
// CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2
// CHECK: [[BITCAST_3:%.*]] = bitcast {{.*}} %3
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* [[BITCAST_2]], i8* [[BITCAST_3]], %swift.type_descriptor* {{.*}} @"$s17generic_metatypes9ThreeArgsVMn" {{.*}})
// CHECK-SAME: ({{i[0-9]+}} %0, ptr %1, ptr %2, ptr %3)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, ptr %1, ptr %2, ptr %3, ptr @"$s17generic_metatypes9ThreeArgsVMn")
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes8FiveArgsVMa"
// CHECK-SAME: ([[INT]] %0, i8** %1) [[NOUNWIND_OPT:#[0-9]+]]
// CHECK-SAME: ([[INT]] %0, ptr %1) [[NOUNWIND_OPT:#[0-9]+]]
// CHECK-NOT: alloc
// CHECK: call swiftcc %swift.metadata_response @swift_getGenericMetadata([[INT]] %0, i8* {{.*}}, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes8FiveArgsVMn" {{.*}})
// CHECK: call swiftcc %swift.metadata_response @swift_getGenericMetadata([[INT]] %0, ptr {{.*}}, ptr @"$s17generic_metatypes8FiveArgsVMn")
// CHECK-NOT: call void @llvm.lifetime.end
// CHECK: ret %swift.metadata_response

118
test/IRGen/generic_metatypes_future.swift
View File

@@ -1,14 +1,14 @@
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-apple-macosx99.99 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-apple-macosx99.99 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-apple-macosx99.99 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-apple-ios99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-apple-tvos99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target i386-apple-watchos9.99 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-unknown-linux-gnu -disable-objc-interop -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-apple-ios99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-apple-tvos99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target i386-apple-watchos9.99 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target x86_64-unknown-linux-gnu -disable-objc-interop -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target arm64-apple-ios99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target arm64-apple-tvos99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift %use_no_opaque_pointers -prespecialize-generic-metadata -module-name generic_metatypes -target armv7k-apple-watchos9.99 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target arm64-apple-ios99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target arm64-apple-tvos99.0 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 -DINT=i64 %s
// RUN: %swift -prespecialize-generic-metadata -module-name generic_metatypes -target armv7k-apple-watchos9.99 -emit-ir -disable-legacy-type-info -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 -DINT=i32 %s
// REQUIRES: VENDOR=apple || OS=linux-gnu
@@ -24,25 +24,25 @@ public func type<T, Metatype>(of value: T) -> Metatype {
never()
}
// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture %0, %swift.type* [[TYPE:%.*]])
// CHECK: define hidden swiftcc ptr [[GENERIC_TYPEOF:@"\$s17generic_metatypes0A6TypeofyxmxlF"]](ptr noalias nocapture %0, ptr [[TYPE:%.*]])
func genericTypeof<T>(_ x: T) -> T.Type {
// CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* {{.*}}, %swift.type* [[TYPE]], i1 false)
// CHECK: ret %swift.type* [[METATYPE]]
// CHECK: [[METATYPE:%.*]] = call ptr @swift_getDynamicType(ptr {{.*}}, ptr [[TYPE]], i1 false)
// CHECK: ret ptr [[METATYPE]]
return type(of: x)
}
struct Foo {}
class Bar {}
// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC* %0) {{.*}} {
// CHECK-LABEL: define hidden swiftcc ptr @"$s17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(ptr %0) {{.*}} {
func remapToSubstitutedMetatypes(_ x: Foo, y: Bar)
-> (Foo.Type, Bar.Type)
{
// CHECK: call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture undef, %swift.type* {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}})
// CHECK: call swiftcc ptr [[GENERIC_TYPEOF]](ptr noalias nocapture undef, ptr {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}})
// CHECK: [[BAR_REQUEST:%.*]] = call {{.*}}@"$s17generic_metatypes3BarCMa"
// CHECK: [[BAR:%.*]] = extractvalue {{.*}} [[BAR_REQUEST]]
// CHECK: [[BAR_META:%.*]] = call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture {{%.*}}, %swift.type* [[BAR]])
// CHECK: ret %swift.type* [[BAR_META]]
// CHECK: [[BAR_META:%.*]] = call swiftcc ptr [[GENERIC_TYPEOF]](ptr noalias nocapture {{%.*}}, ptr [[BAR]])
// CHECK: ret ptr [[BAR_META]]
return (genericTypeof(x), genericTypeof(y))
}
@@ -51,7 +51,7 @@ func remapToSubstitutedMetatypes(_ x: Foo, y: Bar)
func remapToGenericMetatypes() {
// CHECK: [[BAR_REQUEST:%.*]] = call {{.*}}@"$s17generic_metatypes3BarCMa"
// CHECK: [[BAR:%.*]] = extractvalue {{.*}} [[BAR_REQUEST]]
// CHECK: call swiftcc void @"$s17generic_metatypes0A9Metatypes{{.*}}"(%swift.type* {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} %swift.type* [[BAR]], %swift.type* {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} %swift.type* [[BAR]])
// CHECK: call swiftcc void @"$s17generic_metatypes0A9Metatypes{{.*}}"(ptr {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} ptr [[BAR]], ptr {{.*}} @"$s17generic_metatypes3FooVMf", {{.*}} ptr [[BAR]])
genericMetatypes(Foo.self, Bar.self)
}
@@ -59,36 +59,35 @@ func genericMetatypes<T, U>(_ t: T.Type, _ u: U.Type) {}
protocol Bas {}
// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}}) %0)
// CHECK: define hidden swiftcc { ptr, ptr } @"$s17generic_metatypes14protocolTypeof{{.*}}"(ptr noalias nocapture dereferenceable({{.*}}) %0)
func protocolTypeof(_ x: Bas) -> Bas.Type {
// CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X:%.*]], i32 0, i32 1
// CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]]
// CHECK: [[BUFFER:%.*]] = bitcast %T17generic_metatypes3BasP* [[X]] to %__opaque_existential_type_1*
// CHECK: [[VALUE_ADDR:%.*]] = call %swift.opaque* @__swift_project_boxed_opaque_existential_1(%__opaque_existential_type_1* [[BUFFER]], %swift.type* [[METADATA]])
// CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* [[VALUE_ADDR]], %swift.type* [[METADATA]], i1 true)
// CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* %0, i32 0, i32 2
// CHECK: [[WTABLE:%.*]] = load i8**, i8*** [[WTABLE_ADDR]]
// CHECK-NOT: call void @__swift_destroy_boxed_opaque_existential_1(%T17generic_metatypes3BasP* %0)
// CHECK: [[T0:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* [[METATYPE]], 0
// CHECK: [[T1:%.*]] = insertvalue { %swift.type*, i8** } [[T0]], i8** [[WTABLE]], 1
// CHECK: ret { %swift.type*, i8** } [[T1]]
// CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, ptr [[X:%.*]], i32 0, i32 1
// CHECK: [[METADATA:%.*]] = load ptr, ptr [[METADATA_ADDR]]
// CHECK: [[VALUE_ADDR:%.*]] = call ptr @__swift_project_boxed_opaque_existential_1(ptr [[X]], ptr [[METADATA]])
// CHECK: [[METATYPE:%.*]] = call ptr @swift_getDynamicType(ptr [[VALUE_ADDR]], ptr [[METADATA]], i1 true)
// CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, ptr %0, i32 0, i32 2
// CHECK: [[WTABLE:%.*]] = load ptr, ptr [[WTABLE_ADDR]]
// CHECK-NOT: call void @__swift_destroy_boxed_opaque_existential_1(ptr %0)
// CHECK: [[T0:%.*]] = insertvalue { ptr, ptr } undef, ptr [[METATYPE]], 0
// CHECK: [[T1:%.*]] = insertvalue { ptr, ptr } [[T0]], ptr [[WTABLE]], 1
// CHECK: ret { ptr, ptr } [[T1]]
return type(of: x)
}
struct Zim : Bas {}
class Zang : Bas {}
// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA3ZimVmF"() #0
// CHECK-LABEL: define hidden swiftcc { ptr, ptr } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA3ZimVmF"() #0
func metatypeErasure(_ z: Zim.Type) -> Bas.Type {
// CHECK: ret { %swift.type*, i8** } {{.*}} @"$s17generic_metatypes3ZimVMf", {{.*}} @"$s17generic_metatypes3ZimVAA3BasAAWP"
// CHECK: ret { ptr, ptr } {{.*}} @"$s17generic_metatypes3ZimVMf", {{.*}} @"$s17generic_metatypes3ZimVAA3BasAAWP"
return z
}
// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type* %0) #0
// CHECK-LABEL: define hidden swiftcc { ptr, ptr } @"$s17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(ptr %0) #0
func metatypeErasure(_ z: Zang.Type) -> Bas.Type {
// CHECK: [[RET:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* %0, 0
// CHECK: [[RET2:%.*]] = insertvalue { %swift.type*, i8** } [[RET]], i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"$s17generic_metatypes4ZangCAA3BasAAWP", i32 0, i32 0), 1
// CHECK: ret { %swift.type*, i8** } [[RET2]]
// CHECK: [[RET:%.*]] = insertvalue { ptr, ptr } undef, ptr %0, 0
// CHECK: [[RET2:%.*]] = insertvalue { ptr, ptr } [[RET]], ptr @"$s17generic_metatypes4ZangCAA3BasAAWP", 1
// CHECK: ret { ptr, ptr } [[RET2]]
return z
}
@@ -103,34 +102,15 @@ func genericMetatype<A>(_ x: A.Type) {}
// CHECK-LABEL: define hidden swiftcc void @"$s17generic_metatypes20makeGenericMetatypesyyF"() {{.*}} {
func makeGenericMetatypes() {
// CHECK: call swiftcc void @"$s17generic_metatypes0A8MetatypeyyxmlF"(
// CHECK-SAME: %swift.type* getelementptr inbounds (
// CHECK-SAME: %swift.full_type, %swift.full_type* bitcast (
// CHECK-SAME: <{
// CHECK-SAME: i8*,
// CHECK-SAME: i8**,
// CHECK-SAME: [[INT]],
// CHECK-SAME: %swift.type_descriptor*,
// CHECK-SAME: %swift.type*,
// CHECK-SAME: i64
// CHECK-SAME: }>* @"$s17generic_metatypes6OneArgVyAA3FooVGMf"
// CHECK-SAME: to %swift.full_type*
// CHECK-SAME: ),
// CHECK-SAME: ptr getelementptr inbounds (
// CHECK-SAME: %swift.full_type,
// CHECK-SAME: ptr @"$s17generic_metatypes6OneArgVyAA3FooVGMf",
// CHECK-SAME: i32 0,
// CHECK-SAME: i32 2
// CHECK-SAME: ),
// CHECK-SAME: %swift.type* getelementptr inbounds (
// CHECK-SAME: ptr getelementptr inbounds (
// CHECK-SAME: %swift.full_type,
// CHECK-SAME: %swift.full_type* bitcast (
// CHECK-SAME: <{
// CHECK-SAME: i8*,
// CHECK-SAME: i8**,
// CHECK-SAME: [[INT]],
// CHECK-SAME: %swift.type_descriptor*,
// CHECK-SAME: %swift.type*,
// CHECK-SAME: i64
// CHECK-SAME: }>* @"$s17generic_metatypes6OneArgVyAA3FooVGMf"
// CHECK-SAME: to %swift.full_type*
// CHECK-SAME: ),
// CHECK-SAME: ptr @"$s17generic_metatypes6OneArgVyAA3FooVGMf",
// CHECK-SAME: i32 0,
// CHECK-SAME: i32 2
// CHECK-SAME: )
@@ -151,30 +131,24 @@ func makeGenericMetatypes() {
}
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes6OneArgVMa"
// CHECK-SAME: ([[INT]] %0, %swift.type* %1)
// CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateCanonicalPrespecializedGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* undef, i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes6OneArgVMn" {{.*}})
// CHECK-SAME: ([[INT]] %0, ptr %1)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateCanonicalPrespecializedGenericMetadata([[INT]] %0, ptr %1, ptr undef, ptr undef, ptr @"$s17generic_metatypes6OneArgVMn", ptr @"$s17generic_metatypes6OneArgVMz")
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes7TwoArgsVMa"
// CHECK-SAME: ([[INT]] %0, %swift.type* %1, %swift.type* %2)
// CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1
// CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* [[BITCAST_2]], i8* undef, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes7TwoArgsVMn" {{.*}})
// CHECK-SAME: ([[INT]] %0, ptr %1, ptr %2)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, ptr %1, ptr %2, ptr undef, ptr @"$s17generic_metatypes7TwoArgsVMn")
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes9ThreeArgsVMa"
// CHECK-SAME: ({{i[0-9]+}} %0, %swift.type* %1, %swift.type* %2, %swift.type* %3)
// CHECK: [[BITCAST_1:%.*]] = bitcast {{.*}} %1
// CHECK: [[BITCAST_2:%.*]] = bitcast {{.*}} %2
// CHECK: [[BITCAST_3:%.*]] = bitcast {{.*}} %3
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, i8* [[BITCAST_1]], i8* [[BITCAST_2]], i8* [[BITCAST_3]], %swift.type_descriptor* {{.*}} @"$s17generic_metatypes9ThreeArgsVMn" {{.*}})
// CHECK-SAME: ({{i[0-9]+}} %0, ptr %1, ptr %2, ptr %3)
// CHECK: [[T0:%.*]] = call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata([[INT]] %0, ptr %1, ptr %2, ptr %3, ptr @"$s17generic_metatypes9ThreeArgsVMn")
// CHECK: [[METADATA:%.*]] = extractvalue %swift.metadata_response [[T0]], 0
// CHECK-LABEL: define hidden swiftcc %swift.metadata_response @"$s17generic_metatypes8FiveArgsVMa"
// CHECK-SAME: ([[INT]] %0, i8** %1) [[NOUNWIND_OPT:#[0-9]+]]
// CHECK-SAME: ([[INT]] %0, ptr %1) [[NOUNWIND_OPT:#[0-9]+]]
// CHECK-NOT: alloc
// CHECK: call swiftcc %swift.metadata_response @swift_getGenericMetadata([[INT]] %0, i8* {{.*}}, %swift.type_descriptor* {{.*}} @"$s17generic_metatypes8FiveArgsVMn" {{.*}})
// CHECK: call swiftcc %swift.metadata_response @swift_getGenericMetadata([[INT]] %0, ptr {{.*}}, ptr @"$s17generic_metatypes8FiveArgsVMn")
// CHECK-NOT: call void @llvm.lifetime.end
// CHECK: ret %swift.metadata_response