OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bb-reorder: Improve the simple algorithm for -Os (PR67864) 

As the PR points out, the "simple" reorder algorithm makes bigger code
than the STC algorithm did, for -Os, for x86.  I now tested it for many
different targets and it turns out to be worse everywhere.

This simple patch tunes "simple" a bit; this makes it better than STC
almost everywhere.  The only exceptions (for the targets where I have
results) are x86 and mn10300.  For those targets it may be best to switch
the default algorithm for -Os to STC.


2015-10-11  Segher Boessenkool  <segher@kernel.crashing.org>

	PR rtl-optimization/67864
	* gcc/bb-reorder (reorder_basic_blocks_simple): Prefer existing
	fallthrough edges for conditional jumps.  Don't sort candidate
	edges if not optimizing for speed.

From-SVN: r228692
This commit is contained in:
Segher Boessenkool 2015-10-11 11:03:09 +02:00 committed by Segher Boessenkool
parent fac812f0bd
commit c70f0ca26b
2 changed files with 19 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/ChangeLog
View File

@ -1,3 +1,10 @@
2015-10-11 Segher Boessenkool <segher@kernel.crashing.org>
PR rtl-optimization/67864
* gcc/bb-reorder (reorder_basic_blocks_simple): Prefer existing
fallthrough edges for conditional jumps. Don't sort candidate
edges if not optimizing for speed.
2015-10-10 Trevor Saunders <tbsaunde+gcc@tbsaunde.org>
* defaults.h (REVERSE_CONDITION): New default definition.

16
gcc/bb-reorder.c
View File

@ -2318,16 +2318,24 @@ reorder_basic_blocks_simple (void)
if (any_condjump_p (end))
{
edges[n++] = EDGE_SUCC (bb, 0);
edges[n++] = EDGE_SUCC (bb, 1);
edge e0 = EDGE_SUCC (bb, 0);
edge e1 = EDGE_SUCC (bb, 1);
/* When optimizing for size it is best to keep the original
fallthrough edges. */
if (e1->flags & EDGE_FALLTHRU)
std::swap (e0, e1);
edges[n++] = e0;
edges[n++] = e1;
}
else if (single_succ_p (bb))
edges[n++] = EDGE_SUCC (bb, 0);
}
/* Sort the edges, the most desirable first. */
/* Sort the edges, the most desirable first. When optimizing for size
all edges are equally desirable. */
std::stable_sort (edges, edges + n, edge_order);
if (optimize_function_for_speed_p (cfun))
std::stable_sort (edges, edges + n, edge_order);
/* Now decide which of those edges to make fallthrough edges. We set
BB_VISITED if a block already has a fallthrough successor assigned