llvm/test/CodeGen/PowerPC/aix-cc-abi.ll

   1 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff -stop-after=machine-cp -verify-machineinstrs < %s | \
   2 ; RUN: FileCheck --check-prefixes=CHECK,32BIT %s
   3
   4 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
   5 ; RUN:  -mtriple powerpc-ibm-aix-xcoff < %s | \
   6 ; RUN: FileCheck --check-prefixes=CHECKASM,ASM32PWR4 %s
   7
   8 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -stop-after=machine-cp -verify-machineinstrs < %s | \
   9 ; RUN: FileCheck --check-prefixes=CHECK,64BIT %s
  10
  11 ; RUN: llc -verify-machineinstrs -mcpu=pwr4 -mattr=-altivec \
  12 ; RUN:  -mtriple powerpc64-ibm-aix-xcoff < %s | \
  13 ; RUN: FileCheck --check-prefixes=CHECKASM,ASM64PWR4 %s
  14
  15 define void @call_test_chars() {
  16 entry:
  17   call i8 @test_chars(i8 signext 97, i8 signext 97, i8 signext 97, i8 signext 97)
  18   ret void
  19 }
  20
  21 ; CHECK-LABEL: name: call_test_chars
  22
  23 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
  24 ; 32BIT: $r3 = LI 97
  25 ; 32BIT: $r4 = LI 97
  26 ; 32BIT: $r5 = LI 97
  27 ; 32BIT: $r6 = LI 97
  28 ; 32BIT: BL_NOP <mcsymbol .test_chars>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1
  29 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
  30
  31 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
  32 ; 64BIT: $x3 = LI8 97
  33 ; 64BIT: $x4 = LI8 97
  34 ; 64BIT: $x5 = LI8 97
  35 ; 64BIT: $x6 = LI8 97
  36 ; 64BIT: BL8_NOP <mcsymbol .test_chars>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1
  37 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
  38
  39 define signext i8 @test_chars(i8 signext %c1, i8 signext %c2, i8 signext %c3, i8 signext %c4) {
  40 entry:
  41   %conv = sext i8 %c1 to i32
  42   %conv1 = sext i8 %c2 to i32
  43   %add = add nsw i32 %conv, %conv1
  44   %conv2 = sext i8 %c3 to i32
  45   %add3 = add nsw i32 %add, %conv2
  46   %conv4 = sext i8 %c4 to i32
  47   %add5 = add nsw i32 %add3, %conv4
  48   %conv6 = trunc i32 %add5 to i8
  49   ret i8 %conv6
  50 }
  51
  52 ; CHECK-LABEL: name: test_chars
  53
  54 ; 32BIT:       liveins:
  55 ; 32BIT-NEXT:  - { reg: '$r3', virtual-reg: '' }
  56 ; 32BIT-NEXT:  - { reg: '$r4', virtual-reg: '' }
  57 ; 32BIT-NEXT:  - { reg: '$r5', virtual-reg: '' }
  58 ; 32BIT-NEXT:  - { reg: '$r6', virtual-reg: '' }
  59 ; 32BIT:       body:
  60 ; 32BIT-NEXT:    bb.0.entry:
  61 ; 32BIT-NEXT:      liveins: $r3, $r4, $r5, $r6
  62
  63 ; 64BIT:       liveins:
  64 ; 64BIT-NEXT:  - { reg: '$x3', virtual-reg: '' }
  65 ; 64BIT-NEXT:  - { reg: '$x4', virtual-reg: '' }
  66 ; 64BIT-NEXT:  - { reg: '$x5', virtual-reg: '' }
  67 ; 64BIT-NEXT:  - { reg: '$x6', virtual-reg: '' }
  68 ; 64BIT:       body:
  69 ; 64BIT-NEXT:    bb.0.entry:
  70 ; 64BIT-NEXT:      liveins: $x3, $x4, $x5, $x6
  71
  72 define void @call_test_chars_mix() {
  73 entry:
  74   call i8 @test_chars_mix(i8 signext 97, i8 zeroext -31, i8 zeroext 97, i8 signext -31)
  75   ret void
  76 }
  77
  78 ; CHECK-LABEL: name: call_test_chars_mix
  79
  80 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
  81 ; 32BIT: $r3 = LI 97
  82 ; 32BIT: $r4 = LI 225
  83 ; 32BIT: $r5 = LI 97
  84 ; 32BIT: $r6 = LI -31
  85 ; 32BIT: BL_NOP <mcsymbol .test_chars_mix>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1
  86 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
  87
  88 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
  89 ; 64BIT: $x3 = LI8 97
  90 ; 64BIT: $x4 = LI8 225
  91 ; 64BIT: $x5 = LI8 97
  92 ; 64BIT: $x6 = LI8 -31
  93 ; 64BIT: BL8_NOP <mcsymbol .test_chars_mix>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1
  94 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
  95
  96 define signext i8 @test_chars_mix(i8 signext %c1, i8 zeroext %c2, i8 zeroext %c3, i8 signext %c4) {
  97 entry:
  98   %conv = sext i8 %c1 to i32
  99   %conv1 = zext i8 %c2 to i32
 100   %add = add nsw i32 %conv, %conv1
 101   %conv2 = zext i8 %c3 to i32
 102   %add3 = add nsw i32 %add, %conv2
 103   %conv4 = sext i8 %c4 to i32
 104   %add5 = add nsw i32 %add3, %conv4
 105   %conv6 = trunc i32 %add5 to i8
 106   ret i8 %conv6
 107 }
 108
 109 ; CHECK-LABEL: name: test_chars_mix
 110
 111 ; 32BIT:       liveins:
 112 ; 32BIT-NEXT:  - { reg: '$r3', virtual-reg: '' }
 113 ; 32BIT-NEXT:  - { reg: '$r4', virtual-reg: '' }
 114 ; 32BIT-NEXT:  - { reg: '$r5', virtual-reg: '' }
 115 ; 32BIT-NEXT:  - { reg: '$r6', virtual-reg: '' }
 116 ; 32BIT:       body:
 117 ; 32BIT-NEXT:    bb.0.entry:
 118 ; 32BIT-NEXT:      liveins: $r3, $r4, $r5, $r6
 119
 120 ; 64BIT:       liveins:
 121 ; 64BIT-NEXT:  - { reg: '$x3', virtual-reg: '' }
 122 ; 64BIT-NEXT:  - { reg: '$x4', virtual-reg: '' }
 123 ; 64BIT-NEXT:  - { reg: '$x5', virtual-reg: '' }
 124 ; 64BIT-NEXT:  - { reg: '$x6', virtual-reg: '' }
 125 ; 64BIT:       body:
 126 ; 64BIT-NEXT:    bb.0.entry:
 127 ; 64BIT-NEXT:      liveins: $x3, $x4, $x5, $x6
 128
 129 @global_i1 = global i8 0, align 1
 130
 131 define  void @test_i1(i1 %b)  {
 132   entry:
 133    %frombool = zext i1 %b to i8
 134    store i8 %frombool, i8* @global_i1, align 1
 135    ret void
 136 }
 137
 138 ; 32BIT:       liveins:
 139 ; 32BIT-NEXT:  - { reg: '$r3', virtual-reg: '' }
 140 ; 32BIT:       body:             |
 141 ; 32BIT-NEXT:    bb.0.entry:
 142 ; 32BIT-NEXT:      liveins: $r3
 143 ; 32BIT:           renamable $r3 = RLWINM killed renamable $r3, 0, 31, 31
 144 ; 32BIT-NEXT:      STB killed renamable $r3, 0, killed renamable $r4 :: (store (s8) into @global_i1)
 145
 146 ; 64BIT:       liveins:
 147 ; 64BIT-NEXT:  - { reg: '$x3', virtual-reg: '' }
 148 ; 64BIT:       body:             |
 149 ; 64BIT-NEXT:    bb.0.entry:
 150 ; 64BIT-NEXT:      liveins: $x3
 151 ; 64BIT:           renamable $r[[REG1:[0-9]+]] = RLWINM renamable $r[[REG1]], 0, 31, 31, implicit killed $x3
 152 ; 64BIT-NEXT:      STB killed renamable $r[[REG1]], 0, killed renamable $x4 :: (store (s8) into @global_i1)
 153
 154 define void @call_test_i1() {
 155 entry:
 156   call void @test_i1(i1 1)
 157   ret void
 158 }
 159 ; CHECK-LABEL: name: call_test_i1
 160
 161 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 162 ; 32BIT: $r3 = LI 1
 163 ; 32BIT: BL_NOP <mcsymbol .test_i1>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1
 164 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 165
 166 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 167 ; 64BIT: $x3 = LI8 1
 168 ; 64BIT: BL8_NOP <mcsymbol .test_i1>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1
 169 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 170
 171 define void @test_i1zext(i1 zeroext %b) {
 172   entry:
 173     %frombool = zext i1 %b to i8
 174     store i8 %frombool, i8 * @global_i1, align 1
 175     ret void
 176   }
 177
 178 ; 32BIT:       liveins:
 179 ; 32BIT-NEXT:  - { reg: '$r3', virtual-reg: '' }
 180 ; 32BIT:       body:             |
 181 ; 32BIT-NEXT:    bb.0.entry:
 182 ; 32BIT-NEXT:      liveins: $r3
 183 ; CHECK-NOT:       RLWINM
 184 ; 32BIT:           STB killed renamable $r3, 0, killed renamable $r4 :: (store (s8) into @global_i1)
 185
 186 ; 64BIT:       liveins:
 187 ; 64BIT-NEXT:  - { reg: '$x3', virtual-reg: '' }
 188 ; 64BIT:       body:             |
 189 ; 64BIT-NEXT:    bb.0.entry:
 190 ; 64BIT-NEXT:      liveins: $x3
 191 ; CHECK-NOT:       RLWINM
 192 ; 64BIT:           STB8 killed renamable $x3, 0, killed renamable $x4 :: (store (s8) into @global_i1)
 193
 194 define i32 @test_ints(i32 signext %a, i32 zeroext %b, i32 zeroext %c, i32 signext %d, i32 signext %e, i32 signext %f, i32 signext %g, i32 signext %h) {
 195 entry:
 196     %add = add i32 %a, %b
 197     %add1 = add i32 %add, %c
 198     %add2 = add i32 %add1, %d
 199     %add3 = add i32 %add2, %e
 200     %add4 = add i32 %add3, %f
 201     %add5 = add i32 %add4, %g
 202     %add6 = add i32 %add5, %h
 203     ret i32 %add6
 204 }
 205
 206 ; CHECK-LABEL: name: test_ints
 207
 208 ; 32BIT:       liveins:
 209 ; 32BIT-NEXT:  - { reg: '$r3', virtual-reg: '' }
 210 ; 32BIT-NEXT:  - { reg: '$r4', virtual-reg: '' }
 211 ; 32BIT-NEXT:  - { reg: '$r5', virtual-reg: '' }
 212 ; 32BIT-NEXT:  - { reg: '$r6', virtual-reg: '' }
 213 ; 32BIT-NEXT:  - { reg: '$r7', virtual-reg: '' }
 214 ; 32BIT-NEXT:  - { reg: '$r8', virtual-reg: '' }
 215 ; 32BIT-NEXT:  - { reg: '$r9', virtual-reg: '' }
 216 ; 32BIT-NEXT:  - { reg: '$r10', virtual-reg: '' }
 217 ; 32BIT:       body:             |
 218 ; 32BIT-NEXT:    bb.0.entry:
 219 ; 32BIT-NEXT:      liveins: $r3, $r4, $r5, $r6, $r7, $r8, $r9, $r10
 220
 221 ; 64BIT:       liveins:
 222 ; 64BIT-NEXT:  - { reg: '$x3', virtual-reg: '' }
 223 ; 64BIT-NEXT:  - { reg: '$x4', virtual-reg: '' }
 224 ; 64BIT-NEXT:  - { reg: '$x5', virtual-reg: '' }
 225 ; 64BIT-NEXT:  - { reg: '$x6', virtual-reg: '' }
 226 ; 64BIT-NEXT:  - { reg: '$x7', virtual-reg: '' }
 227 ; 64BIT-NEXT:  - { reg: '$x8', virtual-reg: '' }
 228 ; 64BIT-NEXT:  - { reg: '$x9', virtual-reg: '' }
 229 ; 64BIT-NEXT:  - { reg: '$x10', virtual-reg: '' }
 230 ; 64BIT:       body:             |
 231 ; 64BIT-NEXT:    bb.0.entry:
 232 ; 64BIT-NEXT:      liveins: $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10
 233
 234 define void @call_test_ints() {
 235 entry:
 236   call i32 @test_ints(i32 signext 1, i32 zeroext 1, i32 zeroext 2147483648, i32 signext -2147483648, i32 signext 1, i32 signext 1, i32 signext 1, i32 signext 1)
 237   ret void
 238 }
 239
 240 ; CHECK-LABEL: name: call_test_ints
 241
 242 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 243 ; 64BIT: renamable $x3 = LI8 1
 244 ; 64BIT: renamable $x5 = RLDIC killed renamable $x3, 31, 32
 245 ; 64BIT: $x3 = LI8 1
 246 ; 64BIT: $x4 = LI8 1
 247 ; 64BIT: $x6 = LIS8 32768
 248 ; 64BIT: $x7 = LI8 1
 249 ; 64BIT: $x8 = LI8 1
 250 ; 64BIT: $x9 = LI8 1
 251 ; 64BIT: $x10 = LI8 1
 252 ; 64BIT:  BL8_NOP <mcsymbol .test_ints>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit killed $x4, implicit $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $x2, implicit-def $r1, implicit-def dead $x3
 253 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 254
 255 define void @call_test_i64() {
 256 entry:
 257   call i64 @test_i64(i64 1, i64 2, i64 3, i64 4)
 258   ret void
 259 }
 260
 261 ; CHECK-LABEL: name: call_test_i64
 262
 263 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 264 ; 32BIT: $r3 = LI 0
 265 ; 32BIT: $r4 = LI 1
 266 ; 32BIT: $r5 = LI 0
 267 ; 32BIT: $r6 = LI 2
 268 ; 32BIT: $r7 = LI 0
 269 ; 32BIT: $r8 = LI 3
 270 ; 32BIT: $r9 = LI 0
 271 ; 32BIT: $r10 = LI 4
 272 ; 32BIT: BL_NOP <mcsymbol .test_i64>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit killed $r7, implicit killed $r8, implicit killed $r9, implicit killed $r10, implicit $r2, implicit-def $r1
 273 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 274
 275 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 276 ; 64BIT: $x3 = LI8 1
 277 ; 64BIT: $x4 = LI8 2
 278 ; 64BIT: $x5 = LI8 3
 279 ; 64BIT: $x6 = LI8 4
 280 ; 64BIT: BL8_NOP <mcsymbol .test_i64>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1
 281 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 282
 283 define i64 @test_i64(i64 %a, i64 %b, i64 %c, i64 %d) {
 284 entry:
 285   %add = add nsw i64 %a, %b
 286   %add1 = add nsw i64 %add, %c
 287   %add2 = add nsw i64 %add1, %d
 288   ret i64 %add2
 289 }
 290
 291 ; CHECK-LABEL: name: test_i64
 292
 293 ; 32BIT:       liveins:
 294 ; 32BIT-NEXT:  - { reg: '$r3', virtual-reg: '' }
 295 ; 32BIT-NEXT:  - { reg: '$r4', virtual-reg: '' }
 296 ; 32BIT-NEXT:  - { reg: '$r5', virtual-reg: '' }
 297 ; 32BIT-NEXT:  - { reg: '$r6', virtual-reg: '' }
 298 ; 32BIT-NEXT:  - { reg: '$r7', virtual-reg: '' }
 299 ; 32BIT-NEXT:  - { reg: '$r8', virtual-reg: '' }
 300 ; 32BIT-NEXT:  - { reg: '$r9', virtual-reg: '' }
 301 ; 32BIT-NEXT:  - { reg: '$r10', virtual-reg: '' }
 302 ; 32BIT:       body:             |
 303 ; 32BIT-NEXT:    bb.0.entry:
 304 ; 32BIT-NEXT:      liveins: $r3, $r4, $r5, $r6, $r7, $r8, $r9, $r10
 305
 306 ; 64BIT:       liveins:
 307 ; 64BIT-NEXT:  - { reg: '$x3', virtual-reg: '' }
 308 ; 64BIT-NEXT:  - { reg: '$x4', virtual-reg: '' }
 309 ; 64BIT-NEXT:  - { reg: '$x5', virtual-reg: '' }
 310 ; 64BIT-NEXT:  - { reg: '$x6', virtual-reg: '' }
 311 ; 64BIT:       body:             |
 312 ; 64BIT-NEXT:    bb.0.entry:
 313 ; 64BIT-NEXT:      liveins: $x3, $x4, $x5, $x6
 314
 315 define void @call_test_int_ptr() {
 316 entry:
 317   %b = alloca i32, align 4
 318   store i32 0, i32* %b, align 4
 319   call void @test_int_ptr(i32* %b)
 320   ret void
 321 }
 322
 323 ; CHECK-LABEL: name: call_test_int_ptr
 324
 325 ; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 326 ; 32BIT: renamable $r3 = ADDI %stack.0.b, 0
 327 ; 32BIT: BL_NOP <mcsymbol .test_int_ptr>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r2, implicit-def $r1
 328 ; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 329
 330 ; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 331 ; 64BIT: renamable $x3 = ADDI8 %stack.0.b, 0
 332 ; 64BIT: BL8_NOP <mcsymbol .test_int_ptr>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x2, implicit-def $r1
 333 ; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 334
 335 define void @test_int_ptr(i32* %a) {
 336 entry:
 337   %a.addr = alloca i32*, align 8
 338   store i32* %a, i32** %a.addr, align 8
 339   ret void
 340 }
 341
 342 ; CHECK-LABEL: name: test_int_ptr
 343
 344 ; 32BIT:       liveins:
 345 ; 32BIT-NEXT:  - { reg: '$r3', virtual-reg: '' }
 346 ; 32BIT:       body:             |
 347 ; 32BIT-NEXT:    bb.0.entry:
 348 ; 32BIT-NEXT:      liveins: $r3
 349 ; 32BIT:           STW killed renamable $r3, 0, %stack.0.a.addr :: (store (s32) into %ir.a.addr, align 8)
 350
 351 ; 64BIT:       liveins:
 352 ; 64BIT-NEXT:  - { reg: '$x3', virtual-reg: '' }
 353 ; 64BIT:       body:             |
 354 ; 64BIT-NEXT:    bb.0.entry:
 355 ; 64BIT-NEXT:      liveins: $x3
 356 ; 64BIT:           STD killed renamable $x3, 0, %stack.0.a.addr :: (store (s64) into %ir.a.addr)
 357
 358
 359 define i32 @caller(i32 %i)  {
 360 entry:
 361   %i.addr = alloca i32, align 4
 362   %b = alloca i8, align 1
 363   store i32 %i, i32* %i.addr, align 4
 364   %0 = load i32, i32* %i.addr, align 4
 365   %cmp = icmp ne i32 %0, 0
 366   %frombool = zext i1 %cmp to i8
 367   store i8 %frombool, i8* %b, align 1
 368   %1 = load i8, i8* %b, align 1
 369   %tobool = trunc i8 %1 to i1
 370   %call = call i32 @call_test_bool(i1 zeroext %tobool)
 371   ret i32 %call
 372 }
 373
 374 declare i32 @call_test_bool(i1 zeroext)
 375
 376 ; CHECK-LABEL: name:            caller
 377
 378 ; 32BIT:        liveins:
 379 ; 32BIT-NEXT:   - { reg: '$r3', virtual-reg: '' }
 380 ; 32BIT:        body:             |
 381 ; 32BIT-NEXT:   bb.0.entry:
 382 ; 32BIT:         liveins: $r3
 383 ; 32BIT:          ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 384 ; 32BIT:          BL_NOP <mcsymbol .call_test_bool[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r2, implicit-def $r1, implicit-def $r3
 385 ; 32BIT:          ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 386
 387 ; 64BIT:        liveins:
 388 ; 64BIT-NEXT:   - { reg: '$x3', virtual-reg: '' }
 389 ; 64BIT:        body:             |
 390 ; 64BIT-NEXT:    bb.0.entry:
 391 ; 64BIT-NEXT:     liveins: $x3
 392 ; 64BIT:          ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 393 ; 64BIT:          BL8_NOP <mcsymbol .call_test_bool[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x2, implicit-def $r1, implicit-def $x3
 394 ; 64BIT:          ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 395
 396 @f1 = global float 0.000000e+00, align 4
 397 @d1 = global double 0.000000e+00, align 8
 398
 399 define void @call_test_floats() {
 400 entry:
 401   %0 = load float, float* @f1, align 4
 402   call float @test_floats(float %0, float %0, float %0)
 403   ret void
 404 }
 405
 406 ; CHECK-LABEL: name: call_test_floats{{.*}}
 407
 408 ; 32BIT:      renamable $r3 = LWZtoc @f1, $r2 :: (load (s32) from got)
 409 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r3 :: (dereferenceable load (s32) from @f1)
 410 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 411 ; 32BIT-NEXT: $f2 = COPY renamable $f1
 412 ; 32BIT-NEXT: $f3 = COPY renamable $f1
 413 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_floats>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit $r2, implicit-def $r1
 414 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 415
 416 ; 64BIT:      renamable $x3 = LDtoc @f1, $x2 :: (load (s64) from got)
 417 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x3 :: (dereferenceable load (s32) from @f1)
 418 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 419 ; 64BIT-NEXT: $f2 = COPY renamable $f1
 420 ; 64BIT-NEXT: $f3 = COPY renamable $f1
 421 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_floats>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit $x2, implicit-def $r1
 422 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 423
 424 define float @test_floats(float %f1, float %f2, float %f3) {
 425 entry:
 426   %add = fadd float %f1, %f2
 427   %add1 = fadd float %add, %f3
 428   ret float %add1
 429 }
 430
 431 ; CHECK-LABEL: name: test_floats{{.*}}
 432
 433 ; CHECK:      liveins:
 434 ; CHECK-NEXT: - { reg: '$f1', virtual-reg: '' }
 435 ; CHECK-NEXT: - { reg: '$f2', virtual-reg: '' }
 436 ; CHECK-NEXT: - { reg: '$f3', virtual-reg: '' }
 437 ; CHECK:      body:             |
 438 ; CHECK-NEXT:   bb.0.entry:
 439 ; CHECK-NEXT:     liveins: $f1, $f2, $f3
 440
 441 define void @call_test_fpr_max() {
 442 entry:
 443   %0 = load double, double* @d1, align 8
 444   call double @test_fpr_max(double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0)
 445   ret void
 446 }
 447
 448 ; CHECK-LABEL: name: call_test_fpr_max{{.*}}
 449
 450 ; 32BIT:      renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
 451 ; 32BIT-NEXT: renamable $f1 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from @d1)
 452 ; 32BIT-NEXT: ADJCALLSTACKDOWN 128, 0, implicit-def dead $r1, implicit $r1
 453 ; 32BIT-DAG:  STFD renamable $f1, 56, $r1 :: (store (s64))
 454 ; 32BIT-DAG:  STFD renamable $f1, 64, $r1 :: (store (s64))
 455 ; 32BIT-DAG:  STFD renamable $f1, 72, $r1 :: (store (s64))
 456 ; 32BIT-DAG:  STFD renamable $f1, 80, $r1 :: (store (s64))
 457 ; 32BIT-DAG:  STFD renamable $f1, 88, $r1 :: (store (s64))
 458 ; 32BIT-DAG:  STFD renamable $f1, 96, $r1 :: (store (s64))
 459 ; 32BIT-DAG:  STFD renamable $f1, 104, $r1 :: (store (s64))
 460 ; 32BIT-DAG:  STFD renamable $f1, 112, $r1 :: (store (s64))
 461 ; 32BIT-DAG:  STFD renamable $f1, 120, $r1 :: (store (s64))
 462 ; 32BIT-DAG:  $f2 = COPY renamable $f1
 463 ; 32BIT-DAG:  $f3 = COPY renamable $f1
 464 ; 32BIT-DAG:  $f4 = COPY renamable $f1
 465 ; 32BIT-DAG:  $f5 = COPY renamable $f1
 466 ; 32BIT-DAG:  $f6 = COPY renamable $f1
 467 ; 32BIT-DAG:  $f7 = COPY renamable $f1
 468 ; 32BIT-DAG:  $f8 = COPY renamable $f1
 469 ; 32BIT-DAG:  $f9 = COPY renamable $f1
 470 ; 32BIT-DAG:  $f10 = COPY renamable $f1
 471 ; 32BIT-DAG:  $f11 = COPY renamable $f1
 472 ; 32BIT-DAG:  $f12 = COPY renamable $f1
 473 ; 32BIT-DAG:  $f13 = COPY renamable $f1
 474 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_fpr_max>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit killed $f4, implicit killed $f5, implicit killed $f6, implicit killed $f7, implicit killed $f8, implicit killed $f9, implicit killed $f10, implicit killed $f11, implicit killed $f12, implicit killed $f13, implicit $r2, implicit-def $r1, implicit-def dead $f1
 475 ; 32BIT-NEXT: ADJCALLSTACKUP 128, 0, implicit-def dead $r1, implicit $r1
 476
 477 ; CHECKASM-LABEL: .call_test_fpr_max:
 478
 479 ; ASM32PWR4:       stwu 1, -128(1)
 480 ; ASM32PWR4-NEXT:  lwz [[REG:[0-9]+]], L..C2(2)
 481 ; ASM32PWR4-NEXT:  lfd 1, 0([[REG]])
 482 ; ASM32PWR4-DAG:   stfd 1, 56(1)
 483 ; ASM32PWR4-DAG:   stfd 1, 64(1)
 484 ; ASM32PWR4-DAG:   stfd 1, 72(1)
 485 ; ASM32PWR4-DAG:   stfd 1, 80(1)
 486 ; ASM32PWR4-DAG:   stfd 1, 88(1)
 487 ; ASM32PWR4-DAG:   stfd 1, 96(1)
 488 ; ASM32PWR4-DAG:   stfd 1, 104(1)
 489 ; ASM32PWR4-DAG:   stfd 1, 112(1)
 490 ; ASM32PWR4-DAG:   stfd 1, 120(1)
 491 ; ASM32PWR4-DAG:   fmr 2, 1
 492 ; ASM32PWR4-DAG:   fmr 3, 1
 493 ; ASM32PWR4-DAG:   fmr 4, 1
 494 ; ASM32PWR4-DAG:   fmr 5, 1
 495 ; ASM32PWR4-DAG:   fmr 6, 1
 496 ; ASM32PWR4-DAG:   fmr 7, 1
 497 ; ASM32PWR4-DAG:   fmr 8, 1
 498 ; ASM32PWR4-DAG:   fmr 9, 1
 499 ; ASM32PWR4-DAG:   fmr 10, 1
 500 ; ASM32PWR4-DAG:   fmr 11, 1
 501 ; ASM32PWR4-DAG:   fmr 12, 1
 502 ; ASM32PWR4-DAG:   fmr 13, 1
 503 ; ASM32PWR4-NEXT:  bl .test_fpr_max
 504 ; ASM32PWR4-NEXT:  nop
 505 ; ASM32PWR4-NEXT:  addi 1, 1, 128
 506
 507 ; 64BIT:      renamable $x[[REGD1ADDR:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
 508 ; 64BIT-NEXT: renamable $f1 = LFD 0, killed renamable $x[[REGD1ADDR:[0-9]+]] :: (dereferenceable load (s64) from @d1)
 509 ; 64BIT-NEXT: ADJCALLSTACKDOWN 152, 0, implicit-def dead $r1, implicit $r1
 510 ; 64BIT-DAG:  STFD renamable $f1, 112, $x1 :: (store (s64))
 511 ; 64BIT-DAG:  STFD renamable $f1, 120, $x1 :: (store (s64))
 512 ; 64BIT-DAG:  STFD renamable $f1, 128, $x1 :: (store (s64))
 513 ; 64BIT-DAG:  STFD renamable $f1, 136, $x1 :: (store (s64))
 514 ; 64BIT-DAG:  STFD renamable $f1, 144, $x1 :: (store (s64))
 515 ; 64BIT-DAG:  $f2 = COPY renamable $f1
 516 ; 64BIT-DAG:  $f3 = COPY renamable $f1
 517 ; 64BIT-DAG:  $f4 = COPY renamable $f1
 518 ; 64BIT-DAG:  $f5 = COPY renamable $f1
 519 ; 64BIT-DAG:  $f6 = COPY renamable $f1
 520 ; 64BIT-DAG:  $f7 = COPY renamable $f1
 521 ; 64BIT-DAG:  $f8 = COPY renamable $f1
 522 ; 64BIT-DAG:  $f9 = COPY renamable $f1
 523 ; 64BIT-DAG:  $f10 = COPY renamable $f1
 524 ; 64BIT-DAG:  $f11 = COPY renamable $f1
 525 ; 64BIT-DAG:  $f12 = COPY renamable $f1
 526 ; 64BIT-DAG:  $f13 = COPY renamable $f1
 527 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_fpr_max>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit killed $f4, implicit killed $f5, implicit killed $f6, implicit killed $f7, implicit killed $f8, implicit killed $f9, implicit killed $f10, implicit killed $f11, implicit killed $f12, implicit killed $f13, implicit $x2, implicit-def $r1
 528 ; 64BIT-NEXT: ADJCALLSTACKUP 152, 0, implicit-def dead $r1, implicit $r1
 529
 530 ; ASM64PWR4:       stdu 1, -160(1)
 531 ; ASM64PWR4-NEXT:  ld [[REG:[0-9]+]], L..C2(2)
 532 ; ASM64PWR4-NEXT:  lfd 1, 0([[REG]])
 533 ; ASM64PWR4-DAG:   stfd 1, 112(1)
 534 ; ASM64PWR4-DAG:   stfd 1, 120(1)
 535 ; ASM64PWR4-DAG:   stfd 1, 128(1)
 536 ; ASM64PWR4-DAG:   stfd 1, 136(1)
 537 ; ASM64PWR4-DAG:   stfd 1, 144(1)
 538 ; ASM64PWR4-DAG:   fmr 2, 1
 539 ; ASM64PWR4-DAG:   fmr 3, 1
 540 ; ASM64PWR4-DAG:   fmr 4, 1
 541 ; ASM64PWR4-DAG:   fmr 5, 1
 542 ; ASM64PWR4-DAG:   fmr 6, 1
 543 ; ASM64PWR4-DAG:   fmr 7, 1
 544 ; ASM64PWR4-DAG:   fmr 8, 1
 545 ; ASM64PWR4-DAG:   fmr 9, 1
 546 ; ASM64PWR4-DAG:   fmr 10, 1
 547 ; ASM64PWR4-DAG:   fmr 11, 1
 548 ; ASM64PWR4-DAG:   fmr 12, 1
 549 ; ASM64PWR4-DAG:   fmr 13, 1
 550 ; ASM64PWR4-NEXT:  bl .test_fpr_max
 551 ; ASM64PWR4-NEXT:  nop
 552 ; ASM64PWR4-NEXT:  addi 1, 1, 160
 553
 554 define double @test_fpr_max(double %d1, double %d2, double %d3, double %d4, double %d5, double %d6, double %d7, double %d8, double %d9, double %d10, double %d11, double %d12, double %d13) {
 555 entry:
 556   %add = fadd double %d1, %d2
 557   %add1 = fadd double %add, %d3
 558   %add2 = fadd double %add1, %d4
 559   %add3 = fadd double %add2, %d5
 560   %add4 = fadd double %add3, %d6
 561   %add5 = fadd double %add4, %d7
 562   %add6 = fadd double %add5, %d8
 563   %add7 = fadd double %add6, %d9
 564   %add8 = fadd double %add7, %d10
 565   %add9 = fadd double %add8, %d11
 566   %add10 = fadd double %add9, %d12
 567   %add11 = fadd double %add10, %d13
 568   ret double %add11
 569 }
 570
 571 ; CHECK-LABEL: name: test_fpr_max{{.*}}
 572
 573 ; CHECK:      liveins:
 574 ; CHECK-NEXT: - { reg: '$f1', virtual-reg: '' }
 575 ; CHECK-NEXT: - { reg: '$f2', virtual-reg: '' }
 576 ; CHECK-NEXT: - { reg: '$f3', virtual-reg: '' }
 577 ; CHECK-NEXT: - { reg: '$f4', virtual-reg: '' }
 578 ; CHECK-NEXT: - { reg: '$f5', virtual-reg: '' }
 579 ; CHECK-NEXT: - { reg: '$f6', virtual-reg: '' }
 580 ; CHECK-NEXT: - { reg: '$f7', virtual-reg: '' }
 581 ; CHECK-NEXT: - { reg: '$f8', virtual-reg: '' }
 582 ; CHECK-NEXT: - { reg: '$f9', virtual-reg: '' }
 583 ; CHECK-NEXT: - { reg: '$f10', virtual-reg: '' }
 584 ; CHECK-NEXT: - { reg: '$f11', virtual-reg: '' }
 585 ; CHECK-NEXT: - { reg: '$f12', virtual-reg: '' }
 586 ; CHECK-NEXT: - { reg: '$f13', virtual-reg: '' }
 587 ; CHECK:      body:             |
 588 ; CHECK-NEXT:   bb.0.entry:
 589 ; CHECK-NEXT:     liveins: $f1, $f2, $f3, $f4, $f5, $f6, $f7, $f8, $f9, $f10, $f11, $f12, $f13
 590
 591 define void @call_test_mix() {
 592 entry:
 593   %0 = load float, float* @f1, align 4
 594   %1 = load double, double* @d1, align 8
 595   call i32 @test_mix(float %0, i32 1, double %1, i8 signext 97)
 596   ret void
 597 }
 598
 599 ; CHECK-LABEL: name: call_test_mix{{.*}}
 600
 601 ; 32BIT:      renamable $r[[REG1:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
 602 ; 32BIT-NEXT: renamable $r[[REG2:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
 603 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG1]] :: (dereferenceable load (s32) from @f1)
 604 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG2]] :: (dereferenceable load (s64) from @d1)
 605 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 606 ; 32BIT-NEXT: $r4 = LI 1
 607 ; 32BIT-NEXT: $r7 = LI 97
 608 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_mix>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit $r4, implicit $f2, implicit killed $r7, implicit $r2, implicit-def $r1
 609 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 610
 611 ; 64BIT:      renamable $x[[REG1:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
 612 ; 64BIT-NEXT: renamable $x[[REG2:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
 613 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG1]] :: (dereferenceable load (s32) from @f1)
 614 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG2]] :: (dereferenceable load (s64) from @d1)
 615 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 616 ; 64BIT-NEXT: $x4 = LI8 1
 617 ; 64BIT-NEXT: $x6 = LI8 97
 618 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_mix>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit $x4, implicit $f2, implicit killed $x6, implicit $x2, implicit-def $r1
 619 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 620
 621 define i32 @test_mix(float %f, i32 signext %i, double %d, i8 signext %c) {
 622 entry:
 623   %conv = fpext float %f to double
 624   %add = fadd double %conv, %d
 625   %conv1 = fptrunc double %add to float
 626   %conv2 = zext i8 %c to i32
 627   %add3 = add nsw i32 %i, %conv2
 628   %conv4 = sitofp i32 %add3 to float
 629   %add5 = fadd float %conv4, %conv1
 630   %conv6 = fptosi float %add5 to i32
 631   ret i32 %conv6
 632 }
 633
 634 ; CHECK-LABEL: name: test_mix{{.*}}
 635
 636 ; 32BIT:      liveins:
 637 ; 32BIT-NEXT: - { reg: '$f1', virtual-reg: '' }
 638 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
 639 ; 32BIT-NEXT: - { reg: '$f2', virtual-reg: '' }
 640 ; 32BIT-NEXT: - { reg: '$r7', virtual-reg: '' }
 641 ; 32BIT:      body:             |
 642 ; 32BIT-NEXT:   bb.0.entry:
 643 ; 32BIT-NEXT:     liveins: $f1, $f2, $r4, $r7
 644
 645 ; 64BIT:      liveins:
 646 ; 64BIT-NEXT: - { reg: '$f1', virtual-reg: '' }
 647 ; 64BIT-NEXT: - { reg: '$x4', virtual-reg: '' }
 648 ; 64BIT-NEXT: - { reg: '$f2', virtual-reg: '' }
 649 ; 64BIT-NEXT: - { reg: '$x6', virtual-reg: '' }
 650 ; 64BIT:      body:             |
 651 ; 64BIT-NEXT:   bb.0.entry:
 652 ; 64BIT-NEXT:     liveins: $f1, $f2, $x4, $x6
 653
 654
 655 define i64 @callee_mixed_ints(i32 %a, i8 signext %b, i32 %c, i16 signext %d, i64 %e) {
 656 entry:
 657   %conv = zext i8 %b to i32
 658   %add = add nsw i32 %a, %conv
 659   %add1 = add nsw i32 %add, %c
 660   %conv2 = sext i16 %d to i32
 661   %add3 = add nsw i32 %add1, %conv2
 662   %conv4 = sext i32 %add3 to i64
 663   %add5 = add nsw i64 %conv4, %e
 664   ret i64 %add5
 665   }
 666
 667 ; CHECK-LABEL: name:  callee_mixed_ints
 668
 669 ; 32BIT:      liveins:
 670 ; 32BIT-NEXT: - { reg: '$r3', virtual-reg: '' }
 671 ; 32BIT-NEXT: - { reg: '$r4', virtual-reg: '' }
 672 ; 32BIT-NEXT: - { reg: '$r5', virtual-reg: '' }
 673 ; 32BIT-NEXT: - { reg: '$r6', virtual-reg: '' }
 674 ; 32BIT-NEXT: - { reg: '$r7', virtual-reg: '' }
 675 ; 32BIT-NEXT: - { reg: '$r8', virtual-reg: '' }
 676 ; 32BIT:      body:             |
 677 ; 32BIT-NEXT:  bb.0.entry:
 678 ; 32BIT-NEXT:   liveins: $r3, $r4, $r5, $r6, $r7, $r8
 679
 680 ; 64BIT:        liveins:
 681 ; 64BIT-NEXT:   - { reg: '$x3', virtual-reg: '' }
 682 ; 64BIT-NEXT:   - { reg: '$x4', virtual-reg: '' }
 683 ; 64BIT-NEXT:   - { reg: '$x5', virtual-reg: '' }
 684 ; 64BIT-NEXT:   - { reg: '$x6', virtual-reg: '' }
 685 ; 64BIT-NEXT:   - { reg: '$x7', virtual-reg: '' }
 686 ; 64BIT:        body:             |
 687 ; 64BIT-NEXT:    bb.0.entry:
 688 ; 64BIT-NEXT:     liveins: $x3, $x4, $x5, $x6, $x7
 689
 690 define void @call_test_vararg() {
 691 entry:
 692   %0 = load float, float* @f1, align 4
 693   %conv = fpext float %0 to double
 694   %1 = load double, double* @d1, align 8
 695   call void (i32, ...) @test_vararg(i32 42, double %conv, double %1)
 696   ret void
 697 }
 698
 699 declare void @test_vararg(i32, ...)
 700
 701 ; CHECK-LABEL:     name: call_test_vararg
 702
 703 ; 32BIT:      renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
 704 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from @f1)
 705 ; 32BIT-NEXT: renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
 706 ; 32BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
 707 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]], align 8)
 708 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from @d1)
 709 ; 32BIT-NEXT: renamable $r5 = LWZ 4, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]] + 4)
 710 ; 32BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
 711 ; 32BIT-NEXT: renamable $r6 = LWZ 0, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]], align 8)
 712 ; 32BIT-NEXT: renamable $r7 = LWZ 4, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]] + 4)
 713 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 714 ; 32BIT-NEXT: $r3 = LI 42
 715 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $f1, implicit $r4, implicit $r5, implicit $f2, implicit $r6, implicit $r7, implicit $r2, implicit-def $r1
 716 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 717
 718 ; CHECKASM-LABEL: .call_test_vararg:
 719
 720 ; ASM32PWR4:      stwu 1, -80(1)
 721 ; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C1(2)
 722 ; ASM32PWR4-NEXT: lfs 1, 0([[REG]])
 723 ; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C2(2)
 724 ; ASM32PWR4-NEXT: stfd 1, 64(1)
 725 ; ASM32PWR4-NEXT: lfd 2, 0([[REG]])
 726 ; ASM32PWR4-NEXT: li 3, 42
 727 ; ASM32PWR4-NEXT: stfd 2, 72(1)
 728 ; ASM32PWR4-DAG:  lwz 4, 64(1)
 729 ; ASM32PWR4-DAG:  lwz 5, 68(1)
 730 ; ASM32PWR4-DAG:  lwz 6, 72(1)
 731 ; ASM32PWR4-DAG:  lwz 7, 76(1)
 732 ; ASM32PWR4-NEXT: bl .test_vararg[PR]
 733 ; ASM32PWR4-NEXT: nop
 734
 735 ; 64BIT:      renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
 736 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from @f1)
 737 ; 64BIT-NEXT: renamable $x[[REG:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
 738 ; 64BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
 739 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) from @d1)
 740 ; 64BIT-NEXT: renamable $x4 = LD 0, %stack.[[SLOT1]] :: (load (s64) from %stack.[[SLOT1]])
 741 ; 64BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
 742 ; 64BIT-NEXT: renamable $x5 = LD 0, %stack.[[SLOT2]] :: (load (s64) from %stack.[[SLOT2]])
 743 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 744 ; 64BIT-NEXT: $x3 = LI8 42
 745 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $f1, implicit $x4, implicit $f2, implicit $x5, implicit $x2, implicit-def $r1
 746 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 747
 748 ; ASM64PWR4:      stdu 1, -128(1)
 749 ; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
 750 ; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
 751 ; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C2(2)
 752 ; ASM64PWR4-NEXT: stfd 1, 112(1)
 753 ; ASM64PWR4-NEXT: lfd 2, 0([[REG]])
 754 ; ASM64PWR4-NEXT: li 3, 42
 755 ; ASM64PWR4-NEXT: stfd 2, 120(1)
 756 ; ASM64PWR4-NEXT: ld 4, 112(1)
 757 ; ASM64PWR4-NEXT: ld 5, 120(1)
 758 ; ASM64PWR4-NEXT: bl .test_vararg[PR]
 759 ; ASM64PWR4-NEXT: nop
 760
 761 define void @call_test_vararg2() {
 762 entry:
 763   %0 = load float, float* @f1, align 4
 764   %conv = fpext float %0 to double
 765   %1 = load double, double* @d1, align 8
 766   call void (i32, ...) @test_vararg(i32 42, double %conv, i32 42, double %1)
 767   ret void
 768 }
 769
 770 ; CHECK-LABEL:     name: call_test_vararg2
 771
 772 ; 32BIT:      renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
 773 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from @f1)
 774 ; 32BIT-NEXT: renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
 775 ; 32BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
 776 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]], align 8)
 777 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from @d1)
 778 ; 32BIT-NEXT: renamable $r5 = LWZ 4, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]] + 4)
 779 ; 32BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
 780 ; 32BIT-NEXT: renamable $r7 = LWZ 0, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]], align 8)
 781 ; 32BIT-NEXT: renamable $r8 = LWZ 4, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]] + 4)
 782 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 783 ; 32BIT-NEXT: $r3 = LI 42
 784 ; 32BIT-NEXT: $r6 = LI 42
 785 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $f1, implicit $r4, implicit $r5, implicit killed $r6, implicit $f2, implicit $r7, implicit $r8, implicit $r2, implicit-def $r1
 786 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 787
 788 ; ASM32PWR4:      stwu 1, -80(1)
 789 ; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C1(2)
 790 ; ASM32PWR4-NEXT: li 6, 42
 791 ; ASM32PWR4-NEXT: lfs 1, 0([[REG]])
 792 ; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C2(2)
 793 ; ASM32PWR4-NEXT: stfd 1, 64(1)
 794 ; ASM32PWR4-NEXT: lfd 2, 0([[REG]])
 795 ; ASM32PWR4-NEXT: li 3, 42
 796 ; ASM32PWR4-NEXT: stfd 2, 72(1)
 797 ; ASM32PWR4-DAG: lwz 4, 64(1)
 798 ; ASM32PWR4-DAG: lwz 5, 68(1)
 799 ; ASM32PWR4-DAG: lwz 7, 72(1)
 800 ; ASM32PWR4-DAG: lwz 8, 76(1)
 801 ; ASM32PWR4-NEXT: bl .test_vararg[PR]
 802 ; ASM32PWR4-NEXT: nop
 803
 804 ; 64BIT:      renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
 805 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from @f1)
 806 ; 64BIT-NEXT: renamable $x[[REG:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
 807 ; 64BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
 808 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) from @d1)
 809 ; 64BIT-NEXT: renamable $x4 = LD 0, %stack.[[SLOT1]] :: (load (s64) from %stack.[[SLOT1]])
 810 ; 64BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
 811 ; 64BIT-NEXT: renamable $x6 = LD 0, %stack.[[SLOT2]] :: (load (s64) from %stack.[[SLOT2]])
 812 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 813 ; 64BIT-NEXT: $x3 = LI8 42
 814 ; 64BIT-NEXT: $x5 = LI8 42
 815 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $f1, implicit $x4, implicit killed $x5, implicit $f2, implicit $x6, implicit $x2, implicit-def $r1
 816 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 817
 818 ; ASM64PWR4:      stdu 1, -128(1)
 819 ; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
 820 ; ASM64PWR4-NEXT: li 5, 42
 821 ; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
 822 ; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C2(2)
 823 ; ASM64PWR4-NEXT: stfd 1, 112(1)
 824 ; ASM64PWR4-NEXT: lfd 2, 0([[REG]])
 825 ; ASM64PWR4-NEXT: li 3, 42
 826 ; ASM64PWR4-NEXT: stfd 2, 120(1)
 827 ; ASM64PWR4-NEXT: ld 4, 112(1)
 828 ; ASM64PWR4-NEXT: ld 6, 120(1)
 829 ; ASM64PWR4-NEXT: bl .test_vararg[PR]
 830 ; ASM64PWR4-NEXT: nop
 831
 832 define void @call_test_vararg3() {
 833 entry:
 834   %0 = load float, float* @f1, align 4
 835   %conv = fpext float %0 to double
 836   %1 = load double, double* @d1, align 8
 837   call void (i32, ...) @test_vararg(i32 42, double %conv, i64 42, double %1)
 838   ret void
 839 }
 840
 841 ; CHECK-LABEL:     name: call_test_vararg3
 842
 843 ; 32BIT:      renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
 844 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from @f1)
 845 ; 32BIT-NEXT: renamable $r[[REG:[0-9]+]] = LWZtoc @d1, $r2 :: (load (s32) from got)
 846 ; 32BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
 847 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]], align 8)
 848 ; 32BIT-NEXT: renamable $f2 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from @d1)
 849 ; 32BIT-NEXT: renamable $r5 = LWZ 4, %stack.[[SLOT1]] :: (load (s32) from %stack.[[SLOT1]] + 4)
 850 ; 32BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
 851 ; 32BIT-NEXT: renamable $r8 = LWZ 0, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]], align 8)
 852 ; 32BIT-NEXT: renamable $r9 = LWZ 4, %stack.[[SLOT2]] :: (load (s32) from %stack.[[SLOT2]] + 4)
 853 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 854 ; 32BIT-NEXT: $r3 = LI 42
 855 ; 32BIT-NEXT: $r6 = LI 0
 856 ; 32BIT-NEXT: $r7 = LI 42
 857 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $f1, implicit $r4, implicit $r5, implicit killed $r6, implicit killed $r7, implicit $f2, implicit $r8, implicit $r9, implicit $r2, implicit-def $r1
 858 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 859
 860 ; ASM32PWR4:      stwu 1, -80(1)
 861 ; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C1(2)
 862 ; ASM32PWR4-DAG:  li 6, 0
 863 ; ASM32PWR4-DAG:  li 7, 42
 864 ; ASM32PWR4-NEXT: lfs 1, 0([[REG]])
 865 ; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C2(2)
 866 ; ASM32PWR4-NEXT: stfd 1, 64(1)
 867 ; ASM32PWR4-NEXT: lfd 2, 0([[REG]])
 868 ; ASM32PWR4-NEXT: li 3, 42
 869 ; ASM32PWR4-NEXT: stfd 2, 72(1)
 870 ; ASM32PWR4-DAG:  lwz 4, 64(1)
 871 ; ASM32PWR4-DAG:  lwz 5, 68(1)
 872 ; ASM32PWR4-DAG:  lwz 8, 72(1)
 873 ; ASM32PWR4-DAG:  lwz 9, 76(1)
 874 ; ASM32PWR4-NEXT: bl .test_vararg[PR]
 875 ; ASM32PWR4-NEXT: nop
 876
 877 ; 64BIT:      renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
 878 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from @f1)
 879 ; 64BIT-NEXT: renamable $x[[REG:[0-9]+]] = LDtoc @d1, $x2 :: (load (s64) from got)
 880 ; 64BIT-NEXT: STFD renamable $f1, 0, %stack.[[SLOT1:[0-9]+]] :: (store (s64) into %stack.[[SLOT1]])
 881 ; 64BIT-NEXT: renamable $f2 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) from @d1)
 882 ; 64BIT-NEXT: renamable $x4 = LD 0, %stack.[[SLOT1]] :: (load (s64) from %stack.[[SLOT1]])
 883 ; 64BIT-NEXT: STFD renamable $f2, 0, %stack.[[SLOT2:[0-9]+]] :: (store (s64) into %stack.[[SLOT2]])
 884 ; 64BIT-NEXT: renamable $x6 = LD 0, %stack.[[SLOT2]] :: (load (s64) from %stack.[[SLOT2]])
 885 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 886 ; 64BIT-NEXT: $x3 = LI8 42
 887 ; 64BIT-NEXT: $x5 = LI8 42
 888 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $f1, implicit $x4, implicit killed $x5, implicit $f2, implicit $x6, implicit $x2, implicit-def $r1
 889 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 890
 891 ; ASM64PWR4:      stdu 1, -128(1)
 892 ; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
 893 ; ASM64PWR4-NEXT: li 5, 42
 894 ; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
 895 ; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C2(2)
 896 ; ASM64PWR4-NEXT: stfd 1, 112(1)
 897 ; ASM64PWR4-NEXT: lfd 2, 0([[REG]])
 898 ; ASM64PWR4-NEXT: li 3, 42
 899 ; ASM64PWR4-NEXT: stfd 2, 120(1)
 900 ; ASM64PWR4-DAG:  ld 4, 112(1)
 901 ; ASM64PWR4-DAG:  ld 6, 120(1)
 902 ; ASM64PWR4-NEXT: bl .test_vararg[PR]
 903 ; ASM64PWR4-NEXT: nop
 904
 905 define void @call_test_vararg4() {
 906 entry:
 907   %0 = load float, float* @f1, align 4
 908   call void (i32, ...) @test_vararg(i32 42, float %0)
 909   ret void
 910 }
 911
 912 ; CHECK-LABEL:     name: call_test_vararg4
 913
 914 ; 32BIT:      renamable $r[[REG:[0-9]+]] = LWZtoc @f1, $r2 :: (load (s32) from got)
 915 ; 32BIT-NEXT: renamable $f1 = LFS 0, killed renamable $r[[REG]] :: (dereferenceable load (s32) from @f1)
 916 ; 32BIT-NEXT: STFS renamable $f1, 0, %stack.[[SLOT:[0-9]+]] :: (store (s32) into %stack.[[SLOT]])
 917 ; 32BIT-NEXT: renamable $r4 = LWZ 0, %stack.[[SLOT]] :: (load (s32) from %stack.[[SLOT]])
 918 ; 32BIT-NEXT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
 919 ; 32BIT-NEXT: $r3 = LI 42
 920 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_vararg[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $f1, implicit $r4, implicit $r2, implicit-def $r1
 921 ; 32BIT-NEXT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
 922
 923 ; ASM32PWR4:      stwu 1, -64(1)
 924 ; ASM32PWR4-NEXT: lwz [[REG:[0-9]+]], L..C1(2)
 925 ; ASM32PWR4-NEXT: lfs 1, 0([[REG]])
 926 ; ASM32PWR4-NEXT: li 3, 42
 927 ; ASM32PWR4-NEXT: stfs 1, 60(1)
 928 ; ASM32PWR4-NEXT: lwz 4, 60(1)
 929 ; ASM32PWR4-NEXT: bl .test_vararg[PR]
 930 ; ASM32PWR4-NEXT: nop
 931
 932 ; 64BIT:      renamable $x[[REG:[0-9]+]] = LDtoc @f1, $x2 :: (load (s64) from got)
 933 ; 64BIT-NEXT: renamable $f1 = LFS 0, killed renamable $x[[REG]] :: (dereferenceable load (s32) from @f1)
 934 ; 64BIT-NEXT: STFS renamable $f1, 0, %stack.[[SLOT:[0-9]+]] :: (store (s32) into %stack.[[SLOT]])
 935 ; 64BIT-NEXT: renamable $x4 = LWZ8 0, %stack.[[SLOT]] :: (load (s32) from %stack.[[SLOT]])
 936 ; 64BIT-NEXT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
 937 ; 64BIT-NEXT: $x3 = LI8 42
 938 ; 64BIT-NEXT: BL8_NOP <mcsymbol .test_vararg[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $f1, implicit $x4, implicit $x2, implicit-def $r1
 939 ; 64BIT-NEXT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
 940
 941 ; ASM64PWR4:      stdu 1, -128(1)
 942 ; ASM64PWR4-NEXT: ld [[REG:[0-9]+]], L..C1(2)
 943 ; ASM64PWR4-NEXT: lfs 1, 0([[REG]])
 944 ; ASM64PWR4-NEXT: li 3, 42
 945 ; ASM64PWR4-NEXT: stfs 1, 124(1)
 946 ; ASM64PWR4-NEXT: lwz 4, 124(1)
 947 ; ASM64PWR4-NEXT: bl .test_vararg[PR]
 948 ; ASM64PWR4-NEXT: nop
 949
 950 @c = common global i8 0, align 1
 951 @si = common global i16 0, align 2
 952 @i = common global i32 0, align 4
 953 @lli = common global i64 0, align 8
 954 @f = common global float 0.000000e+00, align 4
 955 @d = common global double 0.000000e+00, align 8
 956
 957 ; Basic saving of integral type arguments to the parameter save area.
 958 define void @call_test_stackarg_int() {
 959 entry:
 960   %0 = load i8, i8* @c, align 1
 961   %1 = load i16, i16* @si, align 2
 962   %2 = load i32, i32* @i, align 4
 963   %3 = load i64, i64* @lli, align 8
 964   %4 = load i32, i32* @i, align 4
 965   call void @test_stackarg_int(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i8 zeroext %0, i16 signext %1, i32 %2, i64 %3, i32 %4)
 966   ret void
 967 }
 968
 969 declare void @test_stackarg_int(i32, i32, i32, i32, i32, i32, i32, i32, i8 zeroext, i16 signext, i32, i64, i32)
 970
 971 ; CHECK-LABEL:     name: call_test_stackarg_int{{.*}}
 972
 973 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
 974 ; 32BIT-DAG:  ADJCALLSTACKDOWN 80, 0, implicit-def dead $r1, implicit $r1
 975 ; 32BIT-DAG:  $r3 = LI 1
 976 ; 32BIT-DAG:  $r4 = LI 2
 977 ; 32BIT-DAG:  $r5 = LI 3
 978 ; 32BIT-DAG:  $r6 = LI 4
 979 ; 32BIT-DAG:  $r7 = LI 5
 980 ; 32BIT-DAG:  $r8 = LI 6
 981 ; 32BIT-DAG:  $r9 = LI 7
 982 ; 32BIT-DAG:  $r10 = LI 8
 983 ; 32BIT-DAG:  renamable $r[[REGCADDR:[0-9]+]] = LWZtoc @c, $r2 :: (load (s32) from got)
 984 ; 32BIT-DAG:  renamable $r[[REGC:[0-9]+]] = LBZ 0, killed renamable $r[[REGCADDR]] :: (dereferenceable load (s8) from @c)
 985 ; 32BIT-DAG:  STW killed renamable $r[[REGC]], 56, $r1 :: (store (s32))
 986 ; 32BIT-DAG:  renamable $r[[REGSIADDR:[0-9]+]] = LWZtoc @si, $r2 :: (load (s32) from got)
 987 ; 32BIT-DAG:  renamable $r[[REGSI:[0-9]+]] = LHA 0, killed renamable $r[[REGSIADDR]] :: (dereferenceable load (s16) from @si)
 988 ; 32BIT-DAG:  STW killed renamable $r[[REGSI]], 60, $r1 :: (store (s32))
 989 ; 32BIT-DAG:  renamable $r[[REGIADDR:[0-9]+]] = LWZtoc @i, $r2 :: (load (s32) from got)
 990 ; 32BIT-DAG:  renamable $r[[REGI:[0-9]+]] = LWZ 0, killed renamable $r[[REGIADDR]] :: (dereferenceable load (s32) from @i)
 991 ; 32BIT-DAG:  STW killed renamable $r[[REGI]], 64, $r1 :: (store (s32))
 992 ; 32BIT-DAG:  renamable $r[[REGLLIADDR:[0-9]+]] = LWZtoc @lli, $r2 :: (load (s32) from got)
 993 ; 32BIT-DAG:  renamable $r[[REGLLI1:[0-9]+]] = LWZ 0, renamable $r[[REGLLIADDR]] :: (dereferenceable load (s32) from @lli, align 8)
 994 ; 32BIT-DAG:  STW killed renamable $r[[REGLLI1]], 68, $r1 :: (store (s32))
 995 ; 32BIT-DAG:  renamable $r[[REGLLI2:[0-9]+]] = LWZ 4, killed renamable $r[[REGLLIADDR]] :: (dereferenceable load (s32) from @lli + 4, basealign 8)
 996 ; 32BIT-DAG:  STW killed renamable $r[[REGLLI2]], 72, $r1 :: (store (s32))
 997 ; 32BIT-DAG:  STW renamable $r[[REGI]], 76, $r1 :: (store (s32))
 998 ; 32BIT-NEXT: BL_NOP <mcsymbol .test_stackarg_int[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r4, implicit $r5, implicit $r6, implicit $r7, implicit $r8, implicit $r9, implicit $r10, implicit $r2, implicit-def $r1
 999 ; 32BIT-NEXT: ADJCALLSTACKUP 80, 0, implicit-def dead $r1, implicit $r1
1000
1001 ; CHECKASM-LABEL: .call_test_stackarg_int:
1002
1003 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1004 ; ASM32PWR4:       stwu 1, -80(1)
1005 ; ASM32PWR4-DAG:   li 3, 1
1006 ; ASM32PWR4-DAG:   li 4, 2
1007 ; ASM32PWR4-DAG:   li 5, 3
1008 ; ASM32PWR4-DAG:   li 6, 4
1009 ; ASM32PWR4-DAG:   li 7, 5
1010 ; ASM32PWR4-DAG:   li 8, 6
1011 ; ASM32PWR4-DAG:   li 9, 7
1012 ; ASM32PWR4-DAG:   li 10, 8
1013 ; ASM32PWR4-DAG:   lwz [[REGCADDR:[0-9]+]], L..C6(2)
1014 ; ASM32PWR4-DAG:   lbz [[REGC:[0-9]+]], 0([[REGCADDR]])
1015 ; ASM32PWR4-DAG:   stw [[REGC]], 56(1)
1016 ; ASM32PWR4-DAG:   lwz [[REGSIADDR:[0-9]+]], L..C4(2)
1017 ; ASM32PWR4-DAG:   lha [[REGSI:[0-9]+]], 0([[REGSIADDR]])
1018 ; ASM32PWR4-DAG:   stw [[REGSI]], 60(1)
1019 ; ASM32PWR4-DAG:   lwz [[REGIADDR:[0-9]+]], L..C5(2)
1020 ; ASM32PWR4-DAG:   lwz [[REGI:[0-9]+]], 0([[REGIADDR]])
1021 ; ASM32PWR4-DAG:   stw [[REGI]], 64(1)
1022 ; ASM32PWR4-DAG:   lwz [[REGLLIADDR:[0-9]+]], L..C7(2)
1023 ; ASM32PWR4-DAG:   lwz [[REGLLI1:[0-9]+]], 0([[REGLLIADDR]])
1024 ; ASM32PWR4-DAG:   stw [[REGLLI1]], 68(1)
1025 ; ASM32PWR4-DAG:   lwz [[REGLLI2:[0-9]+]], 4([[REGLLIADDR]])
1026 ; ASM32PWR4-DAG:   stw [[REGLLI2]], 72(1)
1027 ; ASM32PWR4-DAG:   stw [[REGI]], 76(1)
1028 ; ASM32PWR4-NEXT:  bl .test_stackarg_int[PR]
1029 ; ASM32PWR4-NEXT:  nop
1030
1031 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1032 ; 64BIT-DAG:   ADJCALLSTACKDOWN 152, 0, implicit-def dead $r1, implicit $r1
1033 ; 64BIT-DAG:   $x3 = LI8 1
1034 ; 64BIT-DAG:   $x4 = LI8 2
1035 ; 64BIT-DAG:   $x5 = LI8 3
1036 ; 64BIT-DAG:   $x6 = LI8 4
1037 ; 64BIT-DAG:   $x7 = LI8 5
1038 ; 64BIT-DAG:   $x8 = LI8 6
1039 ; 64BIT-DAG:   $x9 = LI8 7
1040 ; 64BIT-DAG:   $x10 = LI8 8
1041 ; 64BIT-DAG:   renamable $x[[REGCADDR:[0-9]+]] = LDtoc @c, $x2 :: (load (s64) from got)
1042 ; 64BIT-DAG:   renamable $x[[REGC:[0-9]+]] = LBZ8 0, killed renamable $x[[REGCADDR]] :: (dereferenceable load (s8) from @c)
1043 ; 64BIT-DAG:   STD killed renamable $x[[REGC]], 112, $x1 :: (store (s64))
1044 ; 64BIT-DAG:   renamable $x[[REGSIADDR:[0-9]+]] = LDtoc @si, $x2 :: (load (s64) from got)
1045 ; 64BIT-DAG:   renamable $x[[REGSI:[0-9]+]] = LHA8 0, killed renamable $x[[REGSIADDR]] :: (dereferenceable load (s16) from @si)
1046 ; 64BIT-DAG:   STD killed renamable $x[[REGSI]], 120, $x1 :: (store (s64))
1047 ; 64BIT-DAG:   renamable $x[[REGIADDR:[0-9]+]] = LDtoc @i, $x2 :: (load (s64) from got)
1048 ; 64BIT-DAG:   renamable $x[[REGI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGIADDR]] :: (dereferenceable load (s32) from @i)
1049 ; 64BIT-DAG:   STD killed renamable $x[[REGI]], 128, $x1 :: (store (s64))
1050 ; 64BIT-DAG:   renamable $x[[REGLLIADDR:[0-9]+]] = LDtoc @lli, $x2 :: (load (s64) from got)
1051 ; 64BIT-DAG:   renamable $x[[REGLLI:[0-9]+]] = LD 0, killed renamable $x[[REGLLIADDR]] :: (dereferenceable load (s64) from @lli)
1052 ; 64BIT-DAG:   STD killed renamable $x[[REGLLI]], 136, $x1 :: (store (s64))
1053 ; 64BIT-DAG:   STD renamable $x[[REGI]], 144, $x1 :: (store (s64))
1054 ; 64BIT-NEXT:  BL8_NOP <mcsymbol .test_stackarg_int[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit $x5, implicit $x6, implicit $x7, implicit $x8, implicit $x9, implicit $x10, implicit $x2, implicit-def $r1
1055 ; 64BIT-NEXT:  ADJCALLSTACKUP 152, 0, implicit-def dead $r1, implicit $r1
1056
1057 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1058 ; ASM64PWR4-DAG:   stdu 1, -160(1)
1059 ; ASM64PWR4-DAG:   li 3, 1
1060 ; ASM64PWR4-DAG:   li 4, 2
1061 ; ASM64PWR4-DAG:   li 5, 3
1062 ; ASM64PWR4-DAG:   li 6, 4
1063 ; ASM64PWR4-DAG:   li 7, 5
1064 ; ASM64PWR4-DAG:   li 8, 6
1065 ; ASM64PWR4-DAG:   li 9, 7
1066 ; ASM64PWR4-DAG:   li 10, 8
1067 ; ASM64PWR4-DAG:   ld [[REGCADDR:[0-9]+]], L..C5(2)
1068 ; ASM64PWR4-DAG:   lbz [[REGC:[0-9]+]], 0([[REGCADDR]])
1069 ; ASM64PWR4-DAG:   std [[REGC]], 112(1)
1070 ; ASM64PWR4-DAG:   ld [[REGSIADDR:[0-9]+]], L..C3(2)
1071 ; ASM64PWR4-DAG:   lha [[REGSI:[0-9]+]], 0([[REGSIADDR]])
1072 ; ASM64PWR4-DAG:   std [[REGSI]], 120(1)
1073 ; ASM64PWR4-DAG:   ld [[REGIADDR:[0-9]+]], L..C4(2)
1074 ; ASM64PWR4-DAG:   lwz [[REGI:[0-9]+]], 0([[REGIADDR]])
1075 ; ASM64PWR4-DAG:   std [[REGI]], 128(1)
1076 ; ASM64PWR4-DAG:   ld [[REGLLIADDR:[0-9]+]], L..C6(2)
1077 ; ASM64PWR4-DAG:   ld [[REGLLI:[0-9]+]], 0([[REGLLIADDR]])
1078 ; ASM64PWR4-DAG:   std [[REGLLI]], 136(1)
1079 ; ASM64PWR4-DAG:   std [[REGI]], 144(1)
1080 ; ASM64PWR4-NEXT:  bl .test_stackarg_int[PR]
1081 ; ASM64PWR4-NEXT:  nop
1082
1083 ; Basic saving of floating point type arguments to the parameter save area.
1084 ; The float and double arguments will pass in both fpr as well as parameter save area.
1085 define void @call_test_stackarg_float() {
1086 entry:
1087   %0 = load float, float* @f, align 4
1088   %1 = load double, double* @d, align 8
1089   call void @test_stackarg_float(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, float %0, double %1)
1090   ret void
1091 }
1092
1093 declare void @test_stackarg_float(i32, i32, i32, i32, i32, i32, i32, i32, float, double)
1094
1095 ; CHECK-LABEL:     name:            call_test_stackarg_float
1096
1097 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1098 ; 32BIT-DAG:   ADJCALLSTACKDOWN 68, 0, implicit-def dead $r1, implicit $r1
1099 ; 32BIT-DAG:   $r3 = LI 1
1100 ; 32BIT-DAG:   $r4 = LI 2
1101 ; 32BIT-DAG:   $r5 = LI 3
1102 ; 32BIT-DAG:   $r6 = LI 4
1103 ; 32BIT-DAG:   $r7 = LI 5
1104 ; 32BIT-DAG:   $r8 = LI 6
1105 ; 32BIT-DAG:   $r9 = LI 7
1106 ; 32BIT-DAG:   $r10 = LI 8
1107 ; 32BIT-DAG:   renamable $r[[REGF:[0-9]+]] = LWZtoc @f, $r2 :: (load (s32) from got)
1108 ; 32BIT-DAG:   renamable $f1 = LFS 0, killed renamable $r[[REGF]] :: (dereferenceable load (s32) from @f)
1109 ; 32BIT-DAG:   renamable $r[[REGD:[0-9]+]] = LWZtoc @d, $r2 :: (load (s32) from got)
1110 ; 32BIT-DAG:   renamable $f2 = LFD 0, killed renamable $r[[REGD]] :: (dereferenceable load (s64) from @d)
1111 ; 32BIT-DAG:   STFS renamable $f1, 56, $r1 :: (store (s32))
1112 ; 32BIT-DAG:   STFD renamable $f2, 60, $r1 :: (store (s64))
1113 ; 32BIT-NEXT:  BL_NOP <mcsymbol .test_stackarg_float[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r4, implicit killed $r5, implicit killed $r6, implicit killed $r7, implicit killed $r8, implicit killed $r9, implicit killed $r10, implicit $f1, implicit $f2, implicit $r2, implicit-def $r1
1114 ; 32BIT-NEXT:  ADJCALLSTACKUP 68, 0, implicit-def dead $r1, implicit $r1
1115
1116 ; CHECKASM-LABEL: .call_test_stackarg_float:
1117
1118 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1119 ; ASM32PWR4:      stwu 1, -80(1)
1120 ; ASM32PWR4-DAG:  li 3, 1
1121 ; ASM32PWR4-DAG:  li 4, 2
1122 ; ASM32PWR4-DAG:  li 5, 3
1123 ; ASM32PWR4-DAG:  li 6, 4
1124 ; ASM32PWR4-DAG:  li 7, 5
1125 ; ASM32PWR4-DAG:  li 8, 6
1126 ; ASM32PWR4-DAG:  li 9, 7
1127 ; ASM32PWR4-DAG:  li 10, 8
1128 ; ASM32PWR4-DAG:  lwz [[REGF:[0-9]+]], L..C8(2)
1129 ; ASM32PWR4-DAG:  lfs 1, 0([[REGF]])
1130 ; ASM32PWR4-DAG:  lwz [[REGD:[0-9]+]], L..C9(2)
1131 ; ASM32PWR4-DAG:  lfd 2, 0([[REGD:[0-9]+]])
1132 ; ASM32PWR4-DAG:  stfs 1, 56(1)
1133 ; ASM32PWR4-DAG:  stfd 2, 60(1)
1134 ; ASM32PWR4-NEXT: bl .test_stackarg_float[PR]
1135 ; ASM32PWR4-NEXT: nop
1136 ; ASM32PWR4-NEXT: addi 1, 1, 80
1137
1138 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1139 ; 64BIT-DAG:   ADJCALLSTACKDOWN 128, 0, implicit-def dead $r1, implicit $r1
1140 ; 64BIT-DAG:   $x3 = LI8 1
1141 ; 64BIT-DAG:   $x4 = LI8 2
1142 ; 64BIT-DAG:   $x5 = LI8 3
1143 ; 64BIT-DAG:   $x6 = LI8 4
1144 ; 64BIT-DAG:   $x7 = LI8 5
1145 ; 64BIT-DAG:   $x8 = LI8 6
1146 ; 64BIT-DAG:   $x9 = LI8 7
1147 ; 64BIT-DAG:   $x10 = LI8 8
1148 ; 64BIT-DAG:   renamable $x[[REGF:[0-9]+]] = LDtoc @f, $x2 :: (load (s64) from got)
1149 ; 64BIT-DAG:   renamable $f1 = LFS 0, killed renamable $x[[REGF]] :: (dereferenceable load (s32) from @f)
1150 ; 64BIT-DAG:   renamable $x[[REGD:[0-9]+]] = LDtoc @d, $x2 :: (load (s64) from got)
1151 ; 64BIT-DAG:   renamable $f2 = LFD 0, killed renamable $x[[REGD]] :: (dereferenceable load (s64) from @d)
1152 ; 64BIT-DAG:   STFS renamable $f1, 112, $x1 :: (store (s32))
1153 ; 64BIT-DAG:   STFD renamable $f2, 120, $x1 :: (store (s64))
1154 ; 64BIT-NEXT:  BL8_NOP <mcsymbol .test_stackarg_float[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit killed $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $f1, implicit $f2, implicit $x2, implicit-def $r1
1155 ; 64BIT-NEXT:  ADJCALLSTACKUP 128, 0, implicit-def dead $r1, implicit $r1
1156
1157 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1158 ; ASM64PWR4:      stdu 1, -128(1)
1159 ; ASM64PWR4-DAG:  li 3, 1
1160 ; ASM64PWR4-DAG:  li 4, 2
1161 ; ASM64PWR4-DAG:  li 5, 3
1162 ; ASM64PWR4-DAG:  li 6, 4
1163 ; ASM64PWR4-DAG:  li 7, 5
1164 ; ASM64PWR4-DAG:  li 8, 6
1165 ; ASM64PWR4-DAG:  li 9, 7
1166 ; ASM64PWR4-DAG:  li 10, 8
1167 ; ASM64PWR4-DAG:  ld [[REGF:[0-9]+]], L..C7(2)
1168 ; ASM64PWR4-DAG:  lfs 1, 0([[REGF]])
1169 ; ASM64PWR4-DAG:  ld [[REGD:[0-9]+]], L..C8(2)
1170 ; ASM64PWR4-DAG:  lfd 2, 0([[REGD]])
1171 ; ASM64PWR4-DAG:  stfs 1, 112(1)
1172 ; ASM64PWR4-DAG:  stfd 2, 120(1)
1173 ; ASM64PWR4-NEXT: bl .test_stackarg_float[PR]
1174 ; ASM64PWR4-NEXT: nop
1175 ; ASM64PWR4-NEXT: addi 1, 1, 128
1176
1177 define void @call_test_stackarg_float2() {
1178 entry:
1179   %0 = load double, double* @d, align 8
1180   call void (i32, i32, i32, i32, i32, i32, ...) @test_stackarg_float2(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, double %0)
1181   ret void
1182 }
1183
1184 declare void @test_stackarg_float2(i32, i32, i32, i32, i32, i32, ...)
1185
1186 ; CHECK-LABEL:     name: call_test_stackarg_float2{{.*}}
1187
1188 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1189 ; 32BIT-DAG:   ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1
1190 ; 32BIT-DAG:   $r3 = LI 1
1191 ; 32BIT-DAG:   $r4 = LI 2
1192 ; 32BIT-DAG:   $r5 = LI 3
1193 ; 32BIT-DAG:   $r6 = LI 4
1194 ; 32BIT-DAG:   $r7 = LI 5
1195 ; 32BIT-DAG:   $r8 = LI 6
1196 ; 32BIT-DAG:   renamable $r[[REG:[0-9]+]] = LWZtoc @d, $r2 :: (load (s32) from got)
1197 ; 32BIT-DAG:   renamable $f1 = LFD 0, killed renamable $r[[REG]] :: (dereferenceable load (s64) from @d)
1198 ; 32BIT-DAG:   STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1199 ; 32BIT-DAG:   renamable $r9 = LWZ 0, %stack.0 :: (load (s32) from %stack.0, align 8)
1200 ; 32BIT-DAG:   renamable $r10 = LWZ 4, %stack.0 :: (load (s32) from %stack.0 + 4)
1201 ; 32BIT-NEXT:   BL_NOP <mcsymbol .test_stackarg_float2[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit killed $r7, implicit killed $r8, implicit $f1, implicit $r9, implicit $r10, implicit $r2, implicit-def $r1
1202 ; 32BIT-NEXT:   ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1
1203
1204 ; CHECKASM-LABEL: .call_test_stackarg_float2:
1205
1206 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1207 ; ASM32PWR4:     stwu 1, -64(1)
1208 ; ASM32PWR4-DAG: li 3, 1
1209 ; ASM32PWR4-DAG: li 4, 2
1210 ; ASM32PWR4-DAG: li 5, 3
1211 ; ASM32PWR4-DAG: li 6, 4
1212 ; ASM32PWR4-DAG: li 7, 5
1213 ; ASM32PWR4-DAG: li 8, 6
1214 ; ASM32PWR4-DAG: lwz [[REG:[0-9]+]], L..C9(2)
1215 ; ASM32PWR4-DAG: lfd 1, 0([[REG]])
1216 ; ASM32PWR4-DAG: stfd 1, 56(1)
1217 ; ASM32PWR4-DAG: lwz 9, 56(1)
1218 ; ASM32PWR4-DAG: lwz 10, 60(1)
1219 ; ASM32PWR4-NEXT: bl .test_stackarg_float2[PR]
1220 ; ASM32PWR4-NEXT: nop
1221 ; ASM32PWR4-NEXT: addi 1, 1, 64
1222
1223 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1224 ; 64BIT-DAG:   ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1
1225 ; 64BIT-DAG:   $x3 = LI8 1
1226 ; 64BIT-DAG:   $x4 = LI8 2
1227 ; 64BIT-DAG:   $x5 = LI8 3
1228 ; 64BIT-DAG:   $x6 = LI8 4
1229 ; 64BIT-DAG:   $x7 = LI8 5
1230 ; 64BIT-DAG:   $x8 = LI8 6
1231 ; 64BIT-DAG:   renamable $x[[REG:[0-9]+]] = LDtoc @d, $x2 :: (load (s64) from got)
1232 ; 64BIT-DAG:   renamable $f1 = LFD 0, killed renamable $x[[REG]] :: (dereferenceable load (s64) from @d)
1233 ; 64BIT-DAG:   STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1234 ; 64BIT-DAG:   renamable $x9 = LD 0, %stack.0 :: (load (s64) from %stack.0)
1235 ; 64BIT-NEXT:  BL8_NOP <mcsymbol .test_stackarg_float2[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit $f1, implicit $x9, implicit $x2, implicit-def $r1
1236 ; 64BIT-NEXT:  ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1
1237
1238 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1239 ; ASM64PWR4:     stdu 1, -128(1)
1240 ; ASM64PWR4-DAG: li 3, 1
1241 ; ASM64PWR4-DAG: li 4, 2
1242 ; ASM64PWR4-DAG: li 5, 3
1243 ; ASM64PWR4-DAG: li 6, 4
1244 ; ASM64PWR4-DAG: li 7, 5
1245 ; ASM64PWR4-DAG: li 8, 6
1246 ; ASM64PWR4-DAG: ld [[REG:[0-9]+]], L..C8(2)
1247 ; ASM64PWR4-DAG: lfd 1, 0([[REG]])
1248 ; ASM64PWR4-DAG: stfd 1, 120(1)
1249 ; ASM64PWR4-DAG: ld 9, 120(1)
1250 ; ASM64PWR4-NEXT: bl .test_stackarg_float2[PR]
1251 ; ASM64PWR4-NEXT: nop
1252 ; ASM64PWR4-NEXT: addi 1, 1, 128
1253
1254 ; A double arg will pass on the stack in PPC32 if there is only one available GPR.
1255 define void @call_test_stackarg_float3() {
1256 entry:
1257   %0 = load double, double* @d, align 8
1258   %1 = load float, float* @f, align 4
1259   call void (i32, i32, i32, i32, i32, i32, i32, ...) @test_stackarg_float3(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, double %0, float %1)
1260   ret void
1261 }
1262
1263 declare void @test_stackarg_float3(i32, i32, i32, i32, i32, i32, i32, ...)
1264
1265 ; CHECK-LABEL:     name: call_test_stackarg_float3{{.*}}
1266
1267 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1268 ; In 32-bit the double arg is written to memory because it cannot be fully stored in the last 32-bit GPR.
1269 ; 32BIT-DAG:   ADJCALLSTACKDOWN 64, 0, implicit-def dead $r1, implicit $r1
1270 ; 32BIT-DAG:   $r3 = LI 1
1271 ; 32BIT-DAG:   $r4 = LI 2
1272 ; 32BIT-DAG:   $r5 = LI 3
1273 ; 32BIT-DAG:   $r6 = LI 4
1274 ; 32BIT-DAG:   $r7 = LI 5
1275 ; 32BIT-DAG:   $r8 = LI 6
1276 ; 32BIT-DAG:   $r9 = LI 7
1277 ; 32BIT-DAG:   renamable $r[[REGD:[0-9]+]] = LWZtoc @d, $r2 :: (load (s32) from got)
1278 ; 32BIT-DAG:   renamable $f1 = LFD 0, killed renamable $r[[REGD]] :: (dereferenceable load (s64) from @d)
1279 ; 32BIT-DAG:   renamable $r[[REGF:[0-9]+]] = LWZtoc @f, $r2 :: (load (s32) from got)
1280 ; 32BIT-DAG:   renamable $f2 = LFS 0, killed renamable $r[[REGF]] :: (dereferenceable load (s32) from @f)
1281 ; 32BIT-DAG:   STFD renamable $f1, 52, $r1 :: (store (s64))
1282 ; 32BIT-DAG:   STFS renamable $f2, 60, $r1 :: (store (s32))
1283 ; 32BIT-DAG:   STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1284 ; 32BIT-DAG:   renamable $r10 = LWZ 0, %stack.0 :: (load (s32) from %stack.0, align 8)
1285 ; 32BIT-NEXT:  BL_NOP <mcsymbol .test_stackarg_float3[PR]>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit killed $r7, implicit killed $r8, implicit killed $r9, implicit $f1, implicit $r10, implicit $f2, implicit $r2, implicit-def $r1
1286 ; 32BIT-NEXT:  ADJCALLSTACKUP 64, 0, implicit-def dead $r1, implicit $r1
1287
1288 ; CHECKASM-LABEL: .call_test_stackarg_float3:
1289
1290 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1291 ; ASM32PWR4:       stwu 1, -80(1)
1292 ; ASM32PWR4-DAG:   li 3, 1
1293 ; ASM32PWR4-DAG:   li 4, 2
1294 ; ASM32PWR4-DAG:   li 5, 3
1295 ; ASM32PWR4-DAG:   li 6, 4
1296 ; ASM32PWR4-DAG:   li 7, 5
1297 ; ASM32PWR4-DAG:   li 8, 6
1298 ; ASM32PWR4-DAG:   li 9, 7
1299 ; ASM32PWR4-DAG:   lwz [[REGD:[0-9]+]], L..C9(2)
1300 ; ASM32PWR4-DAG:   lfd 1, 0([[REGD]])
1301 ; ASM32PWR4-DAG:   lwz [[REGF:[0-9]+]], L..C8(2)
1302 ; ASM32PWR4-DAG:   lfs 2, 0([[REGF]])
1303 ; ASM32PWR4-DAG:   stfd 1, 52(1)
1304 ; ASM32PWR4-DAG:   stfs 2, 60(1)
1305 ; ASM32PWR4-DAG:   stfd 1, 72(1)
1306 ; ASM32PWR4-DAG:   lwz 10, 72(1)
1307 ; ASM32PWR4-NEXT:  bl .test_stackarg_float3[PR]
1308 ; ASM32PWR4-NEXT:  nop
1309 ; ASM32PWR4-NEXT:  addi 1, 1, 80
1310
1311 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1312 ; In 64-bit the double arg is not written to memory because it is fully stored in the last 64-bit GPR.
1313 ; 64BIT-DAG:   ADJCALLSTACKDOWN 120, 0, implicit-def dead $r1, implicit $r1
1314 ; 64BIT-DAG:   $x3 = LI8 1
1315 ; 64BIT-DAG:   $x4 = LI8 2
1316 ; 64BIT-DAG:   $x5 = LI8 3
1317 ; 64BIT-DAG:   $x6 = LI8 4
1318 ; 64BIT-DAG:   $x7 = LI8 5
1319 ; 64BIT-DAG:   $x8 = LI8 6
1320 ; 64BIT-DAG:   $x9 = LI8 7
1321 ; 64BIT-DAG:   renamable $x[[REGD:[0-9]+]] = LDtoc @d, $x2 :: (load (s64) from got)
1322 ; 64BIT-DAG:   renamable $f1 = LFD 0, killed renamable $x[[REGD]] :: (dereferenceable load (s64) from @d)
1323 ; 64BIT-DAG:   renamable $x[[REGF:[0-9]+]] = LDtoc @f, $x2 :: (load (s64) from got)
1324 ; 64BIT-DAG:   renamable $f2 = LFS 0, killed renamable $x[[REGF]] :: (dereferenceable load (s32) from @f)
1325 ; 64BIT-DAG:   STFS renamable $f2, 112, $x1 :: (store (s32))
1326 ; 64BIT-DAG:   STFD renamable $f1, 0, %stack.0 :: (store (s64) into %stack.0)
1327 ; 64BIT-DAG:   renamable $x10 = LD 0, %stack.0 :: (load (s64) from %stack.0)
1328 ; 64BIT-NEXT:  BL8_NOP <mcsymbol .test_stackarg_float3[PR]>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit $f1, implicit $x10, implicit $f2, implicit $x2, implicit-def $r1
1329
1330 ; 64BIT-NEXT: ADJCALLSTACKUP 120, 0, implicit-def dead $r1, implicit $r1
1331
1332 ; The DAG block permits some invalid inputs for the benefit of allowing more valid orderings.
1333 ; ASM64PWR4:       stdu 1, -128(1)
1334 ; ASM64PWR4-DAG:   li 3, 1
1335 ; ASM64PWR4-DAG:   li 4, 2
1336 ; ASM64PWR4-DAG:   li 5, 3
1337 ; ASM64PWR4-DAG:   li 6, 4
1338 ; ASM64PWR4-DAG:   li 7, 5
1339 ; ASM64PWR4-DAG:   li 8, 6
1340 ; ASM64PWR4-DAG:   li 9, 7
1341 ; ASM64PWR4-DAG:   ld [[REGD:[0-9]+]], L..C8(2)
1342 ; ASM64PWR4-DAG:   lfd 1, 0([[REGD]])
1343 ; ASM64PWR4-DAG:   ld [[REGF:[0-9]+]], L..C7(2)
1344 ; ASM64PWR4-DAG:   lfs 2, 0([[REGF]])
1345 ; ASM64PWR4-DAG:   stfs 2, 112(1)
1346 ; ASM64PWR4-DAG:   stfd 1, 120(1)
1347 ; ASM64PWR4-DAG:   ld 10, 120(1)
1348 ; ASM64PWR4-NEXT:  bl .test_stackarg_float3[PR]
1349 ; ASM64PWR4-NEXT:  nop
1350 ; ASM64PWR4-NEXT:  addi 1, 1, 128
1351
1352 define i64 @test_ints_stack(i32 %i1, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6, i32 %i7, i32 %i8, i64 %ll9, i16 signext %s10, i8 zeroext %c11, i32 %ui12, i32 %si13, i64 %ll14, i8 zeroext %uc15, i32 %i16) {
1353 entry:
1354   %add = add nsw i32 %i1, %i2
1355   %add1 = add nsw i32 %add, %i3
1356   %add2 = add nsw i32 %add1, %i4
1357   %add3 = add nsw i32 %add2, %i5
1358   %add4 = add nsw i32 %add3, %i6
1359   %add5 = add nsw i32 %add4, %i7
1360   %add6 = add nsw i32 %add5, %i8
1361   %conv = sext i32 %add6 to i64
1362   %add7 = add nsw i64 %conv, %ll9
1363   %conv8 = sext i16 %s10 to i64
1364   %add9 = add nsw i64 %add7, %conv8
1365   %conv10 = zext i8 %c11 to i64
1366   %add11 = add nsw i64 %add9, %conv10
1367   %conv12 = zext i32 %ui12 to i64
1368   %add13 = add nsw i64 %add11, %conv12
1369   %conv14 = sext i32 %si13 to i64
1370   %add15 = add nsw i64 %add13, %conv14
1371   %add16 = add nsw i64 %add15, %ll14
1372   %conv17 = zext i8 %uc15 to i64
1373   %add18 = add nsw i64 %add16, %conv17
1374   %conv19 = sext i32 %i16 to i64
1375   %add20 = add nsw i64 %add18, %conv19
1376   ret i64 %add20
1377 }
1378
1379 ; CHECK-LABEL: name: test_ints_stack
1380
1381 ; 32BIT-LABEL: liveins:
1382 ; 32BIT-DAG:   - { reg: '$r3', virtual-reg: '' }
1383 ; 32BIT-DAG:   - { reg: '$r4', virtual-reg: '' }
1384 ; 32BIT-DAG:   - { reg: '$r5', virtual-reg: '' }
1385 ; 32BIT-DAG:   - { reg: '$r6', virtual-reg: '' }
1386 ; 32BIT-DAG:   - { reg: '$r7', virtual-reg: '' }
1387 ; 32BIT-DAG:   - { reg: '$r8', virtual-reg: '' }
1388 ; 32BIT-DAG:   - { reg: '$r9', virtual-reg: '' }
1389 ; 32BIT-DAG:   - { reg: '$r10', virtual-reg: '' }
1390
1391 ; 32BIT-LABEL: fixedStack:
1392 ; 32BIT-DAG:   - { id: 9, type: default, offset: 56, size: 4
1393 ; 32BIT-DAG:   - { id: 8, type: default, offset: 60, size: 4
1394 ; 32BIT-DAG:   - { id: 7, type: default, offset: 64, size: 4
1395 ; 32BIT-DAG:   - { id: 6, type: default, offset: 68, size: 4
1396 ; 32BIT-DAG:   - { id: 5, type: default, offset: 72, size: 4
1397 ; 32BIT-DAG:   - { id: 4, type: default, offset: 76, size: 4
1398 ; 32BIT-DAG:   - { id: 3, type: default, offset: 80, size: 4
1399 ; 32BIT-DAG:   - { id: 2, type: default, offset: 84, size: 4
1400 ; 32BIT-DAG:   - { id: 1, type: default, offset: 88, size: 4
1401 ; 32BIT-DAG:   - { id: 0, type: default, offset: 92, size: 4
1402
1403 ; 32BIT-LABEL: body:             |
1404 ; 32BIT-DAG:    bb.0.entry:
1405 ; 32BIT-DAG:      liveins: $r3, $r4, $r5, $r6, $r7, $r8, $r9, $r10
1406
1407 ; 64BIT-LABEL: liveins:
1408 ; 64BIT-DAG:   - { reg: '$x3', virtual-reg: '' }
1409 ; 64BIT-DAG:   - { reg: '$x4', virtual-reg: '' }
1410 ; 64BIT-DAG:   - { reg: '$x5', virtual-reg: '' }
1411 ; 64BIT-DAG:   - { reg: '$x6', virtual-reg: '' }
1412 ; 64BIT-DAG:   - { reg: '$x7', virtual-reg: '' }
1413 ; 64BIT-DAG:   - { reg: '$x8', virtual-reg: '' }
1414 ; 64BIT-DAG:   - { reg: '$x9', virtual-reg: '' }
1415 ; 64BIT-DAG:   - { reg: '$x10', virtual-reg: '' }
1416
1417 ; 64BIT-LABEL:  fixedStack:
1418 ; 64BIT-DAG:   - { id: 7, type: default, offset: 112, size: 8
1419 ; 64BIT-DAG:   - { id: 6, type: default, offset: 124, size: 4
1420 ; 64BIT-DAG:   - { id: 5, type: default, offset: 132, size: 4
1421 ; 64BIT-DAG:   - { id: 4, type: default, offset: 140, size: 4
1422 ; 64BIT-DAG:   - { id: 3, type: default, offset: 148, size: 4
1423 ; 64BIT-DAG:   - { id: 2, type: default, offset: 152, size: 8
1424 ; 64BIT-DAG:   - { id: 1, type: default, offset: 164, size: 4
1425 ; 64BIT-DAG:   - { id: 0, type: default, offset: 172, size: 4
1426 ; 64BIT-DAG:   body:             |
1427 ; 64BIT-DAG:    bb.0.entry:
1428 ; 64BIT-DAG:     liveins: $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10
1429
1430 ; CHECKASM-LABEL:  .test_ints_stack:
1431
1432 ; ASM32PWR4-DAG:   lwz [[REG1:[0-9]+]], 56(1)
1433 ; ASM32PWR4-DAG:   lwz [[REG2:[0-9]+]], 60(1)
1434 ; ASM32PWR4-DAG:   lwz [[REG3:[0-9]+]], 64(1)
1435 ; ASM32PWR4-DAG:   lwz [[REG4:[0-9]+]], 68(1)
1436 ; ASM32PWR4-DAG:   lwz [[REG5:[0-9]+]], 72(1)
1437 ; ASM32PWR4-DAG:   lwz [[REG6:[0-9]+]], 76(1)
1438 ; ASM32PWR4-DAG:   lwz [[REG7:[0-9]+]], 80(1)
1439 ; ASM32PWR4-DAG:   lwz [[REG8:[0-9]+]], 84(1)
1440 ; ASM32PWR4-DAG:   lwz [[REG9:[0-9]+]], 88(1)
1441 ; ASM32PWR4-DAG:   lwz [[REG10:[0-9]+]], 92(1)
1442
1443 ; ASM64PWR4-DAG:   ld [[REG1:[0-9]+]], 112(1)
1444 ; ASM64PWR4-DAG:   lwz [[REG2:[0-9]+]], 124(1)
1445 ; ASM64PWR4-DAG:   lwz [[REG3:[0-9]+]], 132(1)
1446 ; ASM64PWR4-DAG:   lwz [[REG4:[0-9]+]], 140(1)
1447 ; ASM64PWR4-DAG:   lwa [[REG5:[0-9]+]], 148(1)
1448 ; ASM64PWR4-DAG:   ld [[REG6:[0-9]+]], 152(1)
1449 ; ASM64PWR4-DAG:   lwz [[REG7:[0-9]+]], 164(1)
1450 ; ASM64PWR4-DAG:   lwa [[REG8:[0-9]+]], 172(1)
1451
1452 @ll1 = common global i64 0, align 8
1453 @si1 = common global i16 0, align 2
1454 @ch = common global i8 0, align 1
1455 @ui = common global i32 0, align 4
1456 @sint = common global i32 0, align 4
1457 @ll2 = common global i64 0, align 8
1458 @uc1 = common global i8 0, align 1
1459 @i1 = common global i32 0, align 4
1460
1461 define void @caller_ints_stack() {
1462 entry:
1463   %0 = load i64, i64* @ll1, align 8
1464   %1 = load i16, i16* @si1, align 2
1465   %2 = load i8, i8* @ch, align 1
1466   %3 = load i32, i32* @ui, align 4
1467   %4 = load i32, i32* @sint, align 4
1468   %5 = load i64, i64* @ll2, align 8
1469   %6 = load i8, i8* @uc1, align 1
1470   %7 = load i32, i32* @i1, align 4
1471   %call = call i64 @test_ints_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i64 %0, i16 signext %1, i8 zeroext %2, i32 %3, i32 %4, i64 %5, i8 zeroext %6, i32 %7)
1472   ret void
1473 }
1474
1475 ; CHECK-LABEL: name: caller_ints_stack
1476
1477 ; 32BIT-DAG:   $r3 = LI 1
1478 ; 32BIT-DAG:   $r4 = LI 2
1479 ; 32BIT-DAG:   $r5 = LI 3
1480 ; 32BIT-DAG:   $r6 = LI 4
1481 ; 32BIT-DAG:   $r7 = LI 5
1482 ; 32BIT-DAG:   $r8 = LI 6
1483 ; 32BIT-DAG:   $r9 = LI 7
1484 ; 32BIT-DAG:   $r10 = LI 8
1485 ; 32BIT-DAG:   renamable $r[[REGLL1ADDR:[0-9]+]] = LWZtoc @ll1, $r2 :: (load (s32) from got)
1486 ; 32BIT-DAG:   renamable $r[[REGLL1A:[0-9]+]] = LWZ 0, renamable $r[[REGLL1ADDR]] :: (dereferenceable load (s32) from @ll1, align 8)
1487 ; 32BIT-DAG:   renamable $r[[REGLL1B:[0-9]+]] = LWZ 4, killed renamable $r[[REGLL1ADDR]] :: (dereferenceable load (s32) from @ll1 + 4, basealign 8)
1488 ; 32BIT-DAG:   STW killed renamable $r[[REGLL1A]], 56, $r1 :: (store (s32))
1489 ; 32BIT-DAG:   STW killed renamable $r[[REGLL1B]], 60, $r1 :: (store (s32))
1490 ; 32BIT-DAG:   renamable $r[[REGSIADDR:[0-9]+]] = LWZtoc @si1, $r2 :: (load (s32) from got)
1491 ; 32BIT-DAG:   renamable $r[[REGSI:[0-9]+]] = LHA 0, killed renamable $r[[REGSIADDR]] :: (dereferenceable load (s16) from @si1)
1492 ; 32BIT-DAG:   STW killed renamable $r[[REGSI]], 64, $r1 :: (store (s32))
1493 ; 32BIT-DAG:   renamable $r[[REGCHADDR:[0-9]+]] = LWZtoc @ch, $r2 :: (load (s32) from got)
1494 ; 32BIT-DAG:   renamable $r[[REGCH:[0-9]+]] = LBZ 0, killed renamable $r[[REGCHADDR]] :: (dereferenceable load (s8) from @ch)
1495 ; 32BIT-DAG:   STW killed renamable $r[[REGCH]], 68, $r1 :: (store (s32))
1496 ; 32BIT-DAG:   renamable $r[[REGUIADDR:[0-9]+]] = LWZtoc @ui, $r2 :: (load (s32) from got)
1497 ; 32BIT-DAG:   renamable $r[[REGUI:[0-9]+]] = LWZ 0, killed renamable $r[[REGUIADDR]] :: (dereferenceable load (s32) from @ui)
1498 ; 32BIT-DAG:   STW killed renamable $r[[REGUI]], 72, $r1 :: (store (s32))
1499 ; 32BIT-DAG:   renamable $r[[REGSIADDR:[0-9]+]] = LWZtoc @sint, $r2 :: (load (s32) from got)
1500 ; 32BIT-DAG:   renamable $r[[REGSI:[0-9]+]] = LWZ 0, killed renamable $r[[REGSIADDR]] :: (dereferenceable load (s32) from @sint)
1501 ; 32BIT-DAG:   STW killed renamable $r[[REGSI]], 76, $r1 :: (store (s32))
1502 ; 32BIT-DAG:   renamable $r[[REGLL2ADDR:[0-9]+]] = LWZtoc @ll2, $r2 :: (load (s32) from got)
1503 ; 32BIT-DAG:   renamable $r[[REGLL2A:[0-9]+]] = LWZ 0, renamable $r[[REGLL2ADDR]] :: (dereferenceable load (s32) from @ll2, align 8)
1504 ; 32BIT-DAG:   renamable $r[[REGLL2B:[0-9]+]] = LWZ 4, killed renamable $r[[REGLL2ADDR]] :: (dereferenceable load (s32) from @ll2 + 4, basealign 8)
1505 ; 32BIT-DAG:   STW killed renamable $r[[REGLL2A]], 80, $r1 :: (store (s32))
1506 ; 32BIT-DAG:   STW killed renamable $r[[REGLL2B]], 84, $r1 :: (store (s32))
1507 ; 32BIT-DAG:   renamable $r[[REGUCADDR:[0-9]+]] = LWZtoc @uc1, $r2 :: (load (s32) from got)
1508 ; 32BIT-DAG:   renamable $r[[REGUC:[0-9]+]] = LBZ 0, killed renamable $r[[REGUCADDR]] :: (dereferenceable load (s8) from @uc1)
1509 ; 32BIT-DAG:   STW killed renamable $r[[REGUC]], 88, $r1 :: (store (s32))
1510 ; 32BIT-DAG:   renamable $r[[REGIADDR:[0-9]+]] = LWZtoc @i1, $r2 :: (load (s32) from got)
1511 ; 32BIT-DAG:   renamable $r[[REGI:[0-9]+]] = LWZ 0, killed renamable $r[[REGIADDR]] :: (dereferenceable load (s32) from @i1)
1512 ; 32BIT-DAG:   STW killed renamable $r[[REGI]], 92, $r1 :: (store (s32))
1513 ; 32BIT-DAG:   ADJCALLSTACKDOWN 96, 0, implicit-def dead $r1, implicit $r1
1514 ; 32BIT-NEXT:  BL_NOP <mcsymbol .test_ints_stack>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r4, implicit $r5, implicit $r6, implicit $r7, implicit $r8, implicit $r9, implicit $r10, implicit $r2, implicit-def $r1, implicit-def dead $r3
1515 ; 32BIT-NEXT:  ADJCALLSTACKUP 96, 0, implicit-def dead $r1, implicit $r1
1516
1517 ; 64BIT-DAG:   $x3 = LI8 1
1518 ; 64BIT-DAG:   $x4 = LI8 2
1519 ; 64BIT-DAG:   $x5 = LI8 3
1520 ; 64BIT-DAG:   $x6 = LI8 4
1521 ; 64BIT-DAG:   $x7 = LI8 5
1522 ; 64BIT-DAG:   $x8 = LI8 6
1523 ; 64BIT-DAG:   $x9 = LI8 7
1524 ; 64BIT-DAG:   $x10 = LI8 8
1525 ; 64BIT-DAG:   renamable $x[[REGLL1ADDR:[0-9]+]] = LDtoc @ll1, $x2 :: (load (s64) from got)
1526 ; 64BIT-DAG:   renamable $x[[REGLL1:[0-9]+]] = LD 0, killed renamable $x[[REGLL1ADDR]] :: (dereferenceable load (s64) from @ll1)
1527 ; 64BIT-DAG:   STD killed renamable $x[[REGLL1]], 112, $x1 :: (store (s64))
1528 ; 64BIT-DAG:   renamable $x[[REGSIADDR:[0-9]+]] = LDtoc @si1, $x2 :: (load (s64) from got)
1529 ; 64BIT-DAG:   renamable $x[[REGSI:[0-9]+]] = LHA8 0, killed renamable $x[[REGSIADDR]] :: (dereferenceable load (s16) from @si1)
1530 ; 64BIT-DAG:   STD killed renamable $x[[REGSI]], 120, $x1 :: (store (s64))
1531 ; 64BIT-DAG:   renamable $x[[REGCHADDR:[0-9]+]] = LDtoc @ch, $x2 :: (load (s64) from got)
1532 ; 64BIT-DAG:   renamable $x[[REGCH:[0-9]+]] = LBZ8 0, killed renamable $x[[REGCHADDR]] :: (dereferenceable load (s8) from @ch)
1533 ; 64BIT-DAG:   STD killed renamable $x[[REGCH]], 128, $x1 :: (store (s64))
1534 ; 64BIT-DAG:   renamable $x[[REGUIADDR:[0-9]+]] = LDtoc @ui, $x2 :: (load (s64) from got)
1535 ; 64BIT-DAG:   renamable $x[[REGUI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGUIADDR]] :: (dereferenceable load (s32) from @ui)
1536 ; 64BIT-DAG:   STD killed renamable $x[[REGUI]], 136, $x1 :: (store (s64))
1537 ; 64BIT-DAG:   renamable $x[[REGSIADDR:[0-9]+]] = LDtoc @sint, $x2 :: (load (s64) from got)
1538 ; 64BIT-DAG:   renamable $x[[REGSI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGSIADDR]] :: (dereferenceable load (s32) from @sint)
1539 ; 64BIT-DAG:   STD killed renamable $x[[REGSI]], 144, $x1 :: (store (s64))
1540 ; 64BIT-DAG:   renamable $x[[REGLL2ADDR:[0-9]+]] = LDtoc @ll2, $x2 :: (load (s64) from got)
1541 ; 64BIT-DAG:   renamable $x[[REGLL2:[0-9]+]] = LD 0, killed renamable $x[[REGLL2ADDR]] :: (dereferenceable load (s64) from @ll2)
1542 ; 64BIT-DAG:   STD killed renamable $x[[REGLL2]], 152, $x1 :: (store (s64))
1543 ; 64BIT-DAG:   renamable $x[[REGUCADDR:[0-9]+]] = LDtoc @uc1, $x2 :: (load (s64) from got)
1544 ; 64BIT-DAG:   renamable $x[[REGUC:[0-9]+]] = LBZ8 0, killed renamable $x[[REGUCADDR]] :: (dereferenceable load (s8) from @uc1)
1545 ; 64BIT-DAG:   STD killed renamable $x[[REGUC]], 160, $x1 :: (store (s64))
1546 ; 64BIT-DAG:   renamable $x[[REGIADDR:[0-9]+]] = LDtoc @i1, $x2 :: (load (s64) from got)
1547 ; 64BIT-DAG:   renamable $x[[REGI:[0-9]+]] = LWZ8 0, killed renamable $x[[REGIADDR]] :: (dereferenceable load (s32) from @i1)
1548 ; 64BIT-DAG:   STD killed renamable $x[[REGI]], 168, $x1 :: (store (s64))
1549 ; 64BIT-DAG:   ADJCALLSTACKDOWN 176, 0, implicit-def dead $r1, implicit $r1
1550 ; 64BIT-NEXT:  BL8_NOP <mcsymbol .test_ints_stack>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit $x5, implicit $x6, implicit $x7, implicit $x8, implicit $x9, implicit $x10, implicit $x2, implicit-def $r1, implicit-def dead $x3
1551 ; 64BIT-NEXT:  ADJCALLSTACKUP 176, 0, implicit-def dead $r1, implicit $r1
1552 ; 64BIT-NEXT:  BLR8 implicit $lr8, implicit $rm
1553
1554 ; CHECKASM-LABEL:  .caller_ints_stack:
1555
1556 ; ASM32PWR4:        mflr 0
1557 ; ASM32PWR4-DAG:    stw 0, 8(1)
1558 ; ASM32PWR4-DAG:    stwu 1, -96(1)
1559 ; ASM32PWR4-DAG:    li 3, 1
1560 ; ASM32PWR4-DAG:    li 4, 2
1561 ; ASM32PWR4-DAG:    li 5, 3
1562 ; ASM32PWR4-DAG:    li 6, 4
1563 ; ASM32PWR4-DAG:    li 7, 5
1564 ; ASM32PWR4-DAG:    li 9, 7
1565 ; ASM32PWR4-DAG:    li 8, 6
1566 ; ASM32PWR4-DAG:    li 10, 8
1567 ; ASM32PWR4-DAG:    lwz [[REG1:[0-9]+]], L..C10(2)
1568 ; ASM32PWR4-DAG:    lwz [[REG2:[0-9]+]], L..C11(2)
1569 ; ASM32PWR4-DAG:    lwz [[REG3:[0-9]+]], L..C12(2)
1570 ; ASM32PWR4-DAG:    lwz [[REG4:[0-9]+]], L..C13(2)
1571 ; ASM32PWR4-DAG:    lwz [[REG5:[0-9]+]], L..C14(2)
1572 ; ASM32PWR4-DAG:    lwz [[REG6:[0-9]+]], L..C15(2)
1573 ; ASM32PWR4-DAG:    lwz [[REG7:[0-9]+]], L..C16(2)
1574 ; ASM32PWR4-DAG:    lwz [[REG8:[0-9]+]], L..C17(2)
1575 ; ASM32PWR4-DAG:    lha 5, 0([[REG1]])
1576 ; ASM32PWR4-DAG:    lwz 11, 0([[REG7]])
1577 ; ASM32PWR4-DAG:    lwz 7, 4([[REG7]])
1578 ; ASM32PWR4-DAG:    lbz 4, 0([[REG2]])
1579 ; ASM32PWR4-DAG:    lwz 3, 0([[REG8]])
1580 ; ASM32PWR4-DAG:    lwz 6, 0([[REG3]])
1581 ; ASM32PWR4-DAG:    lwz 9, 0([[REG4]])
1582 ; ASM32PWR4-DAG:    lwz 8, 4([[REG4]])
1583 ; ASM32PWR4-DAG:    lbz 10, 0([[REG5]])
1584 ; ASM32PWR4-DAG:    lwz 12, 0([[REG6]])
1585 ; ASM32PWR4-DAG:    stw 11, 56(1)
1586 ; ASM32PWR4-DAG:    stw 7, 60(1)
1587 ; ASM32PWR4-DAG:    stw 5, 64(1)
1588 ; ASM32PWR4-DAG:    stw 4, 68(1)
1589 ; ASM32PWR4-DAG:    stw 3, 72(1)
1590 ; ASM32PWR4-DAG:    stw 6, 76(1)
1591 ; ASM32PWR4-DAG:    stw 9, 80(1)
1592 ; ASM32PWR4-DAG:    stw 8, 84(1)
1593 ; ASM32PWR4-DAG:    stw 10, 88(1)
1594 ; ASM32PWR4-DAG:    stw 12, 92(1)
1595 ; ASM32PWR4-DAG:    bl .test_ints_stack
1596 ; ASM32PWR4-DAG:    nop
1597 ; ASM32PWR4-DAG:    addi 1, 1, 96
1598 ; ASM32PWR4-DAG:    lwz 0, 8(1)
1599 ; ASM32PWR4-NEXT:   mtlr 0
1600 ; ASM32PWR4-NEXT:   blr
1601
1602 ; ASM64PWR4:        mflr 0
1603 ; ASM64PWR4-DAG:    std 0, 16(1)
1604 ; ASM64PWR4-DAG:    stdu 1, -176(1)
1605 ; ASM64PWR4-DAG:    li 3, 1
1606 ; ASM64PWR4-DAG:    li 4, 2
1607 ; ASM64PWR4-DAG:    li 5, 3
1608 ; ASM64PWR4-DAG:    li 6, 4
1609 ; ASM64PWR4-DAG:    li 7, 5
1610 ; ASM64PWR4-DAG:    li 8, 6
1611 ; ASM64PWR4-DAG:    li 9, 7
1612 ; ASM64PWR4-DAG:    li 10, 8
1613 ; ASM64PWR4-DAG:    ld [[REG1:[0-9]+]], L..C9(2)
1614 ; ASM64PWR4-DAG:    ld [[REG2:[0-9]+]], L..C10(2)
1615 ; ASM64PWR4-DAG:    ld [[REG3:[0-9]+]], L..C11(2)
1616 ; ASM64PWR4-DAG:    ld [[REG4:[0-9]+]], L..C12(2)
1617 ; ASM64PWR4-DAG:    ld [[REG5:[0-9]+]], L..C13(2)
1618 ; ASM64PWR4-DAG:    ld [[REG6:[0-9]+]], L..C14(2)
1619 ; ASM64PWR4-DAG:    ld [[REG7:[0-9]+]], L..C15(2)
1620 ; ASM64PWR4-DAG:    ld [[REG8:[0-9]+]], L..C16(2)
1621 ; ASM64PWR4-DAG:    lha 7, 0([[REG1]])
1622 ; ASM64PWR4-DAG:    lbz 5, 0([[REG2]])
1623 ; ASM64PWR4-DAG:    ld 6, 0([[REG3]])
1624 ; ASM64PWR4-DAG:    lbz 8, 0([[REG4]])
1625 ; ASM64PWR4-DAG:    lwz 9, 0([[REG5]])
1626 ; ASM64PWR4-DAG:    ld 11, 0([[REG6]])
1627 ; ASM64PWR4-DAG:    lwz 3, 0([[REG7]])
1628 ; ASM64PWR4-DAG:    lwz 4, 0([[REG8]])
1629 ; ASM64PWR4-DAG:    std 11, 112(1)
1630 ; ASM64PWR4-DAG:    std 7, 120(1)
1631 ; ASM64PWR4-DAG:    std 5, 128(1)
1632 ; ASM64PWR4-DAG:    std 3, 136(1)
1633 ; ASM64PWR4-DAG:    std 4, 144(1)
1634 ; ASM64PWR4-DAG:    std 6, 152(1)
1635 ; ASM64PWR4-DAG:    std 8, 160(1)
1636 ; ASM64PWR4-DAG:    std 9, 168(1)
1637 ; ASM64PWR4-NEXT:   bl .test_ints_stack
1638 ; ASM64PWR4-NEXT:   nop
1639 ; ASM64PWR4-NEXT:   addi 1, 1, 176
1640 ; ASM64PWR4-NEXT:   ld 0, 16(1)
1641 ; ASM64PWR4-NEXT:   mtlr 0
1642 ; ASM64PWR4-NEXT:   blr
1643
1644 @globali1 = global i8 0, align 1
1645
1646 define void @test_i1_stack(i32 %a, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, i1 zeroext %b) {
1647   entry:
1648     %frombool = zext i1 %b to i8
1649     store i8 %frombool, i8* @globali1, align 1
1650     ret void
1651 }
1652
1653 ; CHECK-LABEL:  name:   test_i1_stack
1654
1655 ; 32BIT-LABEL: fixedStack:
1656 ; 32BIT-DAG:   - { id: 0, type: default, offset: 59, size: 1
1657 ; 32BIT-DAG:   body:             |
1658 ; 32BIT-DAG:    bb.0.entry:
1659 ; 32BIT-DAG:     renamable $r[[REGB:[0-9]+]] = LBZ 0, %fixed-stack.0 :: (load (s8) from %fixed-stack.0)
1660 ; 32BIT-DAG:     renamable $r[[REGBTOC:[0-9]+]] = LWZtoc @globali1, $r2 :: (load (s32) from got)
1661 ; 32BIT-DAG:     STB killed renamable $r[[REGB]], 0, killed renamable $r[[REGBTOC]] :: (store (s8) into @globali1)
1662
1663 ; 64BIT-LABEL: fixedStack:
1664 ; 64BIT-DAG:   - { id: 0, type: default, offset: 119, size: 1
1665 ; 64BIT-DAG:   body:             |
1666 ; 64BIT-DAG:     bb.0.entry:
1667 ; 64BIT-DAG:       renamable $r[[REGB:[0-9]+]] = LBZ 0, %fixed-stack.0 :: (load (s8) from %fixed-stack.0)
1668 ; 64BIT-DAG:       renamable $x[[REGBTOC:[0-9]+]] = LDtoc @globali1, $x2 :: (load (s64) from got)
1669 ; 64BIT-DAG:       STB killed renamable $r[[SCRATCHREG:[0-9]+]], 0, killed renamable $x[[REGBTOC]] :: (store (s8) into @globali1)
1670 ; 64BIT-DAG:       BLR8 implicit $lr8, implicit $rm
1671
1672 ; CHECKASM-LABEL:  test_i1_stack:
1673
1674 ; ASM32PWR4-DAG:   lbz [[REGB:[0-9]+]], 59(1)
1675 ; ASM32PWR4-DAG:   lwz [[REGBTOC:[0-9]+]], L..C18(2)
1676 ; ASM32PWR4-DAG:   stb [[SCRATCHREG:[0-9]+]], 0([[REGBTOC]])
1677 ; ASM32PWR4-DAG:   blr
1678
1679 ; ASM64PWR4-DAG:   lbz [[REGB:[0-9]+]], 119(1)
1680 ; ASM64PWR4-DAG:   ld [[REGBTOC:[0-9]+]], L..C17(2)
1681 ; ASM64PWR4-DAG:   stb [[SCRATCHREG:[0-9]+]], 0([[REGBTOC]])
1682 ; ASM64PWR4-DAG:   blr
1683
1684 define void @call_test_i1_stack() {
1685   entry:
1686     call void @test_i1_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i1 true)
1687     ret void
1688 }
1689
1690 ; CHECK-LABEL:  name:   call_test_i1_stack
1691
1692 ; 32BIT-DAG:   ADJCALLSTACKDOWN 60, 0, implicit-def dead $r1, implicit $r1
1693 ; 32BIT-DAG:   $r3 = LI 1
1694 ; 32BIT-DAG:   $r4 = LI 2
1695 ; 32BIT-DAG:   $r5 = LI 3
1696 ; 32BIT-DAG:   $r6 = LI 4
1697 ; 32BIT-DAG:   $r7 = LI 5
1698 ; 32BIT-DAG:   $r8 = LI 6
1699 ; 32BIT-DAG:   $r9 = LI 7
1700 ; 32BIT-DAG:   $r10 = LI 8
1701 ; 32BIT-DAG:   renamable $r[[REGBOOLADDR:[0-9]+]] = LI 1
1702 ; 32BIT-DAG:   STW killed renamable $r[[REGBOOLADDR]], 56, $r1 :: (store (s32))
1703 ; 32BIT-DAG:   BL_NOP <mcsymbol .test_i1_stack>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r4, implicit $r5, implicit $r6, implicit $r7, implicit $r8, implicit $r9, implicit $r10, implicit $r2, implicit-def $r1
1704 ; 32BIT-DAG:   ADJCALLSTACKUP 60, 0, implicit-def dead $r1, implicit $r1
1705
1706 ; 64BIT-DAG:  ADJCALLSTACKDOWN 120, 0, implicit-def dead $r1, implicit $r1
1707 ; 64BIT-DAG:  $x3 = LI8 1
1708 ; 64BIT-DAG:  $x4 = LI8 2
1709 ; 64BIT-DAG:  $x5 = LI8 3
1710 ; 64BIT-DAG:  $x6 = LI8 4
1711 ; 64BIT-DAG:  $x7 = LI8 5
1712 ; 64BIT-DAG:  $x8 = LI8 6
1713 ; 64BIT-DAG:  $x9 = LI8 7
1714 ; 64BIT-DAG:  $x10 = LI8 8
1715 ; 64BIT-DAG:  renamable $x[[REGBOOLADDR:[0-9]+]] = LI8 1
1716 ; 64BIT-DAG:  STD killed renamable $x[[REGBOOLADDR]], 112, $x1 :: (store (s64))
1717 ; 64BIT-DAG:  BL8_NOP <mcsymbol .test_i1_stack>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit $x5, implicit $x6, implicit $x7, implicit $x8, implicit $x9, implicit $x10, implicit $x2, implicit-def $r1
1718 ; 64BIT-DAG:  ADJCALLSTACKUP 120, 0, implicit-def dead $r1, implicit $r1
1719
1720 ; CHECKASM-LABEL: .call_test_i1_stack:
1721
1722 ; ASM32PWR4-DAG:   mflr 0
1723 ; ASM32PWR4-DAG:   li 3, 1
1724 ; ASM32PWR4-DAG:   li 4, 2
1725 ; ASM32PWR4-DAG:   li 5, 3
1726 ; ASM32PWR4-DAG:   li 6, 4
1727 ; ASM32PWR4-DAG:   li 7, 5
1728 ; ASM32PWR4-DAG:   li 8, 6
1729 ; ASM32PWR4-DAG:   li 9, 7
1730 ; ASM32PWR4-DAG:   li 10, 8
1731 ; ASM32PWR4-DAG:   stw [[REGB:[0-9]+]], 56(1)
1732 ; ASM32PWR4-DAG:   li [[REGB]], 1
1733 ; ASM32PWR4-DAG:   bl .test_i1
1734
1735 ; ASM64PWR-DAG:    mflr 0
1736 ; ASM64PWR-DAG:    li 3, 1
1737 ; ASM64PWR-DAG:    li 4, 2
1738 ; ASM64PWR-DAG:    li 5, 3
1739 ; ASM64PWR-DAG:    li 6, 4
1740 ; ASM64PWR-DAG:    li 7, 5
1741 ; ASM64PWR-DAG:    li 8, 6
1742 ; ASM64PWR-DAG:    li 9, 7
1743 ; ASM64PWR-DAG:    li 10, 8
1744 ; ASM64PWR-DAG:    std [[REGB:[0-9]+]], 112(1)
1745 ; ASM64PWR-DAG:    li [[REGB]], 1
1746 ; ASM64PWR-DAG:    bl .test_i1
1747
1748 define double @test_fpr_stack(double %d1, double %d2, double %d3, double %d4, double %d5, double %d6, double %d7, double %d8, double %d9, double %s10, double %l11, double %d12, double %d13, float %f14, double %d15, float %f16) {
1749   entry:
1750     %add = fadd double %d1, %d2
1751     %add1 = fadd double %add, %d3
1752     %add2 = fadd double %add1, %d4
1753     %add3 = fadd double %add2, %d5
1754     %add4 = fadd double %add3, %d6
1755     %add5 = fadd double %add4, %d7
1756     %add6 = fadd double %add5, %d8
1757     %add7 = fadd double %add6, %d9
1758     %add8 = fadd double %add7, %s10
1759     %add9 = fadd double %add8, %l11
1760     %add10 = fadd double %add9, %d12
1761     %add11 = fadd double %add10, %d13
1762     %add12 = fadd double %add11, %d13
1763     %conv = fpext float %f14 to double
1764     %add13 = fadd double %add12, %conv
1765     %add14 = fadd double %add13, %d15
1766     %conv15 = fpext float %f16 to double
1767     %add16 = fadd double %add14, %conv15
1768     ret double %add16
1769   }
1770
1771 ; CHECK-LABEL: name: test_fpr_stack{{.*}}
1772
1773 ; CHECK-LABEL: liveins:
1774 ; CHECK-DAG:   - { reg: '$f1', virtual-reg: '' }
1775 ; CHECK-DAG:   - { reg: '$f2', virtual-reg: '' }
1776 ; CHECK-DAG:   - { reg: '$f3', virtual-reg: '' }
1777 ; CHECK-DAG:   - { reg: '$f4', virtual-reg: '' }
1778 ; CHECK-DAG:   - { reg: '$f5', virtual-reg: '' }
1779 ; CHECK-DAG:   - { reg: '$f6', virtual-reg: '' }
1780 ; CHECK-DAG:   - { reg: '$f7', virtual-reg: '' }
1781 ; CHECK-DAG:   - { reg: '$f8', virtual-reg: '' }
1782 ; CHECK-DAG:   - { reg: '$f9', virtual-reg: '' }
1783 ; CHECK-DAG:   - { reg: '$f10', virtual-reg: '' }
1784 ; CHECK-DAG:   - { reg: '$f11', virtual-reg: '' }
1785 ; CHECK-DAG:   - { reg: '$f12', virtual-reg: '' }
1786 ; CHECK-DAG:   - { reg: '$f13', virtual-reg: '' }
1787
1788 ; CHECK-LABEL: fixedStack:
1789 ; 32BIT-DAG:   - { id: 2, type: default, offset: 128, size: 4
1790 ; 32BIT-DAG:   - { id: 1, type: default, offset: 132, size: 8
1791 ; 32BIT-DAG:   - { id: 0, type: default, offset: 140, size: 4
1792
1793 ; 64BIT-DAG:   - { id: 2, type: default, offset: 152, size: 4
1794 ; 64BIT-DAG:   - { id: 1, type: default, offset: 160, size: 8
1795 ; 64BIT-DAG:   - { id: 0, type: default, offset: 168, size: 4
1796
1797 ; CHECK-LABEL: body:             |
1798 ; CHECK-DAG:    bb.0.entry:
1799 ; CHECK-DAG:      liveins: $f1, $f2, $f3, $f4, $f5, $f6, $f7, $f8, $f9, $f10, $f11, $f12, $f13
1800
1801 ; CHECKASM-LABEL:  .test_fpr_stack:
1802
1803 ; ASM32PWR4-DAG:   lfs  [[REG1:[0-9]+]], 128(1)
1804 ; ASM32PWR4-DAG:   lfd  [[REG2:[0-9]+]], 132(1)
1805 ; ASM32PWR4-DAG:   lfs  [[REG3:[0-9]+]], 140(1)
1806 ; ASM32PWR4-DAG:   fadd 0, 0, [[REG1]]
1807 ; ASM32PWR4-DAG:   fadd 0, 0, [[REG2]]
1808 ; ASM32PWR4-DAG:   fadd 1, 0, [[REG3]]
1809
1810 ; ASM64PWR4-DAG:   lfs [[REG1:[0-9]+]], 152(1)
1811 ; ASM64PWR4-DAG:   lfd [[REG2:[0-9]+]], 160(1)
1812 ; ASM64PWR4-DAG:   lfs [[REG3:[0-9]+]], 168(1)
1813 ; ASM64PWR4-DAG:   fadd 0, 0, [[REG1]]
1814 ; ASM64PWR4-DAG:   fadd 0, 0, [[REG2]]
1815 ; ASM64PWR4-DAG:   fadd 1, 0, [[REG3]]
1816
1817 @f14 = common global float 0.000000e+00, align 4
1818 @d15 = common global double 0.000000e+00, align 8
1819 @f16 = common global float 0.000000e+00, align 4
1820
1821 define void @caller_fpr_stack() {
1822 entry:
1823   %0 = load float, float* @f14, align 4
1824   %1 = load double, double* @d15, align 8
1825   %2 = load float, float* @f16, align 4
1826   %call = call double @test_fpr_stack(double 1.000000e-01, double 2.000000e-01, double 3.000000e-01, double 4.000000e-01, double 5.000000e-01, double 6.000000e-01, double 0x3FE6666666666666, double 8.000000e-01, double 9.000000e-01, double 1.000000e-01, double 1.100000e-01, double 1.200000e-01, double 1.300000e-01, float %0, double %1, float %2)
1827   ret void
1828 }
1829
1830 ; CHECK-LABEL: caller_fpr_stack
1831
1832 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.0, $r2 :: (load (s32) from got)
1833 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.1, $r2 :: (load (s32) from got)
1834 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.2, $r2 :: (load (s32) from got)
1835 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.3, $r2 :: (load (s32) from got)
1836 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.4, $r2 :: (load (s32) from got)
1837 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.5, $r2 :: (load (s32) from got)
1838 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.6, $r2 :: (load (s32) from got)
1839 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.7, $r2 :: (load (s32) from got)
1840 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.8, $r2 :: (load (s32) from got)
1841 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.9, $r2 :: (load (s32) from got)
1842 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.10, $r2 :: (load (s32) from got)
1843 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.11, $r2 :: (load (s32) from got)
1844 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 56, $r1 :: (store (s32), align 8)
1845 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 60, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1846 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 64, $r1 :: (store (s32), align 8)
1847 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 68, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1848 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 72, $r1 :: (store (s32), align 8)
1849 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 76, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1850 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 80, $r1 :: (store (s32), align 8)
1851 ; 32BIT-DAG:   STW renamable $r[[SCRATCHREG:[0-9]+]], 84, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1852 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 88, $r1 :: (store (s32), align 8)
1853 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 92, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1854 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 96, $r1 :: (store (s32), align 8)
1855 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 100, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1856 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 104, $r1 :: (store (s32), align 8)
1857 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 108, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1858 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 112, $r1 :: (store (s32), align 8)
1859 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 116, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1860 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 120, $r1 :: (store (s32), align 8)
1861 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 124, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
1862 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 128, $r1 :: (store (s32))
1863 ; 32BIT-DAG:   renamable $r[[REGF1:[0-9]+]] = LWZtoc @f14, $r2 :: (load (s32) from got)
1864 ; 32BIT-DAG:   renamable $r3 = LWZ 0, killed renamable $r[[REGF1]] :: (load (s32) from @f14)
1865 ; 32BIT-DAG:   STFD killed renamable $f0, 132, $r1 :: (store (s64))
1866 ; 32BIT-DAG:   renamable $r[[REGD:[0-9]+]] = LWZtoc @d15, $r2 :: (load (s32) from got)
1867 ; 32BIT-DAG:   renamable $f0 = LFD 0, killed renamable $r[[REGD]] :: (dereferenceable load (s64) from @d15)
1868 ; 32BIT-DAG:   STW killed renamable $r[[SCRATCHREG:[0-9]+]], 140, $r1 :: (store (s32))
1869 ; 32BIT-DAG:   renamable $r[[REGF2:[0-9]+]] = LWZtoc @f16, $r2 :: (load (s32) from got)
1870 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZ 0, killed renamable $r[[REGF2]] :: (load (s32) from @f16)
1871 ; 32BIT-DAG:   renamable $f1 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1872 ; 32BIT-DAG:   renamable $f2 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1873 ; 32BIT-DAG:   renamable $f3 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1874 ; 32BIT-DAG:   renamable $f4 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1875 ; 32BIT-DAG:   renamable $f5 = LFS 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s32) from constant-pool)
1876 ; 32BIT-DAG:   renamable $f6 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1877 ; 32BIT-DAG:   renamable $f7 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1878 ; 32BIT-DAG:   renamable $f8 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1879 ; 32BIT-DAG:   renamable $f9 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1880 ; 32BIT-DAG:   $f10 = COPY renamable $f1
1881 ; 32BIT-DAG:   renamable $f11 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1882 ; 32BIT-DAG:   renamable $f12 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1883 ; 32BIT-DAG:   renamable $f13 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1884 ; 32BIT-NEXT:  BL_NOP <mcsymbol .test_fpr_stack>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit $f2, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit killed $f10, implicit $f11, implicit $f12, implicit $f13, implicit $r2, implicit-def $r1, implicit-def dead $f1
1885 ; 32BIT-NEXT:  ADJCALLSTACKUP 144, 0, implicit-def dead $r1, implicit $r1
1886
1887 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.0, $x2 :: (load (s64) from got)
1888 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.1, $x2 :: (load (s64) from got)
1889 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.2, $x2 :: (load (s64) from got)
1890 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.[[SCRATCHREG:[0-9]+]], $x2 :: (load (s64) from got)
1891 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.4, $x2 :: (load (s64) from got)
1892 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.5, $x2 :: (load (s64) from got)
1893 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.6, $x2 :: (load (s64) from got)
1894 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.7, $x2 :: (load (s64) from got)
1895 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.8, $x2 :: (load (s64) from got)
1896 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.9, $x2 :: (load (s64) from got)
1897 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.10, $x2 :: (load (s64) from got)
1898 ; 64BIT-DAG:   renamable $x[[REGF1:[0-9]+]] = LDtoc @f14, $x2 :: (load (s64) from got)
1899 ; 64BIT-DAG:   renamable $r3 = LWZ 0, killed renamable $x[[REGF1]] :: (load (s32) from @f14)
1900 ; 64BIT-DAG:   renamable $x[[REGF2:[0-9]+]] = LDtoc @f16, $x2 :: (load (s64) from got)
1901 ; 64BIT-DAG:   renamable $r5 = LWZ 0, killed renamable $x[[REGF2]] :: (load (s32) from @f16)
1902 ; 64BIT-DAG:   renamable $x[[REGD:[0-9]+]] = LDtoc @d15, $x2 :: (load (s64) from got)
1903 ; 64BIT-DAG:   renamable $x4 = LD 0, killed renamable $x[[REGD]] :: (load (s64) from @d15)
1904 ; 64BIT-DAG:   ADJCALLSTACKDOWN 176, 0, implicit-def dead $r1, implicit $r1
1905 ; 64BIT-DAG:   renamable $f1 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1906 ; 64BIT-DAG:   renamable $f2 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1907 ; 64BIT-DAG:   renamable $f[[SCRATCHREG:[0-9]+]] = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1908 ; 64BIT-DAG:   renamable $f4 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1909 ; 64BIT-DAG:   renamable $f5 = LFS 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s32) from constant-pool)
1910 ; 64BIT-DAG:   renamable $f6 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1911 ; 64BIT-DAG:   renamable $f7 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1912 ; 64BIT-DAG:   renamable $f8 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1913 ; 64BIT-DAG:   renamable $f9 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1914 ; 64BIT-DAG:   $f10 = COPY renamable $f1
1915 ; 64BIT-DAG:   renamable $f11 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1916 ; 64BIT-DAG:   renamable $f12 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1917 ; 64BIT-DAG:   renamable $f13 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
1918 ; 64BIT-DAG:   BL8_NOP <mcsymbol .test_fpr_stack>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit $f2, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit killed $f10, implicit $f11, implicit $f12, implicit $f13, implicit $x2, implicit-def $r1, implicit-def dead $f1
1919 ; 64BIT-NEXT:   ADJCALLSTACKUP 176, 0, implicit-def dead $r1, implicit $r1
1920 ; 64BIT-NEXT:   BLR8 implicit $lr8, implicit $rm
1921
1922 ; CHECKASM-LABEL:  .caller_fpr_stack:
1923
1924 ; ASM32PWR4:       mflr 0
1925 ; ASM32PWR4-DAG:   stw 0, 8(1)
1926 ; ASM32PWR4-DAG:   stwu 1, -144(1)
1927 ; ASM32PWR4-DAG:   lwz [[REGF1ADDR:[0-9]+]], L..C20(2)
1928 ; ASM32PWR4-DAG:   lwz [[REGF1:[0-9]+]], 0([[REGF1ADDR]])
1929 ; ASM32PWR4-DAG:   lwz [[REGDADDR:[0-9]+]], L..C19(2)
1930 ; ASM32PWR4-DAG:   lfd [[REGD:[0-9]+]], 0([[REGDADDR]])
1931 ; ASM32PWR4-DAG:   lwz [[REGF2ADDR:[0-9]+]], L..C21(2)
1932 ; ASM32PWR4-DAG:   lwz [[REGF2:[0-9]+]], 0([[REGF2ADDR]])
1933 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 56(1)
1934 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 60(1)
1935 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 64(1)
1936 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 68(1)
1937 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 72(1)
1938 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 76(1)
1939 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 80(1)
1940 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 84(1)
1941 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 88(1)
1942 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 92(1)
1943 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 96(1)
1944 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 100(1)
1945 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 108(1)
1946 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 104(1)
1947 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 112(1)
1948 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 116(1)
1949 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 120(1)
1950 ; ASM32PWR4-DAG:   stw [[SCRATCHREG:[0-9]+]], 124(1)
1951 ; ASM32PWR4-DAG:   stw [[REGF1]], 128(1)
1952 ; ASM32PWR4-DAG:   stfd [[REGD]], 132(1)
1953 ; ASM32PWR4-DAG:   stw [[REGF2]], 140(1)
1954 ; ASM32PWR4-NEXT:  bl .test_fpr_stack
1955
1956 ; ASM64PWR4:       mflr 0
1957 ; ASM64PWR4-DAG:   std 0, 16(1)
1958 ; ASM64PWR4-DAG:   stdu 1, -176(1)
1959 ; ASM64PWR4-DAG:   ld [[REGF1ADDR:[0-9]+]], L..C18(2)
1960 ; ASM64PWR4-DAG:   lwz [[REGF1:[0-9]+]], 0([[REGF1ADDR]])
1961 ; ASM64PWR4-DAG:   ld [[REGDADDR:[0-9]+]], L..C19(2)
1962 ; ASM64PWR4-DAG:   ld [[REGD:[0-9]+]], 0([[REGDADDR]])
1963 ; ASM64PWR4-DAG:   ld [[REGF2ADDR:[0-9]+]], L..C20(2)
1964 ; ASM64PWR4-DAG:   lwz [[REGF2:[0-9]+]], 0([[REGF2ADDR]])
1965 ; ASM64PWR4-DAG:   std [[SCRATCHREG:[0-9]+]], 112(1)
1966 ; ASM64PWR4-DAG:   std [[SCRATCHREG:[0-9]+]], 120(1)
1967 ; ASM64PWR4-DAG:   std [[SCRATCHREG:[0-9]+]], 128(1)
1968 ; ASM64PWR4-DAG:   std [[SCRATCHREG:[0-9]+]], 136(1)
1969 ; ASM64PWR4-DAG:   std [[SCRATCHREG:[0-9]+]], 144(1)
1970 ; ASM64PWR4-DAG:   stw [[REGF1]], 152(1)
1971 ; ASM64PWR4-DAG:   std [[REGD]], 160(1)
1972 ; ASM64PWR4-DAG:   stw [[REGF2]], 168(1)
1973 ; ASM64PWR4-NEXT:  bl .test_fpr_stack
1974
1975 define i32 @mix_callee(double %d1, double %d2, double %d3, double %d4, i8 zeroext %c1, i16 signext %s1, i64 %ll1, i32 %i1, i32 %i2, i32 %i3) {
1976   entry:
1977     %add = fadd double %d1, %d2
1978     %add1 = fadd double %add, %d3
1979     %add2 = fadd double %add1, %d4
1980     %conv = zext i8 %c1 to i32
1981     %conv3 = sext i16 %s1 to i32
1982     %add4 = add nsw i32 %conv, %conv3
1983     %conv5 = sext i32 %add4 to i64
1984     %add6 = add nsw i64 %conv5, %ll1
1985     %conv7 = sext i32 %i1 to i64
1986     %add8 = add nsw i64 %add6, %conv7
1987     %conv9 = sext i32 %i2 to i64
1988     %add10 = add nsw i64 %add8, %conv9
1989     %conv11 = sext i32 %i3 to i64
1990     %add12 = add nsw i64 %add10, %conv11
1991     %conv13 = trunc i64 %add12 to i32
1992     %conv14 = sitofp i32 %conv13 to double
1993     %add15 = fadd double %conv14, %add2
1994     %conv16 = fptosi double %add15 to i32
1995     ret i32 %conv16
1996   }
1997
1998 ; CHECK-LABEL: mix_callee
1999
2000 ; 32BIT-LABEL: liveins:
2001 ; 32BIT-DAG:   - { reg: '$f1', virtual-reg: '' }
2002 ; 32BIT-DAG:   - { reg: '$f2', virtual-reg: '' }
2003 ; 32BIT-DAG:   - { reg: '$f3', virtual-reg: '' }
2004 ; 32BIT-DAG:   - { reg: '$f4', virtual-reg: '' }
2005
2006 ; 32BIT-LABEL: fixedStack:
2007 ; 32BIT-DAG:   - { id: 6, type: default, offset: 56, size: 4
2008 ; 32BIT-DAG:   - { id: 5, type: default, offset: 60, size: 4
2009 ; 32BIT-DAG:   - { id: 4, type: default, offset: 64, size: 4
2010 ; 32BIT-DAG:   - { id: 3, type: default, offset: 68, size: 4
2011 ; 32BIT-DAG:   - { id: 2, type: default, offset: 72, size: 4
2012 ; 32BIT-DAG:   - { id: 1, type: default, offset: 76, size: 4
2013 ; 32BIT-DAG:   - { id: 0, type: default, offset: 80, size: 4
2014
2015 ; 32BIT-LABEL: body:             |
2016 ; 32BIT-DAG:     bb.0.entry:
2017 ; 32BIT-DAG:     liveins: $f1, $f2, $f3, $f4
2018
2019 ; 64BIT-LABEL:  liveins:
2020 ; 64BIT-DAG:    - { reg: '$f1', virtual-reg: '' }
2021 ; 64BIT-DAG:    - { reg: '$f2', virtual-reg: '' }
2022 ; 64BIT-DAG:    - { reg: '$f3', virtual-reg: '' }
2023 ; 64BIT-DAG:    - { reg: '$f4', virtual-reg: '' }
2024 ; 64BIT-DAG:    - { reg: '$x7', virtual-reg: '' }
2025 ; 64BIT-DAG:    - { reg: '$x8', virtual-reg: '' }
2026 ; 64BIT-DAG:    - { reg: '$x9', virtual-reg: '' }
2027 ; 64BIT-DAG:    - { reg: '$x10', virtual-reg: '' }
2028
2029 ; 64BIT-LABEL: fixedStack:
2030 ; 64BIT-DAG:   - { id: 1, type: default, offset: 116, size: 4
2031 ; 64BIT-DAG:   - { id: 0, type: default, offset: 124, size: 4
2032
2033 ; 64BIT-LABEL: body:             |
2034 ; 64BIT-DAG:    bb.0.entry:
2035 ; 64BIT-DAG:     liveins: $f1, $f2, $f3, $f4, $x7, $x8, $x9, $x10
2036
2037 ; CHECKASM-LABEL:   .mix_callee
2038
2039 ; ASM32PWR4-DAG:   lwz [[REG1:[0-9]+]], 56(1)
2040 ; ASM32PWR4-DAG:   lwz [[REG2:[0-9]+]], 60(1)
2041 ; ASM32PWR4-DAG:   lwz [[REG4:[0-9]+]], 68(1)
2042 ; ASM32PWR4-DAG:   lwz [[REG5:[0-9]+]], 72(1)
2043 ; ASM32PWR4-DAG:   lwz [[REG6:[0-9]+]], 76(1)
2044 ; ASM32PWR4-DAG:   lwz [[REG7:[0-9]+]], 80(1)
2045 ; ASM32PWR4-DAG:   blr
2046
2047 ; ASM64PWR-DAG:    ld [[REG1:[0-9]+]], 112(1)
2048 ; ASM64PWR-DAG:    ld [[REG2:[0-9]+]], 120(1)
2049 ; ASM64PWR-DAG:    fadd 0, 0, [[REG1]]
2050 ; ASM64PWR-DAG:    add 3, 3, [[REG2]]
2051 ; ASM64PWR-DAG:    blr
2052
2053 define void @caller_mix() {
2054   entry:
2055 %call = call i32 @mix_callee(double 1.000000e-01, double 2.000000e-01, double 3.000000e-01, double 4.000000e-01, i8 zeroext 1, i16 signext 2, i64 30000000, i32 40, i32 50, i32 60)
2056     ret void
2057   }
2058
2059 ; CHECK-LABEL: name: caller_mix
2060
2061 ; 32BIT-DAG:   ADJCALLSTACKDOWN 84, 0, implicit-def dead $r1, implicit $r1
2062 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.0, $r2 :: (load (s32) from got)
2063 ; 32BIT-DAG:   renamable $f1 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2064 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.1, $r2 :: (load (s32) from got)
2065 ; 32BIT-DAG:   renamable $f2 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2066 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.2, $r2 :: (load (s32) from got)
2067 ; 32BIT-DAG:   renamable $f3 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2068 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LWZtoc %const.3, $r2 :: (load (s32) from got)
2069 ; 32BIT-DAG:   renamable $f4 = LFD 0, killed renamable $r[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2070 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LI 1
2071 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LI 2
2072 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LIS 457
2073 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LI 0
2074 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LI 40
2075 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LI 50
2076 ; 32BIT-DAG:   renamable $r[[SCRATCHREG:[0-9]+]] = LI 60
2077 ; 32BIT-DAG:   STW killed renamable $r[[REG1:[0-9]+]], 56, $r1 :: (store (s32))
2078 ; 32BIT-DAG:   STW killed renamable $r[[REG2:[0-9]+]], 60, $r1 :: (store (s32))
2079 ; 32BIT-DAG:   STW killed renamable $r[[REG3:[0-9]+]], 64, $r1 :: (store (s32))
2080 ; 32BIT-DAG:   STW killed renamable $r[[REG4:[0-9]+]], 68, $r1 :: (store (s32))
2081 ; 32BIT-DAG:   STW killed renamable $r[[REG5:[0-9]+]], 72, $r1 :: (store (s32))
2082 ; 32BIT-DAG:   STW killed renamable $r[[REG6:[0-9]+]], 76, $r1 :: (store (s32))
2083 ; 32BIT-DAG:   STW killed renamable $r[[REG7:[0-9]+]], 80, $r1 :: (store (s32))
2084 ; 32BIT-DAG:   BL_NOP <mcsymbol .mix_callee>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit $f2, implicit $f3, implicit $f4, implicit $r2, implicit-def $r1, implicit-def dead $r3
2085 ; 32BIT-DAG:   ADJCALLSTACKUP 84, 0, implicit-def dead $r1, implicit $r1
2086 ; 32BIT-NEXT:  BLR implicit $lr, implicit $rm
2087
2088 ; 64BIT-DAG:   ADJCALLSTACKDOWN 128, 0, implicit-def dead $r1, implicit $r1
2089 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.0, $x2 :: (load (s64) from got)
2090 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.1, $x2 :: (load (s64) from got)
2091 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.2, $x2 :: (load (s64) from got)
2092 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LDtocCPT %const.3, $x2 :: (load (s64) from got)
2093 ; 64BIT-DAG:   renamable $f1 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2094 ; 64BIT-DAG:   renamable $f2 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2095 ; 64BIT-DAG:   renamable $f3 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2096 ; 64BIT-DAG:   renamable $f4 = LFD 0, killed renamable $x[[SCRATCHREG:[0-9]+]] :: (load (s64) from constant-pool)
2097 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LI8 50
2098 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LI8 60
2099 ; 64BIT-DAG:   renamable $x[[SCRATCHREG:[0-9]+]] = LIS8 457
2100 ; 64BIT-DAG:   $x7 = LI8 1
2101 ; 64BIT-DAG:   $x8 = LI8 2
2102 ; 64BIT-DAG:   $x10 = LI8 40
2103 ; 64BIT-DAG:   STD killed renamable $x[[REG1:[0-9]+]], 112, $x1 :: (store (s64))
2104 ; 64BIT-DAG:   STD killed renamable $x[[REG2:[0-9]+]], 120, $x1 :: (store (s64))
2105 ; 64BIT:       ADJCALLSTACKUP 128, 0, implicit-def dead $r1, implicit $r1
2106 ; 64BIT-NEXT:  BLR8 implicit $lr8, implicit $rm
2107
2108 ; CHEKASM-LABEL:   .caller_mix
2109
2110 ; ASM32PWR4:        mflr 0
2111 ; ASM32PWR4-DAG:    stw [[REG1:[0-9]+]], 56(1)
2112 ; ASM32PWR4-DAG:    stw [[REG2:[0-9]+]], 60(1)
2113 ; ASM32PWR4-DAG:    stw [[REG3:[0-9]+]], 64(1)
2114 ; ASM32PWR4-DAG:    stw [[REG4:[0-9]+]], 68(1)
2115 ; ASM32PWR4-DAG:    stw [[REG5:[0-9]+]], 72(1)
2116 ; ASM32PWR4-DAG:    stw [[REG6:[0-9]+]], 76(1)
2117 ; ASM32PWR4-DAG:    stw [[REG7:[0-9]+]], 80(1)
2118 ; ASM32PWR4-DAG:    bl .mix_callee
2119 ; ASM32PWR4-DAG:    blr
2120
2121 ; ASM64PWR4:        mflr 0
2122 ; ASM64PWR4-DAG:    std [[REG1:[0-9]+]], 112(1)
2123 ; ASM64PWR4-DAG:    std [[REG2:[0-9]+]], 120(1)
2124 ; ASM64PWR4-DAG:    bl .mix_callee
2125 ; ASM64PWR4-DAG:    blr
2126
2127
2128   define i32 @mix_floats(i32 %i1, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6, i32 %i7, i32 %i8, double %d1, double %d2, double %d3, double %d4, double %d5, double %d6, double %d7, double %d8, double %d9, double %d10, double %d11, double %d12, double %d13, double %d14) {
2129   entry:
2130     %add = add nsw i32 %i1, %i2
2131     %add1 = add nsw i32 %add, %i3
2132     %add2 = add nsw i32 %add1, %i4
2133     %add3 = add nsw i32 %add2, %i5
2134     %add4 = add nsw i32 %add3, %i6
2135     %add5 = add nsw i32 %add4, %i7
2136     %add6 = add nsw i32 %add5, %i8
2137     %conv = sitofp i32 %add6 to double
2138     %add7 = fadd double %conv, %d1
2139     %add8 = fadd double %add7, %d2
2140     %add9 = fadd double %add8, %d3
2141     %add10 = fadd double %add9, %d4
2142     %add11 = fadd double %add10, %d5
2143     %add12 = fadd double %add11, %d6
2144     %add13 = fadd double %add12, %d7
2145     %add14 = fadd double %add13, %d8
2146     %add15 = fadd double %add14, %d9
2147     %add16 = fadd double %add15, %d10
2148     %add17 = fadd double %add16, %d11
2149     %add18 = fadd double %add17, %d12
2150     %add19 = fadd double %add18, %d13
2151     %add20 = fadd double %add19, %d14
2152     %conv21 = fptosi double %add20 to i32
2153     ret i32 %conv21
2154   }
2155
2156 ; CHECK-LABEL:   mix_floats
2157
2158 ; 32BIT-LABEL:  liveins:
2159 ; 32BIT-DAG:   - { reg: '$r3', virtual-reg: '' }
2160 ; 32BIT-DAG:   - { reg: '$r4', virtual-reg: '' }
2161 ; 32BIT-DAG:   - { reg: '$r5', virtual-reg: '' }
2162 ; 32BIT-DAG:   - { reg: '$r6', virtual-reg: '' }
2163 ; 32BIT-DAG:   - { reg: '$r7', virtual-reg: '' }
2164 ; 32BIT-DAG:   - { reg: '$r8', virtual-reg: '' }
2165 ; 32BIT-DAG:   - { reg: '$r9', virtual-reg: '' }
2166 ; 32BIT-DAG:   - { reg: '$r10', virtual-reg: '' }
2167 ; 32BIT-DAG:   - { reg: '$f1', virtual-reg: '' }
2168 ; 32BIT-DAG:   - { reg: '$f2', virtual-reg: '' }
2169 ; 32BIT-DAG:   - { reg: '$f3', virtual-reg: '' }
2170 ; 32BIT-DAG:   - { reg: '$f4', virtual-reg: '' }
2171 ; 32BIT-DAG:   - { reg: '$f5', virtual-reg: '' }
2172 ; 32BIT-DAG:   - { reg: '$f6', virtual-reg: '' }
2173 ; 32BIT-DAG:   - { reg: '$f7', virtual-reg: '' }
2174 ; 32BIT-DAG:   - { reg: '$f8', virtual-reg: '' }
2175 ; 32BIT-DAG:   - { reg: '$f9', virtual-reg: '' }
2176 ; 32BIT-DAG:   - { reg: '$f10', virtual-reg: '' }
2177 ; 32BIT-DAG:   - { reg: '$f11', virtual-reg: '' }
2178 ; 32BIT-DAG:   - { reg: '$f12', virtual-reg: '' }
2179 ; 32BIT-DAG:   - { reg: '$f13', virtual-reg: '' }
2180
2181 ; 32BIT-LABEL: fixedStack:
2182 ; 32BIT-DAG:   - { id: 0, type: default, offset: 160, size: 8
2183
2184 ; 32BIT-LABEL: body:             |
2185 ; 32BIT-DAG:     bb.0.entry:
2186 ; 32BIT-DAG:       liveins: $f1, $f2, $f3, $f4, $f5, $f6, $f7, $f8, $f9, $f10, $f11, $f12, $f13, $r3, $r4, $r5, $r6, $r7, $r8, $r9, $r10
2187
2188 ; 64BIT-DAG:   liveins:
2189 ; 64BIT-DAG:   - { reg: '$x3', virtual-reg: '' }
2190 ; 64BIT-DAG:   - { reg: '$x4', virtual-reg: '' }
2191 ; 64BIT-DAG:   - { reg: '$x5', virtual-reg: '' }
2192 ; 64BIT-DAG:   - { reg: '$x6', virtual-reg: '' }
2193 ; 64BIT-DAG:   - { reg: '$x7', virtual-reg: '' }
2194 ; 64BIT-DAG:   - { reg: '$x8', virtual-reg: '' }
2195 ; 64BIT-DAG:   - { reg: '$x9', virtual-reg: '' }
2196 ; 64BIT-DAG:   - { reg: '$x10', virtual-reg: '' }
2197 ; 64BIT-DAG:   - { reg: '$f1', virtual-reg: '' }
2198 ; 64BIT-DAG:   - { reg: '$f2', virtual-reg: '' }
2199 ; 64BIT-DAG:   - { reg: '$f3', virtual-reg: '' }
2200 ; 64BIT-DAG:   - { reg: '$f4', virtual-reg: '' }
2201 ; 64BIT-DAG:   - { reg: '$f5', virtual-reg: '' }
2202 ; 64BIT-DAG:   - { reg: '$f6', virtual-reg: '' }
2203 ; 64BIT-DAG:   - { reg: '$f7', virtual-reg: '' }
2204 ; 64BIT-DAG:   - { reg: '$f8', virtual-reg: '' }
2205 ; 64BIT-DAG:   - { reg: '$f9', virtual-reg: '' }
2206 ; 64BIT-DAG:   - { reg: '$f10', virtual-reg: '' }
2207 ; 64BIT-DAG:   - { reg: '$f11', virtual-reg: '' }
2208 ; 64BIT-DAG:   - { reg: '$f12', virtual-reg: '' }
2209 ; 64BIT-DAG:   - { reg: '$f13', virtual-reg: '' }
2210
2211 ; 64BIT-LABEL: fixedStack:
2212 ; 64BIT-DAG:   - { id: 0, type: default, offset: 216, size: 8
2213
2214 ; 64BIT-LABEL: body:             |
2215 ; 64BIT-DAG:     bb.0.entry:
2216 ; 64BIT-DAG:       liveins: $f1, $f2, $f3, $f4, $f5, $f6, $f7, $f8, $f9, $f10, $f11, $f12, $f13, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10
2217
2218 ; CHECKASM-LABEL: .mix_floats:
2219
2220 ; ASM32PWR4-DAG:   lfd [[REGF:[0-9]+]], 160(1)
2221 ; ASM32PWR4-DAG:   fadd 0, 0, [[REGF]]
2222 ; ASM32PWR4-DAG:   blr
2223
2224 ; ASM64PWR4-DAG:   lfd [[REG1:[0-9]+]], 216(1)
2225 ; ASM64PWR4-DAG:   fadd 0, 0, [[REG1]]
2226 ; ASM64PWR4-DAG:   blr
2227
2228   define void @mix_floats_caller() {
2229   entry:
2230     %call = call i32 @mix_floats(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, double 1.000000e-01, double 2.000000e-01, double 3.000000e-01, double 4.000000e-01, double 5.000000e-01, double 6.000000e-01, double 0x3FE6666666666666, double 8.000000e-01, double 9.000000e-01, double 1.000000e+00, double 1.100000e+00, double 1.200000e+00, double 1.300000e+00, double 1.400000e+00)
2231     ret void
2232   }
2233
2234 ; CHECK-LABEL: mix_floats_caller
2235
2236 ; 32BIT-DAG:   ADJCALLSTACKDOWN 168, 0, implicit-def dead $r1, implicit $r1
2237 ; 32BIT-DAG:   $r3 = LI 1
2238 ; 32BIT-DAG:   $r4 = LI 2
2239 ; 32BIT-DAG:   $r5 = LI 3
2240 ; 32BIT-DAG:   $r6 = LI 4
2241 ; 32BIT-DAG:   $r7 = LI 5
2242 ; 32BIT-DAG:   $r8 = LI 6
2243 ; 32BIT-DAG:   $r9 = LI 7
2244 ; 32BIT-DAG:   $r10 = LI 8
2245 ; 32BIT-DAG:   STW killed renamable $r[[REG1:[0-9]+]], 56, $r1 :: (store (s32), align 8)
2246 ; 32BIT-DAG:   STW renamable $r[[REG2:[0-9]+]], 60, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2247 ; 32BIT-DAG:   STW killed renamable $r[[REG3:[0-9]+]], 64, $r1 :: (store (s32), align 8)
2248 ; 32BIT-DAG:   STW renamable $r[[REG4:[0-9]+]], 68, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2249 ; 32BIT-DAG:   STW killed renamable $r[[REG5:[0-9]+]], 72, $r1 :: (store (s32), align 8)
2250 ; 32BIT-DAG:   STW renamable $r[[REG6:[0-9]+]], 76, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2251 ; 32BIT-DAG:   STW killed renamable $r[[REG7:[0-9]+]], 80, $r1 :: (store (s32), align 8)
2252 ; 32BIT-DAG:   STW renamable $r[[REG8:[0-9]+]], 84, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2253 ; 32BIT-DAG:   STW killed renamable $r[[REG9:[0-9]+]], 88, $r1 :: (store (s32), align 8)
2254 ; 32BIT-DAG:   STW renamable $r[[REG10:[0-9]+]], 92, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2255 ; 32BIT-DAG:   STW killed renamable $r[[REG11:[0-9]+]], 96, $r1 :: (store (s32), align 8)
2256 ; 32BIT-DAG:   STW renamable $r[[REG12:[0-9]+]], 100, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2257 ; 32BIT-DAG:   STW killed renamable $r[[REG13:[0-9]+]], 104, $r1 :: (store (s32), align 8)
2258 ; 32BIT-DAG:   STW renamable $r[[REG14:[0-9]+]], 108, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2259 ; 32BIT-DAG:   STW killed renamable $r[[REG15:[0-9]+]], 112, $r1 :: (store (s32), align 8)
2260 ; 32BIT-DAG:   STW renamable $r[[REG16:[0-9]+]], 116, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2261 ; 32BIT-DAG:   STW killed renamable $r[[REG17:[0-9]+]], 120, $r1 :: (store (s32), align 8)
2262 ; 32BIT-DAG:   STW killed renamable $r[[REG18:[0-9]+]], 128, $r1 :: (store (s32), align 8)
2263 ; 32BIT-DAG:   STW renamable $r[[REG19:[0-9]+]], 124, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2264 ; 32BIT-DAG:   STW killed renamable $r[[REG20:[0-9]+]], 132, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2265 ; 32BIT-DAG:   STW killed renamable $r[[REG21:[0-9]+]], 136, $r1 :: (store (s32), align 8)
2266 ; 32BIT-DAG:   STW killed renamable $r[[REG22:[0-9]+]], 140, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2267 ; 32BIT-DAG:   STW killed renamable $r[[REG23:[0-9]+]], 144, $r1 :: (store (s32), align 8)
2268 ; 32BIT-DAG:   STW killed renamable $r[[REG24:[0-9]+]], 148, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2269 ; 32BIT-DAG:   STW killed renamable $r[[REG25:[0-9]+]], 152, $r1 :: (store (s32), align 8)
2270 ; 32BIT-DAG:   STW killed renamable $r[[REG26:[0-9]+]], 156, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2271 ; 32BIT-DAG:   STW killed renamable $r[[REG27:[0-9]+]], 160, $r1 :: (store (s32), align 8)
2272 ; 32BIT-DAG:   STW killed renamable $r[[REG28:[0-9]+]], 164, $r1 :: (store (s32) into unknown-address + 4, basealign 8)
2273 ; 32BIT-NEXT:  BL_NOP <mcsymbol .mix_floats>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r4, implicit $r5, implicit $r6, implicit $r7, implicit $r8, implicit $r9, implicit $r10, implicit $f1, implicit $f2, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit $f10, implicit $f11, implicit $f12, implicit $f13, implicit $r2, implicit-def $r1, implicit-def dead $r3
2274 ; 32BIT-NEXT:   ADJCALLSTACKUP 168, 0, implicit-def dead $r1, implicit $r1
2275
2276
2277 ; 64BIT-DAG:   ADJCALLSTACKDOWN 224, 0, implicit-def dead $r1, implicit $r1
2278 ; 64BIT-DAG:   $x3 = LI8 1
2279 ; 64BIT-DAG:   $x4 = LI8 2
2280 ; 64BIT-DAG:   $x5 = LI8 3
2281 ; 64BIT-DAG:   $x6 = LI8 4
2282 ; 64BIT-DAG:   $x7 = LI8 5
2283 ; 64BIT-DAG:   $x8 = LI8 6
2284 ; 64BIT-DAG:   $x9 = LI8 7
2285 ; 64BIT-DAG:   $x10 = LI8 8
2286 ; 64BIT-DAG:   STD killed renamable $x[[REG1:[0-9]+]], 112, $x1 :: (store (s64))
2287 ; 64BIT-DAG:   STD killed renamable $x[[REG2:[0-9]+]], 120, $x1 :: (store (s64))
2288 ; 64BIT-DAG:   STD killed renamable $x[[REG3:[0-9]+]], 128, $x1 :: (store (s64))
2289 ; 64BIT-DAG:   STD killed renamable $x[[REG4:[0-9]+]], 136, $x1 :: (store (s64))
2290 ; 64BIT-DAG:   STD killed renamable $x[[REG5:[0-9]+]], 144, $x1 :: (store (s64))
2291 ; 64BIT-DAG:   STD killed renamable $x[[REG6:[0-9]+]], 152, $x1 :: (store (s64))
2292 ; 64BIT-DAG:   STD killed renamable $x[[REG7:[0-9]+]], 160, $x1 :: (store (s64))
2293 ; 64BIT-DAG:   STD killed renamable $x[[REG8:[0-9]+]], 168, $x1 :: (store (s64))
2294 ; 64BIT-DAG:   STD killed renamable $x[[REG9:[0-9]+]], 176, $x1 :: (store (s64))
2295 ; 64BIT-DAG:   STD killed renamable $x[[REG10:[0-9]+]], 184, $x1 :: (store (s64))
2296 ; 64BIT-DAG:   STD killed renamable $x[[REG12:[0-9]+]], 192, $x1 :: (store (s64))
2297 ; 64BIT-DAG:   STD killed renamable $x[[REG13:[0-9]+]], 200, $x1 :: (store (s64))
2298 ; 64BIT-DAG:   STD killed renamable $x[[REG14:[0-9]+]], 208, $x1 :: (store (s64))
2299 ; 64BIT-DAG:   STD killed renamable $x[[REG15:[0-9]+]], 216, $x1 :: (store (s64))
2300 ; 64BIT-DAG:   BL8_NOP <mcsymbol .mix_floats>, csr_ppc64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x4, implicit $x5, implicit $x6, implicit $x7, implicit $x8, implicit $x9, implicit $x10, implicit $f1, implicit $f2, implicit $f3, implicit $f4, implicit $f5, implicit $f6, implicit $f7, implicit $f8, implicit $f9, implicit $f10, implicit $f11, implicit $f12, implicit $f13, implicit $x2, implicit-def $r1, implicit-def dead $x3
2301 ; 64BIT-NEXT:  ADJCALLSTACKUP 224, 0, implicit-def dead $r1, implicit $r1
2302
2303 ; CHEKASM-LABEL:    .mix_floats_caller:
2304
2305 ; ASM32PWR4:       mflr 0
2306 ; ASM32PWR4-DAG:   stw 0, 8(1)
2307 ; ASM32PWR4-DAG:   stwu 1, -176(1)
2308 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 56(1)
2309 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 60(1)
2310 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 64(1)
2311 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 68(1)
2312 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 72(1)
2313 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 76(1)
2314 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 80(1)
2315 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 84(1)
2316 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 88(1)
2317 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 92(1)
2318 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 96(1)
2319 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 100(1)
2320 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 104(1)
2321 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 108(1)
2322 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 112(1)
2323 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 116(1)
2324 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 120(1)
2325 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 124(1)
2326 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 128(1)
2327 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 132(1)
2328 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 136(1)
2329 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 140(1)
2330 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 144(1)
2331 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 148(1)
2332 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 152(1)
2333 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 156(1)
2334 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 160(1)
2335 ; ASM32PWR4-DAG:   stw [[REG:[0-9]+]], 164(1)
2336 ; ASM32PWR4:       bl .mix_floats
2337
2338 ; ASM64PWR4:      mflr 0
2339 ; ASM64PWR4-DAG:  std 0, 16(1)
2340 ; ASM64PWR4-DAG:  stdu 1, -240(1)
2341 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 112(1)
2342 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 120(1)
2343 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 128(1)
2344 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 136(1)
2345 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 144(1)
2346 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 152(1)
2347 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 160(1)
2348 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 168(1)
2349 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 176(1)
2350 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 184(1)
2351 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 192(1)
2352 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 200(1)
2353 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 208(1)
2354 ; ASM64PWR4-DAG:  std [[REG:[0-9]+]], 216(1)
2355 ; ASM64PWR4:      bl .mix_floats