2012-05-06 16:25:16 +02:00
|
|
|
; RUN: llc -march=x86-64 -mcpu=core2 < %s | FileCheck %s
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
llvm-svn: 156234
2012-05-05 14:49:22 +02:00
|
|
|
|
|
|
|
|
; cmp with single-use load, should not form cmov.
|
|
|
|
|
define i32 @test1(double %a, double* nocapture %b, i32 %x, i32 %y) {
|
|
|
|
|
%load = load double* %b, align 8
|
|
|
|
|
%cmp = fcmp olt double %load, %a
|
|
|
|
|
%cond = select i1 %cmp, i32 %x, i32 %y
|
|
|
|
|
ret i32 %cond
|
2013-07-13 22:38:47 +02:00
|
|
|
; CHECK-LABEL: test1:
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
llvm-svn: 156234
2012-05-05 14:49:22 +02:00
|
|
|
; CHECK: ucomisd
|
|
|
|
|
; CHECK-NOT: cmov
|
|
|
|
|
; CHECK: j
|
|
|
|
|
; CHECK-NOT: cmov
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Sanity check: no load.
|
|
|
|
|
define i32 @test2(double %a, double %b, i32 %x, i32 %y) {
|
|
|
|
|
%cmp = fcmp ogt double %a, %b
|
|
|
|
|
%cond = select i1 %cmp, i32 %x, i32 %y
|
|
|
|
|
ret i32 %cond
|
2013-07-13 22:38:47 +02:00
|
|
|
; CHECK-LABEL: test2:
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
llvm-svn: 156234
2012-05-05 14:49:22 +02:00
|
|
|
; CHECK: ucomisd
|
|
|
|
|
; CHECK: cmov
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Multiple uses of %a, should not form cmov.
|
|
|
|
|
define i32 @test3(i32 %a, i32* nocapture %b, i32 %x) {
|
|
|
|
|
%load = load i32* %b, align 4
|
|
|
|
|
%cmp = icmp ult i32 %load, %a
|
|
|
|
|
%cond = select i1 %cmp, i32 %a, i32 %x
|
|
|
|
|
ret i32 %cond
|
2013-07-13 22:38:47 +02:00
|
|
|
; CHECK-LABEL: test3:
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
llvm-svn: 156234
2012-05-05 14:49:22 +02:00
|
|
|
; CHECK: cmpl
|
|
|
|
|
; CHECK-NOT: cmov
|
|
|
|
|
; CHECK: j
|
|
|
|
|
; CHECK-NOT: cmov
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Multiple uses of the load.
|
|
|
|
|
define i32 @test4(i32 %a, i32* nocapture %b, i32 %x, i32 %y) {
|
|
|
|
|
%load = load i32* %b, align 4
|
|
|
|
|
%cmp = icmp ult i32 %load, %a
|
|
|
|
|
%cond = select i1 %cmp, i32 %x, i32 %y
|
|
|
|
|
%add = add i32 %cond, %load
|
|
|
|
|
ret i32 %add
|
2013-07-13 22:38:47 +02:00
|
|
|
; CHECK-LABEL: test4:
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
llvm-svn: 156234
2012-05-05 14:49:22 +02:00
|
|
|
; CHECK: cmpl
|
|
|
|
|
; CHECK: cmov
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; Multiple uses of the cmp.
|
|
|
|
|
define i32 @test5(i32 %a, i32* nocapture %b, i32 %x, i32 %y) {
|
|
|
|
|
%load = load i32* %b, align 4
|
|
|
|
|
%cmp = icmp ult i32 %load, %a
|
|
|
|
|
%cmp1 = icmp ugt i32 %load, %a
|
|
|
|
|
%cond = select i1 %cmp1, i32 %a, i32 %y
|
|
|
|
|
%cond5 = select i1 %cmp, i32 %cond, i32 %x
|
|
|
|
|
ret i32 %cond5
|
2013-07-13 22:38:47 +02:00
|
|
|
; CHECK-LABEL: test5:
|
CodeGenPrepare: Add a transform to turn selects into branches in some cases.
This came up when a change in block placement formed a cmov and slowed down a
hot loop by 50%:
ucomisd (%rdi), %xmm0
cmovbel %edx, %esi
cmov is a really bad choice in this context because it doesn't get branch
prediction. If we emit it as a branch, an out-of-order CPU can do a better job
(if the branch is predicted right) and avoid waiting for the slow load+compare
instruction to finish. Of course it won't help if the branch is unpredictable,
but those are really rare in practice.
This patch uses a dumb conservative heuristic, it turns all cmovs that have one
use and a direct memory operand into branches. cmovs usually save some code
size, so we disable the transform in -Os mode. In-Order architectures are
unlikely to benefit as well, those are included in the
"predictableSelectIsExpensive" flag.
It would be better to reuse branch probability info here, but BPI doesn't
support select instructions currently. It would make sense to use the same
heuristics as the if-converter pass, which does the opposite direction of this
transform.
Test suite shows a small improvement here and there on corei7-level machines,
but the actual results depend a lot on the used microarchitecture. The
transformation is currently disabled by default and available by passing the
-enable-cgp-select2branch flag to the code generator.
Thanks to Chandler for the initial test case to him and Evan Cheng for providing
me with comments and test-suite numbers that were more stable than mine :)
llvm-svn: 156234
2012-05-05 14:49:22 +02:00
|
|
|
; CHECK: cmpl
|
|
|
|
|
; CHECK: cmov
|
|
|
|
|
; CHECK: cmov
|
|
|
|
|
}
|
