llvm/test/CodeGen/X86/flags-copy-lowering.mir

   1 # RUN: llc -run-pass x86-flags-copy-lowering -verify-machineinstrs -o - %s | FileCheck %s
   2 #
   3 # Lower various interesting copy patterns of EFLAGS without using LAHF/SAHF.
   4
   5 --- |
   6   target triple = "x86_64-unknown-unknown"
   7
   8   declare void @foo()
   9
  10   define i32 @test_branch(i64 %a, i64 %b) {
  11   entry:
  12     call void @foo()
  13     ret i32 0
  14   }
  15
  16   define i32 @test_branch_fallthrough(i64 %a, i64 %b) {
  17   entry:
  18     call void @foo()
  19     ret i32 0
  20   }
  21
  22   define void @test_setcc(i64 %a, i64 %b) {
  23   entry:
  24     call void @foo()
  25     ret void
  26   }
  27
  28   define void @test_cmov(i64 %a, i64 %b) {
  29   entry:
  30     call void @foo()
  31     ret void
  32   }
  33
  34   define void @test_adc(i64 %a, i64 %b) {
  35   entry:
  36     call void @foo()
  37     ret void
  38   }
  39
  40   define void @test_sbb(i64 %a, i64 %b) {
  41   entry:
  42     call void @foo()
  43     ret void
  44   }
  45
  46   define void @test_rcl(i64 %a, i64 %b) {
  47   entry:
  48     call void @foo()
  49     ret void
  50   }
  51
  52   define void @test_rcr(i64 %a, i64 %b) {
  53   entry:
  54     call void @foo()
  55     ret void
  56   }
  57
  58   define void @test_setb_c(i64 %a, i64 %b) {
  59   entry:
  60     call void @foo()
  61     ret void
  62   }
  63
  64   define i64 @test_branch_with_livein_and_kill(i64 %a, i64 %b) {
  65   entry:
  66     call void @foo()
  67     ret i64 0
  68   }
  69
  70   define i64 @test_branch_with_interleaved_livein_and_kill(i64 %a, i64 %b) {
  71   entry:
  72     call void @foo()
  73     ret i64 0
  74   }
  75
  76   define i64 @test_mid_cycle_copies(i64 %a, i64 %b) {
  77   entry:
  78     call void @foo()
  79     ret i64 0
  80   }
  81
  82   define i32 @test_existing_setcc(i64 %a, i64 %b) {
  83   entry:
  84     call void @foo()
  85     ret i32 0
  86   }
  87
  88   define i32 @test_existing_setcc_memory(i64 %a, i64 %b) {
  89   entry:
  90     call void @foo()
  91     ret i32 0
  92   }
  93 ...
  94 ---
  95 name:            test_branch
  96 # CHECK-LABEL: name: test_branch
  97 liveins:
  98   - { reg: '$rdi', virtual-reg: '%0' }
  99   - { reg: '$rsi', virtual-reg: '%1' }
 100 body:             |
 101   bb.0:
 102     successors: %bb.1, %bb.2, %bb.3
 103     liveins: $rdi, $rsi
 104
 105     %0:gr64 = COPY $rdi
 106     %1:gr64 = COPY $rsi
 107     CMP64rr %0, %1, implicit-def $eflags
 108     %2:gr64 = COPY $eflags
 109   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 110   ; CHECK:      %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 111   ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 112   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 113
 114     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 115     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 116     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 117
 118     $eflags = COPY %2
 119     JCC_1 %bb.1, 7, implicit $eflags
 120     JCC_1 %bb.2, 2, implicit $eflags
 121     JMP_1 %bb.3
 122   ; CHECK-NOT: $eflags =
 123   ;
 124   ; CHECK:        TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 125   ; CHECK-NEXT:   JCC_1 %bb.1, 5, implicit killed $eflags
 126   ; CHECK-SAME: {{$[[:space:]]}}
 127   ; CHECK-NEXT: bb.4:
 128   ; CHECK-NEXT:   successors: {{.*$}}
 129   ; CHECK-SAME: {{$[[:space:]]}}
 130   ; CHECK-NEXT:   TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
 131   ; CHECK-NEXT:   JCC_1 %bb.2, 5, implicit killed $eflags
 132   ; CHECK-NEXT:   JMP_1 %bb.3
 133
 134   bb.1:
 135     %3:gr32 = MOV32ri 42
 136     $eax = COPY %3
 137     RET 0, $eax
 138
 139   bb.2:
 140     %4:gr32 = MOV32ri 43
 141     $eax = COPY %4
 142     RET 0, $eax
 143
 144   bb.3:
 145     %5:gr32 = MOV32r0 implicit-def dead $eflags
 146     $eax = COPY %5
 147     RET 0, $eax
 148
 149 ...
 150 ---
 151 name:            test_branch_fallthrough
 152 # CHECK-LABEL: name: test_branch_fallthrough
 153 liveins:
 154   - { reg: '$rdi', virtual-reg: '%0' }
 155   - { reg: '$rsi', virtual-reg: '%1' }
 156 body:             |
 157   bb.0:
 158     successors: %bb.1, %bb.2, %bb.3
 159     liveins: $rdi, $rsi
 160
 161     %0:gr64 = COPY $rdi
 162     %1:gr64 = COPY $rsi
 163     CMP64rr %0, %1, implicit-def $eflags
 164     %2:gr64 = COPY $eflags
 165   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 166   ; CHECK:      %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 167   ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 168   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 169
 170     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 171     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 172     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 173
 174     $eflags = COPY %2
 175     JCC_1 %bb.2, 7, implicit $eflags
 176     JCC_1 %bb.3, 2, implicit $eflags
 177   ; CHECK-NOT: $eflags =
 178   ;
 179   ; CHECK:        TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 180   ; CHECK-NEXT:   JCC_1 %bb.2, 5, implicit killed $eflags
 181   ; CHECK-SAME: {{$[[:space:]]}}
 182   ; CHECK-NEXT: bb.4:
 183   ; CHECK-NEXT:   successors: {{.*$}}
 184   ; CHECK-SAME: {{$[[:space:]]}}
 185   ; CHECK-NEXT:   TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
 186   ; CHECK-NEXT:   JCC_1 %bb.3, 5, implicit killed $eflags
 187   ; CHECK-SAME: {{$[[:space:]]}}
 188   ; CHECK-NEXT:   bb.1:
 189
 190   bb.1:
 191     %5:gr32 = MOV32r0 implicit-def dead $eflags
 192     $eax = COPY %5
 193     RET 0, $eax
 194
 195   bb.2:
 196     %3:gr32 = MOV32ri 42
 197     $eax = COPY %3
 198     RET 0, $eax
 199
 200   bb.3:
 201     %4:gr32 = MOV32ri 43
 202     $eax = COPY %4
 203     RET 0, $eax
 204
 205 ...
 206 ---
 207 name:            test_setcc
 208 # CHECK-LABEL: name: test_setcc
 209 liveins:
 210   - { reg: '$rdi', virtual-reg: '%0' }
 211   - { reg: '$rsi', virtual-reg: '%1' }
 212 body:             |
 213   bb.0:
 214     liveins: $rdi, $rsi
 215
 216     %0:gr64 = COPY $rdi
 217     %1:gr64 = COPY $rsi
 218     CMP64rr %0, %1, implicit-def $eflags
 219     %2:gr64 = COPY $eflags
 220   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 221   ; CHECK:      %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 222   ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 223   ; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
 224   ; CHECK-NEXT: %[[NE_REG:[^:]*]]:gr8 = SETCCr 5, implicit $eflags
 225   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 226
 227     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 228     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 229     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 230
 231     $eflags = COPY %2
 232     %3:gr8 = SETCCr 7, implicit $eflags
 233     %4:gr8 = SETCCr 2, implicit $eflags
 234     %5:gr8 = SETCCr 4, implicit $eflags
 235     SETCCm $rsp, 1, $noreg, -16, $noreg, 5, implicit killed $eflags
 236     MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %3
 237     MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %4
 238     MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %5
 239   ; CHECK-NOT:     $eflags =
 240   ; CHECK-NOT:             = SET{{.*}}
 241   ; CHECK:         MOV8mr {{.*}}, %[[A_REG]]
 242   ; CHECK-NEXT:    MOV8mr {{.*}}, %[[B_REG]]
 243   ; CHECK-NEXT:    MOV8mr {{.*}}, %[[E_REG]]
 244   ; CHECK-NOT:     MOV8mr {{.*}}, %[[NE_REG]]
 245
 246     RET 0
 247
 248 ...
 249 ---
 250 name:            test_cmov
 251 # CHECK-LABEL: name: test_cmov
 252 liveins:
 253   - { reg: '$rdi', virtual-reg: '%0' }
 254   - { reg: '$rsi', virtual-reg: '%1' }
 255 body:             |
 256   bb.0:
 257     liveins: $rdi, $rsi
 258
 259     %0:gr64 = COPY $rdi
 260     %1:gr64 = COPY $rsi
 261     CMP64rr %0, %1, implicit-def $eflags
 262     %2:gr64 = COPY $eflags
 263   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 264   ; CHECK:      %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 265   ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 266   ; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
 267   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 268
 269     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 270     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 271     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 272
 273     $eflags = COPY %2
 274     %3:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
 275     %4:gr64 = CMOV64rr %0, %1, 2, implicit $eflags
 276     %5:gr64 = CMOV64rr %0, %1, 4, implicit $eflags
 277     %6:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 278   ; CHECK-NOT:     $eflags =
 279   ; CHECK:         TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 280   ; CHECK-NEXT:    %3:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 281   ; CHECK-NEXT:    TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
 282   ; CHECK-NEXT:    %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 283   ; CHECK-NEXT:    TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
 284   ; CHECK-NEXT:    %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 285   ; CHECK-NEXT:    TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
 286   ; CHECK-NEXT:    %6:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
 287     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %3
 288     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4
 289     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
 290     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %6
 291
 292     RET 0
 293
 294 ...
 295 ---
 296 name:            test_adc
 297 # CHECK-LABEL: name: test_adc
 298 liveins:
 299   - { reg: '$rdi', virtual-reg: '%0' }
 300   - { reg: '$rsi', virtual-reg: '%1' }
 301 body:             |
 302   bb.0:
 303     liveins: $rdi, $rsi
 304
 305     %0:gr64 = COPY $rdi
 306     %1:gr64 = COPY $rsi
 307     %2:gr64 = ADD64rr %0, %1, implicit-def $eflags
 308     %3:gr64 = COPY $eflags
 309   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 310   ; CHECK:      %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 311   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 312
 313     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 314     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 315     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 316
 317     $eflags = COPY %3
 318     %4:gr64 = ADC64ri32 %2:gr64, 42, implicit-def $eflags, implicit $eflags
 319     %5:gr64 = ADC64ri32 %4:gr64, 42, implicit-def $eflags, implicit $eflags
 320   ; CHECK-NOT:     $eflags =
 321   ; CHECK:         dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
 322   ; CHECK-NEXT:    %4:gr64 = ADC64ri32 %2, 42, implicit-def $eflags, implicit killed $eflags
 323   ; CHECK-NEXT:    %5:gr64 = ADC64ri32 %4, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
 324     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
 325
 326     RET 0
 327
 328 ...
 329 ---
 330 name:            test_sbb
 331 # CHECK-LABEL: name: test_sbb
 332 liveins:
 333   - { reg: '$rdi', virtual-reg: '%0' }
 334   - { reg: '$rsi', virtual-reg: '%1' }
 335 body:             |
 336   bb.0:
 337     liveins: $rdi, $rsi
 338
 339     %0:gr64 = COPY $rdi
 340     %1:gr64 = COPY $rsi
 341     %2:gr64 = SUB64rr %0, %1, implicit-def $eflags
 342     %3:gr64 = COPY killed $eflags
 343   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 344   ; CHECK:      %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 345   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 346
 347     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 348     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 349     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 350
 351     $eflags = COPY %3
 352     %4:gr64 = SBB64ri32 %2:gr64, 42, implicit-def $eflags, implicit killed $eflags
 353     %5:gr64 = SBB64ri32 %4:gr64, 42, implicit-def dead $eflags, implicit killed $eflags
 354   ; CHECK-NOT:     $eflags =
 355   ; CHECK:         dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
 356   ; CHECK-NEXT:    %4:gr64 = SBB64ri32 %2, 42, implicit-def $eflags, implicit killed $eflags
 357   ; CHECK-NEXT:    %5:gr64 = SBB64ri32 %4, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
 358     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
 359
 360     RET 0
 361
 362 ...
 363 ---
 364 name:            test_rcl
 365 # CHECK-LABEL: name: test_rcl
 366 liveins:
 367   - { reg: '$rdi', virtual-reg: '%0' }
 368   - { reg: '$rsi', virtual-reg: '%1' }
 369 body:             |
 370   bb.0:
 371     liveins: $rdi, $rsi
 372
 373     %0:gr64 = COPY $rdi
 374     %1:gr64 = COPY $rsi
 375     %2:gr64 = ADD64rr %0, %1, implicit-def $eflags
 376     %3:gr64 = COPY $eflags
 377   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 378   ; CHECK:      %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 379   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 380
 381     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 382     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 383     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 384
 385     $eflags = COPY %3
 386     %4:gr64 = RCL64r1 %2:gr64, implicit-def $eflags, implicit $eflags
 387     %5:gr64 = RCL64r1 %4:gr64, implicit-def $eflags, implicit $eflags
 388   ; CHECK-NOT:     $eflags =
 389   ; CHECK:         dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
 390   ; CHECK-NEXT:    %4:gr64 = RCL64r1 %2, implicit-def $eflags, implicit killed $eflags
 391   ; CHECK-NEXT:    %5:gr64 = RCL64r1 %4, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
 392     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
 393
 394     RET 0
 395
 396 ...
 397 ---
 398 name:            test_rcr
 399 # CHECK-LABEL: name: test_rcr
 400 liveins:
 401   - { reg: '$rdi', virtual-reg: '%0' }
 402   - { reg: '$rsi', virtual-reg: '%1' }
 403 body:             |
 404   bb.0:
 405     liveins: $rdi, $rsi
 406
 407     %0:gr64 = COPY $rdi
 408     %1:gr64 = COPY $rsi
 409     %2:gr64 = ADD64rr %0, %1, implicit-def $eflags
 410     %3:gr64 = COPY $eflags
 411   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 412   ; CHECK:      %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 413   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 414
 415     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 416     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 417     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 418
 419     $eflags = COPY %3
 420     %4:gr64 = RCR64r1 %2:gr64, implicit-def $eflags, implicit $eflags
 421     %5:gr64 = RCR64r1 %4:gr64, implicit-def $eflags, implicit $eflags
 422   ; CHECK-NOT:     $eflags =
 423   ; CHECK:         dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
 424   ; CHECK-NEXT:    %4:gr64 = RCR64r1 %2, implicit-def $eflags, implicit killed $eflags
 425   ; CHECK-NEXT:    %5:gr64 = RCR64r1 %4, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
 426     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
 427
 428     RET 0
 429
 430 ...
 431 ---
 432 name:            test_setb_c
 433 # CHECK-LABEL: name: test_setb_c
 434 liveins:
 435   - { reg: '$rdi', virtual-reg: '%0' }
 436   - { reg: '$rsi', virtual-reg: '%1' }
 437 body:             |
 438   bb.0:
 439     liveins: $rdi, $rsi
 440
 441     %0:gr64 = COPY $rdi
 442     %1:gr64 = COPY $rsi
 443     %2:gr64 = ADD64rr %0, %1, implicit-def $eflags
 444     %3:gr64 = COPY $eflags
 445   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 446   ; CHECK:      %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 447   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 448
 449     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 450     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 451     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 452
 453     $eflags = COPY %3
 454     %4:gr32 = SETB_C32r implicit-def $eflags, implicit $eflags
 455     MOV32mr $rsp, 1, $noreg, -16, $noreg, killed %4
 456   ; CHECK-NOT:     $eflags =
 457   ; CHECK:         dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
 458   ; CHECK-NEXT:    %[[SETB:[^:]*]]:gr32 = SETB_C32r implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
 459   ; CHECK-NEXT:    MOV32mr $rsp, 1, $noreg, -16, $noreg, killed %[[SETB]]
 460
 461     $eflags = COPY %3
 462     %5:gr64 = SETB_C64r implicit-def $eflags, implicit $eflags
 463     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
 464   ; CHECK-NOT:     $eflags =
 465   ; CHECK:         dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
 466   ; CHECK-NEXT:    %[[SETB:[^:]*]]:gr64 = SETB_C64r implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
 467   ; CHECK-NEXT:    MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %[[SETB]]
 468
 469     RET 0
 470
 471 ...
 472 ---
 473 name:            test_branch_with_livein_and_kill
 474 # CHECK-LABEL: name: test_branch_with_livein_and_kill
 475 liveins:
 476   - { reg: '$rdi', virtual-reg: '%0' }
 477   - { reg: '$rsi', virtual-reg: '%1' }
 478 body:             |
 479   bb.0:
 480     successors: %bb.1, %bb.2, %bb.3
 481     liveins: $rdi, $rsi
 482
 483     %0:gr64 = COPY $rdi
 484     %1:gr64 = COPY $rsi
 485     CMP64rr %0, %1, implicit-def $eflags
 486     %2:gr64 = COPY $eflags
 487   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 488   ; CHECK:      %[[S_REG:[^:]*]]:gr8 = SETCCr 8, implicit $eflags
 489   ; CHECK-NEXT: %[[NE_REG:[^:]*]]:gr8 = SETCCr 5, implicit $eflags
 490   ; CHECK-NEXT: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 491   ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 492   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 493
 494     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 495     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 496     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 497
 498     $eflags = COPY %2
 499     JCC_1 %bb.1, 7, implicit $eflags
 500     JCC_1 %bb.2, 2, implicit $eflags
 501     JMP_1 %bb.3
 502   ; CHECK-NOT: $eflags =
 503   ;
 504   ; CHECK:        TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 505   ; CHECK-NEXT:   JCC_1 %bb.1, 5, implicit killed $eflags
 506   ; CHECK-SAME: {{$[[:space:]]}}
 507   ; CHECK-NEXT: bb.4:
 508   ; CHECK-NEXT:   successors: {{.*$}}
 509   ; CHECK-SAME: {{$[[:space:]]}}
 510   ; CHECK-NEXT:   TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
 511   ; CHECK-NEXT:   JCC_1 %bb.2, 5, implicit killed $eflags
 512   ; CHECK-NEXT:   JMP_1 %bb.3
 513
 514   bb.1:
 515     liveins: $eflags
 516
 517     %3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
 518   ; CHECK-NOT:     $eflags =
 519   ; CHECK:         TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
 520   ; CHECK-NEXT:    %3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
 521     $rax = COPY %3
 522     RET 0, $rax
 523
 524   bb.2:
 525     liveins: $eflags
 526
 527     %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 528   ; CHECK-NOT:     $eflags =
 529   ; CHECK:         TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
 530   ; CHECK-NEXT:    %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 531     $rax = COPY %4
 532     RET 0, $rax
 533
 534   bb.3:
 535     liveins: $eflags
 536
 537     %5:gr64 = CMOV64rr %0, %1, 8, implicit killed $eflags
 538   ; CHECK-NOT:     $eflags =
 539   ; CHECK:         TEST8rr %[[S_REG]], %[[S_REG]], implicit-def $eflags
 540   ; CHECK-NEXT:    %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 541     $rax = COPY %5
 542     RET 0, $rax
 543
 544 ...
 545 ---
 546 name:            test_branch_with_interleaved_livein_and_kill
 547 # CHECK-LABEL: name: test_branch_with_interleaved_livein_and_kill
 548 liveins:
 549   - { reg: '$rdi', virtual-reg: '%0' }
 550   - { reg: '$rsi', virtual-reg: '%1' }
 551 body:             |
 552   bb.0:
 553     successors: %bb.1, %bb.2, %bb.5
 554     liveins: $rdi, $rsi
 555
 556     %0:gr64 = COPY $rdi
 557     %1:gr64 = COPY $rsi
 558     CMP64rr %0, %1, implicit-def $eflags
 559     %2:gr64 = COPY $eflags
 560   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 561   ; CHECK:      %[[S_REG:[^:]*]]:gr8 = SETCCr 8, implicit $eflags
 562   ; CHECK-NEXT: %[[P_REG:[^:]*]]:gr8 = SETCCr 10, implicit $eflags
 563   ; CHECK-NEXT: %[[NE_REG:[^:]*]]:gr8 = SETCCr 5, implicit $eflags
 564   ; CHECK-NEXT: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 565   ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 566   ; CHECK-NEXT: %[[O_REG:[^:]*]]:gr8 = SETCCr 0, implicit $eflags
 567   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 568
 569     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 570     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 571     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 572
 573     $eflags = COPY %2
 574     JCC_1 %bb.1, 7, implicit $eflags
 575     JCC_1 %bb.2, 2, implicit $eflags
 576     JMP_1 %bb.5
 577   ; CHECK-NOT: $eflags =
 578   ;
 579   ; CHECK:        TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 580   ; CHECK-NEXT:   JCC_1 %bb.1, 5, implicit killed $eflags
 581   ; CHECK-SAME: {{$[[:space:]]}}
 582   ; CHECK-NEXT: bb.6:
 583   ; CHECK-NEXT:   successors: {{.*$}}
 584   ; CHECK-SAME: {{$[[:space:]]}}
 585   ; CHECK-NEXT:   TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
 586   ; CHECK-NEXT:   JCC_1 %bb.2, 5, implicit killed $eflags
 587   ; CHECK-NEXT:   JMP_1 %bb.5
 588
 589   bb.1:
 590     liveins: $eflags
 591
 592     %3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
 593   ; CHECK-NOT:     $eflags =
 594   ; CHECK:         TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
 595   ; CHECK-NEXT:    %3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
 596     $rax = COPY %3
 597     RET 0, $rax
 598
 599   bb.2:
 600     ; The goal is to have another batch of successors discovered in a block
 601     ; between two successors which kill $eflags. This ensures that neither of
 602     ; the surrounding kills impact recursing through this block.
 603     successors: %bb.3, %bb.4
 604     liveins: $eflags
 605
 606     JCC_1 %bb.3, 0, implicit $eflags
 607     JMP_1 %bb.4
 608   ; CHECK-NOT: $eflags =
 609   ;
 610   ; CHECK:        TEST8rr %[[O_REG]], %[[O_REG]], implicit-def $eflags
 611   ; CHECK-NEXT:   JCC_1 %bb.3, 5, implicit killed $eflags
 612   ; CHECK-NEXT:   JMP_1 %bb.4
 613
 614   bb.3:
 615     liveins: $eflags
 616
 617     %4:gr64 = CMOV64rr %0, %1, 5, implicit $eflags
 618   ; CHECK-NOT:     $eflags =
 619   ; CHECK:         TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
 620   ; CHECK-NEXT:    %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 621     $rax = COPY %4
 622     RET 0, $rax
 623
 624   bb.4:
 625     liveins: $eflags
 626
 627     %5:gr64 = CMOV64rr %0, %1, 10, implicit $eflags
 628   ; CHECK-NOT:     $eflags =
 629   ; CHECK:         TEST8rr %[[P_REG]], %[[P_REG]], implicit-def $eflags
 630   ; CHECK-NEXT:    %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 631     $rax = COPY %5
 632     RET 0, $rax
 633
 634   bb.5:
 635     liveins: $eflags
 636
 637     %6:gr64 = CMOV64rr %0, %1, 8, implicit killed $eflags
 638   ; CHECK-NOT:     $eflags =
 639   ; CHECK:         TEST8rr %[[S_REG]], %[[S_REG]], implicit-def $eflags
 640   ; CHECK-NEXT:    %6:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 641     $rax = COPY %6
 642     RET 0, $rax
 643
 644 ...
 645 ---
 646 # This test case is designed to exercise a particularly challenging situation:
 647 # when the flags are copied and restored *inside* of a complex and cyclic CFG
 648 # all of which have live-in flags. To correctly handle this case we have to walk
 649 # up the dominator tree and locate a viable reaching definition location,
 650 # checking for clobbers along any path. The CFG for this function looks like the
 651 # following diagram, control flowing out the bottom of blocks and in the top:
 652 #
 653 #  bb.0
 654 #   | __________________
 655 #   |/                  \
 656 #  bb.1                  |
 657 #   |\_________          |
 658 #   | __       \ ____    |
 659 #   |/  \      |/    \   |
 660 #  bb.2  |    bb.4    |  |
 661 #   |\__/     / \     |  |
 662 #   |        /   \    |  |
 663 #  bb.3    bb.5  bb.6 |  |
 664 #   |        \   /    |  |
 665 #   |         \ /     |  |
 666 #   |         bb.7    |  |
 667 #   | ________/ \____/   |
 668 #   |/                   |
 669 #  bb.8                  |
 670 #   |\__________________/
 671 #   |
 672 #  bb.9
 673 #
 674 # We set EFLAGS in bb.0, clobber them in bb.3, and copy them in bb.2 and bb.6.
 675 # Because of the cycles this requires hoisting the `SETcc` instructions to
 676 # capture the flags for the bb.6 copy to bb.1 and using them for the copy in
 677 # `bb.2` as well despite the clobber in `bb.3`. The clobber in `bb.3` also
 678 # prevents hoisting the `SETcc`s up to `bb.0`.
 679 #
 680 # Throughout the test we use branch instructions that are totally bogus (as the
 681 # flags are obviously not changing!) but this is just to allow us to send
 682 # a small but complex CFG structure through the backend and force it to choose
 683 # plausible lowering decisions based on the core CFG presented, regardless of
 684 # the futility of the actual branches.
 685 name:            test_mid_cycle_copies
 686 # CHECK-LABEL: name: test_mid_cycle_copies
 687 liveins:
 688   - { reg: '$rdi', virtual-reg: '%0' }
 689   - { reg: '$rsi', virtual-reg: '%1' }
 690 body:             |
 691   bb.0:
 692     successors: %bb.1
 693     liveins: $rdi, $rsi
 694
 695     %0:gr64 = COPY $rdi
 696     %1:gr64 = COPY $rsi
 697     CMP64rr %0, %1, implicit-def $eflags
 698   ; CHECK:      bb.0:
 699   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 700   ; CHECK:        CMP64rr %0, %1, implicit-def $eflags
 701   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 702     JMP_1 %bb.1
 703
 704   bb.1:
 705     successors: %bb.2, %bb.4
 706     liveins: $eflags
 707
 708     ; Outer loop header, target for one set of hoisting.
 709     JCC_1 %bb.2, 4, implicit $eflags
 710     JMP_1 %bb.4
 711   ; CHECK:      bb.1:
 712   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 713   ; CHECK:        %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 714   ; CHECK-NEXT:   %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
 715   ; CHECK-NEXT:   %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
 716   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 717
 718   bb.2:
 719     successors: %bb.2, %bb.3
 720     liveins: $eflags
 721
 722     ; Inner loop with a local copy. We should eliminate this but can't hoist.
 723     %2:gr64 = COPY $eflags
 724     $eflags = COPY %2
 725     JCC_1 %bb.2, 4, implicit $eflags
 726     JMP_1 %bb.3
 727   ; CHECK:      bb.2:
 728   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 729   ; CHECK:        TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
 730   ; CHECK-NEXT:   JCC_1 %bb.2, 5, implicit killed $eflags
 731   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 732
 733   bb.3:
 734     successors: %bb.8
 735     liveins: $eflags
 736
 737     ; Use and then clobber $eflags. Then hop to the outer loop latch.
 738     %3:gr64 = ADC64ri32 %0, 42, implicit-def dead $eflags, implicit $eflags
 739   ; CHECK:      bb.3:
 740   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 741   ; CHECK:        dead %{{[^:]*}}:gr8 = ADD8ri %[[B_REG]], 255, implicit-def $eflags
 742   ; CHECK-NEXT:   %3:gr64 = ADC64ri32 %0, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
 743   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 744     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %3
 745     JMP_1 %bb.8
 746
 747   bb.4:
 748     successors: %bb.5, %bb.6
 749     liveins: $eflags
 750
 751     ; Another inner loop, this one with a diamond.
 752     JCC_1 %bb.5, 4, implicit $eflags
 753     JMP_1 %bb.6
 754   ; CHECK:      bb.4:
 755   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 756   ; CHECK:        TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
 757   ; CHECK-NEXT:   JCC_1 %bb.5, 5, implicit killed $eflags
 758   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 759
 760   bb.5:
 761     successors: %bb.7
 762     liveins: $eflags
 763
 764     ; Just use $eflags on this side of the diamond.
 765     %4:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
 766   ; CHECK:      bb.5:
 767   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 768   ; CHECK:         TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 769   ; CHECK-NEXT:    %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 770   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 771     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4
 772     JMP_1 %bb.7
 773
 774   bb.6:
 775     successors: %bb.7
 776     liveins: $eflags
 777
 778     ; Use, copy, and then use $eflags again.
 779     %5:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
 780   ; CHECK:      bb.6:
 781   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 782   ; CHECK:        TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 783   ; CHECK-NEXT:   %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 784   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 785     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
 786
 787     %6:gr64 = COPY $eflags
 788     $eflags = COPY %6:gr64
 789
 790     %7:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
 791   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 792   ; CHECK:        TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 793   ; CHECK-NEXT:   %7:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
 794   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 795     MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %7
 796     JMP_1 %bb.7
 797
 798   bb.7:
 799     successors: %bb.4, %bb.8
 800     liveins: $eflags
 801
 802     ; Inner loop latch.
 803     JCC_1 %bb.4, 4, implicit $eflags
 804     JMP_1 %bb.8
 805   ; CHECK:      bb.7:
 806   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 807   ; CHECK:        TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
 808   ; CHECK-NEXT:   JCC_1 %bb.4, 5, implicit killed $eflags
 809   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 810
 811   bb.8:
 812     successors: %bb.1, %bb.9
 813
 814     ; Outer loop latch. Note that we cannot have EFLAGS live-in here as that
 815     ; immediately require PHIs.
 816     CMP64rr %0, %1, implicit-def $eflags
 817     JCC_1 %bb.1, 4, implicit $eflags
 818     JMP_1 %bb.9
 819   ; CHECK:      bb.8:
 820   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 821   ; CHECK:        CMP64rr %0, %1, implicit-def $eflags
 822   ; CHECK-NEXT:   JCC_1 %bb.1, 4, implicit $eflags
 823   ; CHECK-NOT:    COPY{{( killed)?}} $eflags
 824
 825   bb.9:
 826     liveins: $eflags
 827
 828     ; And we're done.
 829     %8:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
 830     $rax = COPY %8
 831     RET 0, $rax
 832   ; CHECK:      bb.9:
 833   ; CHECK-NEXT: liveins: $eflags
 834   ; CHECK-NOT:     $eflags
 835   ; CHECK:         %8:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
 836
 837 ...
 838 ---
 839 name:            test_existing_setcc
 840 # CHECK-LABEL: name: test_existing_setcc
 841 liveins:
 842   - { reg: '$rdi', virtual-reg: '%0' }
 843   - { reg: '$rsi', virtual-reg: '%1' }
 844 body:             |
 845   bb.0:
 846     successors: %bb.1, %bb.2, %bb.3
 847     liveins: $rdi, $rsi
 848
 849     %0:gr64 = COPY $rdi
 850     %1:gr64 = COPY $rsi
 851     CMP64rr %0, %1, implicit-def $eflags
 852     %2:gr8 = SETCCr 7, implicit $eflags
 853     %3:gr8 = SETCCr 3, implicit $eflags
 854     %4:gr64 = COPY $eflags
 855   ; CHECK:      CMP64rr %0, %1, implicit-def $eflags
 856   ; CHECK-NEXT: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
 857   ; CHECK-NEXT: %[[AE_REG:[^:]*]]:gr8 = SETCCr 3, implicit $eflags
 858   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 859
 860     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 861     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 862     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 863
 864     $eflags = COPY %4
 865     JCC_1 %bb.1, 7, implicit $eflags
 866     JCC_1 %bb.2, 2, implicit $eflags
 867     JMP_1 %bb.3
 868   ; CHECK-NOT: $eflags =
 869   ;
 870   ; CHECK:        TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
 871   ; CHECK-NEXT:   JCC_1 %bb.1, 5, implicit killed $eflags
 872   ; CHECK-SAME: {{$[[:space:]]}}
 873   ; CHECK-NEXT: bb.4:
 874   ; CHECK-NEXT:   successors: {{.*$}}
 875   ; CHECK-SAME: {{$[[:space:]]}}
 876   ; CHECK-NEXT:   TEST8rr %[[AE_REG]], %[[AE_REG]], implicit-def $eflags
 877   ; CHECK-NEXT:   JCC_1 %bb.2, 4, implicit killed $eflags
 878   ; CHECK-NEXT:   JMP_1 %bb.3
 879
 880   bb.1:
 881     %5:gr32 = MOV32ri 42
 882     $eax = COPY %5
 883     RET 0, $eax
 884
 885   bb.2:
 886     %6:gr32 = MOV32ri 43
 887     $eax = COPY %6
 888     RET 0, $eax
 889
 890   bb.3:
 891     %7:gr32 = MOV32r0 implicit-def dead $eflags
 892     $eax = COPY %7
 893     RET 0, $eax
 894
 895 ...
 896 ---
 897 name:            test_existing_setcc_memory
 898 # CHECK-LABEL: name: test_existing_setcc_memory
 899 liveins:
 900   - { reg: '$rdi', virtual-reg: '%0' }
 901   - { reg: '$rsi', virtual-reg: '%1' }
 902 body:             |
 903   bb.0:
 904     successors: %bb.1, %bb.2
 905     liveins: $rdi, $rsi
 906
 907     %0:gr64 = COPY $rdi
 908     %1:gr64 = COPY $rsi
 909     CMP64rr %0, %1, implicit-def $eflags
 910     SETCCm %0, 1, $noreg, -16, $noreg, 4, implicit $eflags
 911     %2:gr64 = COPY $eflags
 912   ; CHECK:      CMP64rr %0, %1, implicit-def $eflags
 913   ; We cannot reuse this SETE because it stores the flag directly to memory,
 914   ; so we have two SETEs here. FIXME: It'd be great if something could fold
 915   ; these automatically. If not, maybe we want to unfold SETcc instructions
 916   ; writing to memory so we can reuse them.
 917   ; CHECK-NEXT: SETCCm {{.*}} 4, implicit $eflags
 918   ; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
 919   ; CHECK-NOT:  COPY{{( killed)?}} $eflags
 920
 921     ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 922     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
 923     ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
 924
 925     $eflags = COPY %2
 926     JCC_1 %bb.1, 4, implicit $eflags
 927     JMP_1 %bb.2
 928   ; CHECK-NOT: $eflags =
 929   ;
 930   ; CHECK:        TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
 931   ; CHECK-NEXT:   JCC_1 %bb.1, 5, implicit killed $eflags
 932   ; CHECK-NEXT:   JMP_1 %bb.2
 933
 934   bb.1:
 935     %3:gr32 = MOV32ri 42
 936     $eax = COPY %3
 937     RET 0, $eax
 938
 939   bb.2:
 940     %4:gr32 = MOV32ri 43
 941     $eax = COPY %4
 942     RET 0, $eax
 943
 944 ...