1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s 2 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s --check-prefix=X86-64 3 // RUN: %clang_cc1 -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s 4 // RUN: %clang_cc1 -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s --check-prefix=ARM64 5 6 // REQUIRES: aarch64-registered-target,x86-registered-target 7 8 #define SWIFTCALL __attribute__((swiftcall)) 9 #define OUT __attribute__((swift_indirect_result)) 10 #define ERROR __attribute__((swift_error_result)) 11 #define CONTEXT __attribute__((swift_context)) 12 13 // CHECK: [[STRUCT2_RESULT:@.*]] = private {{.*}} constant [[STRUCT2_TYPE:%.*]] { i32 0, i8 0, i8 undef, i8 0, float 0.000000e+00, float 0.000000e+00 } 14 15 /*****************************************************************************/ 16 /****************************** PARAMETER ABIS *******************************/ 17 /*****************************************************************************/ 18 19 SWIFTCALL void indirect_result_1(OUT int *arg0, OUT float *arg1) {} 20 // CHECK-LABEL: define {{.*}} void @indirect_result_1(i32* noalias sret align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}}) 21 22 // TODO: maybe this shouldn't suppress sret. 23 SWIFTCALL int indirect_result_2(OUT int *arg0, OUT float *arg1) { __builtin_unreachable(); } 24 // CHECK-LABEL: define {{.*}} i32 @indirect_result_2(i32* noalias align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}}) 25 26 typedef struct { char array[1024]; } struct_reallybig; 27 SWIFTCALL struct_reallybig indirect_result_3(OUT int *arg0, OUT float *arg1) { __builtin_unreachable(); } 28 // CHECK-LABEL: define {{.*}} void @indirect_result_3({{.*}}* noalias sret {{.*}}, i32* noalias align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}}) 29 30 SWIFTCALL void context_1(CONTEXT void *self) {} 31 // CHECK-LABEL: define {{.*}} void @context_1(i8* swiftself 32 33 SWIFTCALL void context_2(void *arg0, CONTEXT void *self) {} 34 // CHECK-LABEL: define {{.*}} void @context_2(i8*{{.*}}, i8* swiftself 35 36 SWIFTCALL void context_error_1(CONTEXT int *self, ERROR float **error) {} 37 // CHECK-LABEL: define {{.*}} void @context_error_1(i32* swiftself{{.*}}, float** swifterror) 38 // CHECK: [[TEMP:%.*]] = alloca float*, align 8 39 // CHECK: [[T0:%.*]] = load float*, float** [[ERRORARG:%.*]], align 8 40 // CHECK: store float* [[T0]], float** [[TEMP]], align 8 41 // CHECK: [[T0:%.*]] = load float*, float** [[TEMP]], align 8 42 // CHECK: store float* [[T0]], float** [[ERRORARG]], align 8 43 void test_context_error_1() { 44 int x; 45 float *error; 46 context_error_1(&x, &error); 47 } 48 // CHECK-LABEL: define void @test_context_error_1() 49 // CHECK: [[X:%.*]] = alloca i32, align 4 50 // CHECK: [[ERROR:%.*]] = alloca float*, align 8 51 // CHECK: [[TEMP:%.*]] = alloca swifterror float*, align 8 52 // CHECK: [[T0:%.*]] = load float*, float** [[ERROR]], align 8 53 // CHECK: store float* [[T0]], float** [[TEMP]], align 8 54 // CHECK: call [[SWIFTCC:swiftcc]] void @context_error_1(i32* swiftself [[X]], float** swifterror [[TEMP]]) 55 // CHECK: [[T0:%.*]] = load float*, float** [[TEMP]], align 8 56 // CHECK: store float* [[T0]], float** [[ERROR]], align 8 57 58 SWIFTCALL void context_error_2(short s, CONTEXT int *self, ERROR float **error) {} 59 // CHECK-LABEL: define {{.*}} void @context_error_2(i16{{.*}}, i32* swiftself{{.*}}, float** swifterror) 60 61 /*****************************************************************************/ 62 /********************************** LOWERING *********************************/ 63 /*****************************************************************************/ 64 65 typedef float float3 __attribute__((ext_vector_type(3))); 66 typedef float float4 __attribute__((ext_vector_type(4))); 67 typedef float float8 __attribute__((ext_vector_type(8))); 68 typedef double double2 __attribute__((ext_vector_type(2))); 69 typedef double double4 __attribute__((ext_vector_type(4))); 70 typedef int int3 __attribute__((ext_vector_type(3))); 71 typedef int int4 __attribute__((ext_vector_type(4))); 72 typedef int int5 __attribute__((ext_vector_type(5))); 73 typedef int int8 __attribute__((ext_vector_type(8))); 74 typedef char char16 __attribute__((ext_vector_type(16))); 75 typedef short short8 __attribute__((ext_vector_type(8))); 76 typedef long long long2 __attribute__((ext_vector_type(2))); 77 78 #define TEST(TYPE) \ 79 SWIFTCALL TYPE return_##TYPE(void) { \ 80 TYPE result = {}; \ 81 return result; \ 82 } \ 83 SWIFTCALL void take_##TYPE(TYPE v) { \ 84 } \ 85 void test_##TYPE() { \ 86 take_##TYPE(return_##TYPE()); \ 87 } 88 89 /*****************************************************************************/ 90 /*********************************** STRUCTS *********************************/ 91 /*****************************************************************************/ 92 93 typedef struct { 94 } struct_empty; 95 TEST(struct_empty); 96 // CHECK-LABEL: define {{.*}} @return_struct_empty() 97 // CHECK: ret void 98 // CHECK-LABEL: define {{.*}} @take_struct_empty() 99 // CHECK: ret void 100 101 typedef struct { 102 int x; 103 char c0; 104 char c1; 105 float f0; 106 float f1; 107 } struct_1; 108 TEST(struct_1); 109 // CHECK-LABEL: define swiftcc { i64, i64 } @return_struct_1() {{.*}}{ 110 // CHECK: [[RET:%.*]] = alloca [[STRUCT1:%.*]], align 4 111 // CHECK: call void @llvm.memset 112 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT1]]* %retval to { i64, i64 }* 113 // CHECK: [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 114 // CHECK: [[T0:%.*]] = load i64, i64* [[GEP0]], align 4 115 // CHECK: [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 116 // CHECK: [[T1:%.*]] = load i64, i64* [[GEP1]], align 4 117 // CHECK: [[R0:%.*]] = insertvalue { i64, i64 } undef, i64 [[T0]], 0 118 // CHECK: [[R1:%.*]] = insertvalue { i64, i64 } [[R0]], i64 [[T1]], 1 119 // CHECK: ret { i64, i64 } [[R1]] 120 // CHECK: } 121 // CHECK-LABEL: define swiftcc void @take_struct_1(i64, i64) {{.*}}{ 122 // CHECK: [[V:%.*]] = alloca [[STRUCT1:%.*]], align 4 123 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT1]]* [[V]] to { i64, i64 }* 124 // CHECK: [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 125 // CHECK: store i64 %0, i64* [[GEP0]], align 4 126 // CHECK: [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 127 // CHECK: store i64 %1, i64* [[GEP1]], align 4 128 // CHECK: ret void 129 // CHECK: } 130 // CHECK-LABEL: define void @test_struct_1() {{.*}}{ 131 // CHECK: [[AGG:%.*]] = alloca [[STRUCT1:%.*]], align 4 132 // CHECK: [[RET:%.*]] = call swiftcc { i64, i64 } @return_struct_1() 133 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT1]]* [[AGG]] to { i64, i64 }* 134 // CHECK: [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 135 // CHECK: [[E0:%.*]] = extractvalue { i64, i64 } [[RET]], 0 136 // CHECK: store i64 [[E0]], i64* [[GEP0]], align 4 137 // CHECK: [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 138 // CHECK: [[E1:%.*]] = extractvalue { i64, i64 } [[RET]], 1 139 // CHECK: store i64 [[E1]], i64* [[GEP1]], align 4 140 // CHECK: [[CAST2:%.*]] = bitcast [[STRUCT1]]* [[AGG]] to { i64, i64 }* 141 // CHECK: [[GEP2:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST2]], i32 0, i32 0 142 // CHECK: [[V0:%.*]] = load i64, i64* [[GEP2]], align 4 143 // CHECK: [[GEP3:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST2]], i32 0, i32 1 144 // CHECK: [[V1:%.*]] = load i64, i64* [[GEP3]], align 4 145 // CHECK: call swiftcc void @take_struct_1(i64 [[V0]], i64 [[V1]]) 146 // CHECK: ret void 147 // CHECK: } 148 149 typedef struct { 150 int x; 151 char c0; 152 __attribute__((aligned(2))) char c1; 153 float f0; 154 float f1; 155 } struct_2; 156 TEST(struct_2); 157 // CHECK-LABEL: define swiftcc { i64, i64 } @return_struct_2() {{.*}}{ 158 // CHECK: [[RET:%.*]] = alloca [[STRUCT2_TYPE]], align 4 159 // CHECK: [[CASTVAR:%.*]] = bitcast {{.*}} [[RET]] 160 // CHECK: call void @llvm.memcpy{{.*}}({{.*}}[[CASTVAR]], {{.*}}[[STRUCT2_RESULT]] 161 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT2_TYPE]]* [[RET]] to { i64, i64 }* 162 // CHECK: [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 163 // CHECK: [[T0:%.*]] = load i64, i64* [[GEP0]], align 4 164 // CHECK: [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 165 // CHECK: [[T1:%.*]] = load i64, i64* [[GEP1]], align 4 166 // CHECK: [[R0:%.*]] = insertvalue { i64, i64 } undef, i64 [[T0]], 0 167 // CHECK: [[R1:%.*]] = insertvalue { i64, i64 } [[R0]], i64 [[T1]], 1 168 // CHECK: ret { i64, i64 } [[R1]] 169 // CHECK: } 170 // CHECK-LABEL: define swiftcc void @take_struct_2(i64, i64) {{.*}}{ 171 // CHECK: [[V:%.*]] = alloca [[STRUCT:%.*]], align 4 172 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT]]* [[V]] to { i64, i64 }* 173 // CHECK: [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 174 // CHECK: store i64 %0, i64* [[GEP0]], align 4 175 // CHECK: [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 176 // CHECK: store i64 %1, i64* [[GEP1]], align 4 177 // CHECK: ret void 178 // CHECK: } 179 // CHECK-LABEL: define void @test_struct_2() {{.*}} { 180 // CHECK: [[TMP:%.*]] = alloca [[STRUCT2_TYPE]], align 4 181 // CHECK: [[CALL:%.*]] = call swiftcc { i64, i64 } @return_struct_2() 182 // CHECK: [[CAST_TMP:%.*]] = bitcast [[STRUCT2_TYPE]]* [[TMP]] to { i64, i64 }* 183 // CHECK: [[GEP:%.*]] = getelementptr inbounds {{.*}} [[CAST_TMP]], i32 0, i32 0 184 // CHECK: [[T0:%.*]] = extractvalue { i64, i64 } [[CALL]], 0 185 // CHECK: store i64 [[T0]], i64* [[GEP]], align 4 186 // CHECK: [[GEP:%.*]] = getelementptr inbounds {{.*}} [[CAST_TMP]], i32 0, i32 1 187 // CHECK: [[T0:%.*]] = extractvalue { i64, i64 } [[CALL]], 1 188 // CHECK: store i64 [[T0]], i64* [[GEP]], align 4 189 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT2_TYPE]]* [[TMP]] to { i64, i64 }* 190 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 191 // CHECK: [[R0:%.*]] = load i64, i64* [[GEP]], align 4 192 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 193 // CHECK: [[R1:%.*]] = load i64, i64* [[GEP]], align 4 194 // CHECK: call swiftcc void @take_struct_2(i64 [[R0]], i64 [[R1]]) 195 // CHECK: ret void 196 // CHECK: } 197 198 // There's no way to put a field randomly in the middle of an otherwise 199 // empty storage unit in C, so that case has to be tested in C++, which 200 // can use empty structs to introduce arbitrary padding. (In C, they end up 201 // with size 0 and so don't affect layout.) 202 203 // Misaligned data rule. 204 typedef struct { 205 char c0; 206 __attribute__((packed)) float f; 207 } struct_misaligned_1; 208 TEST(struct_misaligned_1) 209 // CHECK-LABEL: define swiftcc i64 @return_struct_misaligned_1() 210 // CHECK: [[RET:%.*]] = alloca [[STRUCT:%.*]], align 1 211 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT]]* [[RET]] to i8* 212 // CHECK: call void @llvm.memset{{.*}}(i8* align 1 [[CAST]], i8 0, i64 5 213 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT]]* [[RET]] to { i64 }* 214 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0 215 // CHECK: [[R0:%.*]] = load i64, i64* [[GEP]], align 1 216 // CHECK: ret i64 [[R0]] 217 // CHECK:} 218 // CHECK-LABEL: define swiftcc void @take_struct_misaligned_1(i64) {{.*}}{ 219 // CHECK: [[V:%.*]] = alloca [[STRUCT:%.*]], align 1 220 // CHECK: [[CAST:%.*]] = bitcast [[STRUCT]]* [[V]] to { i64 }* 221 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0 222 // CHECK: store i64 %0, i64* [[GEP]], align 1 223 // CHECK: ret void 224 // CHECK: } 225 // CHECK: define void @test_struct_misaligned_1() {{.*}}{ 226 // CHECK: [[AGG:%.*]] = alloca [[STRUCT:%.*]], align 1 227 // CHECK: [[CALL:%.*]] = call swiftcc i64 @return_struct_misaligned_1() 228 // CHECK: [[T0:%.*]] = bitcast [[STRUCT]]* [[AGG]] to { i64 }* 229 // CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0 230 // CHECK: store i64 [[CALL]], i64* [[T1]], align 1 231 // CHECK: [[T0:%.*]] = bitcast [[STRUCT]]* [[AGG]] to { i64 }* 232 // CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0 233 // CHECK: [[P:%.*]] = load i64, i64* [[T1]], align 1 234 // CHECK: call swiftcc void @take_struct_misaligned_1(i64 [[P]]) 235 // CHECK: ret void 236 // CHECK: } 237 238 // Too many scalars. 239 typedef struct { 240 long long x[5]; 241 } struct_big_1; 242 TEST(struct_big_1) 243 244 // CHECK-LABEL: define {{.*}} void @return_struct_big_1({{.*}} noalias sret 245 246 // Should not be byval. 247 // CHECK-LABEL: define {{.*}} void @take_struct_big_1({{.*}}*{{( %.*)?}}) 248 249 /*****************************************************************************/ 250 /********************************* TYPE MERGING ******************************/ 251 /*****************************************************************************/ 252 253 typedef union { 254 float f; 255 double d; 256 } union_het_fp; 257 TEST(union_het_fp) 258 // CHECK-LABEL: define swiftcc i64 @return_union_het_fp() 259 // CHECK: [[RET:%.*]] = alloca [[UNION:%.*]], align 8 260 // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to i8* 261 // CHECK: call void @llvm.memcpy{{.*}}(i8* align 8 [[CAST]] 262 // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to { i64 }* 263 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0 264 // CHECK: [[R0:%.*]] = load i64, i64* [[GEP]], align 8 265 // CHECK: ret i64 [[R0]] 266 // CHECK-LABEL: define swiftcc void @take_union_het_fp(i64) {{.*}}{ 267 // CHECK: [[V:%.*]] = alloca [[UNION:%.*]], align 8 268 // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[V]] to { i64 }* 269 // CHECK: [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0 270 // CHECK: store i64 %0, i64* [[GEP]], align 8 271 // CHECK: ret void 272 // CHECK: } 273 // CHECK-LABEL: define void @test_union_het_fp() {{.*}}{ 274 // CHECK: [[AGG:%.*]] = alloca [[UNION:%.*]], align 8 275 // CHECK: [[CALL:%.*]] = call swiftcc i64 @return_union_het_fp() 276 // CHECK: [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }* 277 // CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0 278 // CHECK: store i64 [[CALL]], i64* [[T1]], align 8 279 // CHECK: [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }* 280 // CHECK: [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0 281 // CHECK: [[V0:%.*]] = load i64, i64* [[T1]], align 8 282 // CHECK: call swiftcc void @take_union_het_fp(i64 [[V0]]) 283 // CHECK: ret void 284 // CHECK: } 285 286 287 typedef union { 288 float f1; 289 float f2; 290 } union_hom_fp; 291 TEST(union_hom_fp) 292 // CHECK-LABEL: define void @test_union_hom_fp() 293 // CHECK: [[TMP:%.*]] = alloca [[REC:%.*]], align 4 294 // CHECK: [[CALL:%.*]] = call [[SWIFTCC]] float @return_union_hom_fp() 295 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG:{ float }]]* 296 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 297 // CHECK: store float [[CALL]], float* [[T0]], align 4 298 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]* 299 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 300 // CHECK: [[FIRST:%.*]] = load float, float* [[T0]], align 4 301 // CHECK: call [[SWIFTCC]] void @take_union_hom_fp(float [[FIRST]]) 302 // CHECK: ret void 303 304 typedef union { 305 float f1; 306 float4 fv2; 307 } union_hom_fp_partial; 308 TEST(union_hom_fp_partial) 309 // CHECK: define void @test_union_hom_fp_partial() 310 // CHECK: [[AGG:%.*]] = alloca [[UNION:%.*]], align 16 311 // CHECK: [[CALL:%.*]] = call swiftcc { i64, i64 } @return_union_hom_fp_partial() 312 // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64, i64 }* 313 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 314 // CHECK: [[T1:%.*]] = extractvalue { i64, i64 } [[CALL]], 0 315 // CHECK: store i64 [[T1]], i64* [[T0]], align 16 316 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 317 // CHECK: [[T1:%.*]] = extractvalue { i64, i64 } [[CALL]], 1 318 // CHECK: store i64 [[T1]], i64* [[T0]], align 8 319 // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64, i64 }* 320 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 321 // CHECK: [[V0:%.*]] = load i64, i64* [[T0]], align 16 322 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 323 // CHECK: [[V1:%.*]] = load i64, i64* [[T0]], align 8 324 // CHECK: call swiftcc void @take_union_hom_fp_partial(i64 [[V0]], i64 [[V1]]) 325 // CHECK: ret void 326 // CHECK: } 327 328 typedef union { 329 struct { int x, y; } f1; 330 float4 fv2; 331 } union_het_fpv_partial; 332 TEST(union_het_fpv_partial) 333 // CHECK-LABEL: define void @test_union_het_fpv_partial() 334 // CHECK: [[AGG:%.*]] = alloca [[UNION:%.*]], align 16 335 // CHECK: [[CALL:%.*]] = call swiftcc { i64, i64 } @return_union_het_fpv_partial() 336 // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64, i64 }* 337 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 338 // CHECK: [[T1:%.*]] = extractvalue { i64, i64 } [[CALL]], 0 339 // CHECK: store i64 [[T1]], i64* [[T0]], align 16 340 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 341 // CHECK: [[T1:%.*]] = extractvalue { i64, i64 } [[CALL]], 1 342 // CHECK: store i64 [[T1]], i64* [[T0]], align 8 343 // CHECK: [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64, i64 }* 344 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0 345 // CHECK: [[V0:%.*]] = load i64, i64* [[T0]], align 16 346 // CHECK: [[T0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1 347 // CHECK: [[V1:%.*]] = load i64, i64* [[T0]], align 8 348 // CHECK: call swiftcc void @take_union_het_fpv_partial(i64 [[V0]], i64 [[V1]]) 349 // CHECK: ret void 350 // CHECK: } 351 352 /*****************************************************************************/ 353 /****************************** VECTOR LEGALIZATION **************************/ 354 /*****************************************************************************/ 355 356 TEST(int4) 357 // CHECK-LABEL: define {{.*}} <4 x i32> @return_int4() 358 // CHECK-LABEL: define {{.*}} @take_int4(<4 x i32> 359 360 TEST(int8) 361 // CHECK-LABEL: define {{.*}} @return_int8() 362 // CHECK: [[RET:%.*]] = alloca [[REC:<8 x i32>]], align 16 363 // CHECK: [[VAR:%.*]] = alloca [[REC]], align 364 // CHECK: store 365 // CHECK: load 366 // CHECK: store 367 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ <4 x i32>, <4 x i32> }]]* 368 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 369 // CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align 370 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 371 // CHECK: [[SECOND:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align 372 // CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ <4 x i32>, <4 x i32> }]] undef, <4 x i32> [[FIRST]], 0 373 // CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], <4 x i32> [[SECOND]], 1 374 // CHECK: ret [[UAGG]] [[T1]] 375 // CHECK-LABEL: define {{.*}} @take_int8(<4 x i32>, <4 x i32>) 376 // CHECK: [[V:%.*]] = alloca [[REC]], align 377 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]* 378 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 379 // CHECK: store <4 x i32> %0, <4 x i32>* [[T0]], align 380 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 381 // CHECK: store <4 x i32> %1, <4 x i32>* [[T0]], align 382 // CHECK: ret void 383 // CHECK-LABEL: define void @test_int8() 384 // CHECK: [[TMP1:%.*]] = alloca [[REC]], align 385 // CHECK: [[TMP2:%.*]] = alloca [[REC]], align 386 // CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_int8() 387 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP1]] to [[AGG]]* 388 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 389 // CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0 390 // CHECK: store <4 x i32> [[T1]], <4 x i32>* [[T0]], align 391 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 392 // CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1 393 // CHECK: store <4 x i32> [[T1]], <4 x i32>* [[T0]], align 394 // CHECK: [[V:%.*]] = load [[REC]], [[REC]]* [[TMP1]], align 395 // CHECK: store [[REC]] [[V]], [[REC]]* [[TMP2]], align 396 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP2]] to [[AGG]]* 397 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 398 // CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align 399 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 400 // CHECK: [[SECOND:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align 401 // CHECK: call [[SWIFTCC]] void @take_int8(<4 x i32> [[FIRST]], <4 x i32> [[SECOND]]) 402 // CHECK: ret void 403 404 TEST(int5) 405 // CHECK-LABEL: define {{.*}} @return_int5() 406 // CHECK: [[RET:%.*]] = alloca [[REC:<5 x i32>]], align 16 407 // CHECK: [[VAR:%.*]] = alloca [[REC]], align 408 // CHECK: store 409 // CHECK: load 410 // CHECK: store 411 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ <4 x i32>, i32 }]]* 412 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 413 // CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align 414 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 415 // CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 416 // CHECK: [[T0:%.*]] = insertvalue [[UAGG:{ <4 x i32>, i32 }]] undef, <4 x i32> [[FIRST]], 0 417 // CHECK: [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i32 [[SECOND]], 1 418 // CHECK: ret [[UAGG]] [[T1]] 419 // CHECK-LABEL: define {{.*}} @take_int5(<4 x i32>, i32) 420 // CHECK: [[V:%.*]] = alloca [[REC]], align 421 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]* 422 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 423 // CHECK: store <4 x i32> %0, <4 x i32>* [[T0]], align 424 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 425 // CHECK: store i32 %1, i32* [[T0]], align 426 // CHECK: ret void 427 // CHECK-LABEL: define void @test_int5() 428 // CHECK: [[TMP1:%.*]] = alloca [[REC]], align 429 // CHECK: [[TMP2:%.*]] = alloca [[REC]], align 430 // CHECK: [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_int5() 431 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP1]] to [[AGG]]* 432 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 433 // CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0 434 // CHECK: store <4 x i32> [[T1]], <4 x i32>* [[T0]], align 435 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 436 // CHECK: [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1 437 // CHECK: store i32 [[T1]], i32* [[T0]], align 438 // CHECK: [[V:%.*]] = load [[REC]], [[REC]]* [[TMP1]], align 439 // CHECK: store [[REC]] [[V]], [[REC]]* [[TMP2]], align 440 // CHECK: [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP2]] to [[AGG]]* 441 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0 442 // CHECK: [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align 443 // CHECK: [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1 444 // CHECK: [[SECOND:%.*]] = load i32, i32* [[T0]], align 445 // CHECK: call [[SWIFTCC]] void @take_int5(<4 x i32> [[FIRST]], i32 [[SECOND]]) 446 // CHECK: ret void 447 448 typedef struct { 449 int x; 450 int3 v __attribute__((packed)); 451 } misaligned_int3; 452 TEST(misaligned_int3) 453 // CHECK-LABEL: define swiftcc void @take_misaligned_int3(i64, i64) 454 455 typedef struct { 456 float f0; 457 } struct_f1; 458 TEST(struct_f1) 459 // CHECK-LABEL: define swiftcc float @return_struct_f1() 460 // CHECK-LABEL: define swiftcc void @take_struct_f1(float) 461 462 typedef struct { 463 float f0; 464 float f1; 465 } struct_f2; 466 TEST(struct_f2) 467 // CHECK-LABEL: define swiftcc i64 @return_struct_f2() 468 // CHECK-LABEL: define swiftcc void @take_struct_f2(i64) 469 470 typedef struct { 471 float f0; 472 float f1; 473 float f2; 474 } struct_f3; 475 TEST(struct_f3) 476 // CHECK-LABEL: define swiftcc { i64, float } @return_struct_f3() 477 // CHECK-LABEL: define swiftcc void @take_struct_f3(i64, float) 478 479 typedef struct { 480 float f0; 481 float f1; 482 float f2; 483 float f3; 484 } struct_f4; 485 TEST(struct_f4) 486 // CHECK-LABEL: define swiftcc { i64, i64 } @return_struct_f4() 487 // CHECK-LABEL: define swiftcc void @take_struct_f4(i64, i64) 488 489 490 typedef struct { 491 double d0; 492 } struct_d1; 493 TEST(struct_d1) 494 // CHECK-LABEL: define swiftcc double @return_struct_d1() 495 // CHECK-LABEL: define swiftcc void @take_struct_d1(double) 496 497 typedef struct { 498 double d0; 499 double d1; 500 } struct_d2; 501 TEST(struct_d2) 502 503 // CHECK-LABEL: define swiftcc { double, double } @return_struct_d2() 504 // CHECK-LABEL: define swiftcc void @take_struct_d2(double, double) 505 typedef struct { 506 double d0; 507 double d1; 508 double d2; 509 } struct_d3; 510 TEST(struct_d3) 511 // CHECK-LABEL: define swiftcc { double, double, double } @return_struct_d3() 512 // CHECK-LABEL: define swiftcc void @take_struct_d3(double, double, double) 513 514 typedef struct { 515 double d0; 516 double d1; 517 double d2; 518 double d3; 519 } struct_d4; 520 TEST(struct_d4) 521 // CHECK-LABEL: define swiftcc { double, double, double, double } @return_struct_d4() 522 // CHECK-LABEL: define swiftcc void @take_struct_d4(double, double, double, double) 523 524 typedef struct { 525 double d0; 526 double d1; 527 double d2; 528 double d3; 529 double d4; 530 } struct_d5; 531 TEST(struct_d5) 532 // CHECK: define swiftcc void @return_struct_d5([[STRUCT5:%.*]]* noalias sret 533 // CHECK: define swiftcc void @take_struct_d5([[STRUCT5]] 534 535 typedef struct { 536 char c0; 537 } struct_c1; 538 TEST(struct_c1) 539 // CHECK-LABEL: define swiftcc i8 @return_struct_c1() 540 // CHECK-LABEL: define swiftcc void @take_struct_c1(i8) 541 542 typedef struct { 543 char c0; 544 char c1; 545 } struct_c2; 546 TEST(struct_c2) 547 // CHECK-LABEL: define swiftcc i16 @return_struct_c2() 548 // CHECK-LABEL: define swiftcc void @take_struct_c2(i16) 549 // 550 551 typedef struct { 552 char c0; 553 char c1; 554 char c2; 555 } struct_c3; 556 TEST(struct_c3) 557 // CHECK-LABEL: define swiftcc i32 @return_struct_c3() 558 // CHECK-LABEL: define swiftcc void @take_struct_c3(i32) 559 560 typedef struct { 561 char c0; 562 char c1; 563 char c2; 564 char c3; 565 } struct_c4; 566 TEST(struct_c4) 567 // CHECK-LABEL: define swiftcc i32 @return_struct_c4() 568 // CHECK-LABEL: define swiftcc void @take_struct_c4(i32) 569 570 typedef struct { 571 char c0; 572 char c1; 573 char c2; 574 char c3; 575 char c4; 576 } struct_c5; 577 TEST(struct_c5) 578 // CHECK-LABEL: define swiftcc i64 @return_struct_c5() 579 // CHECK-LABEL: define swiftcc void @take_struct_c5(i64) 580 // 581 typedef struct { 582 char c0; 583 char c1; 584 char c2; 585 char c3; 586 char c4; 587 char c5; 588 char c6; 589 char c7; 590 char c8; 591 } struct_c9; 592 TEST(struct_c9) 593 // CHECK-LABEL: define swiftcc { i64, i8 } @return_struct_c9() 594 // CHECK-LABEL: define swiftcc void @take_struct_c9(i64, i8) 595 596 typedef struct { 597 short s0; 598 } struct_s1; 599 TEST(struct_s1) 600 // CHECK-LABEL: define swiftcc i16 @return_struct_s1() 601 // CHECK-LABEL: define swiftcc void @take_struct_s1(i16) 602 603 typedef struct { 604 short s0; 605 short s1; 606 } struct_s2; 607 TEST(struct_s2) 608 // CHECK-LABEL: define swiftcc i32 @return_struct_s2() 609 // CHECK-LABEL: define swiftcc void @take_struct_s2(i32) 610 // 611 612 typedef struct { 613 short s0; 614 short s1; 615 short s2; 616 } struct_s3; 617 TEST(struct_s3) 618 // CHECK-LABEL: define swiftcc i64 @return_struct_s3() 619 // CHECK-LABEL: define swiftcc void @take_struct_s3(i64) 620 621 typedef struct { 622 short s0; 623 short s1; 624 short s2; 625 short s3; 626 } struct_s4; 627 TEST(struct_s4) 628 // CHECK-LABEL: define swiftcc i64 @return_struct_s4() 629 // CHECK-LABEL: define swiftcc void @take_struct_s4(i64) 630 631 typedef struct { 632 short s0; 633 short s1; 634 short s2; 635 short s3; 636 short s4; 637 } struct_s5; 638 TEST(struct_s5) 639 // CHECK-LABEL: define swiftcc { i64, i16 } @return_struct_s5() 640 // CHECK-LABEL: define swiftcc void @take_struct_s5(i64, i16) 641 642 643 typedef struct { 644 int i0; 645 } struct_i1; 646 TEST(struct_i1) 647 // CHECK-LABEL: define swiftcc i32 @return_struct_i1() 648 // CHECK-LABEL: define swiftcc void @take_struct_i1(i32) 649 650 typedef struct { 651 int i0; 652 int i1; 653 } struct_i2; 654 TEST(struct_i2) 655 // CHECK-LABEL: define swiftcc i64 @return_struct_i2() 656 // CHECK-LABEL: define swiftcc void @take_struct_i2(i64) 657 658 typedef struct { 659 int i0; 660 int i1; 661 int i2; 662 } struct_i3; 663 TEST(struct_i3) 664 // CHECK-LABEL: define swiftcc { i64, i32 } @return_struct_i3() 665 // CHECK-LABEL: define swiftcc void @take_struct_i3(i64, i32) 666 667 typedef struct { 668 int i0; 669 int i1; 670 int i2; 671 int i3; 672 } struct_i4; 673 TEST(struct_i4) 674 // CHECK-LABEL: define swiftcc { i64, i64 } @return_struct_i4() 675 // CHECK-LABEL: define swiftcc void @take_struct_i4(i64, i64) 676 677 typedef struct { 678 long long l0; 679 } struct_l1; 680 TEST(struct_l1) 681 // CHECK-LABEL: define swiftcc i64 @return_struct_l1() 682 // CHECK-LABEL: define swiftcc void @take_struct_l1(i64) 683 684 typedef struct { 685 long long l0; 686 long long l1; 687 } struct_l2; 688 TEST(struct_l2) 689 // CHECK-LABEL: define swiftcc { i64, i64 } @return_struct_l2() 690 // CHECK-LABEL: define swiftcc void @take_struct_l2(i64, i64) 691 692 typedef struct { 693 long long l0; 694 long long l1; 695 long long l2; 696 } struct_l3; 697 TEST(struct_l3) 698 // CHECK-LABEL: define swiftcc { i64, i64, i64 } @return_struct_l3() 699 // CHECK-LABEL: define swiftcc void @take_struct_l3(i64, i64, i64) 700 701 typedef struct { 702 long long l0; 703 long long l1; 704 long long l2; 705 long long l3; 706 } struct_l4; 707 TEST(struct_l4) 708 // CHECK-LABEL: define swiftcc { i64, i64, i64, i64 } @return_struct_l4() 709 // CHECK-LABEL: define swiftcc void @take_struct_l4(i64, i64, i64, i64) 710 711 typedef struct { 712 long long l0; 713 long long l1; 714 long long l2; 715 long long l3; 716 long long l4; 717 } struct_l5; 718 TEST(struct_l5) 719 // CHECK: define swiftcc void @return_struct_l5([[STRUCT5:%.*]]* noalias sret 720 // CHECK: define swiftcc void @take_struct_l5([[STRUCT5]]* 721 722 typedef struct { 723 char16 c0; 724 } struct_vc1; 725 TEST(struct_vc1) 726 // CHECK-LABEL: define swiftcc <16 x i8> @return_struct_vc1() 727 // CHECK-LABEL: define swiftcc void @take_struct_vc1(<16 x i8>) 728 729 typedef struct { 730 char16 c0; 731 char16 c1; 732 } struct_vc2; 733 TEST(struct_vc2) 734 // CHECK-LABEL: define swiftcc { <16 x i8>, <16 x i8> } @return_struct_vc2() 735 // CHECK-LABEL: define swiftcc void @take_struct_vc2(<16 x i8>, <16 x i8>) 736 737 typedef struct { 738 char16 c0; 739 char16 c1; 740 char16 c2; 741 } struct_vc3; 742 TEST(struct_vc3) 743 // CHECK-LABEL: define swiftcc { <16 x i8>, <16 x i8>, <16 x i8> } @return_struct_vc3() 744 // CHECK-LABEL: define swiftcc void @take_struct_vc3(<16 x i8>, <16 x i8>, <16 x i8>) 745 746 typedef struct { 747 char16 c0; 748 char16 c1; 749 char16 c2; 750 char16 c3; 751 } struct_vc4; 752 TEST(struct_vc4) 753 // CHECK-LABEL: define swiftcc { <16 x i8>, <16 x i8>, <16 x i8>, <16 x i8> } @return_struct_vc4() 754 // CHECK-LABEL: define swiftcc void @take_struct_vc4(<16 x i8>, <16 x i8>, <16 x i8>, <16 x i8>) 755 756 typedef struct { 757 char16 c0; 758 char16 c1; 759 char16 c2; 760 char16 c3; 761 char16 c4; 762 } struct_vc5; 763 TEST(struct_vc5) 764 // CHECK: define swiftcc void @return_struct_vc5([[STRUCT:%.*]]* noalias sret 765 // CHECK: define swiftcc void @take_struct_vc5([[STRUCT]] 766 767 typedef struct { 768 short8 c0; 769 } struct_vs1; 770 TEST(struct_vs1) 771 // CHECK-LABEL: define swiftcc <8 x i16> @return_struct_vs1() 772 // CHECK-LABEL: define swiftcc void @take_struct_vs1(<8 x i16>) 773 774 typedef struct { 775 short8 c0; 776 short8 c1; 777 } struct_vs2; 778 TEST(struct_vs2) 779 // CHECK-LABEL: define swiftcc { <8 x i16>, <8 x i16> } @return_struct_vs2() 780 // CHECK-LABEL: define swiftcc void @take_struct_vs2(<8 x i16>, <8 x i16>) 781 782 typedef struct { 783 short8 c0; 784 short8 c1; 785 short8 c2; 786 } struct_vs3; 787 TEST(struct_vs3) 788 // CHECK-LABEL: define swiftcc { <8 x i16>, <8 x i16>, <8 x i16> } @return_struct_vs3() 789 // CHECK-LABEL: define swiftcc void @take_struct_vs3(<8 x i16>, <8 x i16>, <8 x i16>) 790 791 typedef struct { 792 short8 c0; 793 short8 c1; 794 short8 c2; 795 short8 c3; 796 } struct_vs4; 797 TEST(struct_vs4) 798 // CHECK-LABEL: define swiftcc { <8 x i16>, <8 x i16>, <8 x i16>, <8 x i16> } @return_struct_vs4() 799 // CHECK-LABEL: define swiftcc void @take_struct_vs4(<8 x i16>, <8 x i16>, <8 x i16>, <8 x i16>) 800 801 typedef struct { 802 short8 c0; 803 short8 c1; 804 short8 c2; 805 short8 c3; 806 short8 c4; 807 } struct_vs5; 808 TEST(struct_vs5) 809 // CHECK: define swiftcc void @return_struct_vs5([[STRUCT:%.*]]* noalias sret 810 // CHECK: define swiftcc void @take_struct_vs5([[STRUCT]] 811 812 typedef struct { 813 int4 c0; 814 } struct_vi1; 815 TEST(struct_vi1) 816 // CHECK-LABEL: define swiftcc <4 x i32> @return_struct_vi1() 817 // CHECK-LABEL: define swiftcc void @take_struct_vi1(<4 x i32>) 818 819 typedef struct { 820 int4 c0; 821 int4 c1; 822 } struct_vi2; 823 TEST(struct_vi2) 824 // CHECK-LABEL: define swiftcc { <4 x i32>, <4 x i32> } @return_struct_vi2() 825 // CHECK-LABEL: define swiftcc void @take_struct_vi2(<4 x i32>, <4 x i32>) 826 827 typedef struct { 828 int4 c0; 829 int4 c1; 830 int4 c2; 831 } struct_vi3; 832 TEST(struct_vi3) 833 // CHECK-LABEL: define swiftcc { <4 x i32>, <4 x i32>, <4 x i32> } @return_struct_vi3() 834 // CHECK-LABEL: define swiftcc void @take_struct_vi3(<4 x i32>, <4 x i32>, <4 x i32>) 835 836 typedef struct { 837 int4 c0; 838 int4 c1; 839 int4 c2; 840 int4 c3; 841 } struct_vi4; 842 TEST(struct_vi4) 843 // CHECK-LABEL: define swiftcc { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @return_struct_vi4() 844 // CHECK-LABEL: define swiftcc void @take_struct_vi4(<4 x i32>, <4 x i32>, <4 x i32>, <4 x i32>) 845 846 typedef struct { 847 int4 c0; 848 int4 c1; 849 int4 c2; 850 int4 c3; 851 int4 c4; 852 } struct_vi5; 853 TEST(struct_vi5) 854 // CHECK: define swiftcc void @return_struct_vi5([[STRUCT:%.*]]* noalias sret 855 // CHECK: define swiftcc void @take_struct_vi5([[STRUCT]] 856 857 typedef struct { 858 long2 c0; 859 } struct_vl1; 860 TEST(struct_vl1) 861 // CHECK-LABEL: define swiftcc <2 x i64> @return_struct_vl1() 862 // CHECK-LABEL: define swiftcc void @take_struct_vl1(<2 x i64>) 863 864 typedef struct { 865 long2 c0; 866 long2 c1; 867 long2 c2; 868 long2 c3; 869 } struct_vl4; 870 TEST(struct_vl4) 871 // CHECK-LABEL: define swiftcc { <2 x i64>, <2 x i64>, <2 x i64>, <2 x i64> } @return_struct_vl4() 872 // CHECK-LABEL: define swiftcc void @take_struct_vl4(<2 x i64>, <2 x i64>, <2 x i64>, <2 x i64>) 873 874 typedef struct { 875 long2 c0; 876 long2 c1; 877 long2 c2; 878 long2 c3; 879 long2 c4; 880 } struct_vl5; 881 TEST(struct_vl5) 882 // CHECK: define swiftcc void @return_struct_vl5([[STRUCT:%.*]]* noalias sret 883 // CHECK: define swiftcc void @take_struct_vl5([[STRUCT]] 884 885 typedef struct { 886 double2 c0; 887 } struct_vd1; 888 TEST(struct_vd1) 889 // CHECK-LABEL: define swiftcc <2 x double> @return_struct_vd1() 890 // CHECK-LABEL: define swiftcc void @take_struct_vd1(<2 x double>) 891 892 typedef struct { 893 double2 c0; 894 double2 c1; 895 double2 c2; 896 double2 c3; 897 } struct_vd4; 898 TEST(struct_vd4) 899 // CHECK-LABEL: define swiftcc { <2 x double>, <2 x double>, <2 x double>, <2 x double> } @return_struct_vd4() 900 // CHECK-LABEL: define swiftcc void @take_struct_vd4(<2 x double>, <2 x double>, <2 x double>, <2 x double>) 901 902 typedef struct { 903 double2 c0; 904 double2 c1; 905 double2 c2; 906 double2 c3; 907 double2 c4; 908 } struct_vd5; 909 TEST(struct_vd5) 910 // CHECK: define swiftcc void @return_struct_vd5([[STRUCT:%.*]]* noalias sret 911 // CHECK: define swiftcc void @take_struct_vd5([[STRUCT]] 912 913 typedef struct { 914 double4 c0; 915 } struct_vd41; 916 TEST(struct_vd41) 917 // CHECK-LABEL: define swiftcc { <2 x double>, <2 x double> } @return_struct_vd41() 918 // CHECK-LABEL: define swiftcc void @take_struct_vd41(<2 x double>, <2 x double>) 919 920 typedef struct { 921 double4 c0; 922 double4 c1; 923 } struct_vd42; 924 TEST(struct_vd42) 925 // CHECK-LABEL: define swiftcc { <2 x double>, <2 x double>, <2 x double>, <2 x double> } @return_struct_vd42() 926 // CHECK-LABEL: define swiftcc void @take_struct_vd42(<2 x double>, <2 x double>, <2 x double>, <2 x double>) 927 928 typedef struct { 929 double4 c0; 930 double4 c1; 931 double4 c2; 932 } struct_vd43; 933 TEST(struct_vd43) 934 // CHECK: define swiftcc void @return_struct_vd43([[STRUCT:%.*]]* noalias sret 935 // CHECK: define swiftcc void @take_struct_vd43([[STRUCT]] 936 937 typedef struct { 938 float4 c0; 939 } struct_vf1; 940 TEST(struct_vf1) 941 // CHECK-LABEL: define swiftcc <4 x float> @return_struct_vf1() 942 // CHECK-LABEL: define swiftcc void @take_struct_vf1(<4 x float>) 943 944 typedef struct { 945 float4 c0; 946 float4 c1; 947 } struct_vf2; 948 TEST(struct_vf2) 949 // CHECK-LABEL: define swiftcc { <4 x float>, <4 x float> } @return_struct_vf2() 950 // CHECK-LABEL: define swiftcc void @take_struct_vf2(<4 x float>, <4 x float>) 951 952 typedef struct { 953 float4 c0; 954 float4 c1; 955 float4 c2; 956 float4 c3; 957 } struct_vf4; 958 TEST(struct_vf4) 959 // CHECK-LABEL: define swiftcc { <4 x float>, <4 x float>, <4 x float>, <4 x float> } @return_struct_vf4() 960 // CHECK-LABEL: define swiftcc void @take_struct_vf4(<4 x float>, <4 x float>, <4 x float>, <4 x float>) 961 962 typedef struct { 963 float4 c0; 964 float4 c1; 965 float4 c2; 966 float4 c3; 967 float4 c4; 968 } struct_vf5; 969 TEST(struct_vf5) 970 // CHECK: define swiftcc void @return_struct_vf5([[STRUCT:%.*]]* noalias sret 971 // CHECK: define swiftcc void @take_struct_vf5([[STRUCT]] 972 973 typedef struct { 974 float8 c0; 975 } struct_vf81; 976 TEST(struct_vf81) 977 // CHECK-LABEL: define swiftcc { <4 x float>, <4 x float> } @return_struct_vf81() 978 // CHECK-LABEL: define swiftcc void @take_struct_vf81(<4 x float>, <4 x float>) 979 980 // Don't crash. 981 typedef union { 982 int4 v[2]; 983 struct { 984 int LSW; 985 int d7; 986 int d6; 987 int d5; 988 int d4; 989 int d3; 990 int d2; 991 int MSW; 992 } s; 993 } union_het_vecint; 994 TEST(union_het_vecint) 995 // CHECK: define swiftcc void @return_union_het_vecint([[UNION:%.*]]* noalias sret 996 // CHECK: define swiftcc void @take_union_het_vecint([[UNION]]* 997 998 typedef struct { 999 float3 f3; 1000 } struct_v1f3; 1001 TEST(struct_v1f3) 1002 // ARM64-LABEL: define swiftcc { <2 x float>, float } @return_struct_v1f3() 1003 // ARM64-LABEL: define swiftcc void @take_struct_v1f3(<2 x float>, float) 1004 1005 typedef struct { 1006 int3 vect; 1007 unsigned long long val; 1008 } __attribute__((packed)) padded_alloc_size_vector; 1009 TEST(padded_alloc_size_vector) 1010 // X86-64-LABEL: take_padded_alloc_size_vector(<3 x i32>, i64) 1011 // X86-64-NOT: [4 x i8] 1012 // x86-64: ret void 1013 1014 typedef union { 1015 float f1; 1016 float3 fv2; 1017 } union_hom_fp_partial2; 1018 TEST(union_hom_fp_partial2) 1019 // X86-64-LABEL: take_union_hom_fp_partial2(i64, float) 1020 // ARM64-LABEL: take_union_hom_fp_partial2(i64, float) 1021 1022 // At one point, we emitted lifetime.ends without a matching lifetime.start for 1023 // CoerceAndExpanded args. Since we're not performing optimizations, neither 1024 // intrinsic should be emitted. 1025 // CHECK-LABEL: define void @no_lifetime_markers 1026 void no_lifetime_markers() { 1027 // CHECK-NOT: call void @llvm.lifetime. 1028 take_int5(return_int5()); 1029 } 1030