maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/test/Transforms/InstCombine/fmul.ll

615 lines
21 KiB
LLVM
Raw Normal View History

[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
; RUN: opt -S -instcombine < %s | FileCheck %s
; (-0.0 - X) * C => X * -C
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
define float @neg_constant(float %x) {
; CHECK-LABEL: @neg_constant(
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
; CHECK-NEXT: [[MUL:%.*]] = fmul ninf float [[X:%.*]], -2.000000e+01
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: ret float [[MUL]]
;
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
%sub = fsub float -0.000000e+00, %x
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
%mul = fmul ninf float %sub, 2.0e+1
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
ret float %mul
}
; (0.0 - X) * C => X * -C
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
define float @neg_nsz_constant(float %x) {
; CHECK-LABEL: @neg_nsz_constant(
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
; CHECK-NEXT: [[MUL:%.*]] = fmul nnan float [[X:%.*]], -2.000000e+01
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: ret float [[MUL]]
;
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
%sub = fsub nsz float 0.000000e+00, %x
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
%mul = fmul nnan float %sub, 2.0e+1
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
ret float %mul
}
; (-0.0 - X) * (-0.0 - Y) => X * Y
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
define float @neg_neg(float %x, float %y) {
; CHECK-LABEL: @neg_neg(
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
; CHECK-NEXT: [[MUL:%.*]] = fmul arcp float [[X:%.*]], [[Y:%.*]]
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: ret float [[MUL]]
;
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
%sub1 = fsub float -0.000000e+00, %x
%sub2 = fsub float -0.000000e+00, %y
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
%mul = fmul arcp float %sub1, %sub2
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
ret float %mul
}
; (0.0 - X) * (0.0 - Y) => X * Y
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
define float @neg_neg_nsz(float %x, float %y) {
; CHECK-LABEL: @neg_neg_nsz(
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
; CHECK-NEXT: [[MUL:%.*]] = fmul afn float [[X:%.*]], [[Y:%.*]]
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: ret float [[MUL]]
;
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
%sub1 = fsub nsz float 0.000000e+00, %x
%sub2 = fsub nsz float 0.000000e+00, %y
[InstCombine] add some random FMF to tests so we know it's not dropped; NFC llvm-svn: 325734
2018-02-22 06:48:28 +08:00
%mul = fmul afn float %sub1, %sub2
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
ret float %mul
}
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
declare void @use_f32(float)
define float @neg_neg_multi_use(float %x, float %y) {
; CHECK-LABEL: @neg_neg_multi_use(
; CHECK-NEXT: [[NX:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
; CHECK-NEXT: [[NY:%.*]] = fsub float -0.000000e+00, [[Y:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = fmul afn float [[X]], [[Y]]
; CHECK-NEXT: call void @use_f32(float [[NX]])
; CHECK-NEXT: call void @use_f32(float [[NY]])
; CHECK-NEXT: ret float [[MUL]]
;
%nx = fsub float -0.000000e+00, %x
%ny = fsub float -0.000000e+00, %y
%mul = fmul afn float %nx, %ny
call void @use_f32(float %nx)
call void @use_f32(float %ny)
ret float %mul
}
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
; (-0.0 - X) * Y => -0.0 - (X * Y)
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
define float @neg_sink(float %x, float %y) {
; CHECK-LABEL: @neg_sink(
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = fsub float -0.000000e+00, [[TMP1]]
; CHECK-NEXT: ret float [[MUL]]
;
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
%sub1 = fsub float -0.000000e+00, %x
%mul = fmul float %sub1, %y
ret float %mul
}
; (0.0 - X) * Y => 0.0 - (X * Y)
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
define float @neg_sink_nsz(float %x, float %y) {
; CHECK-LABEL: @neg_sink_nsz(
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = fsub float -0.000000e+00, [[TMP1]]
; CHECK-NEXT: ret float [[MUL]]
;
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
%sub1 = fsub nsz float 0.000000e+00, %x
%mul = fmul float %sub1, %y
ret float %mul
}
; "(-0.0 - X) * Y => -0.0 - (X * Y)" is disabled if expression "-0.0 - X"
; has multiple uses.
[InstCombine] add fmul multi-use test; NFC Also, rename tests to make their intent clearer. llvm-svn: 325785
2018-02-22 22:27:16 +08:00
define float @neg_sink_multi_use(float %x, float %y) {
; CHECK-LABEL: @neg_sink_multi_use(
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: [[SUB1:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = fmul float [[SUB1]], [[Y:%.*]]
; CHECK-NEXT: [[MUL2:%.*]] = fmul float [[MUL]], [[SUB1]]
; CHECK-NEXT: ret float [[MUL2]]
;
1. Hoist minus sign as high as possible in an attempt to reveal some optimization opportunities (in the enclosing supper-expressions). rule 1. (-0.0 - X ) * Y => -0.0 - (X * Y) if expression "-0.0 - X" has only one reference. rule 2. (0.0 - X ) * Y => -0.0 - (X * Y) if expression "0.0 - X" has only one reference, and the instruction is marked "noSignedZero". 2. Eliminate negation (The compiler was already able to handle these opt if the 0.0s are replaced with -0.0.) rule 3: (0.0 - X) * (0.0 - Y) => X * Y rule 4: (0.0 - X) * C => X * -C if the expr is flagged "noSignedZero". 3. Rule 5: (X*Y) * X => (X*X) * Y if X!=Y and the expression is flagged with "UnsafeAlgebra". The purpose of this transformation is two-fold: a) to form a power expression (of X). b) potentially shorten the critical path: After transformation, the latency of the instruction Y is amortized by the expression of X*X, and therefore Y is in a "less critical" position compared to what it was before the transformation. 4. Remove the InstCombine code about simplifiying "X * select". The reasons are following: a) The "select" is somewhat architecture-dependent, therefore the higher level optimizers are not able to precisely predict if the simplification really yields any performance improvement or not. b) The "select" operator is bit complicate, and tends to obscure optimization opportunities. It is btter to keep it as low as possible in expr tree, and let CodeGen to tackle the optimization. llvm-svn: 172551
2013-01-16 05:09:32 +08:00
%sub1 = fsub float -0.000000e+00, %x
%mul = fmul float %sub1, %y
%mul2 = fmul float %mul, %sub1
ret float %mul2
}
Fix a bug in InstCombine where it attempted to cast a Value* to an Instruction* when it was actually a Constant*. There are quite a few other casts to Instruction that might have the same problem, but this is the only one I have a test case for. llvm-svn: 191668
2013-09-30 22:18:35 +08:00
; Don't crash when attempting to cast a constant FMul to an instruction.
define void @test8(i32* %inout) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @test8(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_COND:%.*]]
; CHECK: for.cond:
; CHECK-NEXT: [[LOCAL_VAR_7_0:%.*]] = phi <4 x float> [ <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[ENTRY:%.*]] ], [ [[TMP0:%.*]], [[FOR_BODY:%.*]] ]
; CHECK-NEXT: br i1 undef, label [[FOR_BODY]], label [[FOR_END:%.*]]
; CHECK: for.body:
; CHECK-NEXT: [[TMP0]] = insertelement <4 x float> [[LOCAL_VAR_7_0]], float 0.000000e+00, i32 2
; CHECK-NEXT: br label [[FOR_COND]]
; CHECK: for.end:
; CHECK-NEXT: ret void
;
Fix a bug in InstCombine where it attempted to cast a Value* to an Instruction* when it was actually a Constant*. There are quite a few other casts to Instruction that might have the same problem, but this is the only one I have a test case for. llvm-svn: 191668
2013-09-30 22:18:35 +08:00
entry:
[opaque pointer type] Add textual IR support for explicit type parameter to load instruction Essentially the same as the GEP change in r230786. A similar migration script can be used to update test cases, though a few more test case improvements/changes were required this time around: (r229269-r229278) import fileinput import sys import re pat = re.compile(r"((?:=|:|^)\s*load (?:atomic )?(?:volatile )?(.*?))(| addrspace\(\d+\) *)\*($| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$)") for line in sys.stdin: sys.stdout.write(re.sub(pat, r"\1, \2\3*\4", line)) Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7649 llvm-svn: 230794
2015-02-28 05:17:42 +08:00
%0 = load i32, i32* %inout, align 4
Fix a bug in InstCombine where it attempted to cast a Value* to an Instruction* when it was actually a Constant*. There are quite a few other casts to Instruction that might have the same problem, but this is the only one I have a test case for. llvm-svn: 191668
2013-09-30 22:18:35 +08:00
%conv = uitofp i32 %0 to float
%vecinit = insertelement <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float undef>, float %conv, i32 3
%sub = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %vecinit
%1 = shufflevector <4 x float> %sub, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
%mul = fmul <4 x float> zeroinitializer, %1
br label %for.cond
for.cond: ; preds = %for.body, %entry
%local_var_7.0 = phi <4 x float> [ %mul, %entry ], [ %2, %for.body ]
br i1 undef, label %for.body, label %for.end
for.body: ; preds = %for.cond
%2 = insertelement <4 x float> %local_var_7.0, float 0.000000e+00, i32 2
br label %for.cond
for.end: ; preds = %for.cond
ret void
}
Teach InstCombine that (fmul X, -1.0) can be simplified to (fneg X), which LLVM expresses as (fsub -0.0, X). llvm-svn: 199420
2014-01-17 04:36:42 +08:00
; X * -1.0 => -0.0 - X
define float @test9(float %x) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @test9(
; CHECK-NEXT: [[MUL:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
; CHECK-NEXT: ret float [[MUL]]
;
Teach InstCombine that (fmul X, -1.0) can be simplified to (fneg X), which LLVM expresses as (fsub -0.0, X). llvm-svn: 199420
2014-01-17 04:36:42 +08:00
%mul = fmul float %x, -1.0
ret float %mul
}
InstCombine: Make the (fmul X, -1.0) -> (fsub -0.0, X) transform handle vectors too. PR18532. llvm-svn: 199553
2014-01-19 00:43:14 +08:00
; PR18532
define <4 x float> @test10(<4 x float> %x) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @test10(
[InstCombine] simplify code for X * -1.0 --> -X; NFC I've added random FMF to one of the tests to show those are propagated. llvm-svn: 326377
2018-03-01 06:30:04 +08:00
; CHECK-NEXT: [[MUL:%.*]] = fsub arcp afn <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-NEXT: ret <4 x float> [[MUL]]
;
[InstCombine] simplify code for X * -1.0 --> -X; NFC I've added random FMF to one of the tests to show those are propagated. llvm-svn: 326377
2018-03-01 06:30:04 +08:00
%mul = fmul arcp afn <4 x float> %x, <float -1.0, float -1.0, float -1.0, float -1.0>
InstCombine: Make the (fmul X, -1.0) -> (fsub -0.0, X) transform handle vectors too. PR18532. llvm-svn: 199553
2014-01-19 00:43:14 +08:00
ret <4 x float> %mul
}
Fix all the remaining lost-fast-math-flags bugs I've been able to find. The most important of these are cases in the generic logic for combining BinaryOperators. This logic hadn't been updated to handle FastMathFlags, and it took me a while to detect it because it doesn't show up in a simple search for CreateFAdd. llvm-svn: 199629
2014-01-20 15:44:53 +08:00
define float @test11(float %x, float %y) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @test11(
; CHECK-NEXT: [[B:%.*]] = fadd fast float [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[C:%.*]] = fadd fast float [[B]], 3.000000e+00
; CHECK-NEXT: ret float [[C]]
;
Fix all the remaining lost-fast-math-flags bugs I've been able to find. The most important of these are cases in the generic logic for combining BinaryOperators. This logic hadn't been updated to handle FastMathFlags, and it took me a while to detect it because it doesn't show up in a simple search for CreateFAdd. llvm-svn: 199629
2014-01-20 15:44:53 +08:00
%a = fadd fast float %x, 1.0
%b = fadd fast float %y, 2.0
%c = fadd fast float %a, %b
ret float %c
}
Optimize square root squared (PR21126). When unsafe-fp-math is enabled, we can turn sqrt(X) * sqrt(X) into X. This can happen in the real world when calculating x ** 3/2. This occurs in test-suite/SingleSource/Benchmarks/BenchmarkGame/n-body.c. Differential Revision: http://reviews.llvm.org/D5584 llvm-svn: 218906
2014-10-03 05:10:54 +08:00
declare double @llvm.sqrt.f64(double)
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; With unsafe/fast math, sqrt(X) * sqrt(X) is just X,
Optimize square root squared (PR21126). When unsafe-fp-math is enabled, we can turn sqrt(X) * sqrt(X) into X. This can happen in the real world when calculating x ** 3/2. This occurs in test-suite/SingleSource/Benchmarks/BenchmarkGame/n-body.c. Differential Revision: http://reviews.llvm.org/D5584 llvm-svn: 218906
2014-10-03 05:10:54 +08:00
; but make sure another use of the sqrt is intact.
; Note that the remaining fmul is altered but is not 'fast'
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; itself because it was not marked 'fast' originally.
Optimize square root squared (PR21126). When unsafe-fp-math is enabled, we can turn sqrt(X) * sqrt(X) into X. This can happen in the real world when calculating x ** 3/2. This occurs in test-suite/SingleSource/Benchmarks/BenchmarkGame/n-body.c. Differential Revision: http://reviews.llvm.org/D5584 llvm-svn: 218906
2014-10-03 05:10:54 +08:00
; Thus, we have an overall fast result, but no more indication of
; 'fast'ness in the code.
Remove unused function attribute params. llvm-svn: 218909
2014-10-03 05:12:04 +08:00
define double @sqrt_squared2(double %f) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @sqrt_squared2(
; CHECK-NEXT: [[SQRT:%.*]] = call double @llvm.sqrt.f64(double [[F:%.*]])
; CHECK-NEXT: [[MUL2:%.*]] = fmul double [[SQRT]], [[F]]
; CHECK-NEXT: ret double [[MUL2]]
;
Optimize square root squared (PR21126). When unsafe-fp-math is enabled, we can turn sqrt(X) * sqrt(X) into X. This can happen in the real world when calculating x ** 3/2. This occurs in test-suite/SingleSource/Benchmarks/BenchmarkGame/n-body.c. Differential Revision: http://reviews.llvm.org/D5584 llvm-svn: 218906
2014-10-03 05:10:54 +08:00
%sqrt = call double @llvm.sqrt.f64(double %f)
%mul1 = fmul fast double %sqrt, %sqrt
%mul2 = fmul double %mul1, %sqrt
ret double %mul2
}
InstCombine: fabs(x) * fabs(x) -> x * x llvm-svn: 259295
2016-01-30 13:02:00 +08:00
declare float @llvm.fabs.f32(float) nounwind readnone
define float @fabs_squared(float %x) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @fabs_squared(
; CHECK-NEXT: [[MUL:%.*]] = fmul float [[X:%.*]], [[X]]
; CHECK-NEXT: ret float [[MUL]]
;
InstCombine: fabs(x) * fabs(x) -> x * x llvm-svn: 259295
2016-01-30 13:02:00 +08:00
%x.fabs = call float @llvm.fabs.f32(float %x)
%mul = fmul float %x.fabs, %x.fabs
ret float %mul
}
define float @fabs_squared_fast(float %x) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @fabs_squared_fast(
; CHECK-NEXT: [[MUL:%.*]] = fmul fast float [[X:%.*]], [[X]]
; CHECK-NEXT: ret float [[MUL]]
;
InstCombine: fabs(x) * fabs(x) -> x * x llvm-svn: 259295
2016-01-30 13:02:00 +08:00
%x.fabs = call float @llvm.fabs.f32(float %x)
%mul = fmul fast float %x.fabs, %x.fabs
ret float %mul
}
define float @fabs_x_fabs(float %x, float %y) {
[InstCombine] Regenerate FMUL/FMA combine tests with update_test_checks.py llvm-svn: 320922
2017-12-17 01:18:15 +08:00
; CHECK-LABEL: @fabs_x_fabs(
; CHECK-NEXT: [[X_FABS:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])
; CHECK-NEXT: [[Y_FABS:%.*]] = call float @llvm.fabs.f32(float [[Y:%.*]])
; CHECK-NEXT: [[MUL:%.*]] = fmul float [[X_FABS]], [[Y_FABS]]
; CHECK-NEXT: ret float [[MUL]]
;
InstCombine: fabs(x) * fabs(x) -> x * x llvm-svn: 259295
2016-01-30 13:02:00 +08:00
%x.fabs = call float @llvm.fabs.f32(float %x)
%y.fabs = call float @llvm.fabs.f32(float %y)
%mul = fmul float %x.fabs, %y.fabs
ret float %mul
}
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
; (X*Y) * X => (X*X) * Y
[InstCombine] allow fmul fold with less than 'fast' This is a retry of r326502 with updates to the reassociate test file that I missed the first time. @test15_reassoc in the supposed -reassociate test file (except that it tests 2 other passes too...) shows that there's no clear responsiblity for reassociation transforms. Instcombine now gets that case, but only because the constant values are identical. Otherwise, it would still miss that pattern. Reassociate doesn't get that case because it hasn't been updated to use less than 'fast' FMF. llvm-svn: 326513
2018-03-02 08:14:51 +08:00
; The transform only requires 'reassoc', but test other FMF in
; the commuted variants to make sure FMF propagates as expected.
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
define float @reassoc_common_operand1(float %x, float %y) {
; CHECK-LABEL: @reassoc_common_operand1(
[InstCombine] allow fmul fold with less than 'fast' This is a retry of r326502 with updates to the reassociate test file that I missed the first time. @test15_reassoc in the supposed -reassociate test file (except that it tests 2 other passes too...) shows that there's no clear responsiblity for reassociation transforms. Instcombine now gets that case, but only because the constant values are identical. Otherwise, it would still miss that pattern. Reassociate doesn't get that case because it hasn't been updated to use less than 'fast' FMF. llvm-svn: 326513
2018-03-02 08:14:51 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], [[X]]
; CHECK-NEXT: [[MUL2:%.*]] = fmul reassoc float [[TMP1]], [[Y:%.*]]
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
; CHECK-NEXT: ret float [[MUL2]]
;
%mul1 = fmul float %x, %y
[InstCombine] allow fmul fold with less than 'fast' This is a retry of r326502 with updates to the reassociate test file that I missed the first time. @test15_reassoc in the supposed -reassociate test file (except that it tests 2 other passes too...) shows that there's no clear responsiblity for reassociation transforms. Instcombine now gets that case, but only because the constant values are identical. Otherwise, it would still miss that pattern. Reassociate doesn't get that case because it hasn't been updated to use less than 'fast' FMF. llvm-svn: 326513
2018-03-02 08:14:51 +08:00
%mul2 = fmul reassoc float %mul1, %x
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
ret float %mul2
}
; (Y*X) * X => (X*X) * Y
define float @reassoc_common_operand2(float %x, float %y) {
; CHECK-LABEL: @reassoc_common_operand2(
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], [[X]]
; CHECK-NEXT: [[MUL2:%.*]] = fmul fast float [[TMP1]], [[Y:%.*]]
; CHECK-NEXT: ret float [[MUL2]]
;
%mul1 = fmul float %y, %x
%mul2 = fmul fast float %mul1, %x
ret float %mul2
}
; X * (X*Y) => (X*X) * Y
define float @reassoc_common_operand3(float %x1, float %y) {
; CHECK-LABEL: @reassoc_common_operand3(
; CHECK-NEXT: [[X:%.*]] = fdiv float [[X1:%.*]], 3.000000e+00
[InstCombine] allow fmul fold with less than 'fast' This is a retry of r326502 with updates to the reassociate test file that I missed the first time. @test15_reassoc in the supposed -reassociate test file (except that it tests 2 other passes too...) shows that there's no clear responsiblity for reassociation transforms. Instcombine now gets that case, but only because the constant values are identical. Otherwise, it would still miss that pattern. Reassociate doesn't get that case because it hasn't been updated to use less than 'fast' FMF. llvm-svn: 326513
2018-03-02 08:14:51 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul reassoc nnan float [[X]], [[X]]
; CHECK-NEXT: [[MUL2:%.*]] = fmul reassoc nnan float [[TMP1]], [[Y:%.*]]
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
; CHECK-NEXT: ret float [[MUL2]]
;
%x = fdiv float %x1, 3.0 ; thwart complexity-based canonicalization
%mul1 = fmul float %x, %y
[InstCombine] allow fmul fold with less than 'fast' This is a retry of r326502 with updates to the reassociate test file that I missed the first time. @test15_reassoc in the supposed -reassociate test file (except that it tests 2 other passes too...) shows that there's no clear responsiblity for reassociation transforms. Instcombine now gets that case, but only because the constant values are identical. Otherwise, it would still miss that pattern. Reassociate doesn't get that case because it hasn't been updated to use less than 'fast' FMF. llvm-svn: 326513
2018-03-02 08:14:51 +08:00
%mul2 = fmul reassoc nnan float %x, %mul1
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
ret float %mul2
}
; X * (Y*X) => (X*X) * Y
define float @reassoc_common_operand4(float %x1, float %y) {
; CHECK-LABEL: @reassoc_common_operand4(
; CHECK-NEXT: [[X:%.*]] = fdiv float [[X1:%.*]], 3.000000e+00
[InstCombine] allow fmul fold with less than 'fast' This is a retry of r326502 with updates to the reassociate test file that I missed the first time. @test15_reassoc in the supposed -reassociate test file (except that it tests 2 other passes too...) shows that there's no clear responsiblity for reassociation transforms. Instcombine now gets that case, but only because the constant values are identical. Otherwise, it would still miss that pattern. Reassociate doesn't get that case because it hasn't been updated to use less than 'fast' FMF. llvm-svn: 326513
2018-03-02 08:14:51 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul reassoc ninf float [[X]], [[X]]
; CHECK-NEXT: [[MUL2:%.*]] = fmul reassoc ninf float [[TMP1]], [[Y:%.*]]
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
; CHECK-NEXT: ret float [[MUL2]]
;
%x = fdiv float %x1, 3.0 ; thwart complexity-based canonicalization
%mul1 = fmul float %y, %x
[InstCombine] allow fmul fold with less than 'fast' This is a retry of r326502 with updates to the reassociate test file that I missed the first time. @test15_reassoc in the supposed -reassociate test file (except that it tests 2 other passes too...) shows that there's no clear responsiblity for reassociation transforms. Instcombine now gets that case, but only because the constant values are identical. Otherwise, it would still miss that pattern. Reassociate doesn't get that case because it hasn't been updated to use less than 'fast' FMF. llvm-svn: 326513
2018-03-02 08:14:51 +08:00
%mul2 = fmul reassoc ninf float %x, %mul1
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
ret float %mul2
}
; No change if the first fmul has another use.
define float @reassoc_common_operand_multi_use(float %x, float %y) {
; CHECK-LABEL: @reassoc_common_operand_multi_use(
; CHECK-NEXT: [[MUL1:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
revert r326502: [InstCombine] allow fmul fold with less than 'fast' I forgot that I added tests for 'reassoc' to -reassociate, but suprisingly that file calls -instcombine too, so it is affected. I'll update that file and try again. llvm-svn: 326510
2018-03-02 07:39:24 +08:00
; CHECK-NEXT: [[MUL2:%.*]] = fmul fast float [[MUL1]], [[X]]
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
; CHECK-NEXT: call void @use_f32(float [[MUL1]])
; CHECK-NEXT: ret float [[MUL2]]
;
%mul1 = fmul float %x, %y
revert r326502: [InstCombine] allow fmul fold with less than 'fast' I forgot that I added tests for 'reassoc' to -reassociate, but suprisingly that file calls -instcombine too, so it is affected. I'll update that file and try again. llvm-svn: 326510
2018-03-02 07:39:24 +08:00
%mul2 = fmul fast float %mul1, %x
[InstCombine] move/add tests for fmul reassociation; NFC This transform may be out-of-scope for instcombine, but this is only documenting the current behavior. llvm-svn: 326442
2018-03-01 23:30:44 +08:00
call void @use_f32(float %mul1)
ret float %mul2
}
[InstCombine] add tests for rL169025; NFC This narrow fold was added with no motivation or test cases a bit over 5 years ago. Removing a constant operand is a good canonicalization? We should handle Y*2.0 too then? llvm-svn: 326606
2018-03-03 03:26:13 +08:00
declare float @llvm.log2.f32(float)
[InstCombine] partly fix FMF for fmul+log2 fold The code was checking that all of the instructions in the sequence are 'fast', but that's not necessary. The final multiply is all that we need to check (tests adjusted). The fmul doesn't need to be fully 'fast' either, but that can be another patch. llvm-svn: 326608
2018-03-03 04:32:46 +08:00
; log2(Y * 0.5) * X = log2(Y) * X - X
[InstCombine] add tests for rL169025; NFC This narrow fold was added with no motivation or test cases a bit over 5 years ago. Removing a constant operand is a good canonicalization? We should handle Y*2.0 too then? llvm-svn: 326606
2018-03-03 03:26:13 +08:00
define float @log2half(float %x, float %y) {
; CHECK-LABEL: @log2half(
; CHECK-NEXT: [[LOG2:%.*]] = call fast float @llvm.log2.f32(float [[Y:%.*]])
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[LOG2]], [[X:%.*]]
; CHECK-NEXT: [[MUL:%.*]] = fsub fast float [[TMP1]], [[X]]
; CHECK-NEXT: ret float [[MUL]]
;
[InstCombine] partly fix FMF for fmul+log2 fold The code was checking that all of the instructions in the sequence are 'fast', but that's not necessary. The final multiply is all that we need to check (tests adjusted). The fmul doesn't need to be fully 'fast' either, but that can be another patch. llvm-svn: 326608
2018-03-03 04:32:46 +08:00
%halfy = fmul float %y, 0.5
%log2 = call float @llvm.log2.f32(float %halfy)
[InstCombine] add tests for rL169025; NFC This narrow fold was added with no motivation or test cases a bit over 5 years ago. Removing a constant operand is a good canonicalization? We should handle Y*2.0 too then? llvm-svn: 326606
2018-03-03 03:26:13 +08:00
%mul = fmul fast float %log2, %x
ret float %mul
}
define float @log2half_commute(float %x1, float %y) {
; CHECK-LABEL: @log2half_commute(
; CHECK-NEXT: [[X:%.*]] = fdiv float [[X1:%.*]], 7.000000e+00
; CHECK-NEXT: [[LOG2:%.*]] = call fast float @llvm.log2.f32(float [[Y:%.*]])
[InstCombine] partly fix FMF for fmul+log2 fold The code was checking that all of the instructions in the sequence are 'fast', but that's not necessary. The final multiply is all that we need to check (tests adjusted). The fmul doesn't need to be fully 'fast' either, but that can be another patch. llvm-svn: 326608
2018-03-03 04:32:46 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[LOG2]], [[X]]
[InstCombine] add tests for rL169025; NFC This narrow fold was added with no motivation or test cases a bit over 5 years ago. Removing a constant operand is a good canonicalization? We should handle Y*2.0 too then? llvm-svn: 326606
2018-03-03 03:26:13 +08:00
; CHECK-NEXT: [[MUL:%.*]] = fsub fast float [[TMP1]], [[X]]
; CHECK-NEXT: ret float [[MUL]]
;
%x = fdiv float %x1, 7.0 ; thwart complexity-based canonicalization
[InstCombine] partly fix FMF for fmul+log2 fold The code was checking that all of the instructions in the sequence are 'fast', but that's not necessary. The final multiply is all that we need to check (tests adjusted). The fmul doesn't need to be fully 'fast' either, but that can be another patch. llvm-svn: 326608
2018-03-03 04:32:46 +08:00
%halfy = fmul float %y, 0.5
%log2 = call float @llvm.log2.f32(float %halfy)
[InstCombine] add tests for rL169025; NFC This narrow fold was added with no motivation or test cases a bit over 5 years ago. Removing a constant operand is a good canonicalization? We should handle Y*2.0 too then? llvm-svn: 326606
2018-03-03 03:26:13 +08:00
%mul = fmul fast float %x, %log2
ret float %mul
}
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
; C1/X * C2 => (C1*C2) / X
define float @fdiv_constant_numerator_fmul(float %x) {
; CHECK-LABEL: @fdiv_constant_numerator_fmul(
[InstCombine] fix fmul reassociation to avoid creating an extra fdiv This was supposed to be an NFC refactoring that will eventually allow eliminating the isFast() predicate, but there's a rare possibility that we would pessimize the code as shown in the test case because we failed to check 'hasOneUse()' properly. This version also removes an inefficiency of the old code; we would look for: (X * C) * C1 --> X * (C * C1) ...but that pattern is always handled by SimplifyAssociativeOrCommutative(). llvm-svn: 327404
2018-03-13 22:46:32 +08:00
; CHECK-NEXT: [[T3:%.*]] = fdiv fast float 1.200000e+07, [[X:%.*]]
; CHECK-NEXT: ret float [[T3]]
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
;
%t1 = fdiv float 2.0e+3, %x
%t3 = fmul fast float %t1, 6.0e+3
ret float %t3
}
; C1/X * C2 => (C1*C2) / X is disabled if C1/X has multiple uses
@fmul2_external = external global float
define float @fdiv_constant_numerator_fmul_extra_use(float %x) {
; CHECK-LABEL: @fdiv_constant_numerator_fmul_extra_use(
; CHECK-NEXT: [[DIV:%.*]] = fdiv fast float 1.000000e+00, [[X:%.*]]
; CHECK-NEXT: store float [[DIV]], float* @fmul2_external, align 4
; CHECK-NEXT: [[MUL:%.*]] = fmul fast float [[DIV]], 2.000000e+00
; CHECK-NEXT: ret float [[MUL]]
;
%div = fdiv fast float 1.0, %x
store float %div, float* @fmul2_external
%mul = fmul fast float %div, 2.0
ret float %mul
}
; X/C1 * C2 => X * (C2/C1) (if C2/C1 is normal FP)
define float @fdiv_constant_denominator_fmul(float %x) {
; CHECK-LABEL: @fdiv_constant_denominator_fmul(
[InstCombine] fix fmul reassociation to avoid creating an extra fdiv This was supposed to be an NFC refactoring that will eventually allow eliminating the isFast() predicate, but there's a rare possibility that we would pessimize the code as shown in the test case because we failed to check 'hasOneUse()' properly. This version also removes an inefficiency of the old code; we would look for: (X * C) * C1 --> X * (C * C1) ...but that pattern is always handled by SimplifyAssociativeOrCommutative(). llvm-svn: 327404
2018-03-13 22:46:32 +08:00
; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[X:%.*]], 3.000000e+00
; CHECK-NEXT: ret float [[T3]]
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
;
%t1 = fdiv float %x, 2.0e+3
%t3 = fmul fast float %t1, 6.0e+3
ret float %t3
}
define <4 x float> @fdiv_constant_denominator_fmul_vec(<4 x float> %x) {
; CHECK-LABEL: @fdiv_constant_denominator_fmul_vec(
[InstCombine] fix fmul reassociation to avoid creating an extra fdiv This was supposed to be an NFC refactoring that will eventually allow eliminating the isFast() predicate, but there's a rare possibility that we would pessimize the code as shown in the test case because we failed to check 'hasOneUse()' properly. This version also removes an inefficiency of the old code; we would look for: (X * C) * C1 --> X * (C * C1) ...but that pattern is always handled by SimplifyAssociativeOrCommutative(). llvm-svn: 327404
2018-03-13 22:46:32 +08:00
; CHECK-NEXT: [[T3:%.*]] = fmul fast <4 x float> [[X:%.*]], <float 3.000000e+00, float 2.000000e+00, float 1.000000e+00, float 1.000000e+00>
; CHECK-NEXT: ret <4 x float> [[T3]]
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
;
%t1 = fdiv <4 x float> %x, <float 2.0e+3, float 3.0e+3, float 2.0e+3, float 1.0e+3>
%t3 = fmul fast <4 x float> %t1, <float 6.0e+3, float 6.0e+3, float 2.0e+3, float 1.0e+3>
ret <4 x float> %t3
}
; Make sure fmul with constant expression doesn't assert.
define <4 x float> @fdiv_constant_denominator_fmul_vec_constexpr(<4 x float> %x) {
; CHECK-LABEL: @fdiv_constant_denominator_fmul_vec_constexpr(
[InstCombine] fix fmul reassociation to avoid creating an extra fdiv This was supposed to be an NFC refactoring that will eventually allow eliminating the isFast() predicate, but there's a rare possibility that we would pessimize the code as shown in the test case because we failed to check 'hasOneUse()' properly. This version also removes an inefficiency of the old code; we would look for: (X * C) * C1 --> X * (C * C1) ...but that pattern is always handled by SimplifyAssociativeOrCommutative(). llvm-svn: 327404
2018-03-13 22:46:32 +08:00
; CHECK-NEXT: [[T3:%.*]] = fmul fast <4 x float> [[X:%.*]], <float 3.000000e+00, float 2.000000e+00, float 1.000000e+00, float 1.000000e+00>
; CHECK-NEXT: ret <4 x float> [[T3]]
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
;
%constExprMul = bitcast i128 trunc (i160 bitcast (<5 x float> <float 6.0e+3, float 6.0e+3, float 2.0e+3, float 1.0e+3, float undef> to i160) to i128) to <4 x float>
%t1 = fdiv <4 x float> %x, <float 2.0e+3, float 3.0e+3, float 2.0e+3, float 1.0e+3>
%t3 = fmul fast <4 x float> %t1, %constExprMul
ret <4 x float> %t3
}
; Rule "X/C1 * C2 => X * (C2/C1) is not applicable if C2/C1 is abnormal
; 0x3810000000000000 == FLT_MIN
define float @fdiv_constant_denominator_fmul_denorm(float %x) {
; CHECK-LABEL: @fdiv_constant_denominator_fmul_denorm(
; CHECK-NEXT: [[T1:%.*]] = fdiv float [[X:%.*]], 2.000000e+03
; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[T1]], 0x3810000000000000
; CHECK-NEXT: ret float [[T3]]
;
%t1 = fdiv float %x, 2.0e+3
%t3 = fmul fast float %t1, 0x3810000000000000
ret float %t3
}
; X / C1 * C2 => X / (C2/C1) if C1/C2 is abnormal, but C2/C1 is a normal value.
; TODO: We don't convert the fast fdiv to fmul because that would be multiplication
; by a denormal, but we could do better when we know that denormals are not a problem.
define float @fdiv_constant_denominator_fmul_denorm_try_harder(float %x) {
; CHECK-LABEL: @fdiv_constant_denominator_fmul_denorm_try_harder(
[InstCombine] fix fmul reassociation to avoid creating an extra fdiv This was supposed to be an NFC refactoring that will eventually allow eliminating the isFast() predicate, but there's a rare possibility that we would pessimize the code as shown in the test case because we failed to check 'hasOneUse()' properly. This version also removes an inefficiency of the old code; we would look for: (X * C) * C1 --> X * (C * C1) ...but that pattern is always handled by SimplifyAssociativeOrCommutative(). llvm-svn: 327404
2018-03-13 22:46:32 +08:00
; CHECK-NEXT: [[T3:%.*]] = fdiv fast float [[X:%.*]], 0x47E8000000000000
; CHECK-NEXT: ret float [[T3]]
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
;
%t1 = fdiv float %x, 3.0
%t3 = fmul fast float %t1, 0x3810000000000000
ret float %t3
}
[InstCombine] fix fmul reassociation to avoid creating an extra fdiv This was supposed to be an NFC refactoring that will eventually allow eliminating the isFast() predicate, but there's a rare possibility that we would pessimize the code as shown in the test case because we failed to check 'hasOneUse()' properly. This version also removes an inefficiency of the old code; we would look for: (X * C) * C1 --> X * (C * C1) ...but that pattern is always handled by SimplifyAssociativeOrCommutative(). llvm-svn: 327404
2018-03-13 22:46:32 +08:00
; Negative test: we should not have 2 divisions instead of the 1 we started with.
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
define float @fdiv_constant_denominator_fmul_denorm_try_harder_extra_use(float %x) {
; CHECK-LABEL: @fdiv_constant_denominator_fmul_denorm_try_harder_extra_use(
; CHECK-NEXT: [[T1:%.*]] = fdiv float [[X:%.*]], 3.000000e+00
[InstCombine] fix fmul reassociation to avoid creating an extra fdiv This was supposed to be an NFC refactoring that will eventually allow eliminating the isFast() predicate, but there's a rare possibility that we would pessimize the code as shown in the test case because we failed to check 'hasOneUse()' properly. This version also removes an inefficiency of the old code; we would look for: (X * C) * C1 --> X * (C * C1) ...but that pattern is always handled by SimplifyAssociativeOrCommutative(). llvm-svn: 327404
2018-03-13 22:46:32 +08:00
; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[T1]], 0x3810000000000000
; CHECK-NEXT: [[R:%.*]] = fadd float [[T1]], [[T3]]
[InstCombine] add test to show fmul transform creates extra fdiv; NFC Also, move fmul reassociation tests to the same file as other fmul transforms. llvm-svn: 327342
2018-03-13 07:10:08 +08:00
; CHECK-NEXT: ret float [[R]]
;
%t1 = fdiv float %x, 3.0e+0
%t3 = fmul fast float %t1, 0x3810000000000000
%r = fadd float %t1, %t3
ret float %r
}
[InstCombine] move/add tests for fmul distribution; NFC There are at least 3 problems: 1. We're distributing across large patterns, but fail to do that for the minimal patterns. 2. We're not checking uses, so we may create more instructions than we eliminate. 3. We should be able to do these transforms with less than full 'fast' fmuls. llvm-svn: 328152
2018-03-22 05:28:19 +08:00
; (X + C1) * C2 --> (X * C2) + C1*C2
define float @fmul_fadd_distribute(float %x) {
; CHECK-LABEL: @fmul_fadd_distribute(
[InstCombine] distribute fmul over fadd/fsub This replaces a large chunk of code that was looking for compound patterns that include these sub-patterns. Existing tests ensure that all of the previous examples are still folded as expected. We still need to loosen the FMF check. llvm-svn: 328502
2018-03-26 23:03:57 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+00
; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[TMP1]], 6.000000e+00
[InstCombine] move/add tests for fmul distribution; NFC There are at least 3 problems: 1. We're distributing across large patterns, but fail to do that for the minimal patterns. 2. We're not checking uses, so we may create more instructions than we eliminate. 3. We should be able to do these transforms with less than full 'fast' fmuls. llvm-svn: 328152
2018-03-22 05:28:19 +08:00
; CHECK-NEXT: ret float [[T3]]
;
%t2 = fadd float %x, 2.0
%t3 = fmul fast float %t2, 3.0
ret float %t3
}
; (X - C1) * C2 --> (X * C2) - C1*C2
define float @fmul_fsub_distribute1(float %x) {
; CHECK-LABEL: @fmul_fsub_distribute1(
[InstCombine] distribute fmul over fadd/fsub This replaces a large chunk of code that was looking for compound patterns that include these sub-patterns. Existing tests ensure that all of the previous examples are still folded as expected. We still need to loosen the FMF check. llvm-svn: 328502
2018-03-26 23:03:57 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+00
; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[TMP1]], -6.000000e+00
[InstCombine] move/add tests for fmul distribution; NFC There are at least 3 problems: 1. We're distributing across large patterns, but fail to do that for the minimal patterns. 2. We're not checking uses, so we may create more instructions than we eliminate. 3. We should be able to do these transforms with less than full 'fast' fmuls. llvm-svn: 328152
2018-03-22 05:28:19 +08:00
; CHECK-NEXT: ret float [[T3]]
;
%t2 = fsub float %x, 2.0
%t3 = fmul fast float %t2, 3.0
ret float %t3
}
; (C1 - X) * C2 --> C1*C2 - (X * C2)
define float @fmul_fsub_distribute2(float %x) {
; CHECK-LABEL: @fmul_fsub_distribute2(
[InstCombine] distribute fmul over fadd/fsub This replaces a large chunk of code that was looking for compound patterns that include these sub-patterns. Existing tests ensure that all of the previous examples are still folded as expected. We still need to loosen the FMF check. llvm-svn: 328502
2018-03-26 23:03:57 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+00
; CHECK-NEXT: [[T3:%.*]] = fsub fast float 6.000000e+00, [[TMP1]]
[InstCombine] move/add tests for fmul distribution; NFC There are at least 3 problems: 1. We're distributing across large patterns, but fail to do that for the minimal patterns. 2. We're not checking uses, so we may create more instructions than we eliminate. 3. We should be able to do these transforms with less than full 'fast' fmuls. llvm-svn: 328152
2018-03-22 05:28:19 +08:00
; CHECK-NEXT: ret float [[T3]]
;
%t2 = fsub float 2.0, %x
%t3 = fmul fast float %t2, 3.0
ret float %t3
}
; ((X*C1) + C2) * C3 => (X * (C1*C3)) + (C2*C3)
define float @fmul_fadd_fmul_distribute(float %x) {
; CHECK-LABEL: @fmul_fadd_fmul_distribute(
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+01
; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[TMP1]], 1.000000e+01
; CHECK-NEXT: ret float [[T3]]
;
%t1 = fmul float %x, 6.0
%t2 = fadd float %t1, 2.0
%t3 = fmul fast float %t2, 5.0
ret float %t3
}
define float @fmul_fadd_distribute_extra_use(float %x) {
; CHECK-LABEL: @fmul_fadd_distribute_extra_use(
; CHECK-NEXT: [[T1:%.*]] = fmul float [[X:%.*]], 6.000000e+00
; CHECK-NEXT: [[T2:%.*]] = fadd float [[T1]], 2.000000e+00
[InstCombine] check uses before creating instructions for fmul distribution As the tests show, we could create extra instructions without any obvious benefit. llvm-svn: 328498
2018-03-26 22:25:43 +08:00
; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[T2]], 5.000000e+00
[InstCombine] move/add tests for fmul distribution; NFC There are at least 3 problems: 1. We're distributing across large patterns, but fail to do that for the minimal patterns. 2. We're not checking uses, so we may create more instructions than we eliminate. 3. We should be able to do these transforms with less than full 'fast' fmuls. llvm-svn: 328152
2018-03-22 05:28:19 +08:00
; CHECK-NEXT: call void @use_f32(float [[T2]])
; CHECK-NEXT: ret float [[T3]]
;
%t1 = fmul float %x, 6.0
%t2 = fadd float %t1, 2.0
%t3 = fmul fast float %t2, 5.0
call void @use_f32(float %t2)
ret float %t3
}
; (X/C1 + C2) * C3 => X/(C1/C3) + C2*C3
; 0x10000000000000 = DBL_MIN
; TODO: We don't convert the fast fdiv to fmul because that would be multiplication
; by a denormal, but we could do better when we know that denormals are not a problem.
define double @fmul_fadd_fdiv_distribute2(double %x) {
; CHECK-LABEL: @fmul_fadd_fdiv_distribute2(
; CHECK-NEXT: [[TMP1:%.*]] = fdiv fast double [[X:%.*]], 0x7FE8000000000000
; CHECK-NEXT: [[T3:%.*]] = fadd fast double [[TMP1]], 0x34000000000000
; CHECK-NEXT: ret double [[T3]]
;
%t1 = fdiv double %x, 3.0
%t2 = fadd double %t1, 5.0
%t3 = fmul fast double %t2, 0x10000000000000
ret double %t3
}
; 5.0e-1 * DBL_MIN yields denormal, so "(f1*3.0 + 5.0e-1) * DBL_MIN" cannot
; be simplified into f1 * (3.0*DBL_MIN) + (5.0e-1*DBL_MIN)
define double @fmul_fadd_fdiv_distribute3(double %x) {
; CHECK-LABEL: @fmul_fadd_fdiv_distribute3(
; CHECK-NEXT: [[TMP1:%.*]] = fdiv fast double [[X:%.*]], 0x7FE8000000000000
; CHECK-NEXT: [[T3:%.*]] = fadd fast double [[TMP1]], 0x34000000000000
; CHECK-NEXT: ret double [[T3]]
;
%t1 = fdiv double %x, 3.0
%t2 = fadd double %t1, 5.0
%t3 = fmul fast double %t2, 0x10000000000000
ret double %t3
}
; (C2 - (X*C1)) * C3 => (C2*C3) - (X * (C1*C3))
define float @fmul_fsub_fmul_distribute(float %x) {
; CHECK-LABEL: @fmul_fsub_fmul_distribute(
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+01
; CHECK-NEXT: [[T3:%.*]] = fsub fast float 1.000000e+01, [[TMP1]]
; CHECK-NEXT: ret float [[T3]]
;
%t1 = fmul float %x, 6.0
%t2 = fsub float 2.0, %t1
%t3 = fmul fast float %t2, 5.0
ret float %t3
}
define float @fmul_fsub_fmul_distribute_extra_use(float %x) {
; CHECK-LABEL: @fmul_fsub_fmul_distribute_extra_use(
; CHECK-NEXT: [[T1:%.*]] = fmul float [[X:%.*]], 6.000000e+00
; CHECK-NEXT: [[T2:%.*]] = fsub float 2.000000e+00, [[T1]]
[InstCombine] check uses before creating instructions for fmul distribution As the tests show, we could create extra instructions without any obvious benefit. llvm-svn: 328498
2018-03-26 22:25:43 +08:00
; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[T2]], 5.000000e+00
[InstCombine] move/add tests for fmul distribution; NFC There are at least 3 problems: 1. We're distributing across large patterns, but fail to do that for the minimal patterns. 2. We're not checking uses, so we may create more instructions than we eliminate. 3. We should be able to do these transforms with less than full 'fast' fmuls. llvm-svn: 328152
2018-03-22 05:28:19 +08:00
; CHECK-NEXT: call void @use_f32(float [[T2]])
; CHECK-NEXT: ret float [[T3]]
;
%t1 = fmul float %x, 6.0
%t2 = fsub float 2.0, %t1
%t3 = fmul fast float %t2, 5.0
call void @use_f32(float %t2)
ret float %t3
}
; ((X*C1) - C2) * C3 => (X * (C1*C3)) - C2*C3
define float @fmul_fsub_fmul_distribute2(float %x) {
; CHECK-LABEL: @fmul_fsub_fmul_distribute2(
; CHECK-NEXT: [[TMP1:%.*]] = fmul fast float [[X:%.*]], 3.000000e+01
; CHECK-NEXT: [[T3:%.*]] = fadd fast float [[TMP1]], -1.000000e+01
; CHECK-NEXT: ret float [[T3]]
;
%t1 = fmul float %x, 6.0
%t2 = fsub float %t1, 2.0
%t3 = fmul fast float %t2, 5.0
ret float %t3
}
define float @fmul_fsub_fmul_distribute2_extra_use(float %x) {
; CHECK-LABEL: @fmul_fsub_fmul_distribute2_extra_use(
; CHECK-NEXT: [[T1:%.*]] = fmul float [[X:%.*]], 6.000000e+00
; CHECK-NEXT: [[T2:%.*]] = fsub float 2.000000e+00, [[T1]]
[InstCombine] check uses before creating instructions for fmul distribution As the tests show, we could create extra instructions without any obvious benefit. llvm-svn: 328498
2018-03-26 22:25:43 +08:00
; CHECK-NEXT: [[T3:%.*]] = fmul fast float [[T2]], 5.000000e+00
[InstCombine] move/add tests for fmul distribution; NFC There are at least 3 problems: 1. We're distributing across large patterns, but fail to do that for the minimal patterns. 2. We're not checking uses, so we may create more instructions than we eliminate. 3. We should be able to do these transforms with less than full 'fast' fmuls. llvm-svn: 328152
2018-03-22 05:28:19 +08:00
; CHECK-NEXT: call void @use_f32(float [[T2]])
; CHECK-NEXT: ret float [[T3]]
;
%t1 = fmul float %x, 6.0
%t2 = fsub float 2.0, %t1
%t3 = fmul fast float %t2, 5.0
call void @use_f32(float %t2)
ret float %t3
}
; "(X*Y) * X => (X*X) * Y" is disabled if "X*Y" has multiple uses
define float @common_factor(float %x, float %y) {
; CHECK-LABEL: @common_factor(
; CHECK-NEXT: [[MUL:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[MUL1:%.*]] = fmul fast float [[MUL]], [[X]]
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[MUL1]], [[MUL]]
; CHECK-NEXT: ret float [[ADD]]
;
%mul = fmul float %x, %y
%mul1 = fmul fast float %mul, %x
%add = fadd float %mul1, %mul
ret float %add
}