[Bug tree-optimization/102879] [12 Regression] Dead Code Elimination Regression at -O3
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102879 Richard Biener changed: What|Removed |Added Priority|P1 |P3 --- Comment #5 from Richard Biener --- There's nothing special about this bug that makes it more important that the other "DCE" regressions identified against GCC 12 like PRs 102540, 102705, 102892, 102981, 102982, 103388, 104530, 105086.
[Bug tree-optimization/102879] [12 Regression] Dead Code Elimination Regression at -O3
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102879
Richard Biener changed:
What|Removed |Added
CC||rguenth at gcc dot gnu.org
--- Comment #4 from Richard Biener ---
Specifically
;; basic block 3, loop depth 1
-;;pred: 12
+;;pred: 10
foo ();
;;succ: 4
...
+;; basic block 10, loop depth 1
+;;pred: 7
+;;8
+ # _51 = PHI <_55(7), _4(8)>
+ _59 = _30 >> _51;
iftmp.4_60 = (char) _59;
-;;succ: 12
-
-;; basic block 12, loop depth 1
-;;pred: 10
-;;11
- # iftmp.4_61 = PHI <_29(10), iftmp.4_60(11)>
- _62 = (int) iftmp.4_61;
+ _62 = (int) iftmp.4_60;
d = _62;
if (_62 == 0)
-goto ; [33.00%]
+goto ; [66.33%]
else
-goto ; [67.00%]
+goto ; [33.67%]
;;succ: 3
;;4
the wrecking occurs in back_jt_path_registry::duplicate_thread_path via
update_bb_profile_for_threading doing
else if (!(prob == profile_probability::always ()))
{
FOR_EACH_EDGE (c, ei, bb->succs)
c->probability /= prob;
but taken_edge is the skip edge. So it seems that this might be OK after
all but we've threaded the "unlikely path", leaving the "likely" one
exposed to the unroller most probable path with now the call to foo ()
more likely executed?! This is
Checking profitability of path (backwards): bb:12 (4 insns) bb:10
Control statement insns: 2
Overall: 2 insns
[5] Registering jump thread: (10, 12) incoming edge; (12, 4) nocopy;
path: 10->12->4 SUCCESS
where the 10->12 has 59% probability and the 10->4 67%
Again not sure why we need to adjust the 12->3/4 probabilities on the
path leading through 10->11? Sure, we need to adjust the incoming
count into 12 and the counts of 3 and 4 but why adjust probabilities?
[Bug tree-optimization/102879] [12 Regression] Dead Code Elimination Regression at -O3
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102879
Richard Biener changed:
What|Removed |Added
CC||hubicka at gcc dot gnu.org
Priority|P3 |P1
--- Comment #3 from Richard Biener ---
There's an interesting missing value-numbering optimization here,
call_may_clobber_ref_p_1 considers the call to foo () possibly clobbering 'c'
even though 'c' does not escape the TU.
Since 'foo' is external there's no IPA reference or modref data but we
do know that !may_be_aliased (base) so we could amend
/* If the reference is based on a decl that is not aliased the call
cannot possibly clobber it. */
if (DECL_P (base)
&& !may_be_aliased (base)
/* But local non-readonly statics can be modified through recursion
or the call may implement a threading barrier which we must
treat as may-def. */
&& (TREE_READONLY (base)
|| !is_global_var (base)))
return false;
to constrain the "But local ..." (note nested functions make 'local'
difficult to express so we use !is_global_var). Of course the
threading barrier issue would still exist, but then the call itself
isn't clobbering it just serves as a barrier for code motion - I'm not
sure what kind of transforms we have to forbid.
Now, we _do_ have to ensure that foo () cannot access 'c' which it for
example might do if there's a
bar() { c = 3 };
void (*hook)() = bar;
and foo calls the exported *hook. In the end we have
c/1 (c) @0x77ff3180
Type: variable definition analyzed
Visibility: semantic_interposition prevailing_def_ironly
References:
Referring: main/4 (write) main/4 (read)
Availability: available
Varpool flags: used-by-single-function
(semantic_interposition!?), used-by-single-function might be the "trick"
to use here. Maybe we can also compute a non-recursive flag on
main/4 to say that control flow cannot possibly be (indirectly) recursive.
For the threading issue we might need a flag like
not-called-by-address-taken-functions (including not address taken itself) on
functions which should
practically rule out being a thread.
Anyway, the testcase in GCC 11 relies on cunrolli unrolling the inner loop
and cunroll unrolling the outer loop while GCC 12 no longer unrolls the
outer loop because
size: 18-3, last_iteration: 17-3
Loop size: 18
Estimated size after unrolling: 19
Not unrolling loop 1: contains call and code would grow.
while GCC 11 has
size: 17-3, last_iteration: 16-3
Loop size: 17
Estimated size after unrolling: 18
Making edge 14->9 impossible by redistributing probability to other edges.
Making edge 4->5 impossible by redistributing probability to other edges.
t.c:8:21: optimized: loop with 1 iterations completely unrolled (header
execution count 134197598)
Exit condition of peeled iterations was eliminated.
Last iteration exit edge was proved true.
Forced exit to be taken: if (0 != 0)
The difference is get_loop_hot_path () which on trunk gets presented with
a loop body where some extra path duplication has occured, duplicating the
store
to d and directing the path to foo () where the respective edge has 66%
probability vs. 33% on trunk and on the GCC 11 branch the situation
is reversed with 67% for the skip over the call.
On trunk threadfull1 duplicates the path with the store to 'd' and that
is also what wrecks the edge probabilities.
I think that's what we definitely need to fix here - the profile wreckage
done by threadfull1.
[Bug tree-optimization/102879] [12 Regression] Dead Code Elimination Regression at -O3
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102879 Andrew Pinski changed: What|Removed |Added Target Milestone|--- |12.0
[Bug tree-optimization/102879] [12 Regression] Dead Code Elimination Regression at -O3
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102879 --- Comment #2 from Andrew Macleod --- (In reply to Aldy Hernandez from comment #1) > > > So, presumably _62 == 0 cannot be true. If _62 == 0, then > > 0 = _30 >> _6; > > But that cannot happen because _30 is 2 if you follow the series of copies > from the "c" global. > > There is no way 0 = 2 >> x can ever be true. > > There's probably a couple things missing here. Maybe > operator_rshift::op1_range needs to be taught that ~[0,0] = x >> y implies x > is non-zero. But also, we can't see through the load from the c=2 global. > Shouldn't that c=2 have been propagated by someone at this point? (VRP1?) well, that depends on _6. 0 = _30 >> 32 is always true. now, we do happen to know that _6 is [0,1], so if we did manage to determine that _30 is [2,2], then the we will fold [2,2] >> [0,1] into [1,2] and then everything should fall into place as we know we can never take that breanch. That means our core issue is c.2_28 = c; _29 = (char) c.2_28; _30 = (int) _29; if (_29 >= 0) that we don't propagate the 2 into the c.2_28. we are limited to a range of [1,127] because of that.
[Bug tree-optimization/102879] [12 Regression] Dead Code Elimination Regression at -O3
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102879
Aldy Hernandez changed:
What|Removed |Added
CC||amacleod at redhat dot com
--- Comment #1 from Aldy Hernandez ---
We should've elided the call to foo() in the 8->3 edge. This is the IL in
vrp-thread1 dump:
int main ()
{
int h;
int g;
int _3;
_Bool _5;
int _6;
char iftmp.4_11;
int _12;
int _19;
int _21;
char iftmp.4_22;
int d.0_25;
_Bool _26;
int _27;
int c.2_28;
char _29;
int _30;
int _42;
char iftmp.4_43;
int _48;
int _50;
_Bool _53;
int _56;
int _59;
char iftmp.4_60;
int _62;
[local count: 134197598]:
c = 2;
goto ; [100.00%]
[local count: 88583700]:
foo ();
[local count: 268435457]:
g_18 = g_10 + 1;
[local count: 402633054]:
# g_10 = PHI <0(2), g_18(4)>
if (g_10 != 2)
goto ; [66.67%]
else
goto ; [33.33%]
[local count: 268435456]:
d.0_25 = d;
_26 = d.0_25 == 0;
_27 = (int) _26;
c.2_28 = c;
_29 = (char) c.2_28;
_30 = (int) _29;
if (_29 >= 0)
goto ; [59.00%]
else
goto ; [41.00%]
[local count: 110058536]:
# iftmp.4_11 = PHI <_29(6)>
_12 = (int) iftmp.4_11;
d = _12;
_48 = (int) _29;
d = _48;
_19 = (int) _29;
d = _19;
goto ; [100.00%]
[local count: 158376920]:
_42 = _30 >> _27;
iftmp.4_43 = (char) _42;
_50 = _42;
d = _50;
_53 = _50 == 0;
_56 = (int) _53;
_21 = _30 >> _56;
iftmp.4_22 = (char) _21;
_3 = _21;
d = _3;
_5 = _3 == 0;
_6 = (int) _5;
_59 = _30 >> _6;
iftmp.4_60 = (char) _59;
_62 = _59;
d = _62;
if (_62 == 0)
goto ; [66.33%]
else
goto ; [33.67%]
[local count: 134197598]:
return 0;
}
So, presumably _62 == 0 cannot be true. If _62 == 0, then
0 = _30 >> _6;
But that cannot happen because _30 is 2 if you follow the series of copies from
the "c" global.
There is no way 0 = 2 >> x can ever be true.
There's probably a couple things missing here. Maybe
operator_rshift::op1_range needs to be taught that ~[0,0] = x >> y implies x is
non-zero. But also, we can't see through the load from the c=2 global.
Shouldn't that c=2 have been propagated by someone at this point? (VRP1?)
[Bug tree-optimization/102879] [12 Regression] Dead Code Elimination Regression at -O3
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102879 Martin Liška changed: What|Removed |Added Status|UNCONFIRMED |NEW Ever confirmed|0 |1 Last reconfirmed||2021-10-21 CC||aldyh at gcc dot gnu.org, ||marxin at gcc dot gnu.org
