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