1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs 2; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-rewrite-out-arguments < %s | FileCheck %s 3 4 5define void @no_ret_blocks() #0 { 6 unreachable 7} 8 9define void @void_one_out_arg_i32_no_use(i32* %val) #0 { 10 ret void 11} 12 13define void @skip_byval_arg(i32* byval(i32) %val) #0 { 14 store i32 0, i32* %val 15 ret void 16} 17 18define void @skip_optnone(i32* byval(i32) %val) #1 { 19 store i32 0, i32* %val 20 ret void 21} 22 23define void @skip_volatile(i32* byval(i32) %val) #0 { 24 store volatile i32 0, i32* %val 25 ret void 26} 27 28define void @skip_atomic(i32* byval(i32) %val) #0 { 29 store atomic i32 0, i32* %val seq_cst, align 4 30 ret void 31} 32 33define void @skip_store_pointer_val(i32* %val) #0 { 34 store i32* %val, i32** undef 35 ret void 36} 37 38define void @skip_store_gep(i32* %val) #0 { 39 %gep = getelementptr inbounds i32, i32* %val, i32 1 40 store i32 0, i32* %gep 41 ret void 42} 43 44define void @skip_sret(i32* sret(i32) %sret, i32* %out) #0 { 45 store i32 1, i32* %sret 46 store i32 0, i32* %out 47 ret void 48} 49 50 51define void @void_one_out_arg_i32_1_use(i32* %val) #0 { 52 store i32 0, i32* %val 53 ret void 54} 55 56 57define void @void_one_out_arg_i32_1_use_align(i32* align 8 %val) #0 { 58 store i32 0, i32* %val, align 8 59 ret void 60} 61 62 63 64 65define void @void_one_out_arg_i32_2_use(i1 %arg0, i32* %val) #0 { 66 br i1 %arg0, label %ret0, label %ret1 67 68ret0: 69 store i32 0, i32* %val 70 ret void 71 72ret1: 73 store i32 9, i32* %val 74 ret void 75} 76 77declare void @may.clobber() 78 79 80define void @void_one_out_arg_i32_2_stores(i32* %val) #0 { 81 store i32 0, i32* %val 82 store i32 1, i32* %val 83 ret void 84} 85 86 87define void @void_one_out_arg_i32_2_stores_clobber(i32* %val) #0 { 88 store i32 0, i32* %val 89 call void @may.clobber() 90 store i32 1, i32* %val 91 ret void 92} 93 94 95define void @void_one_out_arg_i32_call_may_clobber(i32* %val) #0 { 96 store i32 0, i32* %val 97 call void @may.clobber() 98 ret void 99} 100 101 102define void @void_one_out_arg_i32_pre_call_may_clobber(i32* %val) #0 { 103 call void @may.clobber() 104 store i32 0, i32* %val 105 ret void 106} 107 108define void @void_one_out_arg_i32_reload(i32* %val) #0 { 109 store i32 0, i32* %val 110 %load = load i32, i32* %val, align 4 111 ret void 112} 113 114define void @void_one_out_arg_i32_store_in_different_block(i32* %out) #0 { 115 %load = load i32, i32 addrspace(1)* undef 116 store i32 0, i32* %out 117 br label %ret 118 119ret: 120 ret void 121} 122 123 124define void @unused_out_arg_one_branch(i1 %arg0, i32* %val) #0 { 125 br i1 %arg0, label %ret0, label %ret1 126 127ret0: 128 ret void 129 130ret1: 131 store i32 9, i32* %val 132 ret void 133} 134 135 136define void @void_one_out_arg_v2i32_1_use(<2 x i32>* %val) #0 { 137 store <2 x i32> <i32 17, i32 9>, <2 x i32>* %val 138 ret void 139} 140 141%struct = type { i32, i8, float } 142 143 144; Normally this is split into element accesses which we don't handle. 145define void @void_one_out_arg_struct_1_use(%struct* %out) #0 { 146 store %struct { i32 9, i8 99, float 4.0 }, %struct* %out 147 ret void 148} 149 150 151define i32 @i32_one_out_arg_i32_1_use(i32* %val) #0 { 152 store i32 24, i32* %val 153 ret i32 9 154} 155 156 157define void @unused_different_type(i32* %arg0, float* nocapture %arg1) #0 { 158 store float 4.0, float* %arg1, align 4 159 ret void 160} 161 162 163define void @multiple_same_return_noalias(i32* noalias %out0, i32* noalias %out1) #0 { 164 store i32 1, i32* %out0, align 4 165 store i32 2, i32* %out1, align 4 166 ret void 167} 168 169 170define void @multiple_same_return_mayalias(i32* %out0, i32* %out1) #0 { 171 store i32 1, i32* %out0, align 4 172 store i32 2, i32* %out1, align 4 173 ret void 174} 175 176 177define void @multiple_same_return_mayalias_order(i32* %out0, i32* %out1) #0 { 178 store i32 2, i32* %out1, align 4 179 store i32 1, i32* %out0, align 4 180 ret void 181} 182 183; Currently this fails to convert because the store won't be found if 184; it isn't in the same block as the return. 185define i32 @store_in_entry_block(i1 %arg0, i32* %out) #0 { 186entry: 187 %val0 = load i32, i32 addrspace(1)* undef 188 store i32 %val0, i32* %out 189 br i1 %arg0, label %if, label %endif 190 191if: 192 %val1 = load i32, i32 addrspace(1)* undef 193 br label %endif 194 195endif: 196 %phi = phi i32 [ 0, %entry ], [ %val1, %if ] 197 ret i32 %phi 198} 199 200 201define i1 @i1_one_out_arg_i32_1_use(i32* %val) #0 { 202 store i32 24, i32* %val 203 ret i1 true 204} 205 206; Make sure we don't leave around return attributes that are 207; incompatible with struct return types. 208 209 210define zeroext i1 @i1_zeroext_one_out_arg_i32_1_use(i32* %val) #0 { 211 store i32 24, i32* %val 212 ret i1 true 213} 214 215 216define signext i1 @i1_signext_one_out_arg_i32_1_use(i32* %val) #0 { 217 store i32 24, i32* %val 218 ret i1 true 219} 220 221 222define noalias i32 addrspace(1)* @p1i32_noalias_one_out_arg_i32_1_use(i32* %val) #0 { 223 store i32 24, i32* %val 224 ret i32 addrspace(1)* null 225} 226 227define void @void_one_out_non_private_arg_i32_1_use(i32 addrspace(1)* %val) #0 { 228 store i32 0, i32 addrspace(1)* %val 229 ret void 230} 231 232define void @func_ptr_type(void()** %out) #0 { 233 %func = load void()*, void()** undef 234 store void()* %func, void()** %out 235 ret void 236} 237 238define void @bitcast_func_ptr_type(void()** %out) #0 { 239 %func = load i32()*, i32()** undef 240 %cast = bitcast void()** %out to i32()** 241 store i32()* %func, i32()** %cast 242 ret void 243} 244 245 246define void @out_arg_small_array([4 x i32]* %val) #0 { 247 store [4 x i32] [i32 0, i32 1, i32 2, i32 3], [4 x i32]* %val 248 ret void 249} 250 251define void @out_arg_large_array([17 x i32]* %val) #0 { 252 store [17 x i32] zeroinitializer, [17 x i32]* %val 253 ret void 254} 255 256define <16 x i32> @num_regs_return_limit(i32* %out, i32 %val) #0 { 257 %load = load volatile <16 x i32>, <16 x i32> addrspace(1)* undef 258 store i32 %val, i32* %out 259 ret <16 x i32> %load 260} 261 262define [15 x i32] @num_regs_reach_limit(i32* %out, i32 %val) #0 { 263 %load = load volatile [15 x i32], [15 x i32] addrspace(1)* undef 264 store i32 %val, i32* %out 265 ret [15 x i32] %load 266} 267 268 269define [15 x i32] @num_regs_reach_limit_leftover(i32* %out0, i32* %out1, i32 %val0) #0 { 270 %load0 = load volatile [15 x i32], [15 x i32] addrspace(1)* undef 271 %load1 = load volatile i32, i32 addrspace(1)* undef 272 store i32 %val0, i32* %out0 273 store i32 %load1, i32* %out1 274 ret [15 x i32] %load0 275} 276 277 278define void @preserve_debug_info(i32 %arg0, i32* %val) #0 !dbg !5 { 279 call void @may.clobber(), !dbg !10 280 store i32 %arg0, i32* %val, !dbg !11 281 ret void, !dbg !12 282} 283 284define void @preserve_metadata(i32 %arg0, i32* %val) #0 !kernel_arg_access_qual !13 { 285 call void @may.clobber() 286 store i32 %arg0, i32* %val 287 ret void 288} 289 290; Clang emits this pattern for 3-vectors for some reason. 291 292define void @bitcast_pointer_v4i32_v3i32(<3 x i32>* %out) #0 { 293 %load = load volatile <4 x i32>, <4 x i32> addrspace(1)* undef 294 %bitcast = bitcast <3 x i32>* %out to <4 x i32>* 295 store <4 x i32> %load, <4 x i32>* %bitcast 296 ret void 297} 298 299define void @bitcast_pointer_v4i32_v3f32(<3 x float>* %out) #0 { 300 %load = load volatile <4 x i32>, <4 x i32> addrspace(1)* undef 301 %bitcast = bitcast <3 x float>* %out to <4 x i32>* 302 store <4 x i32> %load, <4 x i32>* %bitcast 303 ret void 304} 305 306 307; Try different element and bitwidths which could produce broken 308; casts. 309 310 311define void @bitcast_pointer_i32_f32(float* %out) #0 { 312 %load = load volatile i32, i32 addrspace(1)* undef 313 %bitcast = bitcast float* %out to i32* 314 store i32 %load, i32* %bitcast 315 ret void 316} 317 318define void @bitcast_pointer_i32_f16(half* %out) #0 { 319 %load = load volatile i32, i32 addrspace(1)* undef 320 %bitcast = bitcast half* %out to i32* 321 store i32 %load, i32* %bitcast 322 ret void 323} 324 325define void @bitcast_pointer_f16_i32(i32* %out) #0 { 326 %load = load volatile half, half addrspace(1)* undef 327 %bitcast = bitcast i32* %out to half* 328 store half %load, half* %bitcast 329 ret void 330} 331 332%struct.i128 = type { i128 } 333%struct.v2f32 = type { <2 x float> } 334%struct.v3f32 = type { <3 x float> } 335%struct.v3f32.f32 = type { <3 x float>, float } 336%struct.v4f32 = type { <4 x float> } 337 338 339define void @bitcast_struct_v3f32_v3f32(%struct.v3f32* %out, <3 x float> %value) #0 { 340 %extractVec = shufflevector <3 x float> %value, <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 341 %cast = bitcast %struct.v3f32* %out to <4 x float>* 342 store <4 x float> %extractVec, <4 x float>* %cast, align 16 343 ret void 344} 345 346 347define void @bitcast_struct_v3f32_v3i32(%struct.v3f32* %out, <3 x i32> %value) #0 { 348 %extractVec = shufflevector <3 x i32> %value, <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 349 %cast = bitcast %struct.v3f32* %out to <4 x i32>* 350 store <4 x i32> %extractVec, <4 x i32>* %cast, align 16 351 ret void 352} 353 354 355define void @bitcast_struct_v4f32_v4f32(%struct.v4f32* %out, <4 x float> %value) #0 { 356 %cast = bitcast %struct.v4f32* %out to <4 x float>* 357 store <4 x float> %value, <4 x float>* %cast, align 16 358 ret void 359} 360 361define void @bitcast_struct_v3f32_v4i32(%struct.v3f32* %out, <4 x i32> %value) #0 { 362 %cast = bitcast %struct.v3f32* %out to <4 x i32>* 363 store <4 x i32> %value, <4 x i32>* %cast, align 16 364 ret void 365} 366 367define void @bitcast_struct_v4f32_v3f32(%struct.v4f32* %out, <3 x float> %value) #0 { 368 %extractVec = shufflevector <3 x float> %value, <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 369 %cast = bitcast %struct.v4f32* %out to <4 x float>* 370 store <4 x float> %extractVec, <4 x float>* %cast, align 16 371 ret void 372} 373 374define void @bitcast_struct_v3f32_v2f32(%struct.v3f32* %out, <2 x float> %value) #0 { 375 %cast = bitcast %struct.v3f32* %out to <2 x float>* 376 store <2 x float> %value, <2 x float>* %cast, align 8 377 ret void 378} 379 380define void @bitcast_struct_v3f32_f32_v3f32(%struct.v3f32.f32* %out, <3 x float> %value) #0 { 381 %extractVec = shufflevector <3 x float> %value, <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 382 %cast = bitcast %struct.v3f32.f32* %out to <4 x float>* 383 store <4 x float> %extractVec, <4 x float>* %cast, align 16 384 ret void 385} 386 387define void @bitcast_struct_v3f32_f32_v4f32(%struct.v3f32.f32* %out, <4 x float> %value) #0 { 388 %cast = bitcast %struct.v3f32.f32* %out to <4 x float>* 389 store <4 x float> %value, <4 x float>* %cast, align 16 390 ret void 391} 392 393define void @bitcast_struct_i128_v4f32(%struct.i128* %out, <4 x float> %value) #0 { 394 %cast = bitcast %struct.i128* %out to <4 x float>* 395 store <4 x float> %value, <4 x float>* %cast, align 16 396 ret void 397} 398 399define void @bitcast_array_v4i32_v4f32([4 x i32]* %out, [4 x float] %value) #0 { 400 %cast = bitcast [4 x i32]* %out to [4 x float]* 401 store [4 x float] %value, [4 x float]* %cast, align 4 402 ret void 403} 404 405 406define void @multi_return_bitcast_struct_v3f32_v3f32(i1 %cond, %struct.v3f32* %out, <3 x float> %value) #0 { 407entry: 408 br i1 %cond, label %ret0, label %ret1 409 410ret0: 411 %extractVec = shufflevector <3 x float> %value, <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 412 %cast0 = bitcast %struct.v3f32* %out to <4 x float>* 413 store <4 x float> %extractVec, <4 x float>* %cast0, align 16 414 ret void 415 416ret1: 417 %cast1 = bitcast %struct.v3f32* %out to <4 x float>* 418 %load = load <4 x float>, <4 x float> addrspace(1)* undef 419 store <4 x float> %load, <4 x float>* %cast1, align 16 420 ret void 421} 422 423define void @bitcast_v3f32_struct_v3f32(<3 x float>* %out, %struct.v3f32 %value) #0 { 424 %cast = bitcast <3 x float>* %out to %struct.v3f32* 425 store %struct.v3f32 %value, %struct.v3f32* %cast, align 4 426 ret void 427} 428 429attributes #0 = { nounwind } 430attributes #1 = { nounwind noinline optnone } 431attributes #2 = { alwaysinline nounwind } 432 433!llvm.dbg.cu = !{!0} 434!llvm.module.flags = !{!3, !4} 435 436!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 5.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2) 437!1 = !DIFile(filename: "code-object-metadata-kernel-debug-props.cl", directory: "/some/random/directory") 438!2 = !{} 439!3 = !{i32 2, !"Dwarf Version", i32 2} 440!4 = !{i32 2, !"Debug Info Version", i32 3} 441!5 = distinct !DISubprogram(name: "test", scope: !1, file: !1, line: 1, type: !6, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2) 442!6 = !DISubroutineType(types: !7) 443!7 = !{null, !8} 444!8 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 64) 445!9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed) 446!10 = !DILocation(line: 2, column: 3, scope: !5) 447!11 = !DILocation(line: 2, column: 8, scope: !5) 448!12 = !DILocation(line: 3, column: 3, scope: !5) 449!13 = !{!"none"} 450 451; CHECK-LABEL: define {{[^@]+}}@no_ret_blocks 452; CHECK-SAME: () #[[ATTR0:[0-9]+]] { 453; CHECK-NEXT: unreachable 454; 455; 456; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_no_use 457; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 458; CHECK-NEXT: ret void 459; 460; 461; CHECK-LABEL: define {{[^@]+}}@skip_byval_arg 462; CHECK-SAME: (i32* byval(i32) [[VAL:%.*]]) #[[ATTR0]] { 463; CHECK-NEXT: store i32 0, i32* [[VAL]], align 4 464; CHECK-NEXT: ret void 465; 466; 467; CHECK-LABEL: define {{[^@]+}}@skip_optnone 468; CHECK-SAME: (i32* byval(i32) [[VAL:%.*]]) #[[ATTR1:[0-9]+]] { 469; CHECK-NEXT: store i32 0, i32* [[VAL]], align 4 470; CHECK-NEXT: ret void 471; 472; 473; CHECK-LABEL: define {{[^@]+}}@skip_volatile 474; CHECK-SAME: (i32* byval(i32) [[VAL:%.*]]) #[[ATTR0]] { 475; CHECK-NEXT: store volatile i32 0, i32* [[VAL]], align 4 476; CHECK-NEXT: ret void 477; 478; 479; CHECK-LABEL: define {{[^@]+}}@skip_atomic 480; CHECK-SAME: (i32* byval(i32) [[VAL:%.*]]) #[[ATTR0]] { 481; CHECK-NEXT: store atomic i32 0, i32* [[VAL]] seq_cst, align 4 482; CHECK-NEXT: ret void 483; 484; 485; CHECK-LABEL: define {{[^@]+}}@skip_store_pointer_val 486; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 487; CHECK-NEXT: store i32* [[VAL]], i32** undef, align 8 488; CHECK-NEXT: ret void 489; 490; 491; CHECK-LABEL: define {{[^@]+}}@skip_store_gep 492; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 493; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i32, i32* [[VAL]], i32 1 494; CHECK-NEXT: store i32 0, i32* [[GEP]], align 4 495; CHECK-NEXT: ret void 496; 497; 498; CHECK-LABEL: define {{[^@]+}}@skip_sret 499; CHECK-SAME: (i32* sret(i32) [[SRET:%.*]], i32* [[OUT:%.*]]) #[[ATTR0]] { 500; CHECK-NEXT: store i32 1, i32* [[SRET]], align 4 501; CHECK-NEXT: store i32 0, i32* [[OUT]], align 4 502; CHECK-NEXT: ret void 503; 504; 505; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_1_use.body 506; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 507; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_I32_1_USE:%.*]] zeroinitializer 508; 509; 510; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_1_use 511; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2:[0-9]+]] { 512; CHECK-NEXT: [[TMP2:%.*]] = call [[VOID_ONE_OUT_ARG_I32_1_USE:%.*]] @void_one_out_arg_i32_1_use.body(i32* undef) 513; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 0 514; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 515; CHECK-NEXT: ret void 516; 517; 518; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_1_use_align.body 519; CHECK-SAME: (i32* align 8 [[VAL:%.*]]) #[[ATTR0]] { 520; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_I32_1_USE_ALIGN:%.*]] zeroinitializer 521; 522; 523; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_1_use_align 524; CHECK-SAME: (i32* align 8 [[TMP0:%.*]]) #[[ATTR2]] { 525; CHECK-NEXT: [[TMP2:%.*]] = call [[VOID_ONE_OUT_ARG_I32_1_USE_ALIGN:%.*]] @void_one_out_arg_i32_1_use_align.body(i32* undef) 526; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_I32_1_USE_ALIGN]] [[TMP2]], 0 527; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 8 528; CHECK-NEXT: ret void 529; 530; 531; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_2_use.body 532; CHECK-SAME: (i1 [[ARG0:%.*]], i32* [[VAL:%.*]]) #[[ATTR0]] { 533; CHECK-NEXT: br i1 [[ARG0]], label [[RET0:%.*]], label [[RET1:%.*]] 534; CHECK: ret0: 535; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_I32_2_USE:%.*]] zeroinitializer 536; CHECK: ret1: 537; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_I32_2_USE]] { i32 9 } 538; 539; 540; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_2_use 541; CHECK-SAME: (i1 [[TMP0:%.*]], i32* [[TMP1:%.*]]) #[[ATTR2]] { 542; CHECK-NEXT: [[TMP3:%.*]] = call [[VOID_ONE_OUT_ARG_I32_2_USE:%.*]] @void_one_out_arg_i32_2_use.body(i1 [[TMP0]], i32* undef) 543; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_I32_2_USE]] [[TMP3]], 0 544; CHECK-NEXT: store i32 [[TMP4]], i32* [[TMP1]], align 4 545; CHECK-NEXT: ret void 546; 547; 548; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_2_stores.body 549; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 550; CHECK-NEXT: store i32 0, i32* [[VAL]], align 4 551; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_I32_2_STORES:%.*]] { i32 1 } 552; 553; 554; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_2_stores 555; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 556; CHECK-NEXT: [[TMP2:%.*]] = call [[VOID_ONE_OUT_ARG_I32_2_STORES:%.*]] @void_one_out_arg_i32_2_stores.body(i32* undef) 557; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_I32_2_STORES]] [[TMP2]], 0 558; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 559; CHECK-NEXT: ret void 560; 561; 562; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_2_stores_clobber.body 563; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 564; CHECK-NEXT: store i32 0, i32* [[VAL]], align 4 565; CHECK-NEXT: call void @may.clobber() 566; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_I32_2_STORES_CLOBBER:%.*]] { i32 1 } 567; 568; 569; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_2_stores_clobber 570; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 571; CHECK-NEXT: [[TMP2:%.*]] = call [[VOID_ONE_OUT_ARG_I32_2_STORES_CLOBBER:%.*]] @void_one_out_arg_i32_2_stores_clobber.body(i32* undef) 572; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_I32_2_STORES_CLOBBER]] [[TMP2]], 0 573; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 574; CHECK-NEXT: ret void 575; 576; 577; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_call_may_clobber 578; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 579; CHECK-NEXT: store i32 0, i32* [[VAL]], align 4 580; CHECK-NEXT: call void @may.clobber() 581; CHECK-NEXT: ret void 582; 583; 584; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_pre_call_may_clobber.body 585; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 586; CHECK-NEXT: call void @may.clobber() 587; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_I32_PRE_CALL_MAY_CLOBBER:%.*]] zeroinitializer 588; 589; 590; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_pre_call_may_clobber 591; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 592; CHECK-NEXT: [[TMP2:%.*]] = call [[VOID_ONE_OUT_ARG_I32_PRE_CALL_MAY_CLOBBER:%.*]] @void_one_out_arg_i32_pre_call_may_clobber.body(i32* undef) 593; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_I32_PRE_CALL_MAY_CLOBBER]] [[TMP2]], 0 594; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 595; CHECK-NEXT: ret void 596; 597; 598; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_reload 599; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 600; CHECK-NEXT: store i32 0, i32* [[VAL]], align 4 601; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[VAL]], align 4 602; CHECK-NEXT: ret void 603; 604; 605; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_i32_store_in_different_block 606; CHECK-SAME: (i32* [[OUT:%.*]]) #[[ATTR0]] { 607; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32 addrspace(1)* undef, align 4 608; CHECK-NEXT: store i32 0, i32* [[OUT]], align 4 609; CHECK-NEXT: br label [[RET:%.*]] 610; CHECK: ret: 611; CHECK-NEXT: ret void 612; 613; 614; CHECK-LABEL: define {{[^@]+}}@unused_out_arg_one_branch 615; CHECK-SAME: (i1 [[ARG0:%.*]], i32* [[VAL:%.*]]) #[[ATTR0]] { 616; CHECK-NEXT: br i1 [[ARG0]], label [[RET0:%.*]], label [[RET1:%.*]] 617; CHECK: ret0: 618; CHECK-NEXT: ret void 619; CHECK: ret1: 620; CHECK-NEXT: store i32 9, i32* [[VAL]], align 4 621; CHECK-NEXT: ret void 622; 623; 624; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_v2i32_1_use.body 625; CHECK-SAME: (<2 x i32>* [[VAL:%.*]]) #[[ATTR0]] { 626; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_V2I32_1_USE:%.*]] { <2 x i32> <i32 17, i32 9> } 627; 628; 629; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_v2i32_1_use 630; CHECK-SAME: (<2 x i32>* [[TMP0:%.*]]) #[[ATTR2]] { 631; CHECK-NEXT: [[TMP2:%.*]] = call [[VOID_ONE_OUT_ARG_V2I32_1_USE:%.*]] @void_one_out_arg_v2i32_1_use.body(<2 x i32>* undef) 632; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_V2I32_1_USE]] [[TMP2]], 0 633; CHECK-NEXT: store <2 x i32> [[TMP3]], <2 x i32>* [[TMP0]], align 8 634; CHECK-NEXT: ret void 635; 636; 637; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_struct_1_use.body 638; CHECK-SAME: (%struct* [[OUT:%.*]]) #[[ATTR0]] { 639; CHECK-NEXT: ret [[VOID_ONE_OUT_ARG_STRUCT_1_USE:%.*]] { [[STRUCT:%.*]] { i32 9, i8 99, float 4.000000e+00 } } 640; 641; 642; CHECK-LABEL: define {{[^@]+}}@void_one_out_arg_struct_1_use 643; CHECK-SAME: (%struct* [[TMP0:%.*]]) #[[ATTR2]] { 644; CHECK-NEXT: [[TMP2:%.*]] = call [[VOID_ONE_OUT_ARG_STRUCT_1_USE:%.*]] @void_one_out_arg_struct_1_use.body(%struct* undef) 645; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[VOID_ONE_OUT_ARG_STRUCT_1_USE]] [[TMP2]], 0 646; CHECK-NEXT: store [[STRUCT:%.*]] [[TMP3]], %struct* [[TMP0]], align 4 647; CHECK-NEXT: ret void 648; 649; 650; CHECK-LABEL: define {{[^@]+}}@i32_one_out_arg_i32_1_use.body 651; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 652; CHECK-NEXT: ret [[I32_ONE_OUT_ARG_I32_1_USE:%.*]] { i32 9, i32 24 } 653; 654; 655; CHECK-LABEL: define {{[^@]+}}@i32_one_out_arg_i32_1_use 656; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 657; CHECK-NEXT: [[TMP2:%.*]] = call [[I32_ONE_OUT_ARG_I32_1_USE:%.*]] @i32_one_out_arg_i32_1_use.body(i32* undef) 658; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[I32_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 1 659; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 660; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[I32_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 0 661; CHECK-NEXT: ret i32 [[TMP4]] 662; 663; 664; CHECK-LABEL: define {{[^@]+}}@unused_different_type.body 665; CHECK-SAME: (i32* [[ARG0:%.*]], float* nocapture [[ARG1:%.*]]) #[[ATTR0]] { 666; CHECK-NEXT: ret [[UNUSED_DIFFERENT_TYPE:%.*]] { float 4.000000e+00 } 667; 668; 669; CHECK-LABEL: define {{[^@]+}}@unused_different_type 670; CHECK-SAME: (i32* [[TMP0:%.*]], float* nocapture [[TMP1:%.*]]) #[[ATTR2]] { 671; CHECK-NEXT: [[TMP3:%.*]] = call [[UNUSED_DIFFERENT_TYPE:%.*]] @unused_different_type.body(i32* [[TMP0]], float* undef) 672; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[UNUSED_DIFFERENT_TYPE]] [[TMP3]], 0 673; CHECK-NEXT: store float [[TMP4]], float* [[TMP1]], align 4 674; CHECK-NEXT: ret void 675; 676; 677; CHECK-LABEL: define {{[^@]+}}@multiple_same_return_noalias.body 678; CHECK-SAME: (i32* noalias [[OUT0:%.*]], i32* noalias [[OUT1:%.*]]) #[[ATTR0]] { 679; CHECK-NEXT: ret [[MULTIPLE_SAME_RETURN_NOALIAS:%.*]] { i32 1, i32 2 } 680; 681; 682; CHECK-LABEL: define {{[^@]+}}@multiple_same_return_noalias 683; CHECK-SAME: (i32* noalias [[TMP0:%.*]], i32* noalias [[TMP1:%.*]]) #[[ATTR2]] { 684; CHECK-NEXT: [[TMP3:%.*]] = call [[MULTIPLE_SAME_RETURN_NOALIAS:%.*]] @multiple_same_return_noalias.body(i32* undef, i32* undef) 685; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[MULTIPLE_SAME_RETURN_NOALIAS]] [[TMP3]], 0 686; CHECK-NEXT: store i32 [[TMP4]], i32* [[TMP0]], align 4 687; CHECK-NEXT: [[TMP5:%.*]] = extractvalue [[MULTIPLE_SAME_RETURN_NOALIAS]] [[TMP3]], 1 688; CHECK-NEXT: store i32 [[TMP5]], i32* [[TMP1]], align 4 689; CHECK-NEXT: ret void 690; 691; 692; CHECK-LABEL: define {{[^@]+}}@multiple_same_return_mayalias.body 693; CHECK-SAME: (i32* [[OUT0:%.*]], i32* [[OUT1:%.*]]) #[[ATTR0]] { 694; CHECK-NEXT: ret [[MULTIPLE_SAME_RETURN_MAYALIAS:%.*]] { i32 2, i32 1 } 695; 696; 697; CHECK-LABEL: define {{[^@]+}}@multiple_same_return_mayalias 698; CHECK-SAME: (i32* [[TMP0:%.*]], i32* [[TMP1:%.*]]) #[[ATTR2]] { 699; CHECK-NEXT: [[TMP3:%.*]] = call [[MULTIPLE_SAME_RETURN_MAYALIAS:%.*]] @multiple_same_return_mayalias.body(i32* undef, i32* undef) 700; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[MULTIPLE_SAME_RETURN_MAYALIAS]] [[TMP3]], 0 701; CHECK-NEXT: store i32 [[TMP4]], i32* [[TMP0]], align 4 702; CHECK-NEXT: [[TMP5:%.*]] = extractvalue [[MULTIPLE_SAME_RETURN_MAYALIAS]] [[TMP3]], 1 703; CHECK-NEXT: store i32 [[TMP5]], i32* [[TMP1]], align 4 704; CHECK-NEXT: ret void 705; 706; 707; CHECK-LABEL: define {{[^@]+}}@multiple_same_return_mayalias_order.body 708; CHECK-SAME: (i32* [[OUT0:%.*]], i32* [[OUT1:%.*]]) #[[ATTR0]] { 709; CHECK-NEXT: ret [[MULTIPLE_SAME_RETURN_MAYALIAS_ORDER:%.*]] { i32 1, i32 2 } 710; 711; 712; CHECK-LABEL: define {{[^@]+}}@multiple_same_return_mayalias_order 713; CHECK-SAME: (i32* [[TMP0:%.*]], i32* [[TMP1:%.*]]) #[[ATTR2]] { 714; CHECK-NEXT: [[TMP3:%.*]] = call [[MULTIPLE_SAME_RETURN_MAYALIAS_ORDER:%.*]] @multiple_same_return_mayalias_order.body(i32* undef, i32* undef) 715; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[MULTIPLE_SAME_RETURN_MAYALIAS_ORDER]] [[TMP3]], 0 716; CHECK-NEXT: store i32 [[TMP4]], i32* [[TMP0]], align 4 717; CHECK-NEXT: [[TMP5:%.*]] = extractvalue [[MULTIPLE_SAME_RETURN_MAYALIAS_ORDER]] [[TMP3]], 1 718; CHECK-NEXT: store i32 [[TMP5]], i32* [[TMP1]], align 4 719; CHECK-NEXT: ret void 720; 721; 722; CHECK-LABEL: define {{[^@]+}}@store_in_entry_block 723; CHECK-SAME: (i1 [[ARG0:%.*]], i32* [[OUT:%.*]]) #[[ATTR0]] { 724; CHECK-NEXT: entry: 725; CHECK-NEXT: [[VAL0:%.*]] = load i32, i32 addrspace(1)* undef, align 4 726; CHECK-NEXT: store i32 [[VAL0]], i32* [[OUT]], align 4 727; CHECK-NEXT: br i1 [[ARG0]], label [[IF:%.*]], label [[ENDIF:%.*]] 728; CHECK: if: 729; CHECK-NEXT: [[VAL1:%.*]] = load i32, i32 addrspace(1)* undef, align 4 730; CHECK-NEXT: br label [[ENDIF]] 731; CHECK: endif: 732; CHECK-NEXT: [[PHI:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[VAL1]], [[IF]] ] 733; CHECK-NEXT: ret i32 [[PHI]] 734; 735; 736; CHECK-LABEL: define {{[^@]+}}@i1_one_out_arg_i32_1_use.body 737; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 738; CHECK-NEXT: ret [[I1_ONE_OUT_ARG_I32_1_USE:%.*]] { i1 true, i32 24 } 739; 740; 741; CHECK-LABEL: define {{[^@]+}}@i1_one_out_arg_i32_1_use 742; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 743; CHECK-NEXT: [[TMP2:%.*]] = call [[I1_ONE_OUT_ARG_I32_1_USE:%.*]] @i1_one_out_arg_i32_1_use.body(i32* undef) 744; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[I1_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 1 745; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 746; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[I1_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 0 747; CHECK-NEXT: ret i1 [[TMP4]] 748; 749; 750; CHECK-LABEL: define {{[^@]+}}@i1_zeroext_one_out_arg_i32_1_use.body 751; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 752; CHECK-NEXT: ret [[I1_ZEROEXT_ONE_OUT_ARG_I32_1_USE:%.*]] { i1 true, i32 24 } 753; 754; 755; CHECK-LABEL: define {{[^@]+}}@i1_zeroext_one_out_arg_i32_1_use 756; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 757; CHECK-NEXT: [[TMP2:%.*]] = call [[I1_ZEROEXT_ONE_OUT_ARG_I32_1_USE:%.*]] @i1_zeroext_one_out_arg_i32_1_use.body(i32* undef) 758; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[I1_ZEROEXT_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 1 759; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 760; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[I1_ZEROEXT_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 0 761; CHECK-NEXT: ret i1 [[TMP4]] 762; 763; 764; CHECK-LABEL: define {{[^@]+}}@i1_signext_one_out_arg_i32_1_use.body 765; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 766; CHECK-NEXT: ret [[I1_SIGNEXT_ONE_OUT_ARG_I32_1_USE:%.*]] { i1 true, i32 24 } 767; 768; 769; CHECK-LABEL: define {{[^@]+}}@i1_signext_one_out_arg_i32_1_use 770; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 771; CHECK-NEXT: [[TMP2:%.*]] = call [[I1_SIGNEXT_ONE_OUT_ARG_I32_1_USE:%.*]] @i1_signext_one_out_arg_i32_1_use.body(i32* undef) 772; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[I1_SIGNEXT_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 1 773; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 774; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[I1_SIGNEXT_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 0 775; CHECK-NEXT: ret i1 [[TMP4]] 776; 777; 778; CHECK-LABEL: define {{[^@]+}}@p1i32_noalias_one_out_arg_i32_1_use.body 779; CHECK-SAME: (i32* [[VAL:%.*]]) #[[ATTR0]] { 780; CHECK-NEXT: ret [[P1I32_NOALIAS_ONE_OUT_ARG_I32_1_USE:%.*]] { i32 addrspace(1)* null, i32 24 } 781; 782; 783; CHECK-LABEL: define {{[^@]+}}@p1i32_noalias_one_out_arg_i32_1_use 784; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 785; CHECK-NEXT: [[TMP2:%.*]] = call [[P1I32_NOALIAS_ONE_OUT_ARG_I32_1_USE:%.*]] @p1i32_noalias_one_out_arg_i32_1_use.body(i32* undef) 786; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[P1I32_NOALIAS_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 1 787; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP0]], align 4 788; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[P1I32_NOALIAS_ONE_OUT_ARG_I32_1_USE]] [[TMP2]], 0 789; CHECK-NEXT: ret i32 addrspace(1)* [[TMP4]] 790; 791; 792; CHECK-LABEL: define {{[^@]+}}@void_one_out_non_private_arg_i32_1_use 793; CHECK-SAME: (i32 addrspace(1)* [[VAL:%.*]]) #[[ATTR0]] { 794; CHECK-NEXT: store i32 0, i32 addrspace(1)* [[VAL]], align 4 795; CHECK-NEXT: ret void 796; 797; 798; CHECK-LABEL: define {{[^@]+}}@func_ptr_type.body 799; CHECK-SAME: (void ()** [[OUT:%.*]]) #[[ATTR0]] { 800; CHECK-NEXT: [[FUNC:%.*]] = load void ()*, void ()** undef, align 8 801; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[FUNC_PTR_TYPE:%.*]] undef, void ()* [[FUNC]], 0 802; CHECK-NEXT: ret [[FUNC_PTR_TYPE]] [[TMP1]] 803; 804; 805; CHECK-LABEL: define {{[^@]+}}@func_ptr_type 806; CHECK-SAME: (void ()** [[TMP0:%.*]]) #[[ATTR2]] { 807; CHECK-NEXT: [[TMP2:%.*]] = call [[FUNC_PTR_TYPE:%.*]] @func_ptr_type.body(void ()** undef) 808; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[FUNC_PTR_TYPE]] [[TMP2]], 0 809; CHECK-NEXT: store void ()* [[TMP3]], void ()** [[TMP0]], align 8 810; CHECK-NEXT: ret void 811; 812; 813; CHECK-LABEL: define {{[^@]+}}@bitcast_func_ptr_type.body 814; CHECK-SAME: (void ()** [[OUT:%.*]]) #[[ATTR0]] { 815; CHECK-NEXT: [[FUNC:%.*]] = load i32 ()*, i32 ()** undef, align 8 816; CHECK-NEXT: [[CAST:%.*]] = bitcast void ()** [[OUT]] to i32 ()** 817; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_FUNC_PTR_TYPE:%.*]] undef, i32 ()* [[FUNC]], 0 818; CHECK-NEXT: ret [[BITCAST_FUNC_PTR_TYPE]] [[TMP1]] 819; 820; 821; CHECK-LABEL: define {{[^@]+}}@bitcast_func_ptr_type 822; CHECK-SAME: (void ()** [[TMP0:%.*]]) #[[ATTR2]] { 823; CHECK-NEXT: [[TMP2:%.*]] = call [[BITCAST_FUNC_PTR_TYPE:%.*]] @bitcast_func_ptr_type.body(void ()** undef) 824; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[BITCAST_FUNC_PTR_TYPE]] [[TMP2]], 0 825; CHECK-NEXT: [[TMP4:%.*]] = bitcast void ()** [[TMP0]] to i32 ()** 826; CHECK-NEXT: store i32 ()* [[TMP3]], i32 ()** [[TMP4]], align 8 827; CHECK-NEXT: ret void 828; 829; 830; CHECK-LABEL: define {{[^@]+}}@out_arg_small_array.body 831; CHECK-SAME: ([4 x i32]* [[VAL:%.*]]) #[[ATTR0]] { 832; CHECK-NEXT: ret [[OUT_ARG_SMALL_ARRAY:%.*]] { [4 x i32] [i32 0, i32 1, i32 2, i32 3] } 833; 834; 835; CHECK-LABEL: define {{[^@]+}}@out_arg_small_array 836; CHECK-SAME: ([4 x i32]* [[TMP0:%.*]]) #[[ATTR2]] { 837; CHECK-NEXT: [[TMP2:%.*]] = call [[OUT_ARG_SMALL_ARRAY:%.*]] @out_arg_small_array.body([4 x i32]* undef) 838; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[OUT_ARG_SMALL_ARRAY]] [[TMP2]], 0 839; CHECK-NEXT: store [4 x i32] [[TMP3]], [4 x i32]* [[TMP0]], align 4 840; CHECK-NEXT: ret void 841; 842; 843; CHECK-LABEL: define {{[^@]+}}@out_arg_large_array 844; CHECK-SAME: ([17 x i32]* [[VAL:%.*]]) #[[ATTR0]] { 845; CHECK-NEXT: store [17 x i32] zeroinitializer, [17 x i32]* [[VAL]], align 4 846; CHECK-NEXT: ret void 847; 848; 849; CHECK-LABEL: define {{[^@]+}}@num_regs_return_limit 850; CHECK-SAME: (i32* [[OUT:%.*]], i32 [[VAL:%.*]]) #[[ATTR0]] { 851; CHECK-NEXT: [[LOAD:%.*]] = load volatile <16 x i32>, <16 x i32> addrspace(1)* undef, align 64 852; CHECK-NEXT: store i32 [[VAL]], i32* [[OUT]], align 4 853; CHECK-NEXT: ret <16 x i32> [[LOAD]] 854; 855; 856; CHECK-LABEL: define {{[^@]+}}@num_regs_reach_limit.body 857; CHECK-SAME: (i32* [[OUT:%.*]], i32 [[VAL:%.*]]) #[[ATTR0]] { 858; CHECK-NEXT: [[LOAD:%.*]] = load volatile [15 x i32], [15 x i32] addrspace(1)* undef, align 4 859; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[NUM_REGS_REACH_LIMIT:%.*]] undef, [15 x i32] [[LOAD]], 0 860; CHECK-NEXT: [[TMP2:%.*]] = insertvalue [[NUM_REGS_REACH_LIMIT]] [[TMP1]], i32 [[VAL]], 1 861; CHECK-NEXT: ret [[NUM_REGS_REACH_LIMIT]] [[TMP2]] 862; 863; 864; CHECK-LABEL: define {{[^@]+}}@num_regs_reach_limit 865; CHECK-SAME: (i32* [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR2]] { 866; CHECK-NEXT: [[TMP3:%.*]] = call [[NUM_REGS_REACH_LIMIT:%.*]] @num_regs_reach_limit.body(i32* undef, i32 [[TMP1]]) 867; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[NUM_REGS_REACH_LIMIT]] [[TMP3]], 1 868; CHECK-NEXT: store i32 [[TMP4]], i32* [[TMP0]], align 4 869; CHECK-NEXT: [[TMP5:%.*]] = extractvalue [[NUM_REGS_REACH_LIMIT]] [[TMP3]], 0 870; CHECK-NEXT: ret [15 x i32] [[TMP5]] 871; 872; 873; CHECK-LABEL: define {{[^@]+}}@num_regs_reach_limit_leftover.body 874; CHECK-SAME: (i32* [[OUT0:%.*]], i32* [[OUT1:%.*]], i32 [[VAL0:%.*]]) #[[ATTR0]] { 875; CHECK-NEXT: [[LOAD0:%.*]] = load volatile [15 x i32], [15 x i32] addrspace(1)* undef, align 4 876; CHECK-NEXT: [[LOAD1:%.*]] = load volatile i32, i32 addrspace(1)* undef, align 4 877; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[NUM_REGS_REACH_LIMIT_LEFTOVER:%.*]] undef, [15 x i32] [[LOAD0]], 0 878; CHECK-NEXT: [[TMP2:%.*]] = insertvalue [[NUM_REGS_REACH_LIMIT_LEFTOVER]] [[TMP1]], i32 [[LOAD1]], 1 879; CHECK-NEXT: [[TMP3:%.*]] = insertvalue [[NUM_REGS_REACH_LIMIT_LEFTOVER]] [[TMP2]], i32 [[VAL0]], 2 880; CHECK-NEXT: ret [[NUM_REGS_REACH_LIMIT_LEFTOVER]] [[TMP3]] 881; 882; 883; CHECK-LABEL: define {{[^@]+}}@num_regs_reach_limit_leftover 884; CHECK-SAME: (i32* [[TMP0:%.*]], i32* [[TMP1:%.*]], i32 [[TMP2:%.*]]) #[[ATTR2]] { 885; CHECK-NEXT: [[TMP4:%.*]] = call [[NUM_REGS_REACH_LIMIT_LEFTOVER:%.*]] @num_regs_reach_limit_leftover.body(i32* undef, i32* undef, i32 [[TMP2]]) 886; CHECK-NEXT: [[TMP5:%.*]] = extractvalue [[NUM_REGS_REACH_LIMIT_LEFTOVER]] [[TMP4]], 1 887; CHECK-NEXT: store i32 [[TMP5]], i32* [[TMP0]], align 4 888; CHECK-NEXT: [[TMP6:%.*]] = extractvalue [[NUM_REGS_REACH_LIMIT_LEFTOVER]] [[TMP4]], 2 889; CHECK-NEXT: store i32 [[TMP6]], i32* [[TMP1]], align 4 890; CHECK-NEXT: [[TMP7:%.*]] = extractvalue [[NUM_REGS_REACH_LIMIT_LEFTOVER]] [[TMP4]], 0 891; CHECK-NEXT: ret [15 x i32] [[TMP7]] 892; 893; 894; CHECK-LABEL: define {{[^@]+}}@preserve_debug_info.body 895; CHECK-SAME: (i32 [[ARG0:%.*]], i32* [[VAL:%.*]]) #[[ATTR0]] { 896; CHECK-NEXT: call void @may.clobber(), !dbg [[DBG5:![0-9]+]] 897; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[PRESERVE_DEBUG_INFO:%.*]] undef, i32 [[ARG0]], 0, !dbg [[DBG11:![0-9]+]] 898; CHECK-NEXT: ret [[PRESERVE_DEBUG_INFO]] [[TMP1]], !dbg [[DBG11]] 899; 900; 901; CHECK-LABEL: define {{[^@]+}}@preserve_debug_info 902; CHECK-SAME: (i32 [[TMP0:%.*]], i32* [[TMP1:%.*]]) #[[ATTR2]] !dbg [[DBG6:![0-9]+]] { 903; CHECK-NEXT: [[TMP3:%.*]] = call [[PRESERVE_DEBUG_INFO:%.*]] @preserve_debug_info.body(i32 [[TMP0]], i32* undef) 904; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[PRESERVE_DEBUG_INFO]] [[TMP3]], 0 905; CHECK-NEXT: store i32 [[TMP4]], i32* [[TMP1]], align 4 906; CHECK-NEXT: ret void 907; 908; 909; CHECK-LABEL: define {{[^@]+}}@preserve_metadata.body 910; CHECK-SAME: (i32 [[ARG0:%.*]], i32* [[VAL:%.*]]) #[[ATTR0]] { 911; CHECK-NEXT: call void @may.clobber() 912; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[PRESERVE_METADATA:%.*]] undef, i32 [[ARG0]], 0 913; CHECK-NEXT: ret [[PRESERVE_METADATA]] [[TMP1]] 914; 915; 916; CHECK-LABEL: define {{[^@]+}}@preserve_metadata 917; CHECK-SAME: (i32 [[TMP0:%.*]], i32* [[TMP1:%.*]]) #[[ATTR2]] !kernel_arg_access_qual !12 { 918; CHECK-NEXT: [[TMP3:%.*]] = call [[PRESERVE_METADATA:%.*]] @preserve_metadata.body(i32 [[TMP0]], i32* undef) 919; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[PRESERVE_METADATA]] [[TMP3]], 0 920; CHECK-NEXT: store i32 [[TMP4]], i32* [[TMP1]], align 4 921; CHECK-NEXT: ret void 922; 923; 924; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_v4i32_v3i32.body 925; CHECK-SAME: (<3 x i32>* [[OUT:%.*]]) #[[ATTR0]] { 926; CHECK-NEXT: [[LOAD:%.*]] = load volatile <4 x i32>, <4 x i32> addrspace(1)* undef, align 16 927; CHECK-NEXT: [[BITCAST:%.*]] = bitcast <3 x i32>* [[OUT]] to <4 x i32>* 928; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_POINTER_V4I32_V3I32:%.*]] undef, <4 x i32> [[LOAD]], 0 929; CHECK-NEXT: ret [[BITCAST_POINTER_V4I32_V3I32]] [[TMP1]] 930; 931; 932; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_v4i32_v3i32 933; CHECK-SAME: (<3 x i32>* [[TMP0:%.*]]) #[[ATTR2]] { 934; CHECK-NEXT: [[TMP2:%.*]] = call [[BITCAST_POINTER_V4I32_V3I32:%.*]] @bitcast_pointer_v4i32_v3i32.body(<3 x i32>* undef) 935; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[BITCAST_POINTER_V4I32_V3I32]] [[TMP2]], 0 936; CHECK-NEXT: [[TMP4:%.*]] = bitcast <3 x i32>* [[TMP0]] to <4 x i32>* 937; CHECK-NEXT: store <4 x i32> [[TMP3]], <4 x i32>* [[TMP4]], align 16 938; CHECK-NEXT: ret void 939; 940; 941; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_v4i32_v3f32.body 942; CHECK-SAME: (<3 x float>* [[OUT:%.*]]) #[[ATTR0]] { 943; CHECK-NEXT: [[LOAD:%.*]] = load volatile <4 x i32>, <4 x i32> addrspace(1)* undef, align 16 944; CHECK-NEXT: [[BITCAST:%.*]] = bitcast <3 x float>* [[OUT]] to <4 x i32>* 945; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_POINTER_V4I32_V3F32:%.*]] undef, <4 x i32> [[LOAD]], 0 946; CHECK-NEXT: ret [[BITCAST_POINTER_V4I32_V3F32]] [[TMP1]] 947; 948; 949; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_v4i32_v3f32 950; CHECK-SAME: (<3 x float>* [[TMP0:%.*]]) #[[ATTR2]] { 951; CHECK-NEXT: [[TMP2:%.*]] = call [[BITCAST_POINTER_V4I32_V3F32:%.*]] @bitcast_pointer_v4i32_v3f32.body(<3 x float>* undef) 952; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[BITCAST_POINTER_V4I32_V3F32]] [[TMP2]], 0 953; CHECK-NEXT: [[TMP4:%.*]] = bitcast <3 x float>* [[TMP0]] to <4 x i32>* 954; CHECK-NEXT: store <4 x i32> [[TMP3]], <4 x i32>* [[TMP4]], align 16 955; CHECK-NEXT: ret void 956; 957; 958; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_i32_f32.body 959; CHECK-SAME: (float* [[OUT:%.*]]) #[[ATTR0]] { 960; CHECK-NEXT: [[LOAD:%.*]] = load volatile i32, i32 addrspace(1)* undef, align 4 961; CHECK-NEXT: [[BITCAST:%.*]] = bitcast float* [[OUT]] to i32* 962; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_POINTER_I32_F32:%.*]] undef, i32 [[LOAD]], 0 963; CHECK-NEXT: ret [[BITCAST_POINTER_I32_F32]] [[TMP1]] 964; 965; 966; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_i32_f32 967; CHECK-SAME: (float* [[TMP0:%.*]]) #[[ATTR2]] { 968; CHECK-NEXT: [[TMP2:%.*]] = call [[BITCAST_POINTER_I32_F32:%.*]] @bitcast_pointer_i32_f32.body(float* undef) 969; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[BITCAST_POINTER_I32_F32]] [[TMP2]], 0 970; CHECK-NEXT: [[TMP4:%.*]] = bitcast float* [[TMP0]] to i32* 971; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP4]], align 4 972; CHECK-NEXT: ret void 973; 974; 975; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_i32_f16.body 976; CHECK-SAME: (half* [[OUT:%.*]]) #[[ATTR0]] { 977; CHECK-NEXT: [[LOAD:%.*]] = load volatile i32, i32 addrspace(1)* undef, align 4 978; CHECK-NEXT: [[BITCAST:%.*]] = bitcast half* [[OUT]] to i32* 979; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_POINTER_I32_F16:%.*]] undef, i32 [[LOAD]], 0 980; CHECK-NEXT: ret [[BITCAST_POINTER_I32_F16]] [[TMP1]] 981; 982; 983; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_i32_f16 984; CHECK-SAME: (half* [[TMP0:%.*]]) #[[ATTR2]] { 985; CHECK-NEXT: [[TMP2:%.*]] = call [[BITCAST_POINTER_I32_F16:%.*]] @bitcast_pointer_i32_f16.body(half* undef) 986; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[BITCAST_POINTER_I32_F16]] [[TMP2]], 0 987; CHECK-NEXT: [[TMP4:%.*]] = bitcast half* [[TMP0]] to i32* 988; CHECK-NEXT: store i32 [[TMP3]], i32* [[TMP4]], align 4 989; CHECK-NEXT: ret void 990; 991; 992; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_f16_i32.body 993; CHECK-SAME: (i32* [[OUT:%.*]]) #[[ATTR0]] { 994; CHECK-NEXT: [[LOAD:%.*]] = load volatile half, half addrspace(1)* undef, align 2 995; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[OUT]] to half* 996; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_POINTER_F16_I32:%.*]] undef, half [[LOAD]], 0 997; CHECK-NEXT: ret [[BITCAST_POINTER_F16_I32]] [[TMP1]] 998; 999; 1000; CHECK-LABEL: define {{[^@]+}}@bitcast_pointer_f16_i32 1001; CHECK-SAME: (i32* [[TMP0:%.*]]) #[[ATTR2]] { 1002; CHECK-NEXT: [[TMP2:%.*]] = call [[BITCAST_POINTER_F16_I32:%.*]] @bitcast_pointer_f16_i32.body(i32* undef) 1003; CHECK-NEXT: [[TMP3:%.*]] = extractvalue [[BITCAST_POINTER_F16_I32]] [[TMP2]], 0 1004; CHECK-NEXT: [[TMP4:%.*]] = bitcast i32* [[TMP0]] to half* 1005; CHECK-NEXT: store half [[TMP3]], half* [[TMP4]], align 2 1006; CHECK-NEXT: ret void 1007; 1008; 1009; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v3f32.body 1010; CHECK-SAME: (%struct.v3f32* [[OUT:%.*]], <3 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1011; CHECK-NEXT: [[EXTRACTVEC:%.*]] = shufflevector <3 x float> [[VALUE]], <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 1012; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v3f32* [[OUT]] to <4 x float>* 1013; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V3F32_V3F32:%.*]] undef, <4 x float> [[EXTRACTVEC]], 0 1014; CHECK-NEXT: ret [[BITCAST_STRUCT_V3F32_V3F32]] [[TMP1]] 1015; 1016; 1017; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v3f32 1018; CHECK-SAME: (%struct.v3f32* [[TMP0:%.*]], <3 x float> [[TMP1:%.*]]) #[[ATTR2]] { 1019; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V3F32_V3F32:%.*]] @bitcast_struct_v3f32_v3f32.body(%struct.v3f32* undef, <3 x float> [[TMP1]]) 1020; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V3F32_V3F32]] [[TMP3]], 0 1021; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v3f32* [[TMP0]] to <4 x float>* 1022; CHECK-NEXT: store <4 x float> [[TMP4]], <4 x float>* [[TMP5]], align 16 1023; CHECK-NEXT: ret void 1024; 1025; 1026; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v3i32.body 1027; CHECK-SAME: (%struct.v3f32* [[OUT:%.*]], <3 x i32> [[VALUE:%.*]]) #[[ATTR0]] { 1028; CHECK-NEXT: [[EXTRACTVEC:%.*]] = shufflevector <3 x i32> [[VALUE]], <3 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 1029; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v3f32* [[OUT]] to <4 x i32>* 1030; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V3F32_V3I32:%.*]] undef, <4 x i32> [[EXTRACTVEC]], 0 1031; CHECK-NEXT: ret [[BITCAST_STRUCT_V3F32_V3I32]] [[TMP1]] 1032; 1033; 1034; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v3i32 1035; CHECK-SAME: (%struct.v3f32* [[TMP0:%.*]], <3 x i32> [[TMP1:%.*]]) #[[ATTR2]] { 1036; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V3F32_V3I32:%.*]] @bitcast_struct_v3f32_v3i32.body(%struct.v3f32* undef, <3 x i32> [[TMP1]]) 1037; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V3F32_V3I32]] [[TMP3]], 0 1038; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v3f32* [[TMP0]] to <4 x i32>* 1039; CHECK-NEXT: store <4 x i32> [[TMP4]], <4 x i32>* [[TMP5]], align 16 1040; CHECK-NEXT: ret void 1041; 1042; 1043; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v4f32_v4f32.body 1044; CHECK-SAME: (%struct.v4f32* [[OUT:%.*]], <4 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1045; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v4f32* [[OUT]] to <4 x float>* 1046; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V4F32_V4F32:%.*]] undef, <4 x float> [[VALUE]], 0 1047; CHECK-NEXT: ret [[BITCAST_STRUCT_V4F32_V4F32]] [[TMP1]] 1048; 1049; 1050; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v4f32_v4f32 1051; CHECK-SAME: (%struct.v4f32* [[TMP0:%.*]], <4 x float> [[TMP1:%.*]]) #[[ATTR2]] { 1052; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V4F32_V4F32:%.*]] @bitcast_struct_v4f32_v4f32.body(%struct.v4f32* undef, <4 x float> [[TMP1]]) 1053; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V4F32_V4F32]] [[TMP3]], 0 1054; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v4f32* [[TMP0]] to <4 x float>* 1055; CHECK-NEXT: store <4 x float> [[TMP4]], <4 x float>* [[TMP5]], align 16 1056; CHECK-NEXT: ret void 1057; 1058; 1059; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v4i32.body 1060; CHECK-SAME: (%struct.v3f32* [[OUT:%.*]], <4 x i32> [[VALUE:%.*]]) #[[ATTR0]] { 1061; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v3f32* [[OUT]] to <4 x i32>* 1062; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V3F32_V4I32:%.*]] undef, <4 x i32> [[VALUE]], 0 1063; CHECK-NEXT: ret [[BITCAST_STRUCT_V3F32_V4I32]] [[TMP1]] 1064; 1065; 1066; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v4i32 1067; CHECK-SAME: (%struct.v3f32* [[TMP0:%.*]], <4 x i32> [[TMP1:%.*]]) #[[ATTR2]] { 1068; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V3F32_V4I32:%.*]] @bitcast_struct_v3f32_v4i32.body(%struct.v3f32* undef, <4 x i32> [[TMP1]]) 1069; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V3F32_V4I32]] [[TMP3]], 0 1070; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v3f32* [[TMP0]] to <4 x i32>* 1071; CHECK-NEXT: store <4 x i32> [[TMP4]], <4 x i32>* [[TMP5]], align 16 1072; CHECK-NEXT: ret void 1073; 1074; 1075; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v4f32_v3f32.body 1076; CHECK-SAME: (%struct.v4f32* [[OUT:%.*]], <3 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1077; CHECK-NEXT: [[EXTRACTVEC:%.*]] = shufflevector <3 x float> [[VALUE]], <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 1078; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v4f32* [[OUT]] to <4 x float>* 1079; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V4F32_V3F32:%.*]] undef, <4 x float> [[EXTRACTVEC]], 0 1080; CHECK-NEXT: ret [[BITCAST_STRUCT_V4F32_V3F32]] [[TMP1]] 1081; 1082; 1083; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v4f32_v3f32 1084; CHECK-SAME: (%struct.v4f32* [[TMP0:%.*]], <3 x float> [[TMP1:%.*]]) #[[ATTR2]] { 1085; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V4F32_V3F32:%.*]] @bitcast_struct_v4f32_v3f32.body(%struct.v4f32* undef, <3 x float> [[TMP1]]) 1086; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V4F32_V3F32]] [[TMP3]], 0 1087; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v4f32* [[TMP0]] to <4 x float>* 1088; CHECK-NEXT: store <4 x float> [[TMP4]], <4 x float>* [[TMP5]], align 16 1089; CHECK-NEXT: ret void 1090; 1091; 1092; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v2f32.body 1093; CHECK-SAME: (%struct.v3f32* [[OUT:%.*]], <2 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1094; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v3f32* [[OUT]] to <2 x float>* 1095; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V3F32_V2F32:%.*]] undef, <2 x float> [[VALUE]], 0 1096; CHECK-NEXT: ret [[BITCAST_STRUCT_V3F32_V2F32]] [[TMP1]] 1097; 1098; 1099; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_v2f32 1100; CHECK-SAME: (%struct.v3f32* [[TMP0:%.*]], <2 x float> [[TMP1:%.*]]) #[[ATTR2]] { 1101; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V3F32_V2F32:%.*]] @bitcast_struct_v3f32_v2f32.body(%struct.v3f32* undef, <2 x float> [[TMP1]]) 1102; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V3F32_V2F32]] [[TMP3]], 0 1103; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v3f32* [[TMP0]] to <2 x float>* 1104; CHECK-NEXT: store <2 x float> [[TMP4]], <2 x float>* [[TMP5]], align 8 1105; CHECK-NEXT: ret void 1106; 1107; 1108; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_f32_v3f32.body 1109; CHECK-SAME: (%struct.v3f32.f32* [[OUT:%.*]], <3 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1110; CHECK-NEXT: [[EXTRACTVEC:%.*]] = shufflevector <3 x float> [[VALUE]], <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 1111; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v3f32.f32* [[OUT]] to <4 x float>* 1112; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V3F32_F32_V3F32:%.*]] undef, <4 x float> [[EXTRACTVEC]], 0 1113; CHECK-NEXT: ret [[BITCAST_STRUCT_V3F32_F32_V3F32]] [[TMP1]] 1114; 1115; 1116; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_f32_v3f32 1117; CHECK-SAME: (%struct.v3f32.f32* [[TMP0:%.*]], <3 x float> [[TMP1:%.*]]) #[[ATTR2]] { 1118; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V3F32_F32_V3F32:%.*]] @bitcast_struct_v3f32_f32_v3f32.body(%struct.v3f32.f32* undef, <3 x float> [[TMP1]]) 1119; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V3F32_F32_V3F32]] [[TMP3]], 0 1120; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v3f32.f32* [[TMP0]] to <4 x float>* 1121; CHECK-NEXT: store <4 x float> [[TMP4]], <4 x float>* [[TMP5]], align 16 1122; CHECK-NEXT: ret void 1123; 1124; 1125; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_f32_v4f32.body 1126; CHECK-SAME: (%struct.v3f32.f32* [[OUT:%.*]], <4 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1127; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.v3f32.f32* [[OUT]] to <4 x float>* 1128; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_V3F32_F32_V4F32:%.*]] undef, <4 x float> [[VALUE]], 0 1129; CHECK-NEXT: ret [[BITCAST_STRUCT_V3F32_F32_V4F32]] [[TMP1]] 1130; 1131; 1132; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_v3f32_f32_v4f32 1133; CHECK-SAME: (%struct.v3f32.f32* [[TMP0:%.*]], <4 x float> [[TMP1:%.*]]) #[[ATTR2]] { 1134; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_V3F32_F32_V4F32:%.*]] @bitcast_struct_v3f32_f32_v4f32.body(%struct.v3f32.f32* undef, <4 x float> [[TMP1]]) 1135; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_V3F32_F32_V4F32]] [[TMP3]], 0 1136; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.v3f32.f32* [[TMP0]] to <4 x float>* 1137; CHECK-NEXT: store <4 x float> [[TMP4]], <4 x float>* [[TMP5]], align 16 1138; CHECK-NEXT: ret void 1139; 1140; 1141; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_i128_v4f32.body 1142; CHECK-SAME: (%struct.i128* [[OUT:%.*]], <4 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1143; CHECK-NEXT: [[CAST:%.*]] = bitcast %struct.i128* [[OUT]] to <4 x float>* 1144; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_STRUCT_I128_V4F32:%.*]] undef, <4 x float> [[VALUE]], 0 1145; CHECK-NEXT: ret [[BITCAST_STRUCT_I128_V4F32]] [[TMP1]] 1146; 1147; 1148; CHECK-LABEL: define {{[^@]+}}@bitcast_struct_i128_v4f32 1149; CHECK-SAME: (%struct.i128* [[TMP0:%.*]], <4 x float> [[TMP1:%.*]]) #[[ATTR2]] { 1150; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_STRUCT_I128_V4F32:%.*]] @bitcast_struct_i128_v4f32.body(%struct.i128* undef, <4 x float> [[TMP1]]) 1151; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_STRUCT_I128_V4F32]] [[TMP3]], 0 1152; CHECK-NEXT: [[TMP5:%.*]] = bitcast %struct.i128* [[TMP0]] to <4 x float>* 1153; CHECK-NEXT: store <4 x float> [[TMP4]], <4 x float>* [[TMP5]], align 16 1154; CHECK-NEXT: ret void 1155; 1156; 1157; CHECK-LABEL: define {{[^@]+}}@bitcast_array_v4i32_v4f32.body 1158; CHECK-SAME: ([4 x i32]* [[OUT:%.*]], [4 x float] [[VALUE:%.*]]) #[[ATTR0]] { 1159; CHECK-NEXT: [[CAST:%.*]] = bitcast [4 x i32]* [[OUT]] to [4 x float]* 1160; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_ARRAY_V4I32_V4F32:%.*]] undef, [4 x float] [[VALUE]], 0 1161; CHECK-NEXT: ret [[BITCAST_ARRAY_V4I32_V4F32]] [[TMP1]] 1162; 1163; 1164; CHECK-LABEL: define {{[^@]+}}@bitcast_array_v4i32_v4f32 1165; CHECK-SAME: ([4 x i32]* [[TMP0:%.*]], [4 x float] [[TMP1:%.*]]) #[[ATTR2]] { 1166; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_ARRAY_V4I32_V4F32:%.*]] @bitcast_array_v4i32_v4f32.body([4 x i32]* undef, [4 x float] [[TMP1]]) 1167; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_ARRAY_V4I32_V4F32]] [[TMP3]], 0 1168; CHECK-NEXT: [[TMP5:%.*]] = bitcast [4 x i32]* [[TMP0]] to [4 x float]* 1169; CHECK-NEXT: store [4 x float] [[TMP4]], [4 x float]* [[TMP5]], align 4 1170; CHECK-NEXT: ret void 1171; 1172; 1173; CHECK-LABEL: define {{[^@]+}}@multi_return_bitcast_struct_v3f32_v3f32.body 1174; CHECK-SAME: (i1 [[COND:%.*]], %struct.v3f32* [[OUT:%.*]], <3 x float> [[VALUE:%.*]]) #[[ATTR0]] { 1175; CHECK-NEXT: entry: 1176; CHECK-NEXT: br i1 [[COND]], label [[RET0:%.*]], label [[RET1:%.*]] 1177; CHECK: ret0: 1178; CHECK-NEXT: [[EXTRACTVEC:%.*]] = shufflevector <3 x float> [[VALUE]], <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef> 1179; CHECK-NEXT: [[CAST0:%.*]] = bitcast %struct.v3f32* [[OUT]] to <4 x float>* 1180; CHECK-NEXT: [[TMP0:%.*]] = insertvalue [[MULTI_RETURN_BITCAST_STRUCT_V3F32_V3F32:%.*]] undef, <4 x float> [[EXTRACTVEC]], 0 1181; CHECK-NEXT: ret [[MULTI_RETURN_BITCAST_STRUCT_V3F32_V3F32]] [[TMP0]] 1182; CHECK: ret1: 1183; CHECK-NEXT: [[CAST1:%.*]] = bitcast %struct.v3f32* [[OUT]] to <4 x float>* 1184; CHECK-NEXT: [[LOAD:%.*]] = load <4 x float>, <4 x float> addrspace(1)* undef, align 16 1185; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[MULTI_RETURN_BITCAST_STRUCT_V3F32_V3F32]] undef, <4 x float> [[LOAD]], 0 1186; CHECK-NEXT: ret [[MULTI_RETURN_BITCAST_STRUCT_V3F32_V3F32]] [[TMP1]] 1187; 1188; 1189; CHECK-LABEL: define {{[^@]+}}@multi_return_bitcast_struct_v3f32_v3f32 1190; CHECK-SAME: (i1 [[TMP0:%.*]], %struct.v3f32* [[TMP1:%.*]], <3 x float> [[TMP2:%.*]]) #[[ATTR2]] { 1191; CHECK-NEXT: [[TMP4:%.*]] = call [[MULTI_RETURN_BITCAST_STRUCT_V3F32_V3F32:%.*]] @multi_return_bitcast_struct_v3f32_v3f32.body(i1 [[TMP0]], %struct.v3f32* undef, <3 x float> [[TMP2]]) 1192; CHECK-NEXT: [[TMP5:%.*]] = extractvalue [[MULTI_RETURN_BITCAST_STRUCT_V3F32_V3F32]] [[TMP4]], 0 1193; CHECK-NEXT: [[TMP6:%.*]] = bitcast %struct.v3f32* [[TMP1]] to <4 x float>* 1194; CHECK-NEXT: store <4 x float> [[TMP5]], <4 x float>* [[TMP6]], align 16 1195; CHECK-NEXT: ret void 1196; 1197; 1198; CHECK-LABEL: define {{[^@]+}}@bitcast_v3f32_struct_v3f32.body 1199; CHECK-SAME: (<3 x float>* [[OUT:%.*]], [[STRUCT_V3F32:%.*]] [[VALUE:%.*]]) #[[ATTR0]] { 1200; CHECK-NEXT: [[CAST:%.*]] = bitcast <3 x float>* [[OUT]] to %struct.v3f32* 1201; CHECK-NEXT: [[TMP1:%.*]] = insertvalue [[BITCAST_V3F32_STRUCT_V3F32:%.*]] undef, [[STRUCT_V3F32]] [[VALUE]], 0 1202; CHECK-NEXT: ret [[BITCAST_V3F32_STRUCT_V3F32]] [[TMP1]] 1203; 1204; 1205; CHECK-LABEL: define {{[^@]+}}@bitcast_v3f32_struct_v3f32 1206; CHECK-SAME: (<3 x float>* [[TMP0:%.*]], [[STRUCT_V3F32:%.*]] [[TMP1:%.*]]) #[[ATTR2]] { 1207; CHECK-NEXT: [[TMP3:%.*]] = call [[BITCAST_V3F32_STRUCT_V3F32:%.*]] @bitcast_v3f32_struct_v3f32.body(<3 x float>* undef, [[STRUCT_V3F32]] [[TMP1]]) 1208; CHECK-NEXT: [[TMP4:%.*]] = extractvalue [[BITCAST_V3F32_STRUCT_V3F32]] [[TMP3]], 0 1209; CHECK-NEXT: [[TMP5:%.*]] = bitcast <3 x float>* [[TMP0]] to %struct.v3f32* 1210; CHECK-NEXT: store [[STRUCT_V3F32]] [[TMP4]], %struct.v3f32* [[TMP5]], align 16 1211; CHECK-NEXT: ret void 1212; 1213