forked from OSchip/llvm-project
1058 lines
37 KiB
YAML
1058 lines
37 KiB
YAML
# RUN: llc -run-pass x86-flags-copy-lowering -verify-machineinstrs -o - %s | FileCheck %s
|
|
#
|
|
# Lower various interesting copy patterns of EFLAGS without using LAHF/SAHF.
|
|
|
|
--- |
|
|
target triple = "x86_64-unknown-unknown"
|
|
|
|
declare void @foo()
|
|
|
|
define i32 @test_branch(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret i32 0
|
|
}
|
|
|
|
define i32 @test_branch_fallthrough(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret i32 0
|
|
}
|
|
|
|
define void @test_setcc(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_cmov(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_adc(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_sbb(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_adcx(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_adox(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_rcl(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_rcr(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define void @test_setb_c(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret void
|
|
}
|
|
|
|
define i64 @test_branch_with_livein_and_kill(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret i64 0
|
|
}
|
|
|
|
define i64 @test_branch_with_interleaved_livein_and_kill(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret i64 0
|
|
}
|
|
|
|
define i64 @test_mid_cycle_copies(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret i64 0
|
|
}
|
|
|
|
define i32 @test_existing_setcc(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret i32 0
|
|
}
|
|
|
|
define i32 @test_existing_setcc_memory(i64 %a, i64 %b) {
|
|
entry:
|
|
call void @foo()
|
|
ret i32 0
|
|
}
|
|
...
|
|
---
|
|
name: test_branch
|
|
# CHECK-LABEL: name: test_branch
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
successors: %bb.1, %bb.2, %bb.3
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
%2:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %2
|
|
JCC_1 %bb.1, 7, implicit $eflags
|
|
JCC_1 %bb.2, 2, implicit $eflags
|
|
JMP_1 %bb.3
|
|
; CHECK-NOT: $eflags =
|
|
;
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.1, 5, implicit killed $eflags
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: bb.4:
|
|
; CHECK-NEXT: successors: {{.*$}}
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.2, 5, implicit killed $eflags
|
|
; CHECK-NEXT: JMP_1 %bb.3
|
|
|
|
bb.1:
|
|
%3:gr32 = MOV32ri 42
|
|
$eax = COPY %3
|
|
RET 0, $eax
|
|
|
|
bb.2:
|
|
%4:gr32 = MOV32ri 43
|
|
$eax = COPY %4
|
|
RET 0, $eax
|
|
|
|
bb.3:
|
|
%5:gr32 = MOV32r0 implicit-def dead $eflags
|
|
$eax = COPY %5
|
|
RET 0, $eax
|
|
|
|
...
|
|
---
|
|
name: test_branch_fallthrough
|
|
# CHECK-LABEL: name: test_branch_fallthrough
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
successors: %bb.1, %bb.2, %bb.3
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
%2:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %2
|
|
JCC_1 %bb.2, 7, implicit $eflags
|
|
JCC_1 %bb.3, 2, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
;
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.2, 5, implicit killed $eflags
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: bb.4:
|
|
; CHECK-NEXT: successors: {{.*$}}
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.3, 5, implicit killed $eflags
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: bb.1:
|
|
|
|
bb.1:
|
|
%5:gr32 = MOV32r0 implicit-def dead $eflags
|
|
$eax = COPY %5
|
|
RET 0, $eax
|
|
|
|
bb.2:
|
|
%3:gr32 = MOV32ri 42
|
|
$eax = COPY %3
|
|
RET 0, $eax
|
|
|
|
bb.3:
|
|
%4:gr32 = MOV32ri 43
|
|
$eax = COPY %4
|
|
RET 0, $eax
|
|
|
|
...
|
|
---
|
|
name: test_setcc
|
|
# CHECK-LABEL: name: test_setcc
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
%2:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
|
|
; CHECK-NEXT: %[[NE_REG:[^:]*]]:gr8 = SETCCr 5, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %2
|
|
%3:gr8 = SETCCr 7, implicit $eflags
|
|
%4:gr8 = SETCCr 2, implicit $eflags
|
|
%5:gr8 = SETCCr 4, implicit $eflags
|
|
SETCCm $rsp, 1, $noreg, -16, $noreg, 5, implicit killed $eflags
|
|
MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %3
|
|
MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %4
|
|
MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK-NOT: = SET{{.*}}
|
|
; CHECK: MOV8mr {{.*}}, killed %[[A_REG]]
|
|
; CHECK-NEXT: MOV8mr {{.*}}, killed %[[B_REG]]
|
|
; CHECK-NEXT: MOV8mr {{.*}}, killed %[[E_REG]]
|
|
; CHECK-NOT: MOV8mr {{.*}}, killed %[[NE_REG]]
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_cmov
|
|
# CHECK-LABEL: name: test_cmov
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
%2:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %2
|
|
%3:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
|
|
%4:gr64 = CMOV64rr %0, %1, 2, implicit $eflags
|
|
%5:gr64 = CMOV64rr %0, %1, 4, implicit $eflags
|
|
%6:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %3:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NEXT: TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NEXT: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NEXT: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %6:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %3
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %6
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_adc
|
|
# CHECK-LABEL: name: test_adc
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
%2:gr64 = ADD64rr %0, %1, implicit-def $eflags
|
|
%3:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %3
|
|
%4:gr64 = ADC64ri32 %2:gr64, 42, implicit-def $eflags, implicit $eflags
|
|
%5:gr64 = ADC64ri32 %4:gr64, 42, implicit-def $eflags, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = ADC64ri32 %2, 42, implicit-def $eflags, implicit killed $eflags
|
|
; CHECK-NEXT: %5:gr64 = ADC64ri32 %4, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_sbb
|
|
# CHECK-LABEL: name: test_sbb
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
%2:gr64 = SUB64rr %0, %1, implicit-def $eflags
|
|
%3:gr64 = COPY killed $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %3
|
|
%4:gr64 = SBB64ri32 %2:gr64, 42, implicit-def $eflags, implicit killed $eflags
|
|
%5:gr64 = SBB64ri32 %4:gr64, 42, implicit-def dead $eflags, implicit killed $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = SBB64ri32 %2, 42, implicit-def $eflags, implicit killed $eflags
|
|
; CHECK-NEXT: %5:gr64 = SBB64ri32 %4, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_adcx
|
|
# CHECK-LABEL: name: test_adcx
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
%2:gr64 = ADD64rr %0, %1, implicit-def $eflags
|
|
%3:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
|
|
; CHECK-NEXT: %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %3
|
|
%4:gr64 = CMOV64rr %0, %1, 4, implicit $eflags
|
|
%5:gr64 = MOV64ri32 42
|
|
%6:gr64 = ADCX64rr %2, %5, implicit-def $eflags, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NEXT: %5:gr64 = MOV64ri32 42
|
|
; CHECK-NEXT: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
|
|
; CHECK-NEXT: %6:gr64 = ADCX64rr %2, %5, implicit-def{{( dead)?}} $eflags, implicit killed $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %6
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_adox
|
|
# CHECK-LABEL: name: test_adox
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
%2:gr64 = ADD64rr %0, %1, implicit-def $eflags
|
|
%3:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
|
|
; CHECK-NEXT: %[[OF_REG:[^:]*]]:gr8 = SETCCr 0, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %3
|
|
%4:gr64 = CMOV64rr %0, %1, 4, implicit $eflags
|
|
%5:gr64 = MOV64ri32 42
|
|
%6:gr64 = ADOX64rr %2, %5, implicit-def $eflags, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NEXT: %5:gr64 = MOV64ri32 42
|
|
; CHECK-NEXT: dead %{{[^:]*}}:gr8 = ADD8ri %[[OF_REG]], 127, implicit-def $eflags
|
|
; CHECK-NEXT: %6:gr64 = ADOX64rr %2, %5, implicit-def{{( dead)?}} $eflags, implicit killed $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %6
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_rcl
|
|
# CHECK-LABEL: name: test_rcl
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
%2:gr64 = ADD64rr %0, %1, implicit-def $eflags
|
|
%3:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %3
|
|
%4:gr64 = RCL64r1 %2:gr64, implicit-def $eflags, implicit $eflags
|
|
%5:gr64 = RCL64r1 %4:gr64, implicit-def $eflags, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = RCL64r1 %2, implicit-def $eflags, implicit killed $eflags
|
|
; CHECK-NEXT: %5:gr64 = RCL64r1 %4, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_rcr
|
|
# CHECK-LABEL: name: test_rcr
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
%2:gr64 = ADD64rr %0, %1, implicit-def $eflags
|
|
%3:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %3
|
|
%4:gr64 = RCR64r1 %2:gr64, implicit-def $eflags, implicit $eflags
|
|
%5:gr64 = RCR64r1 %4:gr64, implicit-def $eflags, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 255, implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = RCR64r1 %2, implicit-def $eflags, implicit killed $eflags
|
|
; CHECK-NEXT: %5:gr64 = RCR64r1 %4, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_setb_c
|
|
# CHECK-LABEL: name: test_setb_c
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
%2:gr64 = ADD64rr %0, %1, implicit-def $eflags
|
|
%3:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %3
|
|
%4:gr8 = SETB_C8r implicit-def $eflags, implicit $eflags
|
|
MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %4
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: %[[ZERO:[^:]*]]:gr32 = MOV32r0 implicit-def $eflags
|
|
; CHECK-NEXT: %[[ZERO_SUBREG:[^:]*]]:gr8 = COPY %[[ZERO]].sub_8bit
|
|
; CHECK-NEXT: %[[REPLACEMENT:[^:]*]]:gr8 = SUB8rr %[[ZERO_SUBREG]], %[[CF_REG]]
|
|
; CHECK-NEXT: MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %[[REPLACEMENT]]
|
|
|
|
$eflags = COPY %3
|
|
%5:gr16 = SETB_C16r implicit-def $eflags, implicit $eflags
|
|
MOV16mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: %[[CF_EXT:[^:]*]]:gr32 = MOVZX32rr8 %[[CF_REG]]
|
|
; CHECK-NEXT: %[[CF_TRUNC:[^:]*]]:gr16 = COPY %[[CF_EXT]].sub_16bit
|
|
; CHECK-NEXT: %[[ZERO:[^:]*]]:gr32 = MOV32r0 implicit-def $eflags
|
|
; CHECK-NEXT: %[[ZERO_SUBREG:[^:]*]]:gr16 = COPY %[[ZERO]].sub_16bit
|
|
; CHECK-NEXT: %[[REPLACEMENT:[^:]*]]:gr16 = SUB16rr %[[ZERO_SUBREG]], %[[CF_TRUNC]]
|
|
; CHECK-NEXT: MOV16mr $rsp, 1, $noreg, -16, $noreg, killed %[[REPLACEMENT]]
|
|
|
|
$eflags = COPY %3
|
|
%6:gr32 = SETB_C32r implicit-def $eflags, implicit $eflags
|
|
MOV32mr $rsp, 1, $noreg, -16, $noreg, killed %6
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: %[[CF_EXT:[^:]*]]:gr32 = MOVZX32rr8 %[[CF_REG]]
|
|
; CHECK-NEXT: %[[ZERO:[^:]*]]:gr32 = MOV32r0 implicit-def $eflags
|
|
; CHECK-NEXT: %[[REPLACEMENT:[^:]*]]:gr32 = SUB32rr %[[ZERO]], %[[CF_EXT]]
|
|
; CHECK-NEXT: MOV32mr $rsp, 1, $noreg, -16, $noreg, killed %[[REPLACEMENT]]
|
|
|
|
$eflags = COPY %3
|
|
%7:gr64 = SETB_C64r implicit-def $eflags, implicit $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %7
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: %[[CF_EXT1:[^:]*]]:gr32 = MOVZX32rr8 %[[CF_REG]]
|
|
; CHECK-NEXT: %[[CF_EXT2:[^:]*]]:gr64 = SUBREG_TO_REG 0, %[[CF_EXT1]], %subreg.sub_32bit
|
|
; CHECK-NEXT: %[[ZERO:[^:]*]]:gr32 = MOV32r0 implicit-def $eflags
|
|
; CHECK-NEXT: %[[ZERO_EXT:[^:]*]]:gr64 = SUBREG_TO_REG 0, %[[ZERO]], %subreg.sub_32bit
|
|
; CHECK-NEXT: %[[REPLACEMENT:[^:]*]]:gr64 = SUB64rr %[[ZERO_EXT]], %[[CF_EXT2]]
|
|
; CHECK-NEXT: MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %[[REPLACEMENT]]
|
|
|
|
RET 0
|
|
|
|
...
|
|
---
|
|
name: test_branch_with_livein_and_kill
|
|
# CHECK-LABEL: name: test_branch_with_livein_and_kill
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
successors: %bb.1, %bb.2, %bb.3
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
%2:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[S_REG:[^:]*]]:gr8 = SETCCr 8, implicit $eflags
|
|
; CHECK-NEXT: %[[NE_REG:[^:]*]]:gr8 = SETCCr 5, implicit $eflags
|
|
; CHECK-NEXT: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %2
|
|
JCC_1 %bb.1, 7, implicit $eflags
|
|
JCC_1 %bb.2, 2, implicit $eflags
|
|
JMP_1 %bb.3
|
|
; CHECK-NOT: $eflags =
|
|
;
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.1, 5, implicit killed $eflags
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: bb.4:
|
|
; CHECK-NEXT: successors: {{.*$}}
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.2, 5, implicit killed $eflags
|
|
; CHECK-NEXT: JMP_1 %bb.3
|
|
|
|
bb.1:
|
|
liveins: $eflags
|
|
|
|
%3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
|
|
$rax = COPY %3
|
|
RET 0, $rax
|
|
|
|
bb.2:
|
|
liveins: $eflags
|
|
|
|
%4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
$rax = COPY %4
|
|
RET 0, $rax
|
|
|
|
bb.3:
|
|
liveins: $eflags
|
|
|
|
%5:gr64 = CMOV64rr %0, %1, 8, implicit killed $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[S_REG]], %[[S_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
$rax = COPY %5
|
|
RET 0, $rax
|
|
|
|
...
|
|
---
|
|
name: test_branch_with_interleaved_livein_and_kill
|
|
# CHECK-LABEL: name: test_branch_with_interleaved_livein_and_kill
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
successors: %bb.1, %bb.2, %bb.5
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
%2:gr64 = COPY $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[S_REG:[^:]*]]:gr8 = SETCCr 8, implicit $eflags
|
|
; CHECK-NEXT: %[[P_REG:[^:]*]]:gr8 = SETCCr 10, implicit $eflags
|
|
; CHECK-NEXT: %[[NE_REG:[^:]*]]:gr8 = SETCCr 5, implicit $eflags
|
|
; CHECK-NEXT: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NEXT: %[[O_REG:[^:]*]]:gr8 = SETCCr 0, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %2
|
|
JCC_1 %bb.1, 7, implicit $eflags
|
|
JCC_1 %bb.2, 2, implicit $eflags
|
|
JMP_1 %bb.5
|
|
; CHECK-NOT: $eflags =
|
|
;
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.1, 5, implicit killed $eflags
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: bb.6:
|
|
; CHECK-NEXT: successors: {{.*$}}
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: TEST8rr %[[B_REG]], %[[B_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.2, 5, implicit killed $eflags
|
|
; CHECK-NEXT: JMP_1 %bb.5
|
|
|
|
bb.1:
|
|
liveins: $eflags
|
|
|
|
%3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %3:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
|
|
$rax = COPY %3
|
|
RET 0, $rax
|
|
|
|
bb.2:
|
|
; The goal is to have another batch of successors discovered in a block
|
|
; between two successors which kill $eflags. This ensures that neither of
|
|
; the surrounding kills impact recursing through this block.
|
|
successors: %bb.3, %bb.4
|
|
liveins: $eflags
|
|
|
|
JCC_1 %bb.3, 0, implicit $eflags
|
|
JMP_1 %bb.4
|
|
; CHECK-NOT: $eflags =
|
|
;
|
|
; CHECK: TEST8rr %[[O_REG]], %[[O_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.3, 5, implicit killed $eflags
|
|
; CHECK-NEXT: JMP_1 %bb.4
|
|
|
|
bb.3:
|
|
liveins: $eflags
|
|
|
|
%4:gr64 = CMOV64rr %0, %1, 5, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[NE_REG]], %[[NE_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
$rax = COPY %4
|
|
RET 0, $rax
|
|
|
|
bb.4:
|
|
liveins: $eflags
|
|
|
|
%5:gr64 = CMOV64rr %0, %1, 10, implicit $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[P_REG]], %[[P_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
$rax = COPY %5
|
|
RET 0, $rax
|
|
|
|
bb.5:
|
|
liveins: $eflags
|
|
|
|
%6:gr64 = CMOV64rr %0, %1, 8, implicit killed $eflags
|
|
; CHECK-NOT: $eflags =
|
|
; CHECK: TEST8rr %[[S_REG]], %[[S_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %6:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
$rax = COPY %6
|
|
RET 0, $rax
|
|
|
|
...
|
|
---
|
|
# This test case is designed to exercise a particularly challenging situation:
|
|
# when the flags are copied and restored *inside* of a complex and cyclic CFG
|
|
# all of which have live-in flags. To correctly handle this case we have to walk
|
|
# up the dominator tree and locate a viable reaching definition location,
|
|
# checking for clobbers along any path. The CFG for this function looks like the
|
|
# following diagram, control flowing out the bottom of blocks and in the top:
|
|
#
|
|
# bb.0
|
|
# | __________________
|
|
# |/ \
|
|
# bb.1 |
|
|
# |\_________ |
|
|
# | __ \ ____ |
|
|
# |/ \ |/ \ |
|
|
# bb.2 | bb.4 | |
|
|
# |\__/ / \ | |
|
|
# | / \ | |
|
|
# bb.3 bb.5 bb.6 | |
|
|
# | \ / | |
|
|
# | \ / | |
|
|
# | bb.7 | |
|
|
# | ________/ \____/ |
|
|
# |/ |
|
|
# bb.8 |
|
|
# |\__________________/
|
|
# |
|
|
# bb.9
|
|
#
|
|
# We set EFLAGS in bb.0, clobber them in bb.3, and copy them in bb.2 and bb.6.
|
|
# Because of the cycles this requires hoisting the `SETcc` instructions to
|
|
# capture the flags for the bb.6 copy to bb.1 and using them for the copy in
|
|
# `bb.2` as well despite the clobber in `bb.3`. The clobber in `bb.3` also
|
|
# prevents hoisting the `SETcc`s up to `bb.0`.
|
|
#
|
|
# Throughout the test we use branch instructions that are totally bogus (as the
|
|
# flags are obviously not changing!) but this is just to allow us to send
|
|
# a small but complex CFG structure through the backend and force it to choose
|
|
# plausible lowering decisions based on the core CFG presented, regardless of
|
|
# the futility of the actual branches.
|
|
name: test_mid_cycle_copies
|
|
# CHECK-LABEL: name: test_mid_cycle_copies
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
successors: %bb.1
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
; CHECK: bb.0:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: CMP64rr %0, %1, implicit-def $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
JMP_1 %bb.1
|
|
|
|
bb.1:
|
|
successors: %bb.2, %bb.4
|
|
liveins: $eflags
|
|
|
|
; Outer loop header, target for one set of hoisting.
|
|
JCC_1 %bb.2, 4, implicit $eflags
|
|
JMP_1 %bb.4
|
|
; CHECK: bb.1:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
|
|
; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETCCr 2, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
bb.2:
|
|
successors: %bb.2, %bb.3
|
|
liveins: $eflags
|
|
|
|
; Inner loop with a local copy. We should eliminate this but can't hoist.
|
|
%2:gr64 = COPY $eflags
|
|
$eflags = COPY %2
|
|
JCC_1 %bb.2, 4, implicit $eflags
|
|
JMP_1 %bb.3
|
|
; CHECK: bb.2:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.2, 5, implicit killed $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
bb.3:
|
|
successors: %bb.8
|
|
liveins: $eflags
|
|
|
|
; Use and then clobber $eflags. Then hop to the outer loop latch.
|
|
%3:gr64 = ADC64ri32 %0, 42, implicit-def dead $eflags, implicit $eflags
|
|
; CHECK: bb.3:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[B_REG]], 255, implicit-def $eflags
|
|
; CHECK-NEXT: %3:gr64 = ADC64ri32 %0, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %3
|
|
JMP_1 %bb.8
|
|
|
|
bb.4:
|
|
successors: %bb.5, %bb.6
|
|
liveins: $eflags
|
|
|
|
; Another inner loop, this one with a diamond.
|
|
JCC_1 %bb.5, 4, implicit $eflags
|
|
JMP_1 %bb.6
|
|
; CHECK: bb.4:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.5, 5, implicit killed $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
bb.5:
|
|
successors: %bb.7
|
|
liveins: $eflags
|
|
|
|
; Just use $eflags on this side of the diamond.
|
|
%4:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
|
|
; CHECK: bb.5:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %4:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4
|
|
JMP_1 %bb.7
|
|
|
|
bb.6:
|
|
successors: %bb.7
|
|
liveins: $eflags
|
|
|
|
; Use, copy, and then use $eflags again.
|
|
%5:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
|
|
; CHECK: bb.6:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %5:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5
|
|
|
|
%6:gr64 = COPY $eflags
|
|
$eflags = COPY %6:gr64
|
|
|
|
%7:gr64 = CMOV64rr %0, %1, 7, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: %7:gr64 = CMOV64rr %0, %1, 5, implicit killed $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %7
|
|
JMP_1 %bb.7
|
|
|
|
bb.7:
|
|
successors: %bb.4, %bb.8
|
|
liveins: $eflags
|
|
|
|
; Inner loop latch.
|
|
JCC_1 %bb.4, 4, implicit $eflags
|
|
JMP_1 %bb.8
|
|
; CHECK: bb.7:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.4, 5, implicit killed $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
bb.8:
|
|
successors: %bb.1, %bb.9
|
|
|
|
; Outer loop latch. Note that we cannot have EFLAGS live-in here as that
|
|
; immediately require PHIs.
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
JCC_1 %bb.1, 4, implicit $eflags
|
|
JMP_1 %bb.9
|
|
; CHECK: bb.8:
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
; CHECK: CMP64rr %0, %1, implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.1, 4, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
bb.9:
|
|
liveins: $eflags
|
|
|
|
; And we're done.
|
|
%8:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
|
|
$rax = COPY %8
|
|
RET 0, $rax
|
|
; CHECK: bb.9:
|
|
; CHECK-NOT: $eflags
|
|
; CHECK: %8:gr64 = CMOV64rr %0, %1, 4, implicit killed $eflags
|
|
|
|
...
|
|
---
|
|
name: test_existing_setcc
|
|
# CHECK-LABEL: name: test_existing_setcc
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
successors: %bb.1, %bb.2, %bb.3
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
%2:gr8 = SETCCr 7, implicit $eflags
|
|
%3:gr8 = SETCCr 3, implicit $eflags
|
|
%4:gr64 = COPY $eflags
|
|
; CHECK: CMP64rr %0, %1, implicit-def $eflags
|
|
; CHECK-NEXT: %[[A_REG:[^:]*]]:gr8 = SETCCr 7, implicit $eflags
|
|
; CHECK-NEXT: %[[AE_REG:[^:]*]]:gr8 = SETCCr 3, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %4
|
|
JCC_1 %bb.1, 7, implicit $eflags
|
|
JCC_1 %bb.2, 2, implicit $eflags
|
|
JMP_1 %bb.3
|
|
; CHECK-NOT: $eflags =
|
|
;
|
|
; CHECK: TEST8rr %[[A_REG]], %[[A_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.1, 5, implicit killed $eflags
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: bb.4:
|
|
; CHECK-NEXT: successors: {{.*$}}
|
|
; CHECK-SAME: {{$[[:space:]]}}
|
|
; CHECK-NEXT: TEST8rr %[[AE_REG]], %[[AE_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.2, 4, implicit killed $eflags
|
|
; CHECK-NEXT: JMP_1 %bb.3
|
|
|
|
bb.1:
|
|
%5:gr32 = MOV32ri 42
|
|
$eax = COPY %5
|
|
RET 0, $eax
|
|
|
|
bb.2:
|
|
%6:gr32 = MOV32ri 43
|
|
$eax = COPY %6
|
|
RET 0, $eax
|
|
|
|
bb.3:
|
|
%7:gr32 = MOV32r0 implicit-def dead $eflags
|
|
$eax = COPY %7
|
|
RET 0, $eax
|
|
|
|
...
|
|
---
|
|
name: test_existing_setcc_memory
|
|
# CHECK-LABEL: name: test_existing_setcc_memory
|
|
liveins:
|
|
- { reg: '$rdi', virtual-reg: '%0' }
|
|
- { reg: '$rsi', virtual-reg: '%1' }
|
|
body: |
|
|
bb.0:
|
|
successors: %bb.1, %bb.2
|
|
liveins: $rdi, $rsi
|
|
|
|
%0:gr64 = COPY $rdi
|
|
%1:gr64 = COPY $rsi
|
|
CMP64rr %0, %1, implicit-def $eflags
|
|
SETCCm %0, 1, $noreg, -16, $noreg, 4, implicit $eflags
|
|
%2:gr64 = COPY $eflags
|
|
; CHECK: CMP64rr %0, %1, implicit-def $eflags
|
|
; We cannot reuse this SETE because it stores the flag directly to memory,
|
|
; so we have two SETEs here. FIXME: It'd be great if something could fold
|
|
; these automatically. If not, maybe we want to unfold SETcc instructions
|
|
; writing to memory so we can reuse them.
|
|
; CHECK-NEXT: SETCCm {{.*}} 4, implicit $eflags
|
|
; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETCCr 4, implicit $eflags
|
|
; CHECK-NOT: COPY{{( killed)?}} $eflags
|
|
|
|
ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax
|
|
ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp
|
|
|
|
$eflags = COPY %2
|
|
JCC_1 %bb.1, 4, implicit $eflags
|
|
JMP_1 %bb.2
|
|
; CHECK-NOT: $eflags =
|
|
;
|
|
; CHECK: TEST8rr %[[E_REG]], %[[E_REG]], implicit-def $eflags
|
|
; CHECK-NEXT: JCC_1 %bb.1, 5, implicit killed $eflags
|
|
; CHECK-NEXT: JMP_1 %bb.2
|
|
|
|
bb.1:
|
|
%3:gr32 = MOV32ri 42
|
|
$eax = COPY %3
|
|
RET 0, $eax
|
|
|
|
bb.2:
|
|
%4:gr32 = MOV32ri 43
|
|
$eax = COPY %4
|
|
RET 0, $eax
|
|
|
|
...
|