* cfg.c (update_bb_profile_for_threading): Use RDIV.
(scale_bbs_frequencies_int): Likewise, assert for possible overflow.
(scale_bbs_frequencies_gcov_type): Be more curefull about overflows and
roundoff errors.
* tree-cfg.c (tree_duplicate_sese_region): Use counts for updating
profile when available.
* update-loopch.c: New testcase.
From-SVN: r102466
-2005-07-28 Jan Beulich <jbeulich@novell.com>
+2005-07-28 Jan Hubicka <jh@suse.cz>
+
+ * cfg.c (update_bb_profile_for_threading): Use RDIV.
+ (scale_bbs_frequencies_int): Likewise, assert for possible overflow.
+ (scale_bbs_frequencies_gcov_type): Be more curefull about overflows and
+ roundoff errors.
+ * tree-cfg.c (tree_duplicate_sese_region): Use counts for updating
+ profile when available.
+
+2005-07-28 Jan Beulich <jbeulich@novell.com>
* config/ia64/ia64.c (ia64_load_pair_ok): New.
(ia64_print_operand): Describe and handle 'X'.
}
else if (prob != REG_BR_PROB_BASE)
{
- int scale = 65536 * REG_BR_PROB_BASE / prob;
+ int scale = RDIV (65536 * REG_BR_PROB_BASE, prob);
FOR_EACH_EDGE (c, ei, bb->succs)
{
- c->probability = (c->probability * scale) / 65536;
+ c->probability = RDIV (c->probability * scale, 65536);
if (c->probability > REG_BR_PROB_BASE)
c->probability = REG_BR_PROB_BASE;
}
num = 0;
if (num > den)
return;
+ /* Assume that the users are producing the fraction from frequencies
+ that never grow far enought to risk arithmetic overflow. */
+ gcc_assert (num < 65536);
for (i = 0; i < nbbs; i++)
{
edge_iterator ei;
- bbs[i]->frequency = (bbs[i]->frequency * num) / den;
+ bbs[i]->frequency = RDIV (bbs[i]->frequency * num, den);
bbs[i]->count = RDIV (bbs[i]->count * num, den);
FOR_EACH_EDGE (e, ei, bbs[i]->succs)
- e->count = (e->count * num) /den;
+ e->count = RDIV (e->count * num, den);
}
}
+/* numbers smaller than this value are safe to multiply without getting
+ 64bit overflow. */
+#define MAX_SAFE_MULTIPLIER (1 << (sizeof (HOST_WIDEST_INT) * 4 - 1))
+
/* Multiply all frequencies of basic blocks in array BBS of length NBBS
by NUM/DEN, in gcov_type arithmetic. More accurate than previous
function but considerably slower. */
{
int i;
edge e;
+ gcov_type fraction = RDIV (num * 65536, den);
- for (i = 0; i < nbbs; i++)
- {
- edge_iterator ei;
- bbs[i]->frequency = (bbs[i]->frequency * num) / den;
- bbs[i]->count = RDIV (bbs[i]->count * num, den);
- FOR_EACH_EDGE (e, ei, bbs[i]->succs)
- e->count = (e->count * num) /den;
- }
+ gcc_assert (fraction >= 0);
+
+ if (num < MAX_SAFE_MULTIPLIER)
+ for (i = 0; i < nbbs; i++)
+ {
+ edge_iterator ei;
+ bbs[i]->frequency = RDIV (bbs[i]->frequency * num, den);
+ if (bbs[i]->count <= MAX_SAFE_MULTIPLIER)
+ bbs[i]->count = RDIV (bbs[i]->count * num, den);
+ else
+ bbs[i]->count = RDIV (bbs[i]->count * fraction, 65536);
+ FOR_EACH_EDGE (e, ei, bbs[i]->succs)
+ if (bbs[i]->count <= MAX_SAFE_MULTIPLIER)
+ e->count = RDIV (e->count * num, den);
+ else
+ e->count = RDIV (e->count * fraction, 65536);
+ }
+ else
+ for (i = 0; i < nbbs; i++)
+ {
+ edge_iterator ei;
+ if (sizeof (gcov_type) > sizeof (int))
+ bbs[i]->frequency = RDIV (bbs[i]->frequency * num, den);
+ else
+ bbs[i]->frequency = RDIV (bbs[i]->frequency * fraction, 65536);
+ bbs[i]->count = RDIV (bbs[i]->count * fraction, 65536);
+ FOR_EACH_EDGE (e, ei, bbs[i]->succs)
+ e->count = RDIV (e->count * fraction, 65536);
+ }
}
/* Data structures used to maintain mapping between basic blocks and
+2005-07-28 Jan Hubicka <jh@suse.cz>
+
+ * update-loopch.c: New testcase.
+
2005-07-27 James A. Morrison <phython@gcc.gnu.org>
PR rtl-optimization/23047
--- /dev/null
+/* { dg-options "-O2 -fdump-tree_profile -fdump-tree-optimized" } */
+int max = 33333;
+int a[8];
+int
+main ()
+{
+ int i;
+ for (i = 0; i < max; i++)
+ {
+ a[i % 8]++;
+ }
+ return 0;
+}
+/* Loop header copying will peel away the initial conditional, so the loop body
+ is once reached directly from entry point of function, rest via loopback
+ edge. */
+/* { dg-final-use { scan-tree-dump-not "count:33333" "tree_profile"} } */
+/* { dg-final-use { scan-tree-dump "count:33332" "optimized"} } */
+/* { dg-final-use { scan-tree-dump-not "Invalid sum" "optimized"} } */
+/* { dg-final-use { cleanup-tree-dump "tree_profile" } } */
+/* { dg-final-use { cleanup-tree-dump "optimized" } } */
edge exit_copy;
basic_block *doms;
edge redirected;
- int total_freq, entry_freq;
+ int total_freq = 0, entry_freq = 0;
+ gcov_type total_count = 0, entry_count = 0;
if (!can_copy_bbs_p (region, n_region))
return false;
n_doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region, doms);
- total_freq = entry->dest->frequency;
- entry_freq = EDGE_FREQUENCY (entry);
- /* Fix up corner cases, to avoid division by zero or creation of negative
- frequencies. */
- if (total_freq == 0)
- total_freq = 1;
- else if (entry_freq > total_freq)
- entry_freq = total_freq;
+ if (entry->dest->count)
+ {
+ total_count = entry->dest->count;
+ entry_count = entry->count;
+ /* Fix up corner cases, to avoid division by zero or creation of negative
+ frequencies. */
+ if (entry_count > total_count)
+ entry_count = total_count;
+ }
+ else
+ {
+ total_freq = entry->dest->frequency;
+ entry_freq = EDGE_FREQUENCY (entry);
+ /* Fix up corner cases, to avoid division by zero or creation of negative
+ frequencies. */
+ if (total_freq == 0)
+ total_freq = 1;
+ else if (entry_freq > total_freq)
+ entry_freq = total_freq;
+ }
copy_bbs (region, n_region, region_copy, &exit, 1, &exit_copy, loop);
- scale_bbs_frequencies_int (region, n_region, total_freq - entry_freq,
- total_freq);
- scale_bbs_frequencies_int (region_copy, n_region, entry_freq, total_freq);
+ if (total_count)
+ {
+ scale_bbs_frequencies_gcov_type (region, n_region,
+ total_count - entry_count,
+ total_count);
+ scale_bbs_frequencies_gcov_type (region_copy, n_region, entry_count,
+ total_count);
+ }
+ else
+ {
+ scale_bbs_frequencies_int (region, n_region, total_freq - entry_freq,
+ total_freq);
+ scale_bbs_frequencies_int (region_copy, n_region, entry_freq, total_freq);
+ }
if (copying_header)
{