* [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y
@ 2022-02-19 9:36 Zhao Wei Liew
2022-02-19 10:05 ` Zhao Wei Liew
0 siblings, 1 reply; 5+ messages in thread
From: Zhao Wei Liew @ 2022-02-19 9:36 UTC (permalink / raw)
To: GCC Patches
This pattern converts (trunc_div (convert a) (convert b)) to
(convert (trunc_div a b)) when:
1. type, a, and b all have unsigned integeral types
2. a and b have the same type precision
3. type has type precision at least as larger as a and b
This is useful as wider divisions are typically more expensive.
To illustrate the effects, consider the following code snippet:
unsigned long long f(unsigned int a, unsigned int b) {
unsigned long long all = a;
return all / b;
}
Without the pattern, g++ -std=c++20 -O2 generates the following
assembly:
f(unsigned int, unsigned int):
mov eax, edi
mov esi, esi
xor edx, edx
div rsi
ret
With the pattern, it generates this:
f(unsigned int, unsigned int):
mov eax, edi
xor edx, edx
div esi
ret
This is identical to what clang++ -std=c++20 -O2 generates.
Signed-off-by: Zhao Wei Liew <zhaoweiliew@gmail.com>
PR tree-optimization/103855
gcc/ChangeLog:
* match.pd: Add pattern for (type)X / (type)Y.
gcc/testsuite/ChangeLog:
* gcc.dg/tree-ssa/divide-8.c: New test.
* gcc.dg/tree-ssa/divide-9.c: New test.
---
gcc/match.pd | 15 +++++++++++++++
gcc/testsuite/gcc.dg/tree-ssa/divide-8.c | 9 +++++++++
gcc/testsuite/gcc.dg/tree-ssa/divide-9.c | 10 ++++++++++
3 files changed, 34 insertions(+)
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
diff --git a/gcc/match.pd b/gcc/match.pd
index 10f62284862..393b43756dd 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -684,6 +684,21 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
(convert (trunc_mod @0 @1))))
+/* (type)X / (type)Y -> (type)(X / Y)
+ when the resulting type is at least precise as the original types
+ and when all the types are unsigned integral types. */
+(simplify
+ (trunc_div (convert @0) (convert @1))
+ (if (INTEGRAL_TYPE_P (type)
+ && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+ && INTEGRAL_TYPE_P (TREE_TYPE (@1))
+ && TYPE_UNSIGNED (type)
+ && TYPE_UNSIGNED (TREE_TYPE (@0))
+ && TYPE_UNSIGNED (TREE_TYPE (@1))
+ && TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1))
+ && TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (@0)))
+ (convert (trunc_div @0 @1))))
+
/* x * (1 + y / x) - y -> x - y % x */
(simplify
(minus (mult:cs @0 (plus:s (trunc_div:s @1 @0) integer_onep)) @1)
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
new file mode 100644
index 00000000000..489604c4eb6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
@@ -0,0 +1,9 @@
+/* PR tree-optimization/103855 */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+unsigned int f(unsigned int a, unsigned int b) {
+ unsigned long long all = a;
+ return all / b;
+}
+
+/* { dg-final { scan-tree-dump-not "\(unsigned long long int)" "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
new file mode 100644
index 00000000000..3e75a49b509
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
@@ -0,0 +1,10 @@
+/* PR tree-optimization/103855 */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+unsigned long long f(unsigned int a, unsigned int b) {
+ unsigned long long all = a;
+ return all / b;
+}
+
+/* { dg-final { scan-tree-dump-times "\\\(unsigned long long int\\\)" 1 "optimized" } } */
+
--
2.35.1
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y
2022-02-19 9:36 [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y Zhao Wei Liew
@ 2022-02-19 10:05 ` Zhao Wei Liew
0 siblings, 0 replies; 5+ messages in thread
From: Zhao Wei Liew @ 2022-02-19 10:05 UTC (permalink / raw)
To: GCC Patches
> On 19 Feb 2022, at 5:36 PM, Zhao Wei Liew <zhaoweiliew@gmail.com> wrote:
>
> This pattern converts (trunc_div (convert a) (convert b)) to
> (convert (trunc_div a b)) when:
>
> 1. type, a, and b all have unsigned integeral types
> 2. a and b have the same type precision
> 3. type has type precision at least as larger as a and b
>
> This is useful as wider divisions are typically more expensive.
>
> To illustrate the effects, consider the following code snippet:
>
> unsigned long long f(unsigned int a, unsigned int b) {
> unsigned long long all = a;
> return all / b;
> }
>
> Without the pattern, g++ -std=c++20 -O2 generates the following
> assembly:
>
> f(unsigned int, unsigned int):
> mov eax, edi
> mov esi, esi
> xor edx, edx
> div rsi
> ret
>
> With the pattern, it generates this:
>
> f(unsigned int, unsigned int):
> mov eax, edi
> xor edx, edx
> div esi
> ret
>
> This is identical to what clang++ -std=c++20 -O2 generates.
>
> Signed-off-by: Zhao Wei Liew <zhaoweiliew@gmail.com>
>
> PR tree-optimization/103855
>
> gcc/ChangeLog:
>
> * match.pd: Add pattern for (type)X / (type)Y.
>
> gcc/testsuite/ChangeLog:
>
> * gcc.dg/tree-ssa/divide-8.c: New test.
> * gcc.dg/tree-ssa/divide-9.c: New test.
> ---
> gcc/match.pd | 15 +++++++++++++++
> gcc/testsuite/gcc.dg/tree-ssa/divide-8.c | 9 +++++++++
> gcc/testsuite/gcc.dg/tree-ssa/divide-9.c | 10 ++++++++++
> 3 files changed, 34 insertions(+)
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
> create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
>
> diff --git a/gcc/match.pd b/gcc/match.pd
> index 10f62284862..393b43756dd 100644
> --- a/gcc/match.pd
> +++ b/gcc/match.pd
> @@ -684,6 +684,21 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
> (if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
> (convert (trunc_mod @0 @1))))
>
> +/* (type)X / (type)Y -> (type)(X / Y)
> + when the resulting type is at least precise as the original types
> + and when all the types are unsigned integral types. */
> +(simplify
> + (trunc_div (convert @0) (convert @1))
> + (if (INTEGRAL_TYPE_P (type)
> + && INTEGRAL_TYPE_P (TREE_TYPE (@0))
> + && INTEGRAL_TYPE_P (TREE_TYPE (@1))
> + && TYPE_UNSIGNED (type)
> + && TYPE_UNSIGNED (TREE_TYPE (@0))
> + && TYPE_UNSIGNED (TREE_TYPE (@1))
> + && TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1))
> + && TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (@0)))
> + (convert (trunc_div @0 @1))))
> +
> /* x * (1 + y / x) - y -> x - y % x */
> (simplify
> (minus (mult:cs @0 (plus:s (trunc_div:s @1 @0) integer_onep)) @1)
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
> new file mode 100644
> index 00000000000..489604c4eb6
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
> @@ -0,0 +1,9 @@
> +/* PR tree-optimization/103855 */
> +/* { dg-options "-O -fdump-tree-optimized" } */
> +
> +unsigned int f(unsigned int a, unsigned int b) {
> + unsigned long long all = a;
> + return all / b;
> +}
> +
> +/* { dg-final { scan-tree-dump-not "\(unsigned long long int)" "optimized" } } */
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
> new file mode 100644
> index 00000000000..3e75a49b509
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
> @@ -0,0 +1,10 @@
> +/* PR tree-optimization/103855 */
> +/* { dg-options "-O -fdump-tree-optimized" } */
> +
> +unsigned long long f(unsigned int a, unsigned int b) {
> + unsigned long long all = a;
> + return all / b;
> +}
> +
> +/* { dg-final { scan-tree-dump-times "\\\(unsigned long long int\\\)" 1 "optimized" } } */
> +
> --
> 2.35.1
>
Sorry, I noticed issues with the test cases when running a regression test.
I’ll complete regression testing before uploading a v2.
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y
2022-02-22 4:00 ` Zhao Wei Liew
@ 2022-02-22 7:53 ` Richard Biener
0 siblings, 0 replies; 5+ messages in thread
From: Richard Biener @ 2022-02-22 7:53 UTC (permalink / raw)
To: Zhao Wei Liew; +Cc: GCC Patches
On Tue, Feb 22, 2022 at 5:01 AM Zhao Wei Liew via Gcc-patches
<gcc-patches@gcc.gnu.org> wrote:
>
> On Tue, 22 Feb 2022 at 11:57, Zhao Wei Liew <zhaoweiliew@gmail.com> wrote:
> >
> > Hi,
> >
> > This is a partial optimization for PR103855.
> >
> > Initially, I looked into optimizing RTL generation or a more complex
> > GIMPLE transformation so that we could optimize other cases as well,
> > such as ((unsigned long long) short / int).
> >
> > However, that is a bit too complex for now. While I continue to look
> > into that change, I've decided to implement this simpler match.pd
> > transformation.
> >
> > Greatly appreciate any feedback on this patch or guidance for
> > implementing the more advanced optimizations!
> >
> > Thanks,
> > Zhao Wei
>
> Sorry, the original patch wasn't recognized as a text file. I've added
> a .txt extension to make it explicit.
A few comments - note the change is only appropriate for next stage1.
Since we're
currently in a regression fixing period reviews can be slow - do not
hesitate to ping
forgotten patches when stage1 opens again.
+/* (type)X / (type)Y -> (type)(X / Y)
+ when the resulting type is at least precise as the original types
+ and when all the types are unsigned integral types. */
+(simplify
+ (trunc_div (convert @0) (convert @1))
+ (if (INTEGRAL_TYPE_P (type)
+ && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+ && INTEGRAL_TYPE_P (TREE_TYPE (@1))
+ && TYPE_UNSIGNED (type)
+ && TYPE_UNSIGNED (TREE_TYPE (@0))
+ && TYPE_UNSIGNED (TREE_TYPE (@1))
+ && TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1))
+ && TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (@0)))
+ (convert (trunc_div @0 @1))))
since you are requiring the types of @0 and @1 to match it's easier to write
&& types_match (TREE_TYPE(@0), TREE_TYPE (@1))
that allows you to elide checks on either @0 or @1. I suppose the transform
does not work for signed types because of the -INT_MIN / -1 overflow case?
It might be possible to use expr_not_equal_to (@0, -INT_MIN) ||
expr_not_equal_to (@1, -1)
(correctly written, lookup the existing examples in match.pd for the X
% -Y transform)
I'll note that as written the transform will not catch CST / (T)x or
(T)x / CST since
you'll not see conversions around constants. I'm not sure whether
using (convert[12]? ...)
or writing special patterns with INTEGER_CST operands is more convenient.
There is int_fits_type_p to check whether a constant will fit in a
type without truncation
or sign change.
When @0 and @1 do not have the same type there might still be a common type
that can be used and is smaller than 'type', it might be as simple as using
build_nonstandard_integer_type (MIN (@0-prec, @1-prec), 1 /*unsigned_p*/).
In the past there have been attempts to more globally narrow operations using
a new pass rather than using individual patterns. So for more complicated cases
that might be the way to go. There's now also the ISEL pass which does
pre-RTL expansion transforms that need some global context and for example
can look at SSA uses.
Richard.
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y
2022-02-22 3:57 Zhao Wei Liew
@ 2022-02-22 4:00 ` Zhao Wei Liew
2022-02-22 7:53 ` Richard Biener
0 siblings, 1 reply; 5+ messages in thread
From: Zhao Wei Liew @ 2022-02-22 4:00 UTC (permalink / raw)
To: GCC Patches
[-- Attachment #1: Type: text/plain, Size: 728 bytes --]
On Tue, 22 Feb 2022 at 11:57, Zhao Wei Liew <zhaoweiliew@gmail.com> wrote:
>
> Hi,
>
> This is a partial optimization for PR103855.
>
> Initially, I looked into optimizing RTL generation or a more complex
> GIMPLE transformation so that we could optimize other cases as well,
> such as ((unsigned long long) short / int).
>
> However, that is a bit too complex for now. While I continue to look
> into that change, I've decided to implement this simpler match.pd
> transformation.
>
> Greatly appreciate any feedback on this patch or guidance for
> implementing the more advanced optimizations!
>
> Thanks,
> Zhao Wei
Sorry, the original patch wasn't recognized as a text file. I've added
a .txt extension to make it explicit.
[-- Attachment #2: 0001-tree-optimization-PR103855-Fold-type-X-type-Y.patch.txt --]
[-- Type: text/plain, Size: 3754 bytes --]
From dd3bb05cd7be72d080598cb693549ac74d5cb02d Mon Sep 17 00:00:00 2001
From: Zhao Wei Liew <zhaoweiliew@gmail.com>
Date: Sat, 19 Feb 2022 16:28:38 +0800
Subject: [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y
This pattern converts (trunc_div (convert a) (convert b)) to
(convert (trunc_div a b)) when:
1. type, a, and b all have unsigned integeral types
2. a and b have the same type precision
3. type has type precision at least as larger as a and b
This is useful as wider divisions are typically more expensive.
To illustrate the effects, consider the following code snippet:
unsigned long long f(unsigned int a, unsigned int b) {
unsigned long long all = a;
return all / b;
}
Without the pattern, g++ -std=c++20 -O2 generates the following
assembly:
f(unsigned int, unsigned int):
mov eax, edi
mov esi, esi
xor edx, edx
div rsi
ret
With the pattern, it generates this:
f(unsigned int, unsigned int):
mov eax, edi
xor edx, edx
div esi
ret
This is identical to what clang++ -std=c++20 -O2 generates.
Bootstrapped and regression tested on x86_64-pc-linux-gnu.
Signed-off-by: Zhao Wei Liew <zhaoweiliew@gmail.com>
PR tree-optimization/103855
gcc/ChangeLog:
* match.pd: Add pattern for (type)X / (type)Y.
gcc/testsuite/ChangeLog:
* gcc.dg/tree-ssa/divide-8.c: New test.
* gcc.dg/tree-ssa/divide-9.c: New test.
---
gcc/match.pd | 15 +++++++++++++++
gcc/testsuite/gcc.dg/tree-ssa/divide-8.c | 9 +++++++++
gcc/testsuite/gcc.dg/tree-ssa/divide-9.c | 9 +++++++++
3 files changed, 33 insertions(+)
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
diff --git a/gcc/match.pd b/gcc/match.pd
index 10f62284862..393b43756dd 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -684,6 +684,21 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
(convert (trunc_mod @0 @1))))
+/* (type)X / (type)Y -> (type)(X / Y)
+ when the resulting type is at least precise as the original types
+ and when all the types are unsigned integral types. */
+(simplify
+ (trunc_div (convert @0) (convert @1))
+ (if (INTEGRAL_TYPE_P (type)
+ && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+ && INTEGRAL_TYPE_P (TREE_TYPE (@1))
+ && TYPE_UNSIGNED (type)
+ && TYPE_UNSIGNED (TREE_TYPE (@0))
+ && TYPE_UNSIGNED (TREE_TYPE (@1))
+ && TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1))
+ && TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (@0)))
+ (convert (trunc_div @0 @1))))
+
/* x * (1 + y / x) - y -> x - y % x */
(simplify
(minus (mult:cs @0 (plus:s (trunc_div:s @1 @0) integer_onep)) @1)
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
new file mode 100644
index 00000000000..dc3dc9ca769
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
@@ -0,0 +1,9 @@
+/* PR tree-optimization/103855 */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+unsigned int f(unsigned int a, unsigned int b) {
+ unsigned long long all = a;
+ return all / b;
+}
+
+/* { dg-final { scan-tree-dump-not "\\\(long long unsigned int\\\)" "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
new file mode 100644
index 00000000000..6986b5484e4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
@@ -0,0 +1,9 @@
+/* PR tree-optimization/103855 */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+unsigned long long f(unsigned int a, unsigned int b) {
+ unsigned long long all = a;
+ return all / b;
+}
+
+/* { dg-final { scan-tree-dump-times "\\\(long long unsigned int\\\)" 1 "optimized" } } */
--
2.35.1
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y
@ 2022-02-22 3:57 Zhao Wei Liew
2022-02-22 4:00 ` Zhao Wei Liew
0 siblings, 1 reply; 5+ messages in thread
From: Zhao Wei Liew @ 2022-02-22 3:57 UTC (permalink / raw)
To: GCC Patches
[-- Attachment #1: Type: text/plain, Size: 512 bytes --]
Hi,
This is a partial optimization for PR103855.
Initially, I looked into optimizing RTL generation or a more complex
GIMPLE transformation so that we could optimize other cases as well,
such as ((unsigned long long) short / int).
However, that is a bit too complex for now. While I continue to look
into that change, I've decided to implement this simpler match.pd
transformation.
Greatly appreciate any feedback on this patch or guidance for
implementing the more advanced optimizations!
Thanks,
Zhao Wei
[-- Attachment #2: 0001-tree-optimization-PR103855-Fold-type-X-type-Y.patch --]
[-- Type: application/octet-stream, Size: 3754 bytes --]
From dd3bb05cd7be72d080598cb693549ac74d5cb02d Mon Sep 17 00:00:00 2001
From: Zhao Wei Liew <zhaoweiliew@gmail.com>
Date: Sat, 19 Feb 2022 16:28:38 +0800
Subject: [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y
This pattern converts (trunc_div (convert a) (convert b)) to
(convert (trunc_div a b)) when:
1. type, a, and b all have unsigned integeral types
2. a and b have the same type precision
3. type has type precision at least as larger as a and b
This is useful as wider divisions are typically more expensive.
To illustrate the effects, consider the following code snippet:
unsigned long long f(unsigned int a, unsigned int b) {
unsigned long long all = a;
return all / b;
}
Without the pattern, g++ -std=c++20 -O2 generates the following
assembly:
f(unsigned int, unsigned int):
mov eax, edi
mov esi, esi
xor edx, edx
div rsi
ret
With the pattern, it generates this:
f(unsigned int, unsigned int):
mov eax, edi
xor edx, edx
div esi
ret
This is identical to what clang++ -std=c++20 -O2 generates.
Bootstrapped and regression tested on x86_64-pc-linux-gnu.
Signed-off-by: Zhao Wei Liew <zhaoweiliew@gmail.com>
PR tree-optimization/103855
gcc/ChangeLog:
* match.pd: Add pattern for (type)X / (type)Y.
gcc/testsuite/ChangeLog:
* gcc.dg/tree-ssa/divide-8.c: New test.
* gcc.dg/tree-ssa/divide-9.c: New test.
---
gcc/match.pd | 15 +++++++++++++++
gcc/testsuite/gcc.dg/tree-ssa/divide-8.c | 9 +++++++++
gcc/testsuite/gcc.dg/tree-ssa/divide-9.c | 9 +++++++++
3 files changed, 33 insertions(+)
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
diff --git a/gcc/match.pd b/gcc/match.pd
index 10f62284862..393b43756dd 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -684,6 +684,21 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
(if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
(convert (trunc_mod @0 @1))))
+/* (type)X / (type)Y -> (type)(X / Y)
+ when the resulting type is at least precise as the original types
+ and when all the types are unsigned integral types. */
+(simplify
+ (trunc_div (convert @0) (convert @1))
+ (if (INTEGRAL_TYPE_P (type)
+ && INTEGRAL_TYPE_P (TREE_TYPE (@0))
+ && INTEGRAL_TYPE_P (TREE_TYPE (@1))
+ && TYPE_UNSIGNED (type)
+ && TYPE_UNSIGNED (TREE_TYPE (@0))
+ && TYPE_UNSIGNED (TREE_TYPE (@1))
+ && TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1))
+ && TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (@0)))
+ (convert (trunc_div @0 @1))))
+
/* x * (1 + y / x) - y -> x - y % x */
(simplify
(minus (mult:cs @0 (plus:s (trunc_div:s @1 @0) integer_onep)) @1)
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
new file mode 100644
index 00000000000..dc3dc9ca769
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-8.c
@@ -0,0 +1,9 @@
+/* PR tree-optimization/103855 */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+unsigned int f(unsigned int a, unsigned int b) {
+ unsigned long long all = a;
+ return all / b;
+}
+
+/* { dg-final { scan-tree-dump-not "\\\(long long unsigned int\\\)" "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
new file mode 100644
index 00000000000..6986b5484e4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/divide-9.c
@@ -0,0 +1,9 @@
+/* PR tree-optimization/103855 */
+/* { dg-options "-O -fdump-tree-optimized" } */
+
+unsigned long long f(unsigned int a, unsigned int b) {
+ unsigned long long all = a;
+ return all / b;
+}
+
+/* { dg-final { scan-tree-dump-times "\\\(long long unsigned int\\\)" 1 "optimized" } } */
--
2.35.1
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2022-02-22 7:54 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-02-19 9:36 [PATCH] tree-optimization: [PR103855] Fold (type)X / (type)Y Zhao Wei Liew
2022-02-19 10:05 ` Zhao Wei Liew
2022-02-22 3:57 Zhao Wei Liew
2022-02-22 4:00 ` Zhao Wei Liew
2022-02-22 7:53 ` Richard Biener
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).