llvm/test/CodeGen/AArch64/bitfield-insert.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=aarch64-none-linux-gnu < %s | FileCheck %s
   3
   4 ; First, a simple example from Clang. The registers could plausibly be
   5 ; different, but probably won't be.
   6
   7 %struct.foo = type { i8, [2 x i8], i8 }
   8
   9 define [1 x i64] @from_clang([1 x i64] %f.coerce, i32 %n) nounwind readnone {
  10 ; CHECK-LABEL: from_clang:
  11 ; CHECK:       // %bb.0: // %entry
  12 ; CHECK-NEXT:    mov w8, #135 // =0x87
  13 ; CHECK-NEXT:    and x9, x0, #0xffffff00
  14 ; CHECK-NEXT:    and w8, w0, w8
  15 ; CHECK-NEXT:    bfi w8, w1, #3, #4
  16 ; CHECK-NEXT:    orr x0, x8, x9
  17 ; CHECK-NEXT:    ret
  18 entry:
  19   %f.coerce.fca.0.extract = extractvalue [1 x i64] %f.coerce, 0
  20   %tmp.sroa.0.0.extract.trunc = trunc i64 %f.coerce.fca.0.extract to i32
  21   %bf.value = shl i32 %n, 3
  22   %0 = and i32 %bf.value, 120
  23   %f.sroa.0.0.insert.ext.masked = and i32 %tmp.sroa.0.0.extract.trunc, 135
  24   %1 = or i32 %f.sroa.0.0.insert.ext.masked, %0
  25   %f.sroa.0.0.extract.trunc = zext i32 %1 to i64
  26   %tmp1.sroa.1.1.insert.insert = and i64 %f.coerce.fca.0.extract, 4294967040
  27   %tmp1.sroa.0.0.insert.insert = or i64 %f.sroa.0.0.extract.trunc, %tmp1.sroa.1.1.insert.insert
  28   %.fca.0.insert = insertvalue [1 x i64] undef, i64 %tmp1.sroa.0.0.insert.insert, 0
  29   ret [1 x i64] %.fca.0.insert
  30 }
  31
  32 define void @test_whole32(ptr %existing, ptr %new) {
  33 ; CHECK-LABEL: test_whole32:
  34 ; CHECK:       // %bb.0:
  35 ; CHECK-NEXT:    ldr w8, [x0]
  36 ; CHECK-NEXT:    ldr w9, [x1]
  37 ; CHECK-NEXT:    bfi w8, w9, #26, #5
  38 ; CHECK-NEXT:    str w8, [x0]
  39 ; CHECK-NEXT:    ret
  40   %oldval = load volatile i32, ptr %existing
  41   %oldval_keep = and i32 %oldval, 2214592511 ; =0x83ffffff
  42
  43   %newval = load volatile i32, ptr %new
  44   %newval_shifted = shl i32 %newval, 26
  45   %newval_masked = and i32 %newval_shifted, 2080374784 ; = 0x7c000000
  46
  47   %combined = or i32 %oldval_keep, %newval_masked
  48   store volatile i32 %combined, ptr %existing
  49
  50   ret void
  51 }
  52
  53 define void @test_whole64(ptr %existing, ptr %new) {
  54 ; CHECK-LABEL: test_whole64:
  55 ; CHECK:       // %bb.0:
  56 ; CHECK-NEXT:    ldr x8, [x0]
  57 ; CHECK-NEXT:    ldr x9, [x1]
  58 ; CHECK-NEXT:    bfi x8, x9, #26, #14
  59 ; CHECK-NEXT:    str x8, [x0]
  60 ; CHECK-NEXT:    ret
  61   %oldval = load volatile i64, ptr %existing
  62   %oldval_keep = and i64 %oldval, 18446742974265032703 ; = 0xffffff0003ffffffL
  63
  64   %newval = load volatile i64, ptr %new
  65   %newval_shifted = shl i64 %newval, 26
  66   %newval_masked = and i64 %newval_shifted, 1099444518912 ; = 0xfffc000000
  67
  68   %combined = or i64 %oldval_keep, %newval_masked
  69   store volatile i64 %combined, ptr %existing
  70
  71   ret void
  72 }
  73
  74 define void @test_whole32_from64(ptr %existing, ptr %new) {
  75 ; CHECK-LABEL: test_whole32_from64:
  76 ; CHECK:       // %bb.0:
  77 ; CHECK-NEXT:    ldr x8, [x0]
  78 ; CHECK-NEXT:    ldr x9, [x1]
  79 ; CHECK-NEXT:    and x8, x8, #0xffff0000
  80 ; CHECK-NEXT:    bfxil x8, x9, #0, #16
  81 ; CHECK-NEXT:    str x8, [x0]
  82 ; CHECK-NEXT:    ret
  83   %oldval = load volatile i64, ptr %existing
  84   %oldval_keep = and i64 %oldval, 4294901760 ; = 0xffff0000
  85
  86   %newval = load volatile i64, ptr %new
  87   %newval_masked = and i64 %newval, 65535 ; = 0xffff
  88
  89   %combined = or i64 %oldval_keep, %newval_masked
  90   store volatile i64 %combined, ptr %existing
  91
  92   ret void
  93 }
  94
  95 define void @test_32bit_masked(ptr %existing, ptr %new) {
  96 ; CHECK-LABEL: test_32bit_masked:
  97 ; CHECK:       // %bb.0:
  98 ; CHECK-NEXT:    ldr w9, [x0]
  99 ; CHECK-NEXT:    mov w8, #135 // =0x87
 100 ; CHECK-NEXT:    ldr w10, [x1]
 101 ; CHECK-NEXT:    and w8, w9, w8
 102 ; CHECK-NEXT:    bfi w8, w10, #3, #4
 103 ; CHECK-NEXT:    str w8, [x0]
 104 ; CHECK-NEXT:    ret
 105   %oldval = load volatile i32, ptr %existing
 106   %oldval_keep = and i32 %oldval, 135 ; = 0x87
 107
 108   %newval = load volatile i32, ptr %new
 109   %newval_shifted = shl i32 %newval, 3
 110   %newval_masked = and i32 %newval_shifted, 120 ; = 0x78
 111
 112   %combined = or i32 %oldval_keep, %newval_masked
 113   store volatile i32 %combined, ptr %existing
 114
 115   ret void
 116 }
 117
 118 define void @test_64bit_masked(ptr %existing, ptr %new) {
 119 ; CHECK-LABEL: test_64bit_masked:
 120 ; CHECK:       // %bb.0:
 121 ; CHECK-NEXT:    ldr x8, [x0]
 122 ; CHECK-NEXT:    ldr x9, [x1]
 123 ; CHECK-NEXT:    and x8, x8, #0xff00000000
 124 ; CHECK-NEXT:    bfi x8, x9, #40, #8
 125 ; CHECK-NEXT:    str x8, [x0]
 126 ; CHECK-NEXT:    ret
 127   %oldval = load volatile i64, ptr %existing
 128   %oldval_keep = and i64 %oldval, 1095216660480 ; = 0xff_0000_0000
 129
 130   %newval = load volatile i64, ptr %new
 131   %newval_shifted = shl i64 %newval, 40
 132   %newval_masked = and i64 %newval_shifted, 280375465082880 ; = 0xff00_0000_0000
 133
 134   %combined = or i64 %newval_masked, %oldval_keep
 135   store volatile i64 %combined, ptr %existing
 136
 137   ret void
 138 }
 139
 140 ; Mask is too complicated for literal ANDwwi, make sure other avenues are tried.
 141 define void @test_32bit_complexmask(ptr %existing, ptr %new) {
 142 ; CHECK-LABEL: test_32bit_complexmask:
 143 ; CHECK:       // %bb.0:
 144 ; CHECK-NEXT:    ldr w9, [x0]
 145 ; CHECK-NEXT:    mov w8, #647 // =0x287
 146 ; CHECK-NEXT:    ldr w10, [x1]
 147 ; CHECK-NEXT:    and w8, w9, w8
 148 ; CHECK-NEXT:    bfi w8, w10, #3, #4
 149 ; CHECK-NEXT:    str w8, [x0]
 150 ; CHECK-NEXT:    ret
 151   %oldval = load volatile i32, ptr %existing
 152   %oldval_keep = and i32 %oldval, 647 ; = 0x287
 153
 154   %newval = load volatile i32, ptr %new
 155   %newval_shifted = shl i32 %newval, 3
 156   %newval_masked = and i32 %newval_shifted, 120 ; = 0x278
 157
 158   %combined = or i32 %oldval_keep, %newval_masked
 159   store volatile i32 %combined, ptr %existing
 160
 161   ret void
 162 }
 163
 164 ; Neither mask is a contiguous set of 1s. BFI can't be used
 165 define void @test_32bit_badmask(ptr %existing, ptr %new) {
 166 ; CHECK-LABEL: test_32bit_badmask:
 167 ; CHECK:       // %bb.0:
 168 ; CHECK-NEXT:    ldr w8, [x0]
 169 ; CHECK-NEXT:    ldr w9, [x1]
 170 ; CHECK-NEXT:    mov w10, #632 // =0x278
 171 ; CHECK-NEXT:    mov w11, #135 // =0x87
 172 ; CHECK-NEXT:    and w9, w10, w9, lsl #3
 173 ; CHECK-NEXT:    and w8, w8, w11
 174 ; CHECK-NEXT:    orr w8, w8, w9
 175 ; CHECK-NEXT:    str w8, [x0]
 176 ; CHECK-NEXT:    ret
 177   %oldval = load volatile i32, ptr %existing
 178   %oldval_keep = and i32 %oldval, 135 ; = 0x87
 179
 180   %newval = load volatile i32, ptr %new
 181   %newval_shifted = shl i32 %newval, 3
 182   %newval_masked = and i32 %newval_shifted, 632 ; = 0x278
 183
 184   %combined = or i32 %oldval_keep, %newval_masked
 185   store volatile i32 %combined, ptr %existing
 186
 187   ret void
 188 }
 189
 190 ; Ditto
 191 define void @test_64bit_badmask(ptr %existing, ptr %new) {
 192 ; CHECK-LABEL: test_64bit_badmask:
 193 ; CHECK:       // %bb.0:
 194 ; CHECK-NEXT:    ldr x8, [x0]
 195 ; CHECK-NEXT:    ldr x9, [x1]
 196 ; CHECK-NEXT:    mov w10, #135 // =0x87
 197 ; CHECK-NEXT:    mov w11, #664 // =0x298
 198 ; CHECK-NEXT:    lsl w9, w9, #3
 199 ; CHECK-NEXT:    and x8, x8, x10
 200 ; CHECK-NEXT:    and x9, x9, x11
 201 ; CHECK-NEXT:    orr x8, x8, x9
 202 ; CHECK-NEXT:    str x8, [x0]
 203 ; CHECK-NEXT:    ret
 204   %oldval = load volatile i64, ptr %existing
 205   %oldval_keep = and i64 %oldval, 135 ; = 0x87
 206
 207   %newval = load volatile i64, ptr %new
 208   %newval_shifted = shl i64 %newval, 3
 209   %newval_masked = and i64 %newval_shifted, 664 ; = 0x278
 210
 211   %combined = or i64 %oldval_keep, %newval_masked
 212   store volatile i64 %combined, ptr %existing
 213
 214   ret void
 215 }
 216
 217 ; Bitfield insert where there's a left-over shr needed at the beginning
 218 ; (e.g. result of str.bf1 = str.bf2)
 219 define void @test_32bit_with_shr(ptr %existing, ptr %new) {
 220 ; CHECK-LABEL: test_32bit_with_shr:
 221 ; CHECK:       // %bb.0:
 222 ; CHECK-NEXT:    ldr w8, [x0]
 223 ; CHECK-NEXT:    ldr w9, [x1]
 224 ; CHECK-NEXT:    lsr w9, w9, #14
 225 ; CHECK-NEXT:    bfi w8, w9, #26, #5
 226 ; CHECK-NEXT:    str w8, [x0]
 227 ; CHECK-NEXT:    ret
 228   %oldval = load volatile i32, ptr %existing
 229   %oldval_keep = and i32 %oldval, 2214592511 ; =0x83ffffff
 230
 231   %newval = load i32, ptr %new
 232   %newval_shifted = shl i32 %newval, 12
 233   %newval_masked = and i32 %newval_shifted, 2080374784 ; = 0x7c000000
 234
 235   %combined = or i32 %oldval_keep, %newval_masked
 236   store volatile i32 %combined, ptr %existing
 237
 238   ret void
 239 }
 240
 241 ; Bitfield insert where the second or operand is a better match to be folded into the BFM
 242 define void @test_32bit_opnd1_better(ptr %existing, ptr %new) {
 243 ; CHECK-LABEL: test_32bit_opnd1_better:
 244 ; CHECK:       // %bb.0:
 245 ; CHECK-NEXT:    ldr w8, [x0]
 246 ; CHECK-NEXT:    ldr w9, [x1]
 247 ; CHECK-NEXT:    and w8, w8, #0xffff
 248 ; CHECK-NEXT:    bfi w8, w9, #16, #8
 249 ; CHECK-NEXT:    str w8, [x0]
 250 ; CHECK-NEXT:    ret
 251   %oldval = load volatile i32, ptr %existing
 252   %oldval_keep = and i32 %oldval, 65535 ; 0x0000ffff
 253
 254   %newval = load i32, ptr %new
 255   %newval_shifted = shl i32 %newval, 16
 256   %newval_masked = and i32 %newval_shifted, 16711680 ; 0x00ff0000
 257
 258   %combined = or i32 %oldval_keep, %newval_masked
 259   store volatile i32 %combined, ptr %existing
 260
 261   ret void
 262 }
 263
 264 ; Tests when all the bits from one operand are not useful
 265 define i32 @test_nouseful_bits(i8 %a, i32 %b) {
 266 ; CHECK-LABEL: test_nouseful_bits:
 267 ; CHECK:       // %bb.0:
 268 ; CHECK-NEXT:    and w8, w0, #0xff
 269 ; CHECK-NEXT:    lsl w8, w8, #8
 270 ; CHECK-NEXT:    mov w9, w8
 271 ; CHECK-NEXT:    bfxil w9, w0, #0, #8
 272 ; CHECK-NEXT:    orr w0, w8, w9, lsl #16
 273 ; CHECK-NEXT:    ret
 274   %conv = zext i8 %a to i32     ;   0  0  0  A
 275   %shl = shl i32 %b, 8          ;   B2 B1 B0 0
 276   %or = or i32 %conv, %shl      ;   B2 B1 B0 A
 277   %shl.1 = shl i32 %or, 8       ;   B1 B0 A 0
 278   %or.1 = or i32 %conv, %shl.1  ;   B1 B0 A A
 279   %shl.2 = shl i32 %or.1, 8     ;   B0 A A 0
 280   %or.2 = or i32 %conv, %shl.2  ;   B0 A A A
 281   %shl.3 = shl i32 %or.2, 8     ;   A A A 0
 282   %or.3 = or i32 %conv, %shl.3  ;   A A A A
 283   %shl.4 = shl i32 %or.3, 8     ;   A A A 0
 284   ret i32 %shl.4
 285 }
 286
 287 define void @test_nouseful_strb(ptr %ptr32, ptr %ptr8, i32 %x)  {
 288 ; CHECK-LABEL: test_nouseful_strb:
 289 ; CHECK:       // %bb.0: // %entry
 290 ; CHECK-NEXT:    ldr w8, [x0]
 291 ; CHECK-NEXT:    bfxil w8, w2, #16, #3
 292 ; CHECK-NEXT:    strb w8, [x1]
 293 ; CHECK-NEXT:    ret
 294 entry:
 295   %0 = load i32, ptr %ptr32, align 8
 296   %and = and i32 %0, -8
 297   %shr = lshr i32 %x, 16
 298   %and1 = and i32 %shr, 7
 299   %or = or i32 %and, %and1
 300   %trunc = trunc i32 %or to i8
 301   store i8 %trunc, ptr %ptr8
 302   ret void
 303 }
 304
 305 define void @test_nouseful_strh(ptr %ptr32, ptr %ptr16, i32 %x)  {
 306 ; CHECK-LABEL: test_nouseful_strh:
 307 ; CHECK:       // %bb.0: // %entry
 308 ; CHECK-NEXT:    ldr w8, [x0]
 309 ; CHECK-NEXT:    bfxil w8, w2, #16, #4
 310 ; CHECK-NEXT:    strh w8, [x1]
 311 ; CHECK-NEXT:    ret
 312 entry:
 313   %0 = load i32, ptr %ptr32, align 8
 314   %and = and i32 %0, -16
 315   %shr = lshr i32 %x, 16
 316   %and1 = and i32 %shr, 15
 317   %or = or i32 %and, %and1
 318   %trunc = trunc i32 %or to i16
 319   store i16 %trunc, ptr %ptr16
 320   ret void
 321 }
 322
 323 define void @test_nouseful_sturb(ptr %ptr32, ptr %ptr8, i32 %x)  {
 324 ; CHECK-LABEL: test_nouseful_sturb:
 325 ; CHECK:       // %bb.0: // %entry
 326 ; CHECK-NEXT:    ldr w8, [x0]
 327 ; CHECK-NEXT:    bfxil w8, w2, #16, #3
 328 ; CHECK-NEXT:    sturb w8, [x1, #-1]
 329 ; CHECK-NEXT:    ret
 330 entry:
 331   %0 = load i32, ptr %ptr32, align 8
 332   %and = and i32 %0, -8
 333   %shr = lshr i32 %x, 16
 334   %and1 = and i32 %shr, 7
 335   %or = or i32 %and, %and1
 336   %trunc = trunc i32 %or to i8
 337   %gep = getelementptr i8, ptr %ptr8, i64 -1
 338   store i8 %trunc, ptr %gep
 339   ret void
 340 }
 341
 342 define void @test_nouseful_sturh(ptr %ptr32, ptr %ptr16, i32 %x)  {
 343 ; CHECK-LABEL: test_nouseful_sturh:
 344 ; CHECK:       // %bb.0: // %entry
 345 ; CHECK-NEXT:    ldr w8, [x0]
 346 ; CHECK-NEXT:    bfxil w8, w2, #16, #4
 347 ; CHECK-NEXT:    sturh w8, [x1, #-2]
 348 ; CHECK-NEXT:    ret
 349 entry:
 350   %0 = load i32, ptr %ptr32, align 8
 351   %and = and i32 %0, -16
 352   %shr = lshr i32 %x, 16
 353   %and1 = and i32 %shr, 15
 354   %or = or i32 %and, %and1
 355   %trunc = trunc i32 %or to i16
 356   %gep = getelementptr i16, ptr %ptr16, i64 -1
 357   store i16 %trunc, ptr %gep
 358   ret void
 359 }
 360
 361 ; The next set of tests generate a BFXIL from 'or (and X, Mask0Imm),
 362 ; (and Y, Mask1Imm)' iff Mask0Imm and ~Mask1Imm are equivalent and one of the
 363 ; MaskImms is a shifted mask (e.g., 0x000ffff0).
 364
 365 define i32 @test_or_and_and1(i32 %a, i32 %b) {
 366 ; CHECK-LABEL: test_or_and_and1:
 367 ; CHECK:       // %bb.0: // %entry
 368 ; CHECK-NEXT:    lsr w8, w1, #4
 369 ; CHECK-NEXT:    bfi w0, w8, #4, #12
 370 ; CHECK-NEXT:    ret
 371 entry:
 372   %and = and i32 %a, -65521 ; 0xffff000f
 373   %and1 = and i32 %b, 65520 ; 0x0000fff0
 374   %or = or i32 %and1, %and
 375   ret i32 %or
 376 }
 377
 378 define i32 @test_or_and_and2(i32 %a, i32 %b) {
 379 ; CHECK-LABEL: test_or_and_and2:
 380 ; CHECK:       // %bb.0: // %entry
 381 ; CHECK-NEXT:    lsr w8, w0, #4
 382 ; CHECK-NEXT:    mov w0, w1
 383 ; CHECK-NEXT:    bfi w0, w8, #4, #12
 384 ; CHECK-NEXT:    ret
 385 entry:
 386   %and = and i32 %a, 65520   ; 0x0000fff0
 387   %and1 = and i32 %b, -65521 ; 0xffff000f
 388   %or = or i32 %and1, %and
 389   ret i32 %or
 390 }
 391
 392 define i64 @test_or_and_and3(i64 %a, i64 %b) {
 393 ; CHECK-LABEL: test_or_and_and3:
 394 ; CHECK:       // %bb.0: // %entry
 395 ; CHECK-NEXT:    lsr x8, x1, #16
 396 ; CHECK-NEXT:    bfi x0, x8, #16, #32
 397 ; CHECK-NEXT:    ret
 398 entry:
 399   %and = and i64 %a, -281474976645121 ; 0xffff00000000ffff
 400   %and1 = and i64 %b, 281474976645120 ; 0x0000ffffffff0000
 401   %or = or i64 %and1, %and
 402   ret i64 %or
 403 }
 404
 405 ; Don't convert 'and' with multiple uses.
 406 define i32 @test_or_and_and4(i32 %a, i32 %b, ptr %ptr) {
 407 ; CHECK-LABEL: test_or_and_and4:
 408 ; CHECK:       // %bb.0: // %entry
 409 ; CHECK-NEXT:    and w8, w0, #0xffff000f
 410 ; CHECK-NEXT:    and w9, w1, #0xfff0
 411 ; CHECK-NEXT:    orr w0, w9, w8
 412 ; CHECK-NEXT:    str w8, [x2]
 413 ; CHECK-NEXT:    ret
 414 entry:
 415   %and = and i32 %a, -65521
 416   store i32 %and, ptr %ptr, align 4
 417   %and2 = and i32 %b, 65520
 418   %or = or i32 %and2, %and
 419   ret i32 %or
 420 }
 421
 422 ; Don't convert 'and' with multiple uses.
 423 define i32 @test_or_and_and5(i32 %a, i32 %b, ptr %ptr) {
 424 ; CHECK-LABEL: test_or_and_and5:
 425 ; CHECK:       // %bb.0: // %entry
 426 ; CHECK-NEXT:    and w8, w1, #0xfff0
 427 ; CHECK-NEXT:    and w9, w0, #0xffff000f
 428 ; CHECK-NEXT:    orr w0, w8, w9
 429 ; CHECK-NEXT:    str w8, [x2]
 430 ; CHECK-NEXT:    ret
 431 entry:
 432   %and = and i32 %b, 65520
 433   store i32 %and, ptr %ptr, align 4
 434   %and1 = and i32 %a, -65521
 435   %or = or i32 %and, %and1
 436   ret i32 %or
 437 }
 438
 439 define i32 @test1(i32 %a) {
 440 ; CHECK-LABEL: test1:
 441 ; CHECK:       // %bb.0:
 442 ; CHECK-NEXT:    mov w8, #5 // =0x5
 443 ; CHECK-NEXT:    bfxil w0, w8, #0, #4
 444 ; CHECK-NEXT:    ret
 445   %1 = and i32 %a, -16 ; 0xfffffff0
 446   %2 = or i32 %1, 5    ; 0x00000005
 447   ret i32 %2
 448 }
 449
 450 define i32 @test2(i32 %a) {
 451 ; CHECK-LABEL: test2:
 452 ; CHECK:       // %bb.0:
 453 ; CHECK-NEXT:    mov w8, #10 // =0xa
 454 ; CHECK-NEXT:    bfi w0, w8, #22, #4
 455 ; CHECK-NEXT:    ret
 456   %1 = and i32 %a, -62914561 ; 0xfc3fffff
 457   %2 = or i32 %1, 41943040   ; 0x06400000
 458   ret i32 %2
 459 }
 460
 461 define i64 @test3(i64 %a) {
 462 ; CHECK-LABEL: test3:
 463 ; CHECK:       // %bb.0:
 464 ; CHECK-NEXT:    mov x8, #5 // =0x5
 465 ; CHECK-NEXT:    bfxil x0, x8, #0, #3
 466 ; CHECK-NEXT:    ret
 467   %1 = and i64 %a, -8 ; 0xfffffffffffffff8
 468   %2 = or i64 %1, 5   ; 0x0000000000000005
 469   ret i64 %2
 470 }
 471
 472 define i64 @test4(i64 %a) {
 473 ; CHECK-LABEL: test4:
 474 ; CHECK:       // %bb.0:
 475 ; CHECK-NEXT:    mov x8, #9 // =0x9
 476 ; CHECK-NEXT:    bfi x0, x8, #1, #7
 477 ; CHECK-NEXT:    ret
 478   %1 = and i64 %a, -255 ; 0xffffffffffffff01
 479   %2 = or i64 %1,  18   ; 0x0000000000000012
 480   ret i64 %2
 481 }
 482
 483 ; Don't generate BFI/BFXIL if the immediate can be encoded in the ORR.
 484 define i32 @test5(i32 %a) {
 485 ; CHECK-LABEL: test5:
 486 ; CHECK:       // %bb.0:
 487 ; CHECK-NEXT:    and w8, w0, #0xfffffff0
 488 ; CHECK-NEXT:    orr w0, w8, #0x6
 489 ; CHECK-NEXT:    ret
 490   %1 = and i32 %a, 4294967280 ; 0xfffffff0
 491   %2 = or i32 %1, 6           ; 0x00000006
 492   ret i32 %2
 493 }
 494
 495 ; BFXIL will use the same constant as the ORR, so we don't care how the constant
 496 ; is materialized (it's an equal cost either way).
 497 define i32 @test6(i32 %a) {
 498 ; CHECK-LABEL: test6:
 499 ; CHECK:       // %bb.0:
 500 ; CHECK-NEXT:    mov w8, #23250 // =0x5ad2
 501 ; CHECK-NEXT:    movk w8, #11, lsl #16
 502 ; CHECK-NEXT:    bfxil w0, w8, #0, #20
 503 ; CHECK-NEXT:    ret
 504   %1 = and i32 %a, 4293918720 ; 0xfff00000
 505   %2 = or i32 %1, 744146      ; 0x000b5ad2
 506   ret i32 %2
 507 }
 508
 509 ; BFIs that require the same number of instruction to materialize the constant
 510 ; as the original ORR are okay.
 511 define i32 @test7(i32 %a) {
 512 ; CHECK-LABEL: test7:
 513 ; CHECK:       // %bb.0:
 514 ; CHECK-NEXT:    mov w8, #44393 // =0xad69
 515 ; CHECK-NEXT:    movk w8, #5, lsl #16
 516 ; CHECK-NEXT:    bfi w0, w8, #1, #19
 517 ; CHECK-NEXT:    ret
 518   %1 = and i32 %a, 4293918721 ; 0xfff00001
 519   %2 = or i32 %1, 744146      ; 0x000b5ad2
 520   ret i32 %2
 521 }
 522
 523 ; BFIs that require more instructions to materialize the constant as compared
 524 ; to the original ORR are not okay.  In this case we would be replacing the
 525 ; 'and' with a 'movk', which would decrease ILP while using the same number of
 526 ; instructions.
 527 define i64 @test8(i64 %a) {
 528 ; CHECK-LABEL: test8:
 529 ; CHECK:       // %bb.0:
 530 ; CHECK-NEXT:    mov x8, #2035482624 // =0x79530000
 531 ; CHECK-NEXT:    and x9, x0, #0xff000000000000ff
 532 ; CHECK-NEXT:    movk x8, #36694, lsl #32
 533 ; CHECK-NEXT:    orr x0, x9, x8
 534 ; CHECK-NEXT:    ret
 535   %1 = and i64 %a, -72057594037927681 ; 0xff000000000000ff
 536   %2 = or i64 %1, 157601565442048     ; 0x00008f5679530000
 537   ret i64 %2
 538 }
 539
 540 ; This test exposed an issue with an overly aggressive assert.  The bit of code
 541 ; that is expected to catch this case is unable to deal with the trunc, which
 542 ; results in a failing check due to a mismatch between the BFI opcode and
 543 ; the expected value type of the OR.
 544 define i32 @test9(i64 %b, i32 %e) {
 545 ; CHECK-LABEL: test9:
 546 ; CHECK:       // %bb.0:
 547 ; CHECK-NEXT:    lsr x0, x0, #12
 548 ; CHECK-NEXT:    lsr w8, w1, #23
 549 ; CHECK-NEXT:    bfi w0, w8, #23, #9
 550 ; CHECK-NEXT:    // kill: def $w0 killed $w0 killed $x0
 551 ; CHECK-NEXT:    ret
 552   %c = lshr i64 %b, 12
 553   %d = trunc i64 %c to i32
 554   %f = and i32 %d, 8388607
 555   %g = and i32 %e, -8388608
 556   %h = or i32 %g, %f
 557   ret i32 %h
 558 }
 559
 560 define <2 x i32> @test_complex_type(ptr %addr, i64 %in, ptr %bf ) {
 561 ; CHECK-LABEL: test_complex_type:
 562 ; CHECK:       // %bb.0:
 563 ; CHECK-NEXT:    ldr d0, [x0], #8
 564 ; CHECK-NEXT:    orr x8, x0, x1, lsl #32
 565 ; CHECK-NEXT:    str x8, [x2]
 566 ; CHECK-NEXT:    ret
 567   %vec = load <2 x i32>, ptr %addr
 568
 569   %vec.next = getelementptr <2 x i32>, ptr %addr, i32 1
 570   %lo = ptrtoint ptr %vec.next to i64
 571
 572   %hi = shl i64 %in, 32
 573   %both = or i64 %lo, %hi
 574   store i64 %both, ptr %bf
 575
 576   ret <2 x i32> %vec
 577 }
 578
 579 define i64 @test_truncated_shift(i64 %x, i64 %y) {
 580 ; CHECK-LABEL: test_truncated_shift:
 581 ; CHECK:       // %bb.0: // %entry
 582 ; CHECK-NEXT:    // kill: def $w1 killed $w1 killed $x1 def $x1
 583 ; CHECK-NEXT:    bfi x0, x1, #25, #5
 584 ; CHECK-NEXT:    ret
 585 entry:
 586   %and = and i64 %x, -1040187393
 587   %shl4 = shl i64 %y, 25
 588   %and5 = and i64 %shl4, 1040187392
 589   %or = or i64 %and5, %and
 590   ret i64 %or
 591 }
 592
 593 define i64 @test_and_extended_shift_with_imm(i64 %0) {
 594 ; CHECK-LABEL: test_and_extended_shift_with_imm:
 595 ; CHECK:       // %bb.0:
 596 ; CHECK-NEXT:    // kill: def $w0 killed $w0 killed $x0 def $x0
 597 ; CHECK-NEXT:    ubfiz x0, x0, #7, #8
 598 ; CHECK-NEXT:    ret
 599   %2 = shl i64 %0, 7
 600   %3 = and i64 %2, 32640  ; #0x7f80
 601   ret i64 %3
 602 }
 603
 604 ; orr with left-shifted operand is better than bfi, since it improves data
 605 ; dependency, and orr has a smaller latency and higher throughput than bfm on
 606 ; some AArch64 processors (for the rest, orr is at least as good as bfm)
 607 ;
 608 ; ubfx x8, x0, #8, #7
 609 ; and x9, x0, #0x7f
 610 ; orr x0, x9, x8, lsl #7
 611 define i64 @test_orr_not_bfxil_i64(i64 %0) {
 612 ; CHECK-LABEL: test_orr_not_bfxil_i64:
 613 ; CHECK:       // %bb.0:
 614 ; CHECK-NEXT:    ubfx x8, x0, #8, #7
 615 ; CHECK-NEXT:    and x9, x0, #0x7f
 616 ; CHECK-NEXT:    orr x0, x9, x8, lsl #7
 617 ; CHECK-NEXT:    ret
 618   %2 = and i64 %0, 127
 619   %3 = lshr i64 %0, 1
 620   %4 = and i64 %3, 16256  ; 0x3f80
 621   %5 = or i64 %4, %2
 622   ret i64 %5
 623 }
 624
 625 ; The 32-bit test for `test_orr_not_bfxil_i64`.
 626 define i32 @test_orr_not_bfxil_i32(i32 %0) {
 627 ; CHECK-LABEL: test_orr_not_bfxil_i32:
 628 ; CHECK:       // %bb.0:
 629 ; CHECK-NEXT:    ubfx w8, w0, #8, #7
 630 ; CHECK-NEXT:    and w9, w0, #0x7f
 631 ; CHECK-NEXT:    orr w0, w9, w8, lsl #7
 632 ; CHECK-NEXT:    ret
 633   %2 = and i32 %0, 127
 634   %3 = lshr i32 %0, 1
 635   %4 = and i32 %3, 16256  ; 0x3f80
 636   %5 = or i32 %4, %2
 637   ret i32 %5
 638 }
 639
 640 ; For or operation, one operand is a left shift of another operand.
 641 ; So orr with a left-shifted operand is generated (not bfi).
 642 define i64 @test_orr_not_bfi_i64(i64 %0) {
 643 ; CHECK-LABEL: test_orr_not_bfi_i64:
 644 ; CHECK:       // %bb.0:
 645 ; CHECK-NEXT:    and x8, x0, #0xff
 646 ; CHECK-NEXT:    orr x0, x8, x8, lsl #8
 647 ; CHECK-NEXT:    ret
 648   %2 = and i64 %0, 255
 649   %3 = shl i64 %2, 8
 650   %4 = or i64 %2, %3
 651   ret i64 %4
 652 }
 653
 654 ; bfi is better than orr, since it would simplify away two instructions
 655 ; (%mask and %bit-field-pos-op).
 656 define i32 @test_bfi_not_orr_i32(i32 %0, i32 %1) {
 657 ; CHECK-LABEL: test_bfi_not_orr_i32:
 658 ; CHECK:       // %bb.0:
 659 ; CHECK-NEXT:    and w8, w1, #0xff
 660 ; CHECK-NEXT:    bfi w8, w0, #8, #8
 661 ; CHECK-NEXT:    mov w0, w8
 662 ; CHECK-NEXT:    ret
 663   %bfi_dst = and i32 %1, 255
 664   %mask = and i32 %0, 255
 665   %bit-field-pos-op = shl i32 %mask, 8
 666   %or_res = or i32 %bit-field-pos-op, %bfi_dst
 667   ret i32 %or_res
 668 }
 669
 670 ; orr is generated (not bfi), since both simplify away one instruction (%3)
 671 ; while orr has shorter latency and higher throughput.
 672 define i32 @test_orr_not_bfi_i32(i32 %0) {
 673 ; CHECK-LABEL: test_orr_not_bfi_i32:
 674 ; CHECK:       // %bb.0:
 675 ; CHECK-NEXT:    and w8, w0, #0xff
 676 ; CHECK-NEXT:    orr w0, w8, w8, lsl #8
 677 ; CHECK-NEXT:    ret
 678   %2 = and i32 %0, 255
 679   %3 = shl i32 %2, 8
 680   %4 = or i32 %2, %3
 681   ret i32 %4
 682 }
 683
 684 ; bfxil is better than orr, since it would simplify away two instructions
 685 ; (%mask and %bit-field-extract-op).
 686 define i64 @test_bfxil_not_orr_i64(i64 %0, i64 %1) {
 687 ; CHECK-LABEL: test_bfxil_not_orr_i64:
 688 ; CHECK:       // %bb.0:
 689 ; CHECK-NEXT:    and x0, x0, #0xff000
 690 ; CHECK-NEXT:    bfxil x0, x1, #12, #8
 691 ; CHECK-NEXT:    ret
 692   %shifted-mask = and i64 %1, 1044480
 693   %bfi-dst = and i64 %0, 1044480
 694   %bit-field-extract-op = lshr i64 %shifted-mask, 12
 695   %or_res = or i64 %bit-field-extract-op, %bfi-dst
 696   ret i64 %or_res
 697 }
 698
 699 ; orr is generated (not bfxil), since one operand is the right shift of another
 700 ; operand.
 701 define i64 @orr_not_bfxil_test2_i64(i64 %0) {
 702 ; CHECK-LABEL: orr_not_bfxil_test2_i64:
 703 ; CHECK:       // %bb.0:
 704 ; CHECK-NEXT:    and x8, x0, #0xff000
 705 ; CHECK-NEXT:    orr x0, x8, x8, lsr #12
 706 ; CHECK-NEXT:    ret
 707   %2 = and i64 %0, 1044480 ; 0xff000
 708   %3 = lshr i64 %2, 12
 709   %4 = or i64 %2, %3
 710   ret i64 %4
 711 }
 712
 713 ; bfxil simplifies away two instructions (that computes %shifted-mask and
 714 ; %bit-field-extract-op respectively), so it's better than orr (which
 715 ; simplifies away at most one shift).
 716 define i32 @test_bfxil_not_orr_i32(i32 %0, i32 %1) {
 717 ; CHECK-LABEL: test_bfxil_not_orr_i32:
 718 ; CHECK:       // %bb.0:
 719 ; CHECK-NEXT:    and w0, w0, #0xff000
 720 ; CHECK-NEXT:    bfxil w0, w1, #12, #8
 721 ; CHECK-NEXT:    ret
 722   %shifted-mask = and i32 %1, 1044480
 723   %bfxil-dst = and i32 %0, 1044480
 724   %bit-field-extract-op = lshr i32 %shifted-mask, 12
 725   %or_res = or i32 %bit-field-extract-op, %bfxil-dst
 726   ret i32 %or_res
 727 }
 728
 729 ; one operand is the shift of another operand, so orr is generated (not bfxil).
 730 define i32 @orr_not_bfxil_test2_i32(i32 %0) {
 731 ; CHECK-LABEL: orr_not_bfxil_test2_i32:
 732 ; CHECK:       // %bb.0:
 733 ; CHECK-NEXT:    and w8, w0, #0xff000
 734 ; CHECK-NEXT:    orr w0, w8, w8, lsr #12
 735 ; CHECK-NEXT:    ret
 736   %2 = and i32 %0, 1044480  ; 0xff000
 737   %3 = lshr i32 %2, 12
 738   %4 = or i32 %2, %3
 739   ret i32 %4
 740 }