llvm/test/CodeGen/ARM/GlobalISel/arm-irtranslator.ll

   1 ; RUN: llc -mtriple arm-unknown -mattr=+vfp2,+v4t -global-isel -stop-after=irtranslator -verify-machineinstrs %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=LITTLE
   2 ; RUN: llc -mtriple armeb-unknown -mattr=+vfp2,+v4t -global-isel -global-isel-abort=0 -enable-arm-gisel-bigendian -stop-after=irtranslator -verify-machineinstrs %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=BIG
   3
   4 define void @test_void_return() {
   5 ; CHECK-LABEL: name: test_void_return
   6 ; CHECK: BX_RET 14 /* CC::al */, $noreg
   7 entry:
   8   ret void
   9 }
  10
  11 define signext i1 @test_add_i1(i1 %x, i1 %y) {
  12 ; CHECK-LABEL: name: test_add_i1
  13 ; CHECK: liveins: $r0, $r1
  14 ; CHECK-DAG: [[VREGR0:%[0-9]+]]:_(s32) = COPY $r0
  15 ; CHECK-DAG: [[VREGX:%[0-9]+]]:_(s1) = G_TRUNC [[VREGR0]]
  16 ; CHECK-DAG: [[VREGR1:%[0-9]+]]:_(s32) = COPY $r1
  17 ; CHECK-DAG: [[VREGY:%[0-9]+]]:_(s1) = G_TRUNC [[VREGR1]]
  18 ; CHECK: [[SUM:%[0-9]+]]:_(s1) = G_ADD [[VREGX]], [[VREGY]]
  19 ; CHECK: [[EXT:%[0-9]+]]:_(s32) = G_SEXT [[SUM]]
  20 ; CHECK: $r0 = COPY [[EXT]](s32)
  21 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
  22 entry:
  23   %sum = add i1 %x, %y
  24   ret i1 %sum
  25 }
  26
  27 define i8 @test_add_i8(i8 %x, i8 %y) {
  28 ; CHECK-LABEL: name: test_add_i8
  29 ; CHECK: liveins: $r0, $r1
  30 ; CHECK-DAG: [[VREGR0:%[0-9]+]]:_(s32) = COPY $r0
  31 ; CHECK-DAG: [[VREGX:%[0-9]+]]:_(s8) = G_TRUNC [[VREGR0]]
  32 ; CHECK-DAG: [[VREGR1:%[0-9]+]]:_(s32) = COPY $r1
  33 ; CHECK-DAG: [[VREGY:%[0-9]+]]:_(s8) = G_TRUNC [[VREGR1]]
  34 ; CHECK: [[SUM:%[0-9]+]]:_(s8) = G_ADD [[VREGX]], [[VREGY]]
  35 ; CHECK: [[SUM_EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[SUM]]
  36 ; CHECK: $r0 = COPY [[SUM_EXT]](s32)
  37 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
  38 entry:
  39   %sum = add i8 %x, %y
  40   ret i8 %sum
  41 }
  42
  43 define i8 @test_sub_i8(i8 %x, i8 %y) {
  44 ; CHECK-LABEL: name: test_sub_i8
  45 ; CHECK: liveins: $r0, $r1
  46 ; CHECK-DAG: [[VREGR0:%[0-9]+]]:_(s32) = COPY $r0
  47 ; CHECK-DAG: [[VREGX:%[0-9]+]]:_(s8) = G_TRUNC [[VREGR0]]
  48 ; CHECK-DAG: [[VREGR1:%[0-9]+]]:_(s32) = COPY $r1
  49 ; CHECK-DAG: [[VREGY:%[0-9]+]]:_(s8) = G_TRUNC [[VREGR1]]
  50 ; CHECK: [[RES:%[0-9]+]]:_(s8) = G_SUB [[VREGX]], [[VREGY]]
  51 ; CHECK: [[RES_EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[RES]]
  52 ; CHECK: $r0 = COPY [[RES_EXT]](s32)
  53 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
  54 entry:
  55   %res = sub i8 %x, %y
  56   ret i8 %res
  57 }
  58
  59 define signext i8 @test_return_sext_i8(i8 %x) {
  60 ; CHECK-LABEL: name: test_return_sext_i8
  61 ; CHECK: liveins: $r0
  62 ; CHECK: [[VREGR0:%[0-9]+]]:_(s32) = COPY $r0
  63 ; CHECK: [[VREG:%[0-9]+]]:_(s8) = G_TRUNC [[VREGR0]]
  64 ; CHECK: [[VREGEXT:%[0-9]+]]:_(s32) = G_SEXT [[VREG]]
  65 ; CHECK: $r0 = COPY [[VREGEXT]](s32)
  66 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
  67 entry:
  68   ret i8 %x
  69 }
  70
  71 define i16 @test_add_i16(i16 %x, i16 %y) {
  72 ; CHECK-LABEL: name: test_add_i16
  73 ; CHECK: liveins: $r0, $r1
  74 ; CHECK-DAG: [[VREGR0:%[0-9]+]]:_(s32) = COPY $r0
  75 ; CHECK-DAG: [[VREGX:%[0-9]+]]:_(s16) = G_TRUNC [[VREGR0]]
  76 ; CHECK-DAG: [[VREGR1:%[0-9]+]]:_(s32) = COPY $r1
  77 ; CHECK-DAG: [[VREGY:%[0-9]+]]:_(s16) = G_TRUNC [[VREGR1]]
  78 ; CHECK: [[SUM:%[0-9]+]]:_(s16) = G_ADD [[VREGX]], [[VREGY]]
  79 ; CHECK: [[SUM_EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[SUM]]
  80 ; CHECK: $r0 = COPY [[SUM_EXT]](s32)
  81 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
  82 entry:
  83   %sum = add i16 %x, %y
  84   ret i16 %sum
  85 }
  86
  87 define i16 @test_sub_i16(i16 %x, i16 %y) {
  88 ; CHECK-LABEL: name: test_sub_i16
  89 ; CHECK: liveins: $r0, $r1
  90 ; CHECK-DAG: [[VREGR0:%[0-9]+]]:_(s32) = COPY $r0
  91 ; CHECK-DAG: [[VREGX:%[0-9]+]]:_(s16) = G_TRUNC [[VREGR0]]
  92 ; CHECK-DAG: [[VREGR1:%[0-9]+]]:_(s32) = COPY $r1
  93 ; CHECK-DAG: [[VREGY:%[0-9]+]]:_(s16) = G_TRUNC [[VREGR1]]
  94 ; CHECK: [[RES:%[0-9]+]]:_(s16) = G_SUB [[VREGX]], [[VREGY]]
  95 ; CHECK: [[RES_EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[RES]]
  96 ; CHECK: $r0 = COPY [[RES_EXT]](s32)
  97 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
  98 entry:
  99   %res = sub i16 %x, %y
 100   ret i16 %res
 101 }
 102
 103 define zeroext i16 @test_return_zext_i16(i16 %x) {
 104 ; CHECK-LABEL: name: test_return_zext_i16
 105 ; CHECK: liveins: $r0
 106 ; CHECK: [[VREGR0:%[0-9]+]]:_(s32) = COPY $r0
 107 ; CHECK: [[VREG:%[0-9]+]]:_(s16) = G_TRUNC [[VREGR0]]
 108 ; CHECK: [[VREGEXT:%[0-9]+]]:_(s32) = G_ZEXT [[VREG]]
 109 ; CHECK: $r0 = COPY [[VREGEXT]](s32)
 110 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 111 entry:
 112   ret i16 %x
 113 }
 114
 115 define i32 @test_add_i32(i32 %x, i32 %y) {
 116 ; CHECK-LABEL: name: test_add_i32
 117 ; CHECK: liveins: $r0, $r1
 118 ; CHECK-DAG: [[VREGX:%[0-9]+]]:_(s32) = COPY $r0
 119 ; CHECK-DAG: [[VREGY:%[0-9]+]]:_(s32) = COPY $r1
 120 ; CHECK: [[SUM:%[0-9]+]]:_(s32) = G_ADD [[VREGX]], [[VREGY]]
 121 ; CHECK: $r0 = COPY [[SUM]](s32)
 122 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 123 entry:
 124   %sum = add i32 %x, %y
 125   ret i32 %sum
 126 }
 127
 128 define i32 @test_sub_i32(i32 %x, i32 %y) {
 129 ; CHECK-LABEL: name: test_sub_i32
 130 ; CHECK: liveins: $r0, $r1
 131 ; CHECK-DAG: [[VREGX:%[0-9]+]]:_(s32) = COPY $r0
 132 ; CHECK-DAG: [[VREGY:%[0-9]+]]:_(s32) = COPY $r1
 133 ; CHECK: [[RES:%[0-9]+]]:_(s32) = G_SUB [[VREGX]], [[VREGY]]
 134 ; CHECK: $r0 = COPY [[RES]](s32)
 135 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 136 entry:
 137   %res = sub i32 %x, %y
 138   ret i32 %res
 139 }
 140
 141 define i32 @test_stack_args(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %p4, i32 %p5) {
 142 ; CHECK-LABEL: name: test_stack_args
 143 ; CHECK: fixedStack:
 144 ; CHECK-DAG: id: [[P4:[0-9]]]{{.*}}offset: 0{{.*}}size: 4
 145 ; CHECK-DAG: id: [[P5:[0-9]]]{{.*}}offset: 4{{.*}}size: 4
 146 ; CHECK: liveins: $r0, $r1, $r2, $r3
 147 ; CHECK: [[VREGP2:%[0-9]+]]:_(s32) = COPY $r2
 148 ; CHECK: [[FIP5:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P5]]
 149 ; CHECK: [[VREGP5:%[0-9]+]]:_(s32) = G_LOAD [[FIP5]]{{.*}}load (s32)
 150 ; CHECK: [[SUM:%[0-9]+]]:_(s32) = G_ADD [[VREGP2]], [[VREGP5]]
 151 ; CHECK: $r0 = COPY [[SUM]]
 152 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 153 entry:
 154   %sum = add i32 %p2, %p5
 155   ret i32 %sum
 156 }
 157
 158 define i16 @test_stack_args_signext(i32 %p0, i16 %p1, i8 %p2, i1 %p3,
 159                                     i8 signext %p4, i16 signext %p5) {
 160 ; CHECK-LABEL: name: test_stack_args_signext
 161 ; CHECK: fixedStack:
 162 ; CHECK-DAG: id: [[P4:[0-9]]]{{.*}}offset: 0{{.*}}size: 4
 163 ; CHECK-DAG: id: [[P5:[0-9]]]{{.*}}offset: 4{{.*}}size: 4
 164 ; CHECK: liveins: $r0, $r1, $r2, $r3
 165 ; CHECK: [[VREGR1:%[0-9]+]]:_(s32) = COPY $r1
 166 ; CHECK: [[VREGP1:%[0-9]+]]:_(s16) = G_TRUNC [[VREGR1]]
 167 ; CHECK: [[FIP5:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P5]]
 168 ; CHECK: [[VREGP5EXT:%[0-9]+]]:_(s32) = G_LOAD [[FIP5]](p0){{.*}}load (s32)
 169 ; CHECK: [[ASSERT_SEXT:%[0-9]+]]:_(s32) = G_ASSERT_SEXT [[VREGP5EXT]], 16
 170 ; CHECK: [[VREGP5:%[0-9]+]]:_(s16) = G_TRUNC [[ASSERT_SEXT]]
 171 ; CHECK: [[SUM:%[0-9]+]]:_(s16) = G_ADD [[VREGP1]], [[VREGP5]]
 172 ; CHECK: [[SUM_EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[SUM]]
 173 ; CHECK: $r0 = COPY [[SUM_EXT]](s32)
 174 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 175 entry:
 176   %sum = add i16 %p1, %p5
 177   ret i16 %sum
 178 }
 179
 180 define i8 @test_stack_args_zeroext(i32 %p0, i16 %p1, i8 %p2, i1 %p3,
 181                                     i8 zeroext %p4, i16 zeroext %p5) {
 182 ; CHECK-LABEL: name: test_stack_args_zeroext
 183 ; CHECK: fixedStack:
 184 ; CHECK-DAG: id: [[P4:[0-9]]]{{.*}}offset: 0{{.*}}size: 4
 185 ; CHECK-DAG: id: [[P5:[0-9]]]{{.*}}offset: 4{{.*}}size: 4
 186 ; CHECK: liveins: $r0, $r1, $r2, $r3
 187 ; CHECK: [[VREGR2:%[0-9]+]]:_(s32) = COPY $r2
 188 ; CHECK: [[VREGP2:%[0-9]+]]:_(s8) = G_TRUNC [[VREGR2]]
 189 ; CHECK: [[FIP4:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P4]]
 190 ; CHECK: [[VREGP4EXT:%[0-9]+]]:_(s32) = G_LOAD [[FIP4]](p0){{.*}}load (s32)
 191 ; CHECK: [[ASSERT_ZEXT:%[0-9]+]]:_(s32) = G_ASSERT_ZEXT [[VREGP4EXT]], 8
 192 ; CHECK: [[VREGP4:%[0-9]+]]:_(s8) = G_TRUNC [[ASSERT_ZEXT]]
 193 ; CHECK: [[SUM:%[0-9]+]]:_(s8) = G_ADD [[VREGP2]], [[VREGP4]]
 194 ; CHECK: [[SUM_EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[SUM]]
 195 ; CHECK: $r0 = COPY [[SUM_EXT]](s32)
 196 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 197 entry:
 198   %sum = add i8 %p2, %p4
 199   ret i8 %sum
 200 }
 201
 202 define i8 @test_stack_args_noext(i32 %p0, i16 %p1, i8 %p2, i1 %p3,
 203                                  i8 %p4, i16 %p5) {
 204 ; CHECK-LABEL: name: test_stack_args_noext
 205 ; CHECK: fixedStack:
 206 ; CHECK-DAG: id: [[P4:[0-9]]]{{.*}}offset: 0, size: 4, alignment: 8,
 207 ; CHECK-DAG: id: [[P5:[0-9]]]{{.*}}offset: 4, size: 4, alignment: 4,
 208 ; CHECK: liveins: $r0, $r1, $r2, $r3
 209 ; CHECK: [[VREGR2:%[0-9]+]]:_(s32) = COPY $r2
 210 ; CHECK: [[VREGP2:%[0-9]+]]:_(s8) = G_TRUNC [[VREGR2]]
 211 ; CHECK: [[FIP4:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P4]]
 212 ; CHECK: [[VREGP4:%[0-9]+]]:_(s32) = G_LOAD [[FIP4]](p0){{.*}}load (s32)
 213 ; CHECK: [[TRUNC_VREGP4:%[0-9]+]]:_(s8) = G_TRUNC [[VREGP4]]
 214 ; CHECK: [[SUM:%[0-9]+]]:_(s8) = G_ADD [[VREGP2]], [[TRUNC_VREGP4]]
 215 ; CHECK: [[SUM_EXT:%[0-9]+]]:_(s32) = G_ANYEXT [[SUM]]
 216 ; CHECK: $r0 = COPY [[SUM_EXT]](s32)
 217 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 218 entry:
 219   %sum = add i8 %p2, %p4
 220   ret i8 %sum
 221 }
 222
 223 define zeroext i16 @test_stack_args_extend_the_extended(i32 %p0, i16 %p1, i8 %p2, i1 %p3,
 224                                                         i8 signext %p4, i16 signext %p5) {
 225 ; CHECK-LABEL: name: test_stack_args_extend_the_extended
 226 ; CHECK: fixedStack:
 227 ; CHECK-DAG: id: [[P4:[0-9]]]{{.*}}offset: 0{{.*}}size: 4, alignment: 8
 228 ; CHECK-DAG: id: [[P5:[0-9]]]{{.*}}offset: 4{{.*}}size: 4, alignment: 4
 229 ; CHECK: liveins: $r0, $r1, $r2, $r3
 230 ; CHECK: [[FIP5:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P5]]
 231 ; CHECK: [[VREGP5SEXT:%[0-9]+]]:_(s32) = G_LOAD [[FIP5]](p0){{.*}}load (s32)
 232 ; CHECK: [[ASSERT_SEXT:%[0-9]+]]:_(s32) = G_ASSERT_SEXT [[VREGP5SEXT]], 16
 233 ; CHECK: [[VREGP5:%[0-9]+]]:_(s16) = G_TRUNC [[ASSERT_SEXT]]
 234 ; CHECK: [[VREGP5ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[VREGP5]]
 235 ; CHECK: $r0 = COPY [[VREGP5ZEXT]]
 236 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 237 entry:
 238   ret i16 %p5
 239 }
 240
 241 define i16 @test_ptr_arg(ptr %p) {
 242 ; CHECK-LABEL: name: test_ptr_arg
 243 ; CHECK: liveins: $r0
 244 ; CHECK: [[VREGP:%[0-9]+]]:_(p0) = COPY $r0
 245 ; CHECK: [[VREGV:%[0-9]+]]:_(s16) = G_LOAD [[VREGP]](p0){{.*}}load (s16)
 246 entry:
 247   %v = load i16, ptr %p
 248   ret i16 %v
 249 }
 250
 251 define ptr @test_ptr_ret(ptr %p) {
 252 ; Test pointer returns and pointer-to-pointer arguments
 253 ; CHECK-LABEL: name: test_ptr_ret
 254 ; CHECK: liveins: $r0
 255 ; CHECK: [[VREGP:%[0-9]+]]:_(p0) = COPY $r0
 256 ; CHECK: [[VREGV:%[0-9]+]]:_(p0) = G_LOAD [[VREGP]](p0){{.*}}load (p0)
 257 ; CHECK: $r0 = COPY [[VREGV]]
 258 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 259 entry:
 260   %v = load ptr, ptr %p
 261   ret ptr %v
 262 }
 263
 264 define i32 @test_ptr_arg_on_stack(i32 %a0, i32 %a1, i32 %a2, i32 %a3, ptr %p) {
 265 ; CHECK-LABEL: name: test_ptr_arg_on_stack
 266 ; CHECK: fixedStack:
 267 ; CHECK: id: [[P:[0-9]+]]{{.*}}offset: 0{{.*}}size: 4
 268 ; CHECK: liveins: $r0, $r1, $r2, $r3
 269 ; CHECK: [[FIP:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P]]
 270 ; CHECK: [[VREGP:%[0-9]+]]:_(p0) = G_LOAD [[FIP]](p0){{.*}}load (p0)
 271 ; CHECK: [[VREGV:%[0-9]+]]:_(s32) = G_LOAD [[VREGP]](p0){{.*}}load (s32)
 272 ; CHECK: $r0 = COPY [[VREGV]]
 273 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 274 entry:
 275   %v = load i32, ptr %p
 276   ret i32 %v
 277 }
 278
 279 define arm_aapcscc float @test_float_aapcscc(float %p0, float %p1, float %p2,
 280                                              float %p3, float %p4, float %p5) {
 281 ; CHECK-LABEL: name: test_float_aapcscc
 282 ; CHECK: fixedStack:
 283 ; CHECK-DAG: id: [[P4:[0-9]+]]{{.*}}offset: 0{{.*}}size: 4
 284 ; CHECK-DAG: id: [[P5:[0-9]+]]{{.*}}offset: 4{{.*}}size: 4
 285 ; CHECK: liveins: $r0, $r1, $r2, $r3
 286 ; CHECK: [[VREGP1:%[0-9]+]]:_(s32) = COPY $r1
 287 ; CHECK: [[FIP5:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P5]]
 288 ; CHECK: [[VREGP5:%[0-9]+]]:_(s32) = G_LOAD [[FIP5]](p0){{.*}}load (s32)
 289 ; CHECK: [[VREGV:%[0-9]+]]:_(s32) = G_FADD [[VREGP1]], [[VREGP5]]
 290 ; CHECK: $r0 = COPY [[VREGV]]
 291 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0
 292 entry:
 293   %v = fadd float %p1, %p5
 294   ret float %v
 295 }
 296
 297 define arm_aapcs_vfpcc float @test_float_vfpcc(float %p0, float %p1, float %p2,
 298                                                float %p3, float %p4, float %p5,
 299                                                float %ridiculous,
 300                                                float %number,
 301                                                float %of,
 302                                                float %parameters,
 303                                                float %that,
 304                                                float %should,
 305                                                float %never,
 306                                                float %exist,
 307                                                float %in,
 308                                                float %practice,
 309                                                float %q0, float %q1) {
 310 ; CHECK-LABEL: name: test_float_vfpcc
 311 ; CHECK: fixedStack:
 312 ; CHECK-DAG: id: [[Q0:[0-9]+]]{{.*}}offset: 0{{.*}}size: 4
 313 ; CHECK-DAG: id: [[Q1:[0-9]+]]{{.*}}offset: 4{{.*}}size: 4
 314 ; CHECK: liveins: $s0, $s1, $s2, $s3, $s4, $s5, $s6, $s7, $s8, $s9, $s10, $s11, $s12, $s13, $s14, $s15
 315 ; CHECK: [[VREGP1:%[0-9]+]]:_(s32) = COPY $s1
 316 ; CHECK: [[FIQ1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[Q1]]
 317 ; CHECK: [[VREGQ1:%[0-9]+]]:_(s32) = G_LOAD [[FIQ1]](p0){{.*}}load (s32)
 318 ; CHECK: [[VREGV:%[0-9]+]]:_(s32) = G_FADD [[VREGP1]], [[VREGQ1]]
 319 ; CHECK: $s0 = COPY [[VREGV]]
 320 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $s0
 321 entry:
 322   %v = fadd float %p1, %q1
 323   ret float %v
 324 }
 325
 326 define arm_aapcs_vfpcc double @test_double_vfpcc(double %p0, double %p1, double %p2,
 327                                                  double %p3, double %p4, double %p5,
 328                                                  double %reasonable,
 329                                                  double %parameters,
 330                                                  double %q0, double %q1) {
 331 ; CHECK-LABEL: name: test_double_vfpcc
 332 ; CHECK: fixedStack:
 333 ; CHECK-DAG: id: [[Q0:[0-9]+]]{{.*}}offset: 0{{.*}}size: 8
 334 ; CHECK-DAG: id: [[Q1:[0-9]+]]{{.*}}offset: 8{{.*}}size: 8
 335 ; CHECK: liveins: $d0, $d1, $d2, $d3, $d4, $d5, $d6, $d7
 336 ; CHECK: [[VREGP1:%[0-9]+]]:_(s64) = COPY $d1
 337 ; CHECK: [[FIQ1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[Q1]]
 338 ; CHECK: [[VREGQ1:%[0-9]+]]:_(s64) = G_LOAD [[FIQ1]](p0){{.*}}load (s64)
 339 ; CHECK: [[VREGV:%[0-9]+]]:_(s64) = G_FADD [[VREGP1]], [[VREGQ1]]
 340 ; CHECK: $d0 = COPY [[VREGV]]
 341 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $d0
 342 entry:
 343   %v = fadd double %p1, %q1
 344   ret double %v
 345 }
 346
 347 define arm_aapcscc double @test_double_aapcscc(double %p0, double %p1, double %p2,
 348                                                double %p3, double %p4, double %p5) {
 349 ; CHECK-LABEL: name: test_double_aapcscc
 350 ; CHECK: fixedStack:
 351 ; CHECK-DAG: id: [[P2:[0-9]+]]{{.*}}offset: 0{{.*}}size: 8
 352 ; CHECK-DAG: id: [[P3:[0-9]+]]{{.*}}offset: 8{{.*}}size: 8
 353 ; CHECK-DAG: id: [[P4:[0-9]+]]{{.*}}offset: 16{{.*}}size: 8
 354 ; CHECK-DAG: id: [[P5:[0-9]+]]{{.*}}offset: 24{{.*}}size: 8
 355 ; CHECK: liveins: $r0, $r1, $r2, $r3
 356 ; CHECK-DAG: [[VREGP1LO:%[0-9]+]]:_(s32) = COPY $r2
 357 ; CHECK-DAG: [[VREGP1HI:%[0-9]+]]:_(s32) = COPY $r3
 358 ; LITTLE: [[VREGP1:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[VREGP1LO]](s32), [[VREGP1HI]](s32)
 359 ; BIG: [[VREGP1:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[VREGP1HI]](s32), [[VREGP1LO]](s32)
 360 ; CHECK: [[FIP5:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P5]]
 361 ; CHECK: [[VREGP5:%[0-9]+]]:_(s64) = G_LOAD [[FIP5]](p0){{.*}}load (s64)
 362 ; CHECK: [[VREGV:%[0-9]+]]:_(s64) = G_FADD [[VREGP1]], [[VREGP5]]
 363 ; LITTLE: [[VREGVLO:%[0-9]+]]:_(s32), [[VREGVHI:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[VREGV]](s64)
 364 ; BIG: [[VREGVHI:%[0-9]+]]:_(s32), [[VREGVLO:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[VREGV]](s64)
 365 ; CHECK-DAG: $r0 = COPY [[VREGVLO]]
 366 ; CHECK-DAG: $r1 = COPY [[VREGVHI]]
 367 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0, implicit $r1
 368 entry:
 369   %v = fadd double %p1, %p5
 370   ret double %v
 371 }
 372
 373 define arm_aapcs_vfpcc double @test_double_gap_vfpcc(double %p0, float %filler,
 374                                                      double %p1, double %p2,
 375                                                      double %p3, double %p4,
 376                                                      double %reasonable,
 377                                                      double %parameters,
 378                                                      double %q0, double %q1) {
 379 ; CHECK-LABEL: name: test_double_gap_vfpcc
 380 ; CHECK: fixedStack:
 381 ; CHECK-DAG: id: [[Q0:[0-9]+]]{{.*}}offset: 0{{.*}}size: 8
 382 ; CHECK-DAG: id: [[Q1:[0-9]+]]{{.*}}offset: 8{{.*}}size: 8
 383 ; CHECK: liveins: $d0, $d2, $d3, $d4, $d5, $d6, $d7, $s2
 384 ; CHECK: [[VREGP1:%[0-9]+]]:_(s64) = COPY $d2
 385 ; CHECK: [[FIQ1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[Q1]]
 386 ; CHECK: [[VREGQ1:%[0-9]+]]:_(s64) = G_LOAD [[FIQ1]](p0){{.*}}load (s64)
 387 ; CHECK: [[VREGV:%[0-9]+]]:_(s64) = G_FADD [[VREGP1]], [[VREGQ1]]
 388 ; CHECK: $d0 = COPY [[VREGV]]
 389 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $d0
 390 entry:
 391   %v = fadd double %p1, %q1
 392   ret double %v
 393 }
 394
 395 define arm_aapcscc double @test_double_gap_aapcscc(float %filler, double %p0,
 396                                                    double %p1) {
 397 ; CHECK-LABEL: name: test_double_gap_aapcscc
 398 ; CHECK: fixedStack:
 399 ; CHECK-DAG: id: [[P1:[0-9]+]]{{.*}}offset: 0{{.*}}size: 8
 400 ; CHECK: liveins: $r0, $r2, $r3
 401 ; CHECK-DAG: [[VREGP0LO:%[0-9]+]]:_(s32) = COPY $r2
 402 ; CHECK-DAG: [[VREGP0HI:%[0-9]+]]:_(s32) = COPY $r3
 403 ; LITTLE: [[VREGP0:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[VREGP0LO]](s32), [[VREGP0HI]](s32)
 404 ; BIG: [[VREGP0:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[VREGP0HI]](s32), [[VREGP0LO]](s32)
 405 ; CHECK: [[FIP1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P1]]
 406 ; CHECK: [[VREGP1:%[0-9]+]]:_(s64) = G_LOAD [[FIP1]](p0){{.*}}load (s64)
 407 ; CHECK: [[VREGV:%[0-9]+]]:_(s64) = G_FADD [[VREGP0]], [[VREGP1]]
 408 ; LITTLE: [[VREGVLO:%[0-9]+]]:_(s32), [[VREGVHI:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[VREGV]](s64)
 409 ; BIG: [[VREGVHI:%[0-9]+]]:_(s32), [[VREGVLO:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[VREGV]](s64)
 410 ; CHECK-DAG: $r0 = COPY [[VREGVLO]]
 411 ; CHECK-DAG: $r1 = COPY [[VREGVHI]]
 412 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0, implicit $r1
 413 entry:
 414   %v = fadd double %p0, %p1
 415   ret double %v
 416 }
 417
 418 define arm_aapcscc double @test_double_gap2_aapcscc(double %p0, float %filler,
 419                                                     double %p1) {
 420 ; CHECK-LABEL: name: test_double_gap2_aapcscc
 421 ; CHECK: fixedStack:
 422 ; CHECK-DAG: id: [[P1:[0-9]+]]{{.*}}offset: 0{{.*}}size: 8
 423 ; CHECK: liveins: $r0, $r1, $r2
 424 ; CHECK-DAG: [[VREGP0LO:%[0-9]+]]:_(s32) = COPY $r0
 425 ; CHECK-DAG: [[VREGP0HI:%[0-9]+]]:_(s32) = COPY $r1
 426 ; LITTLE: [[VREGP0:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[VREGP0LO]](s32), [[VREGP0HI]](s32)
 427 ; BIG: [[VREGP0:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[VREGP0HI]](s32), [[VREGP0LO]](s32)
 428 ; CHECK: [[FIP1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.[[P1]]
 429 ; CHECK: [[VREGP1:%[0-9]+]]:_(s64) = G_LOAD [[FIP1]](p0){{.*}}load (s64)
 430 ; CHECK: [[VREGV:%[0-9]+]]:_(s64) = G_FADD [[VREGP0]], [[VREGP1]]
 431 ; LITTLE: [[VREGVLO:%[0-9]+]]:_(s32), [[VREGVHI:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[VREGV]](s64)
 432 ; BIG: [[VREGVHI:%[0-9]+]]:_(s32), [[VREGVLO:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[VREGV]](s64)
 433 ; CHECK-DAG: $r0 = COPY [[VREGVLO]]
 434 ; CHECK-DAG: $r1 = COPY [[VREGVHI]]
 435 ; CHECK: BX_RET 14 /* CC::al */, $noreg, implicit $r0, implicit $r1
 436 entry:
 437   %v = fadd double %p0, %p1
 438   ret double %v
 439 }
 440
 441 define i32 @test_shufflevector_s32_v2s32(i32 %arg) {
 442 ; CHECK-LABEL: name: test_shufflevector_s32_v2s32
 443 ; CHECK: [[ARG:%[0-9]+]]:_(s32) = COPY $r0
 444 ; CHECK-DAG: [[UNDEF:%[0-9]+]]:_(s32) = G_IMPLICIT_DEF
 445 ; CHECK: [[VEC:%[0-9]+]]:_(<2 x s32>) = G_SHUFFLE_VECTOR [[ARG]](s32), [[UNDEF]], shufflemask(0, 0)
 446 ; CHECK: G_EXTRACT_VECTOR_ELT [[VEC]](<2 x s32>)
 447   %vec = insertelement <1 x i32> undef, i32 %arg, i32 0
 448   %shuffle = shufflevector <1 x i32> %vec, <1 x i32> undef, <2 x i32> zeroinitializer
 449   %res = extractelement <2 x i32> %shuffle, i32 0
 450   ret i32 %res
 451 }
 452
 453 define i32 @test_shufflevector_s32_s32_s32(i32 %arg) {
 454 ; CHECK-LABEL: name: test_shufflevector_s32_s32_s32
 455 ; CHECK: [[ARG:%[0-9]+]]:_(s32) = COPY $r0
 456 ; CHECK-DAG: [[UNDEF:%[0-9]+]]:_(s32) = G_IMPLICIT_DEF
 457 ; CHECK: [[VEC:%[0-9]+]]:_(s32) = G_SHUFFLE_VECTOR [[ARG]](s32), [[UNDEF]], shufflemask(0)
 458   %vec = insertelement <1 x i32> undef, i32 %arg, i32 0
 459   %shuffle = shufflevector <1 x i32> %vec, <1 x i32> undef, <1 x i32> zeroinitializer
 460   %res = extractelement <1 x i32> %shuffle, i32 0
 461   ret i32 %res
 462 }
 463
 464 define i32 @test_shufflevector_v2s32_v3s32(i32 %arg1, i32 %arg2) {
 465 ; CHECK-LABEL: name: test_shufflevector_v2s32_v3s32
 466 ; CHECK: [[ARG1:%[0-9]+]]:_(s32) = COPY $r0
 467 ; CHECK: [[ARG2:%[0-9]+]]:_(s32) = COPY $r1
 468 ; CHECK-DAG: [[UNDEF:%[0-9]+]]:_(<2 x s32>) = G_IMPLICIT_DEF
 469 ; CHECK-DAG: [[C0:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 470 ; CHECK-DAG: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 471 ; CHECK-DAG: [[V1:%[0-9]+]]:_(<2 x s32>) = G_INSERT_VECTOR_ELT [[UNDEF]], [[ARG1]](s32), [[C0]](s32)
 472 ; CHECK-DAG: [[V2:%[0-9]+]]:_(<2 x s32>) = G_INSERT_VECTOR_ELT [[V1]], [[ARG2]](s32), [[C1]](s32)
 473 ; CHECK: [[VEC:%[0-9]+]]:_(<3 x s32>) = G_SHUFFLE_VECTOR [[V2]](<2 x s32>), [[UNDEF]], shufflemask(1, 0, 1)
 474 ; CHECK: G_EXTRACT_VECTOR_ELT [[VEC]](<3 x s32>)
 475   %v1 = insertelement <2 x i32> undef, i32 %arg1, i32 0
 476   %v2 = insertelement <2 x i32> %v1, i32 %arg2, i32 1
 477   %shuffle = shufflevector <2 x i32> %v2, <2 x i32> undef, <3 x i32> <i32 1, i32 0, i32 1>
 478   %res = extractelement <3 x i32> %shuffle, i32 0
 479   ret i32 %res
 480 }
 481
 482
 483 define i32 @test_shufflevector_v2s32_v4s32(i32 %arg1, i32 %arg2) {
 484 ; CHECK-LABEL: name: test_shufflevector_v2s32_v4s32
 485 ; CHECK: [[ARG1:%[0-9]+]]:_(s32) = COPY $r0
 486 ; CHECK: [[ARG2:%[0-9]+]]:_(s32) = COPY $r1
 487 ; CHECK-DAG: [[UNDEF:%[0-9]+]]:_(<2 x s32>) = G_IMPLICIT_DEF
 488 ; CHECK-DAG: [[C0:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 489 ; CHECK-DAG: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 490 ; CHECK-DAG: [[V1:%[0-9]+]]:_(<2 x s32>) = G_INSERT_VECTOR_ELT [[UNDEF]], [[ARG1]](s32), [[C0]](s32)
 491 ; CHECK-DAG: [[V2:%[0-9]+]]:_(<2 x s32>) = G_INSERT_VECTOR_ELT [[V1]], [[ARG2]](s32), [[C1]](s32)
 492 ; CHECK: [[VEC:%[0-9]+]]:_(<4 x s32>) = G_SHUFFLE_VECTOR [[V2]](<2 x s32>), [[UNDEF]], shufflemask(0, 0, 0, 0)
 493 ; CHECK: G_EXTRACT_VECTOR_ELT [[VEC]](<4 x s32>)
 494   %v1 = insertelement <2 x i32> undef, i32 %arg1, i32 0
 495   %v2 = insertelement <2 x i32> %v1, i32 %arg2, i32 1
 496   %shuffle = shufflevector <2 x i32> %v2, <2 x i32> undef, <4 x i32> zeroinitializer
 497   %res = extractelement <4 x i32> %shuffle, i32 0
 498   ret i32 %res
 499 }
 500
 501 define i32 @test_shufflevector_v4s32_v2s32(i32 %arg1, i32 %arg2, i32 %arg3, i32 %arg4) {
 502 ; CHECK-LABEL: name: test_shufflevector_v4s32_v2s32
 503 ; CHECK: [[ARG1:%[0-9]+]]:_(s32) = COPY $r0
 504 ; CHECK: [[ARG2:%[0-9]+]]:_(s32) = COPY $r1
 505 ; CHECK: [[ARG3:%[0-9]+]]:_(s32) = COPY $r2
 506 ; CHECK: [[ARG4:%[0-9]+]]:_(s32) = COPY $r3
 507 ; CHECK-DAG: [[UNDEF:%[0-9]+]]:_(<4 x s32>) = G_IMPLICIT_DEF
 508 ; CHECK-DAG: [[C0:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 509 ; CHECK-DAG: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 510 ; CHECK-DAG: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 2
 511 ; CHECK-DAG: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 3
 512 ; CHECK-DAG: [[V1:%[0-9]+]]:_(<4 x s32>) = G_INSERT_VECTOR_ELT [[UNDEF]], [[ARG1]](s32), [[C0]](s32)
 513 ; CHECK-DAG: [[V2:%[0-9]+]]:_(<4 x s32>) = G_INSERT_VECTOR_ELT [[V1]], [[ARG2]](s32), [[C1]](s32)
 514 ; CHECK-DAG: [[V3:%[0-9]+]]:_(<4 x s32>) = G_INSERT_VECTOR_ELT [[V2]], [[ARG3]](s32), [[C2]](s32)
 515 ; CHECK-DAG: [[V4:%[0-9]+]]:_(<4 x s32>) = G_INSERT_VECTOR_ELT [[V3]], [[ARG4]](s32), [[C3]](s32)
 516 ; CHECK: [[VEC:%[0-9]+]]:_(<2 x s32>) = G_SHUFFLE_VECTOR [[V4]](<4 x s32>), [[UNDEF]], shufflemask(1, 3)
 517 ; CHECK: G_EXTRACT_VECTOR_ELT [[VEC]](<2 x s32>)
 518   %v1 = insertelement <4 x i32> undef, i32 %arg1, i32 0
 519   %v2 = insertelement <4 x i32> %v1, i32 %arg2, i32 1
 520   %v3 = insertelement <4 x i32> %v2, i32 %arg3, i32 2
 521   %v4 = insertelement <4 x i32> %v3, i32 %arg4, i32 3
 522   %shuffle = shufflevector <4 x i32> %v4, <4 x i32> undef, <2 x i32> <i32 1, i32 3>
 523   %res = extractelement <2 x i32> %shuffle, i32 0
 524   ret i32 %res
 525 }
 526
 527 %struct.v2s32 = type { <2 x i32> }
 528
 529 define i32 @test_constantstruct_v2s32() {
 530 ; CHECK-LABEL: name: test_constantstruct_v2s32
 531 ; CHECK: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 532 ; CHECK: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 2
 533 ; CHECK: [[VEC:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[C1]](s32), [[C2]](s32)
 534 ; CHECK: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 535 ; CHECK: G_EXTRACT_VECTOR_ELT [[VEC]](<2 x s32>), [[C3]]
 536   %vec = extractvalue %struct.v2s32 {<2 x i32><i32 1, i32 2>}, 0
 537   %elt = extractelement <2 x i32> %vec, i32 0
 538   ret i32 %elt
 539 }
 540
 541 %struct.v2s32.s32.s32 = type { <2 x i32>, i32, i32 }
 542
 543 define i32 @test_constantstruct_v2s32_s32_s32() {
 544 ; CHECK-LABEL: name: test_constantstruct_v2s32_s32_s32
 545 ; CHECK: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
 546 ; CHECK: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 2
 547 ; CHECK: [[VEC:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[C1]](s32), [[C2]](s32)
 548 ; CHECK: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 3
 549 ; CHECK: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
 550 ; CHECK: [[C5:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
 551 ; CHECK: G_EXTRACT_VECTOR_ELT [[VEC]](<2 x s32>), [[C5]](s32)
 552   %vec = extractvalue %struct.v2s32.s32.s32 {<2 x i32><i32 1, i32 2>, i32 3, i32 4}, 0
 553   %elt = extractelement <2 x i32> %vec, i32 0
 554   ret i32 %elt
 555 }
 556
 557 define void @test_load_store_struct(ptr %addr) {
 558 ; Make sure the IRTranslator doesn't use an unnecessarily large GEP index type
 559 ; when breaking up loads and stores of aggregates.
 560 ; CHECK-LABEL: name: test_load_store_struct
 561 ; CHECK: [[ADDR1:%[0-9]+]]:_(p0) = COPY $r0
 562 ; CHECK-DAG: [[VAL1:%[0-9]+]]:_(s32) = G_LOAD [[ADDR1]](p0) :: (load (s32) from %ir.addr)
 563 ; CHECK-DAG: [[OFFSET:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
 564 ; CHECK-DAG: [[ADDR2:%[0-9]+]]:_(p0) = G_PTR_ADD [[ADDR1]], [[OFFSET]](s32)
 565 ; CHECK-DAG: [[VAL2:%[0-9]+]]:_(s32) = G_LOAD [[ADDR2]](p0) :: (load (s32) from %ir.addr + 4)
 566 ; CHECK-DAG: G_STORE [[VAL1]](s32), [[ADDR1]](p0) :: (store (s32) into %ir.addr)
 567 ; CHECK-DAG: [[ADDR3:%[0-9]+]]:_(p0) = COPY [[ADDR2]]
 568 ; CHECK-DAG: G_STORE [[VAL2]](s32), [[ADDR3]](p0) :: (store (s32) into %ir.addr + 4)
 569   %val = load {i32, i32}, ptr %addr, align 4
 570   store {i32, i32} %val, ptr %addr, align 4
 571   ret void
 572 }