llvm/test/CodeGen/AArch64/aarch64-fix-cortex-a53-835769.ll

   1 ; REQUIRES: asserts
   2 ; The regression tests need to test for order of emitted instructions, and
   3 ; therefore, the tests are a bit fragile/reliant on instruction scheduling. The
   4 ; test cases have been minimized as much as possible, but still most of the test
   5 ; cases could break if instruction scheduling heuristics for cortex-a53 change
   6 ; RUN: llc < %s -mcpu=cortex-a53 -mattr=+fix-cortex-a53-835769 -frame-pointer=non-leaf -stats 2>&1 \
   7 ; RUN:  | FileCheck %s
   8 ; RUN: llc < %s -mcpu=cortex-a53 -mattr=-fix-cortex-a53-835769 -frame-pointer=non-leaf -stats 2>&1 \
   9 ; RUN:  | FileCheck %s --check-prefix CHECK-NOWORKAROUND
  10 ; The following run lines are just to verify whether or not this pass runs by
  11 ; default for given CPUs. Given the fragility of the tests, this is only run on
  12 ; a test case where the scheduler has not freedom at all to reschedule the
  13 ; instructions, so the potentially massively different scheduling heuristics
  14 ; will not break the test case.
  15 ; RUN: llc < %s -mcpu=generic    -frame-pointer=non-leaf | FileCheck %s --check-prefix CHECK-BASIC-PASS-DISABLED
  16 ; RUN: llc < %s -mcpu=cortex-a53 -frame-pointer=non-leaf | FileCheck %s --check-prefix CHECK-BASIC-PASS-DISABLED
  17 ; RUN: llc < %s -mcpu=cortex-a57 -frame-pointer=non-leaf | FileCheck %s --check-prefix CHECK-BASIC-PASS-DISABLED
  18 ; RUN: llc < %s -mcpu=cyclone    -frame-pointer=non-leaf | FileCheck %s --check-prefix CHECK-BASIC-PASS-DISABLED
  19
  20 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
  21 target triple = "aarch64--linux-gnu"
  22
  23 define i64 @f_load_madd_64(i64 %a, i64 %b, ptr nocapture readonly %c) #0 {
  24 entry:
  25   %0 = load i64, ptr %c, align 8
  26   %mul = mul nsw i64 %0, %b
  27   %add = add nsw i64 %mul, %a
  28   ret i64 %add
  29 }
  30 ; CHECK-LABEL: f_load_madd_64:
  31 ; CHECK:        ldr
  32 ; CHECK-NEXT:   nop
  33 ; CHECK-NEXT:   madd
  34 ; CHECK-NOWORKAROUND-LABEL: f_load_madd_64:
  35 ; CHECK-NOWORKAROUND:   ldr
  36 ; CHECK-NOWORKAROUND-NEXT:      madd
  37 ; CHECK-BASIC-PASS-DISABLED-LABEL: f_load_madd_64:
  38 ; CHECK-BASIC-PASS-DISABLED:  ldr
  39 ; CHECK-BASIC-PASS-DISABLED-NEXT:  madd
  40
  41
  42 define i32 @f_load_madd_32(i32 %a, i32 %b, ptr nocapture readonly %c) #0 {
  43 entry:
  44   %0 = load i32, ptr %c, align 4
  45   %mul = mul nsw i32 %0, %b
  46   %add = add nsw i32 %mul, %a
  47   ret i32 %add
  48 }
  49 ; CHECK-LABEL: f_load_madd_32:
  50 ; CHECK:        ldr
  51 ; CHECK-NEXT:   madd
  52 ; CHECK-NOWORKAROUND-LABEL: f_load_madd_32:
  53 ; CHECK-NOWORKAROUND:   ldr
  54 ; CHECK-NOWORKAROUND-NEXT:      madd
  55
  56
  57 define i64 @f_load_msub_64(i64 %a, i64 %b, ptr nocapture readonly %c) #0 {
  58 entry:
  59   %0 = load i64, ptr %c, align 8
  60   %mul = mul nsw i64 %0, %b
  61   %sub = sub nsw i64 %a, %mul
  62   ret i64 %sub
  63 }
  64 ; CHECK-LABEL: f_load_msub_64:
  65 ; CHECK:        ldr
  66 ; CHECK-NEXT:   nop
  67 ; CHECK-NEXT:   msub
  68 ; CHECK-NOWORKAROUND-LABEL: f_load_msub_64:
  69 ; CHECK-NOWORKAROUND:   ldr
  70 ; CHECK-NOWORKAROUND-NEXT:      msub
  71
  72
  73 define i32 @f_load_msub_32(i32 %a, i32 %b, ptr nocapture readonly %c) #0 {
  74 entry:
  75   %0 = load i32, ptr %c, align 4
  76   %mul = mul nsw i32 %0, %b
  77   %sub = sub nsw i32 %a, %mul
  78   ret i32 %sub
  79 }
  80 ; CHECK-LABEL: f_load_msub_32:
  81 ; CHECK:        ldr
  82 ; CHECK-NEXT:   msub
  83 ; CHECK-NOWORKAROUND-LABEL: f_load_msub_32:
  84 ; CHECK-NOWORKAROUND:   ldr
  85 ; CHECK-NOWORKAROUND-NEXT:      msub
  86
  87
  88 define i64 @f_load_mul_64(i64 %a, i64 %b, ptr nocapture readonly %c) #0 {
  89 entry:
  90   %0 = load i64, ptr %c, align 8
  91   %mul = mul nsw i64 %0, %b
  92   ret i64 %mul
  93 }
  94 ; CHECK-LABEL: f_load_mul_64:
  95 ; CHECK:        ldr
  96 ; CHECK-NEXT:   mul
  97 ; CHECK-NOWORKAROUND-LABEL: f_load_mul_64:
  98 ; CHECK-NOWORKAROUND:   ldr
  99 ; CHECK-NOWORKAROUND-NEXT:      mul
 100
 101
 102 define i32 @f_load_mul_32(i32 %a, i32 %b, ptr nocapture readonly %c) #0 {
 103 entry:
 104   %0 = load i32, ptr %c, align 4
 105   %mul = mul nsw i32 %0, %b
 106   ret i32 %mul
 107 }
 108 ; CHECK-LABEL: f_load_mul_32:
 109 ; CHECK:        ldr
 110 ; CHECK-NEXT:   mul
 111 ; CHECK-NOWORKAROUND-LABEL: f_load_mul_32:
 112 ; CHECK-NOWORKAROUND:   ldr
 113 ; CHECK-NOWORKAROUND-NEXT:      mul
 114
 115
 116 define i64 @f_load_mneg_64(i64 %a, i64 %b, ptr nocapture readonly %c) #0 {
 117 entry:
 118   %0 = load i64, ptr %c, align 8
 119   %mul = sub i64 0, %b
 120   %sub = mul i64 %0, %mul
 121   ret i64 %sub
 122 }
 123 ; CHECK-LABEL: f_load_mneg_64:
 124 ; CHECK-NOWORKAROUND-LABEL: f_load_mneg_64:
 125 ; FIXME: only add further checks here once LLVM actually produces
 126 ;        neg instructions
 127 ; FIXME-CHECK: ldr
 128 ; FIXME-CHECK-NEXT: nop
 129 ; FIXME-CHECK-NEXT: mneg
 130 ; FIXME-CHECK-NOWORKAROUND: ldr
 131 ; FIXME-CHECK-NOWORKAROUND-NEXT: mneg
 132
 133
 134 define i32 @f_load_mneg_32(i32 %a, i32 %b, ptr nocapture readonly %c) #0 {
 135 entry:
 136   %0 = load i32, ptr %c, align 4
 137   %mul = sub i32 0, %b
 138   %sub = mul i32 %0, %mul
 139   ret i32 %sub
 140 }
 141 ; CHECK-LABEL: f_load_mneg_32:
 142 ; CHECK-NOWORKAROUND-LABEL: f_load_mneg_32:
 143 ; FIXME: only add further checks here once LLVM actually produces
 144 ;        neg instructions
 145 ; FIXME-CHECK: ldr
 146 ; FIXME-CHECK-NEXT: mneg
 147 ; FIXME-CHECK-NOWORKAROUND: ldr
 148 ; FIXME-CHECK-NOWORKAROUND-NEXT: mneg
 149
 150
 151 define i64 @f_load_smaddl(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 152 entry:
 153   %conv = sext i32 %b to i64
 154   %conv1 = sext i32 %c to i64
 155   %mul = mul nsw i64 %conv1, %conv
 156   %add = add nsw i64 %mul, %a
 157   %0 = load i32, ptr %d, align 4
 158   %conv2 = sext i32 %0 to i64
 159   %add3 = add nsw i64 %add, %conv2
 160   ret i64 %add3
 161 }
 162 ; CHECK-LABEL: f_load_smaddl:
 163 ; CHECK:        ldrsw
 164 ; CHECK-NEXT:   nop
 165 ; CHECK-NEXT:   smaddl
 166 ; CHECK-NOWORKAROUND-LABEL: f_load_smaddl:
 167 ; CHECK-NOWORKAROUND:   ldrsw
 168 ; CHECK-NOWORKAROUND-NEXT:      smaddl
 169
 170
 171 define i64 @f_load_smsubl_64(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 172 entry:
 173   %conv = sext i32 %b to i64
 174   %conv1 = sext i32 %c to i64
 175   %mul = mul nsw i64 %conv1, %conv
 176   %sub = sub i64 %a, %mul
 177   %0 = load i32, ptr %d, align 4
 178   %conv2 = sext i32 %0 to i64
 179   %add = add nsw i64 %sub, %conv2
 180   ret i64 %add
 181 }
 182 ; CHECK-LABEL: f_load_smsubl_64:
 183 ; CHECK:        ldrsw
 184 ; CHECK-NEXT:   nop
 185 ; CHECK-NEXT:   smsubl
 186 ; CHECK-NOWORKAROUND-LABEL: f_load_smsubl_64:
 187 ; CHECK-NOWORKAROUND:   ldrsw
 188 ; CHECK-NOWORKAROUND-NEXT:      smsubl
 189
 190
 191 define i64 @f_load_smull(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 192 entry:
 193   %conv = sext i32 %b to i64
 194   %conv1 = sext i32 %c to i64
 195   %mul = mul nsw i64 %conv1, %conv
 196   %0 = load i32, ptr %d, align 4
 197   %conv2 = sext i32 %0 to i64
 198   %div = sdiv i64 %mul, %conv2
 199   ret i64 %div
 200 }
 201 ; CHECK-LABEL: f_load_smull:
 202 ; CHECK:        ldrsw
 203 ; CHECK-NEXT:   smull
 204 ; CHECK-NOWORKAROUND-LABEL: f_load_smull:
 205 ; CHECK-NOWORKAROUND:   ldrsw
 206 ; CHECK-NOWORKAROUND-NEXT:      smull
 207
 208
 209 define i64 @f_load_smnegl_64(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 210 entry:
 211   %conv = sext i32 %b to i64
 212   %conv1 = sext i32 %c to i64
 213   %mul = sub nsw i64 0, %conv
 214   %sub = mul i64 %conv1, %mul
 215   %0 = load i32, ptr %d, align 4
 216   %conv2 = sext i32 %0 to i64
 217   %div = sdiv i64 %sub, %conv2
 218   ret i64 %div
 219 }
 220 ; CHECK-LABEL: f_load_smnegl_64:
 221 ; CHECK-NOWORKAROUND-LABEL: f_load_smnegl_64:
 222 ; FIXME: only add further checks here once LLVM actually produces
 223 ;        smnegl instructions
 224
 225
 226 define i64 @f_load_umaddl(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 227 entry:
 228   %conv = zext i32 %b to i64
 229   %conv1 = zext i32 %c to i64
 230   %mul = mul i64 %conv1, %conv
 231   %add = add i64 %mul, %a
 232   %0 = load i32, ptr %d, align 4
 233   %conv2 = zext i32 %0 to i64
 234   %add3 = add i64 %add, %conv2
 235   ret i64 %add3
 236 }
 237 ; CHECK-LABEL: f_load_umaddl:
 238 ; CHECK:        ldr
 239 ; CHECK-NEXT:   nop
 240 ; CHECK-NEXT:   umaddl
 241 ; CHECK-NOWORKAROUND-LABEL: f_load_umaddl:
 242 ; CHECK-NOWORKAROUND:   ldr
 243 ; CHECK-NOWORKAROUND-NEXT:      umaddl
 244
 245
 246 define i64 @f_load_umsubl_64(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 247 entry:
 248   %conv = zext i32 %b to i64
 249   %conv1 = zext i32 %c to i64
 250   %mul = mul i64 %conv1, %conv
 251   %sub = sub i64 %a, %mul
 252   %0 = load i32, ptr %d, align 4
 253   %conv2 = zext i32 %0 to i64
 254   %add = add i64 %sub, %conv2
 255   ret i64 %add
 256 }
 257 ; CHECK-LABEL: f_load_umsubl_64:
 258 ; CHECK:        ldr
 259 ; CHECK-NEXT:   nop
 260 ; CHECK-NEXT:   umsubl
 261 ; CHECK-NOWORKAROUND-LABEL: f_load_umsubl_64:
 262 ; CHECK-NOWORKAROUND:   ldr
 263 ; CHECK-NOWORKAROUND-NEXT:      umsubl
 264
 265
 266 define i64 @f_load_umull(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 267 entry:
 268   %conv = zext i32 %b to i64
 269   %conv1 = zext i32 %c to i64
 270   %mul = mul i64 %conv1, %conv
 271   %0 = load i32, ptr %d, align 4
 272   %conv2 = zext i32 %0 to i64
 273   %div = udiv i64 %mul, %conv2
 274   ret i64 %div
 275 }
 276 ; CHECK-LABEL: f_load_umull:
 277 ; CHECK:        ldr
 278 ; CHECK-NEXT:   umull
 279 ; CHECK-NOWORKAROUND-LABEL: f_load_umull:
 280 ; CHECK-NOWORKAROUND:   ldr
 281 ; CHECK-NOWORKAROUND-NEXT:      umull
 282
 283
 284 define i64 @f_load_umnegl_64(i64 %a, i32 %b, i32 %c, ptr nocapture readonly %d) #0 {
 285 entry:
 286   %conv = zext i32 %b to i64
 287   %conv1 = zext i32 %c to i64
 288   %mul = sub nsw i64 0, %conv
 289   %sub = mul i64 %conv1, %mul
 290   %0 = load i32, ptr %d, align 4
 291   %conv2 = zext i32 %0 to i64
 292   %div = udiv i64 %sub, %conv2
 293   ret i64 %div
 294 }
 295 ; CHECK-LABEL: f_load_umnegl_64:
 296 ; CHECK-NOWORKAROUND-LABEL: f_load_umnegl_64:
 297 ; FIXME: only add further checks here once LLVM actually produces
 298 ;        umnegl instructions
 299
 300
 301 define i64 @f_store_madd_64(i64 %a, i64 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 302 entry:
 303   %0 = load i64, ptr %cp, align 8
 304   store i64 %a, ptr %e, align 8
 305   %mul = mul nsw i64 %0, %b
 306   %add = add nsw i64 %mul, %a
 307   ret i64 %add
 308 }
 309 ; CHECK-LABEL: f_store_madd_64:
 310 ; CHECK:        str
 311 ; CHECK-NEXT:   nop
 312 ; CHECK-NEXT:   madd
 313 ; CHECK-NOWORKAROUND-LABEL: f_store_madd_64:
 314 ; CHECK-NOWORKAROUND:   str
 315 ; CHECK-NOWORKAROUND-NEXT:      madd
 316
 317
 318 define i32 @f_store_madd_32(i32 %a, i32 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 319 entry:
 320   %0 = load i32, ptr %cp, align 4
 321   store i32 %a, ptr %e, align 4
 322   %mul = mul nsw i32 %0, %b
 323   %add = add nsw i32 %mul, %a
 324   ret i32 %add
 325 }
 326 ; CHECK-LABEL: f_store_madd_32:
 327 ; CHECK:        str
 328 ; CHECK-NEXT:   madd
 329 ; CHECK-NOWORKAROUND-LABEL: f_store_madd_32:
 330 ; CHECK-NOWORKAROUND:   str
 331 ; CHECK-NOWORKAROUND-NEXT:      madd
 332
 333
 334 define i64 @f_store_msub_64(i64 %a, i64 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 335 entry:
 336   %0 = load i64, ptr %cp, align 8
 337   store i64 %a, ptr %e, align 8
 338   %mul = mul nsw i64 %0, %b
 339   %sub = sub nsw i64 %a, %mul
 340   ret i64 %sub
 341 }
 342 ; CHECK-LABEL: f_store_msub_64:
 343 ; CHECK:        str
 344 ; CHECK-NEXT:   nop
 345 ; CHECK-NEXT:   msub
 346 ; CHECK-NOWORKAROUND-LABEL: f_store_msub_64:
 347 ; CHECK-NOWORKAROUND:   str
 348 ; CHECK-NOWORKAROUND-NEXT:      msub
 349
 350
 351 define i32 @f_store_msub_32(i32 %a, i32 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 352 entry:
 353   %0 = load i32, ptr %cp, align 4
 354   store i32 %a, ptr %e, align 4
 355   %mul = mul nsw i32 %0, %b
 356   %sub = sub nsw i32 %a, %mul
 357   ret i32 %sub
 358 }
 359 ; CHECK-LABEL: f_store_msub_32:
 360 ; CHECK:        str
 361 ; CHECK-NEXT:   msub
 362 ; CHECK-NOWORKAROUND-LABEL: f_store_msub_32:
 363 ; CHECK-NOWORKAROUND:   str
 364 ; CHECK-NOWORKAROUND-NEXT:      msub
 365
 366
 367 define i64 @f_store_mul_64(i64 %a, i64 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 368 entry:
 369   %0 = load i64, ptr %cp, align 8
 370   store i64 %a, ptr %e, align 8
 371   %mul = mul nsw i64 %0, %b
 372   ret i64 %mul
 373 }
 374 ; CHECK-LABEL: f_store_mul_64:
 375 ; CHECK:        str
 376 ; CHECK-NEXT:   mul
 377 ; CHECK-NOWORKAROUND-LABEL: f_store_mul_64:
 378 ; CHECK-NOWORKAROUND:   str
 379 ; CHECK-NOWORKAROUND-NEXT:      mul
 380
 381
 382 define i32 @f_store_mul_32(i32 %a, i32 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 383 entry:
 384   %0 = load i32, ptr %cp, align 4
 385   store i32 %a, ptr %e, align 4
 386   %mul = mul nsw i32 %0, %b
 387   ret i32 %mul
 388 }
 389 ; CHECK-LABEL: f_store_mul_32:
 390 ; CHECK:        str
 391 ; CHECK-NEXT:   mul
 392 ; CHECK-NOWORKAROUND-LABEL: f_store_mul_32:
 393 ; CHECK-NOWORKAROUND:   str
 394 ; CHECK-NOWORKAROUND-NEXT:      mul
 395
 396
 397 define i64 @f_prefetch_madd_64(i64 %a, i64 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 398 entry:
 399   %0 = load i64, ptr %cp, align 8
 400   tail call void @llvm.prefetch(ptr %e, i32 0, i32 0, i32 1)
 401   %mul = mul nsw i64 %0, %b
 402   %add = add nsw i64 %mul, %a
 403   ret i64 %add
 404 }
 405 ; CHECK-LABEL: f_prefetch_madd_64:
 406 ; CHECK:        prfm
 407 ; CHECK-NEXT:   nop
 408 ; CHECK-NEXT:   madd
 409 ; CHECK-NOWORKAROUND-LABEL: f_prefetch_madd_64:
 410 ; CHECK-NOWORKAROUND:   prfm
 411 ; CHECK-NOWORKAROUND-NEXT:      madd
 412
 413 declare void @llvm.prefetch(ptr nocapture, i32, i32, i32) #2
 414
 415 define i32 @f_prefetch_madd_32(i32 %a, i32 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 416 entry:
 417   %0 = load i32, ptr %cp, align 4
 418   tail call void @llvm.prefetch(ptr %e, i32 1, i32 0, i32 1)
 419   %mul = mul nsw i32 %0, %b
 420   %add = add nsw i32 %mul, %a
 421   ret i32 %add
 422 }
 423 ; CHECK-LABEL: f_prefetch_madd_32:
 424 ; CHECK:        prfm
 425 ; CHECK-NEXT:   madd
 426 ; CHECK-NOWORKAROUND-LABEL: f_prefetch_madd_32:
 427 ; CHECK-NOWORKAROUND:   prfm
 428 ; CHECK-NOWORKAROUND-NEXT:      madd
 429
 430 define i64 @f_prefetch_msub_64(i64 %a, i64 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 431 entry:
 432   %0 = load i64, ptr %cp, align 8
 433   tail call void @llvm.prefetch(ptr %e, i32 0, i32 1, i32 1)
 434   %mul = mul nsw i64 %0, %b
 435   %sub = sub nsw i64 %a, %mul
 436   ret i64 %sub
 437 }
 438 ; CHECK-LABEL: f_prefetch_msub_64:
 439 ; CHECK:        prfm
 440 ; CHECK-NEXT:   nop
 441 ; CHECK-NEXT:   msub
 442 ; CHECK-NOWORKAROUND-LABEL: f_prefetch_msub_64:
 443 ; CHECK-NOWORKAROUND:   prfm
 444 ; CHECK-NOWORKAROUND-NEXT:      msub
 445
 446 define i32 @f_prefetch_msub_32(i32 %a, i32 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 447 entry:
 448   %0 = load i32, ptr %cp, align 4
 449   tail call void @llvm.prefetch(ptr %e, i32 1, i32 1, i32 1)
 450   %mul = mul nsw i32 %0, %b
 451   %sub = sub nsw i32 %a, %mul
 452   ret i32 %sub
 453 }
 454 ; CHECK-LABEL: f_prefetch_msub_32:
 455 ; CHECK:        prfm
 456 ; CHECK-NEXT:   msub
 457 ; CHECK-NOWORKAROUND-LABEL: f_prefetch_msub_32:
 458 ; CHECK-NOWORKAROUND:   prfm
 459 ; CHECK-NOWORKAROUND-NEXT:      msub
 460
 461 define i64 @f_prefetch_mul_64(i64 %a, i64 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 462 entry:
 463   %0 = load i64, ptr %cp, align 8
 464   tail call void @llvm.prefetch(ptr %e, i32 0, i32 3, i32 1)
 465   %mul = mul nsw i64 %0, %b
 466   ret i64 %mul
 467 }
 468 ; CHECK-LABEL: f_prefetch_mul_64:
 469 ; CHECK:        prfm
 470 ; CHECK-NEXT:   mul
 471 ; CHECK-NOWORKAROUND-LABEL: f_prefetch_mul_64:
 472 ; CHECK-NOWORKAROUND:   prfm
 473 ; CHECK-NOWORKAROUND-NEXT:      mul
 474
 475 define i32 @f_prefetch_mul_32(i32 %a, i32 %b, ptr nocapture readonly %cp, ptr nocapture %e) #1 {
 476 entry:
 477   %0 = load i32, ptr %cp, align 4
 478   tail call void @llvm.prefetch(ptr %e, i32 1, i32 3, i32 1)
 479   %mul = mul nsw i32 %0, %b
 480   ret i32 %mul
 481 }
 482 ; CHECK-LABEL: f_prefetch_mul_32:
 483 ; CHECK:        prfm
 484 ; CHECK-NEXT:   mul
 485 ; CHECK-NOWORKAROUND-LABEL: f_prefetch_mul_32:
 486 ; CHECK-NOWORKAROUND:   prfm
 487 ; CHECK-NOWORKAROUND-NEXT:      mul
 488
 489 define i64 @fall_through(i64 %a, i64 %b, ptr nocapture readonly %c) #0 {
 490 entry:
 491   %0 = load i64, ptr %c, align 8
 492   br label %block1
 493
 494 block1:
 495   %mul = mul nsw i64 %0, %b
 496   %add = add nsw i64 %mul, %a
 497   %tmp = ptrtoint ptr blockaddress(@fall_through, %block1) to i64
 498   %ret = add nsw i64 %tmp, %add
 499   ret i64 %ret
 500 }
 501 ; CHECK-LABEL:  fall_through
 502 ; CHECK:        ldr
 503 ; CHECK-NEXT:   nop
 504 ; CHECK-NEXT:   .Ltmp
 505 ; CHECK-NEXT:   %bb.
 506 ; CHECK-NEXT:   madd
 507 ; CHECK-NOWORKAROUND-LABEL:     fall_through
 508 ; CHECK-NOWORKAROUND:   ldr
 509 ; CHECK-NOWORKAROUND-NEXT:      .Ltmp
 510 ; CHECK-NOWORKAROUND-NEXT:      %bb.
 511 ; CHECK-NOWORKAROUND-NEXT:      madd
 512
 513 ; No checks for this, just check it doesn't crash
 514 define i32 @crash_check(ptr nocapture readnone %data) #0 {
 515 entry:
 516   br label %while.cond
 517
 518 while.cond:
 519   br label %while.cond
 520 }
 521
 522 attributes #0 = { nounwind readonly "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 523 attributes #1 = { nounwind "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 524 attributes #2 = { nounwind }
 525
 526
 527 ; CHECK-LABEL: ... Statistics Collected ...
 528 ; CHECK: 11 aarch64-fix-cortex-a53-835769 - Number of Nops added to work around erratum 835769