clang/test/CodeGen/arm-swiftcall.c

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