/* Control flow graph manipulation code for GNU compiler.
- Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005
- Free Software Foundation, Inc.
+ Copyright (C) 1987-2016 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
/* This file contains low level functions to manipulate the CFG and
analyze it. All other modules should not transform the data structure
verify_flow_info
- Dumping and debugging
print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
+
+ TODO: Document these "Available functionality" functions in the files
+ that implement them.
*/
\f
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
-#include "tree.h"
-#include "rtl.h"
+#include "backend.h"
#include "hard-reg-set.h"
-#include "regs.h"
-#include "flags.h"
-#include "output.h"
-#include "function.h"
-#include "except.h"
-#include "toplev.h"
-#include "tm_p.h"
-#include "obstack.h"
-#include "timevar.h"
-#include "ggc.h"
-#include "hashtab.h"
-#include "alloc-pool.h"
-
-/* The obstack on which the flow graph components are allocated. */
-
-struct bitmap_obstack reg_obstack;
-
-void debug_flow_info (void);
-static void free_edge (edge);
+#include "tree.h"
+#include "cfghooks.h"
+#include "df.h"
+#include "cfganal.h"
+#include "cfgloop.h" /* FIXME: For struct loop. */
+#include "dumpfile.h"
+
\f
#define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
/* Called once at initialization time. */
void
-init_flow (void)
+init_flow (struct function *the_fun)
{
- if (!cfun->cfg)
- cfun->cfg = ggc_alloc_cleared (sizeof (struct control_flow_graph));
- n_edges = 0;
- ENTRY_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
- ENTRY_BLOCK_PTR->index = ENTRY_BLOCK;
- EXIT_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
- EXIT_BLOCK_PTR->index = EXIT_BLOCK;
- ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
- EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
+ if (!the_fun->cfg)
+ the_fun->cfg = ggc_cleared_alloc<control_flow_graph> ();
+ n_edges_for_fn (the_fun) = 0;
+ ENTRY_BLOCK_PTR_FOR_FN (the_fun)
+ = ggc_cleared_alloc<basic_block_def> ();
+ ENTRY_BLOCK_PTR_FOR_FN (the_fun)->index = ENTRY_BLOCK;
+ EXIT_BLOCK_PTR_FOR_FN (the_fun)
+ = ggc_cleared_alloc<basic_block_def> ();
+ EXIT_BLOCK_PTR_FOR_FN (the_fun)->index = EXIT_BLOCK;
+ ENTRY_BLOCK_PTR_FOR_FN (the_fun)->next_bb
+ = EXIT_BLOCK_PTR_FOR_FN (the_fun);
+ EXIT_BLOCK_PTR_FOR_FN (the_fun)->prev_bb
+ = ENTRY_BLOCK_PTR_FOR_FN (the_fun);
}
\f
/* Helper function for remove_edge and clear_edges. Frees edge structure
- without actually unlinking it from the pred/succ lists. */
+ without actually removing it from the pred/succ arrays. */
static void
-free_edge (edge e ATTRIBUTE_UNUSED)
+free_edge (function *fn, edge e)
{
- n_edges--;
+ n_edges_for_fn (fn)--;
ggc_free (e);
}
/* Free the memory associated with the edge structures. */
void
-clear_edges (void)
+clear_edges (struct function *fn)
{
basic_block bb;
edge e;
edge_iterator ei;
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, fn)
{
FOR_EACH_EDGE (e, ei, bb->succs)
- free_edge (e);
- VEC_truncate (edge, bb->succs, 0);
- VEC_truncate (edge, bb->preds, 0);
+ free_edge (fn, e);
+ vec_safe_truncate (bb->succs, 0);
+ vec_safe_truncate (bb->preds, 0);
}
- FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
- free_edge (e);
- VEC_truncate (edge, EXIT_BLOCK_PTR->preds, 0);
- VEC_truncate (edge, ENTRY_BLOCK_PTR->succs, 0);
+ FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (fn)->succs)
+ free_edge (fn, e);
+ vec_safe_truncate (EXIT_BLOCK_PTR_FOR_FN (fn)->preds, 0);
+ vec_safe_truncate (ENTRY_BLOCK_PTR_FOR_FN (fn)->succs, 0);
- gcc_assert (!n_edges);
+ gcc_assert (!n_edges_for_fn (fn));
}
\f
/* Allocate memory for basic_block. */
alloc_block (void)
{
basic_block bb;
- bb = ggc_alloc_cleared (sizeof (*bb));
+ bb = ggc_cleared_alloc<basic_block_def> ();
return bb;
}
-/* Initialize rbi (the structure containing data used by basic block
- duplication and reordering) for the given basic block. */
-
-void
-initialize_bb_rbi (basic_block bb)
-{
- gcc_assert (!bb->rbi);
- bb->rbi = ggc_alloc_cleared (sizeof (struct reorder_block_def));
-}
-
/* Link block B to chain after AFTER. */
void
link_block (basic_block b, basic_block after)
compact_blocks (void)
{
int i;
- basic_block bb;
- i = 0;
- FOR_EACH_BB (bb)
- {
- BASIC_BLOCK (i) = bb;
- bb->index = i;
- i++;
- }
+ SET_BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (cfun));
+ SET_BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (cfun));
- gcc_assert (i == n_basic_blocks);
+ if (df)
+ df_compact_blocks ();
+ else
+ {
+ basic_block bb;
- for (; i < last_basic_block; i++)
- BASIC_BLOCK (i) = NULL;
+ i = NUM_FIXED_BLOCKS;
+ FOR_EACH_BB_FN (bb, cfun)
+ {
+ SET_BASIC_BLOCK_FOR_FN (cfun, i, bb);
+ bb->index = i;
+ i++;
+ }
+ gcc_assert (i == n_basic_blocks_for_fn (cfun));
- last_basic_block = n_basic_blocks;
+ for (; i < last_basic_block_for_fn (cfun); i++)
+ SET_BASIC_BLOCK_FOR_FN (cfun, i, NULL);
+ }
+ last_basic_block_for_fn (cfun) = n_basic_blocks_for_fn (cfun);
}
/* Remove block B from the basic block array. */
expunge_block (basic_block b)
{
unlink_block (b);
- BASIC_BLOCK (b->index) = NULL;
- n_basic_blocks--;
+ SET_BASIC_BLOCK_FOR_FN (cfun, b->index, NULL);
+ n_basic_blocks_for_fn (cfun)--;
/* We should be able to ggc_free here, but we are not.
The dead SSA_NAMES are left pointing to dead statements that are pointing
to dead basic blocks making garbage collector to die.
static inline void
connect_src (edge e)
{
- VEC_safe_push (edge, gc, e->src->succs, e);
+ vec_safe_push (e->src->succs, e);
+ df_mark_solutions_dirty ();
}
/* Connect E to E->dest. */
connect_dest (edge e)
{
basic_block dest = e->dest;
- VEC_safe_push (edge, gc, dest->preds, e);
+ vec_safe_push (dest->preds, e);
e->dest_idx = EDGE_COUNT (dest->preds) - 1;
+ df_mark_solutions_dirty ();
}
/* Disconnect edge E from E->src. */
{
if (tmp == e)
{
- VEC_unordered_remove (edge, src->succs, ei.index);
+ src->succs->unordered_remove (ei.index);
+ df_mark_solutions_dirty ();
return;
}
else
basic_block dest = e->dest;
unsigned int dest_idx = e->dest_idx;
- VEC_unordered_remove (edge, dest->preds, dest_idx);
+ dest->preds->unordered_remove (dest_idx);
/* If we removed an edge in the middle of the edge vector, we need
to update dest_idx of the edge that moved into the "hole". */
if (dest_idx < EDGE_COUNT (dest->preds))
EDGE_PRED (dest, dest_idx)->dest_idx = dest_idx;
+ df_mark_solutions_dirty ();
}
/* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
unchecked_make_edge (basic_block src, basic_block dst, int flags)
{
edge e;
- e = ggc_alloc_cleared (sizeof (*e));
- n_edges++;
+ e = ggc_cleared_alloc<edge_def> ();
+ n_edges_for_fn (cfun)++;
e->src = src;
e->dest = dst;
connect_dest (e);
execute_on_growing_pred (e);
-
return e;
}
cached_make_edge (sbitmap edge_cache, basic_block src, basic_block dst, int flags)
{
if (edge_cache == NULL
- || src == ENTRY_BLOCK_PTR
- || dst == EXIT_BLOCK_PTR)
+ || src == ENTRY_BLOCK_PTR_FOR_FN (cfun)
+ || dst == EXIT_BLOCK_PTR_FOR_FN (cfun))
return make_edge (src, dst, flags);
/* Does the requested edge already exist? */
- if (! TEST_BIT (edge_cache, dst->index))
+ if (! bitmap_bit_p (edge_cache, dst->index))
{
/* The edge does not exist. Create one and update the
cache. */
- SET_BIT (edge_cache, dst->index);
+ bitmap_set_bit (edge_cache, dst->index);
return unchecked_make_edge (src, dst, flags);
}
/* This function will remove an edge from the flow graph. */
void
-remove_edge (edge e)
+remove_edge_raw (edge e)
{
remove_predictions_associated_with_edge (e);
execute_on_shrinking_pred (e);
disconnect_src (e);
disconnect_dest (e);
- free_edge (e);
+ free_edge (cfun, e);
}
/* Redirect an edge's successor from one block to another. */
execute_on_growing_pred (e);
}
-/* Like previous but avoid possible duplicate edge. */
-
-edge
-redirect_edge_succ_nodup (edge e, basic_block new_succ)
-{
- edge s;
-
- s = find_edge (e->src, new_succ);
- if (s && s != e)
- {
- s->flags |= e->flags;
- s->probability += e->probability;
- if (s->probability > REG_BR_PROB_BASE)
- s->probability = REG_BR_PROB_BASE;
- s->count += e->count;
- remove_edge (e);
- e = s;
- }
- else
- redirect_edge_succ (e, new_succ);
-
- return e;
-}
-
/* Redirect an edge's predecessor from one block to another. */
void
connect_src (e);
}
-/* Clear all basic block flags, with the exception of partitioning. */
+/* Clear all basic block flags that do not have to be preserved. */
void
clear_bb_flags (void)
{
basic_block bb;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
- bb->flags = (BB_PARTITION (bb) | (bb->flags & BB_DISABLE_SCHEDULE)
- | (bb->flags & BB_RTL));
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
+ bb->flags &= BB_FLAGS_TO_PRESERVE;
}
\f
/* Check the consistency of profile information. We can't do that
solved graphs, later eliminating of conditionals or roundoff errors.
It is still practical to have them reported for debugging of simple
testcases. */
-void
-check_bb_profile (basic_block bb, FILE * file)
+static void
+check_bb_profile (basic_block bb, FILE * file, int indent, int flags)
{
edge e;
int sum = 0;
gcov_type lsum;
edge_iterator ei;
+ struct function *fun = DECL_STRUCT_FUNCTION (current_function_decl);
+ char *s_indent = (char *) alloca ((size_t) indent + 1);
+ memset ((void *) s_indent, ' ', (size_t) indent);
+ s_indent[indent] = '\0';
- if (profile_status == PROFILE_ABSENT)
+ if (profile_status_for_fn (fun) == PROFILE_ABSENT)
return;
- if (bb != EXIT_BLOCK_PTR)
+ if (bb != EXIT_BLOCK_PTR_FOR_FN (fun))
{
FOR_EACH_EDGE (e, ei, bb->succs)
sum += e->probability;
if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
- fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
+ fprintf (file, "%s%sInvalid sum of outgoing probabilities %.1f%%\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
sum * 100.0 / REG_BR_PROB_BASE);
lsum = 0;
FOR_EACH_EDGE (e, ei, bb->succs)
lsum += e->count;
if (EDGE_COUNT (bb->succs)
&& (lsum - bb->count > 100 || lsum - bb->count < -100))
- fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
+ fprintf (file, "%s%sInvalid sum of outgoing counts %i, should be %i\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
(int) lsum, (int) bb->count);
}
- if (bb != ENTRY_BLOCK_PTR)
+ if (bb != ENTRY_BLOCK_PTR_FOR_FN (fun))
{
sum = 0;
FOR_EACH_EDGE (e, ei, bb->preds)
sum += EDGE_FREQUENCY (e);
if (abs (sum - bb->frequency) > 100)
fprintf (file,
- "Invalid sum of incoming frequencies %i, should be %i\n",
+ "%s%sInvalid sum of incoming frequencies %i, should be %i\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
sum, bb->frequency);
lsum = 0;
FOR_EACH_EDGE (e, ei, bb->preds)
lsum += e->count;
if (lsum - bb->count > 100 || lsum - bb->count < -100)
- fprintf (file, "Invalid sum of incoming counts %i, should be %i\n",
+ fprintf (file, "%s%sInvalid sum of incoming counts %i, should be %i\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent,
(int) lsum, (int) bb->count);
}
-}
-\f
-void
-dump_flow_info (FILE *file)
-{
- basic_block bb;
-
- /* There are no pseudo registers after reload. Don't dump them. */
- if (reg_n_info && !reload_completed)
- {
- unsigned int i, max = max_reg_num ();
- fprintf (file, "%d registers.\n", max);
- for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
- if (REG_N_REFS (i))
- {
- enum reg_class class, altclass;
-
- fprintf (file, "\nRegister %d used %d times across %d insns",
- i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
- if (REG_BASIC_BLOCK (i) >= 0)
- fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
- if (REG_N_SETS (i))
- fprintf (file, "; set %d time%s", REG_N_SETS (i),
- (REG_N_SETS (i) == 1) ? "" : "s");
- if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
- fprintf (file, "; user var");
- if (REG_N_DEATHS (i) != 1)
- fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
- if (REG_N_CALLS_CROSSED (i) == 1)
- fprintf (file, "; crosses 1 call");
- else if (REG_N_CALLS_CROSSED (i))
- fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
- if (regno_reg_rtx[i] != NULL
- && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
- fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
-
- class = reg_preferred_class (i);
- altclass = reg_alternate_class (i);
- if (class != GENERAL_REGS || altclass != ALL_REGS)
- {
- if (altclass == ALL_REGS || class == ALL_REGS)
- fprintf (file, "; pref %s", reg_class_names[(int) class]);
- else if (altclass == NO_REGS)
- fprintf (file, "; %s or none", reg_class_names[(int) class]);
- else
- fprintf (file, "; pref %s, else %s",
- reg_class_names[(int) class],
- reg_class_names[(int) altclass]);
- }
-
- if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
- fprintf (file, "; pointer");
- fprintf (file, ".\n");
- }
- }
-
- fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
- FOR_EACH_BB (bb)
+ if (BB_PARTITION (bb) == BB_COLD_PARTITION)
{
- edge e;
- edge_iterator ei;
-
- fprintf (file, "\nBasic block %d ", bb->index);
- fprintf (file, "prev %d, next %d, ",
- bb->prev_bb->index, bb->next_bb->index);
- fprintf (file, "loop_depth %d, count ", bb->loop_depth);
- fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
- fprintf (file, ", freq %i", bb->frequency);
- if (maybe_hot_bb_p (bb))
- fprintf (file, ", maybe hot");
- if (probably_never_executed_bb_p (bb))
- fprintf (file, ", probably never executed");
- fprintf (file, ".\n");
-
- fprintf (file, "Predecessors: ");
+ /* Warn about inconsistencies in the partitioning that are
+ currently caused by profile insanities created via optimization. */
+ if (!probably_never_executed_bb_p (fun, bb))
+ fprintf (file, "%s%sBlock in cold partition with hot count\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent);
FOR_EACH_EDGE (e, ei, bb->preds)
- dump_edge_info (file, e, 0);
-
- fprintf (file, "\nSuccessors: ");
- FOR_EACH_EDGE (e, ei, bb->succs)
- dump_edge_info (file, e, 1);
-
- if (bb->flags & BB_RTL)
- {
- if (bb->il.rtl->global_live_at_start)
- {
- fprintf (file, "\nRegisters live at start:");
- dump_regset (bb->il.rtl->global_live_at_start, file);
- }
-
- if (bb->il.rtl->global_live_at_end)
- {
- fprintf (file, "\nRegisters live at end:");
- dump_regset (bb->il.rtl->global_live_at_end, file);
- }
- }
-
- putc ('\n', file);
- check_bb_profile (bb, file);
+ {
+ if (!probably_never_executed_edge_p (fun, e))
+ fprintf (file,
+ "%s%sBlock in cold partition with incoming hot edge\n",
+ (flags & TDF_COMMENT) ? ";; " : "", s_indent);
+ }
}
-
- putc ('\n', file);
-}
-
-void
-debug_flow_info (void)
-{
- dump_flow_info (stderr);
}
-
+\f
void
-dump_edge_info (FILE *file, edge e, int do_succ)
+dump_edge_info (FILE *file, edge e, int flags, int do_succ)
{
basic_block side = (do_succ ? e->dest : e->src);
+ bool do_details = false;
+
+ if ((flags & TDF_DETAILS) != 0
+ && (flags & TDF_SLIM) == 0)
+ do_details = true;
- if (side == ENTRY_BLOCK_PTR)
+ if (side->index == ENTRY_BLOCK)
fputs (" ENTRY", file);
- else if (side == EXIT_BLOCK_PTR)
+ else if (side->index == EXIT_BLOCK)
fputs (" EXIT", file);
else
fprintf (file, " %d", side->index);
- if (e->probability)
+ if (e->probability && do_details)
fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
- if (e->count)
+ if (e->count && do_details)
{
- fprintf (file, " count:");
- fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
+ fputs (" count:", file);
+ fprintf (file, "%" PRId64, e->count);
}
- if (e->flags)
+ if (e->flags && do_details)
{
- static const char * const bitnames[] = {
- "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
- "can_fallthru", "irreducible", "sibcall", "loop_exit",
- "true", "false", "exec"
- };
- int comma = 0;
+ static const char * const bitnames[] =
+ {
+#define DEF_EDGE_FLAG(NAME,IDX) #NAME ,
+#include "cfg-flags.def"
+ NULL
+#undef DEF_EDGE_FLAG
+ };
+ bool comma = false;
int i, flags = e->flags;
+ gcc_assert (e->flags <= EDGE_ALL_FLAGS);
fputs (" (", file);
for (i = 0; flags; i++)
if (flags & (1 << i))
if (comma)
fputc (',', file);
- if (i < (int) ARRAY_SIZE (bitnames))
- fputs (bitnames[i], file);
- else
- fprintf (file, "%d", i);
- comma = 1;
+ fputs (bitnames[i], file);
+ comma = true;
}
fputc (')', file);
}
}
+
+DEBUG_FUNCTION void
+debug (edge_def &ref)
+{
+ /* FIXME (crowl): Is this desireable? */
+ dump_edge_info (stderr, &ref, 0, false);
+ dump_edge_info (stderr, &ref, 0, true);
+}
+
+DEBUG_FUNCTION void
+debug (edge_def *ptr)
+{
+ if (ptr)
+ debug (*ptr);
+ else
+ fprintf (stderr, "<nil>\n");
+}
\f
/* Simple routines to easily allocate AUX fields of basic blocks. */
/* Allocate a memory block of SIZE as BB->aux. The obstack must
be first initialized by alloc_aux_for_blocks. */
-inline void
+static void
alloc_aux_for_block (basic_block bb, int size)
{
/* Verify that aux field is clear. */
else
/* Check whether AUX data are still allocated. */
gcc_assert (!first_block_aux_obj);
-
+
first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
if (size)
{
basic_block bb;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+ FOR_ALL_BB_FN (bb, cfun)
alloc_aux_for_block (bb, size);
}
}
{
basic_block bb;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
+ FOR_ALL_BB_FN (bb, cfun)
bb->aux = NULL;
}
clear_aux_for_blocks ();
}
-/* Allocate a memory edge of SIZE as BB->aux. The obstack must
+/* Allocate a memory edge of SIZE as E->aux. The obstack must
be first initialized by alloc_aux_for_edges. */
-inline void
+void
alloc_aux_for_edge (edge e, int size)
{
/* Verify that aux field is clear. */
{
basic_block bb;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
+ EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
{
edge e;
edge_iterator ei;
basic_block bb;
edge e;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
+ EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
{
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->succs)
clear_aux_for_edges ();
}
-void
+DEBUG_FUNCTION void
debug_bb (basic_block bb)
{
- dump_bb (bb, stderr, 0);
+ dump_bb (stderr, bb, 0, dump_flags);
}
-basic_block
+DEBUG_FUNCTION basic_block
debug_bb_n (int n)
{
- basic_block bb = BASIC_BLOCK (n);
- dump_bb (bb, stderr, 0);
+ basic_block bb = BASIC_BLOCK_FOR_FN (cfun, n);
+ debug_bb (bb);
return bb;
}
-/* Dumps cfg related information about basic block BB to FILE. */
+/* Dumps cfg related information about basic block BB to OUTF.
+ If HEADER is true, dump things that appear before the instructions
+ contained in BB. If FOOTER is true, dump things that appear after.
+ Flags are the TDF_* masks as documented in dumpfile.h.
+ NB: With TDF_DETAILS, it is assumed that cfun is available, so
+ that maybe_hot_bb_p and probably_never_executed_bb_p don't ICE. */
-static void
-dump_cfg_bb_info (FILE *file, basic_block bb)
+void
+dump_bb_info (FILE *outf, basic_block bb, int indent, int flags,
+ bool do_header, bool do_footer)
{
- unsigned i;
edge_iterator ei;
- bool first = true;
+ edge e;
static const char * const bb_bitnames[] =
{
- "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
+#define DEF_BASIC_BLOCK_FLAG(NAME,IDX) #NAME ,
+#include "cfg-flags.def"
+ NULL
+#undef DEF_BASIC_BLOCK_FLAG
};
const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
- edge e;
+ bool first;
+ char *s_indent = (char *) alloca ((size_t) indent + 1);
+ memset ((void *) s_indent, ' ', (size_t) indent);
+ s_indent[indent] = '\0';
- fprintf (file, "Basic block %d", bb->index);
- for (i = 0; i < n_bitnames; i++)
- if (bb->flags & (1 << i))
- {
- if (first)
- fprintf (file, " (");
- else
- fprintf (file, ", ");
- first = false;
- fprintf (file, bb_bitnames[i]);
- }
- if (!first)
- fprintf (file, ")");
- fprintf (file, "\n");
-
- fprintf (file, "Predecessors: ");
- FOR_EACH_EDGE (e, ei, bb->preds)
- dump_edge_info (file, e, 0);
-
- fprintf (file, "\nSuccessors: ");
- FOR_EACH_EDGE (e, ei, bb->succs)
- dump_edge_info (file, e, 1);
- fprintf (file, "\n\n");
+ gcc_assert (bb->flags <= BB_ALL_FLAGS);
+
+ if (do_header)
+ {
+ unsigned i;
+
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%sbasic block %d, loop depth %d",
+ s_indent, bb->index, bb_loop_depth (bb));
+ if (flags & TDF_DETAILS)
+ {
+ struct function *fun = DECL_STRUCT_FUNCTION (current_function_decl);
+ fprintf (outf, ", count " "%" PRId64,
+ (int64_t) bb->count);
+ fprintf (outf, ", freq %i", bb->frequency);
+ if (maybe_hot_bb_p (fun, bb))
+ fputs (", maybe hot", outf);
+ if (probably_never_executed_bb_p (fun, bb))
+ fputs (", probably never executed", outf);
+ }
+ fputc ('\n', outf);
+
+ if (flags & TDF_DETAILS)
+ {
+ check_bb_profile (bb, outf, indent, flags);
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%s prev block ", s_indent);
+ if (bb->prev_bb)
+ fprintf (outf, "%d", bb->prev_bb->index);
+ else
+ fprintf (outf, "(nil)");
+ fprintf (outf, ", next block ");
+ if (bb->next_bb)
+ fprintf (outf, "%d", bb->next_bb->index);
+ else
+ fprintf (outf, "(nil)");
+
+ fputs (", flags:", outf);
+ first = true;
+ for (i = 0; i < n_bitnames; i++)
+ if (bb->flags & (1 << i))
+ {
+ if (first)
+ fputs (" (", outf);
+ else
+ fputs (", ", outf);
+ first = false;
+ fputs (bb_bitnames[i], outf);
+ }
+ if (!first)
+ fputc (')', outf);
+ fputc ('\n', outf);
+ }
+
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%s pred: ", s_indent);
+ first = true;
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ {
+ if (! first)
+ {
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%s ", s_indent);
+ }
+ first = false;
+ dump_edge_info (outf, e, flags, 0);
+ fputc ('\n', outf);
+ }
+ if (first)
+ fputc ('\n', outf);
+ }
+
+ if (do_footer)
+ {
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%s succ: ", s_indent);
+ first = true;
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ {
+ if (! first)
+ {
+ if (flags & TDF_COMMENT)
+ fputs (";; ", outf);
+ fprintf (outf, "%s ", s_indent);
+ }
+ first = false;
+ dump_edge_info (outf, e, flags, 1);
+ fputc ('\n', outf);
+ }
+ if (first)
+ fputc ('\n', outf);
+ }
}
/* Dumps a brief description of cfg to FILE. */
void
-brief_dump_cfg (FILE *file)
+brief_dump_cfg (FILE *file, int flags)
{
basic_block bb;
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
{
- dump_cfg_bb_info (file, bb);
+ dump_bb_info (file, bb, 0,
+ flags & (TDF_COMMENT | TDF_DETAILS),
+ true, true);
}
}
/* An edge originally destinating BB of FREQUENCY and COUNT has been proved to
leave the block by TAKEN_EDGE. Update profile of BB such that edge E can be
- redirected to destination of TAKEN_EDGE.
+ redirected to destination of TAKEN_EDGE.
This function may leave the profile inconsistent in the case TAKEN_EDGE
frequency or count is believed to be lower than FREQUENCY or COUNT
bb->count -= count;
if (bb->count < 0)
- bb->count = 0;
+ {
+ if (dump_file)
+ fprintf (dump_file, "bb %i count became negative after threading",
+ bb->index);
+ bb->count = 0;
+ }
/* Compute the probability of TAKEN_EDGE being reached via threaded edge.
Watch for overflows. */
if (bb->frequency)
- prob = edge_frequency * REG_BR_PROB_BASE / bb->frequency;
+ prob = GCOV_COMPUTE_SCALE (edge_frequency, bb->frequency);
else
prob = 0;
if (prob > taken_edge->probability)
}
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;
+ {
+ /* Protect from overflow due to additional scaling. */
+ if (c->probability > prob)
+ c->probability = REG_BR_PROB_BASE;
+ else
+ {
+ c->probability = RDIV (c->probability * scale, 65536);
+ if (c->probability > REG_BR_PROB_BASE)
+ c->probability = REG_BR_PROB_BASE;
+ }
+ }
}
gcc_assert (bb == taken_edge->src);
taken_edge->count -= count;
if (taken_edge->count < 0)
- taken_edge->count = 0;
+ {
+ if (dump_file)
+ fprintf (dump_file, "edge %i->%i count became negative after threading",
+ taken_edge->src->index, taken_edge->dest->index);
+ taken_edge->count = 0;
+ }
}
/* Multiply all frequencies of basic blocks in array BBS of length NBBS
{
int i;
edge e;
+ if (num < 0)
+ num = 0;
+
+ /* Scale NUM and DEN to avoid overflows. Frequencies are in order of
+ 10^4, if we make DEN <= 10^3, we can afford to upscale by 100
+ and still safely fit in int during calculations. */
+ if (den > 1000)
+ {
+ if (num > 1000000)
+ return;
+
+ num = RDIV (1000 * num, den);
+ den = 1000;
+ }
+ if (num > 100 * den)
+ return;
+
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);
+ /* Make sure the frequencies do not grow over BB_FREQ_MAX. */
+ if (bbs[i]->frequency > BB_FREQ_MAX)
+ bbs[i]->frequency = BB_FREQ_MAX;
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 (int64_t) * 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. */
void
-scale_bbs_frequencies_gcov_type (basic_block *bbs, int nbbs, gcov_type num,
- gcov_type den)
+scale_bbs_frequencies_gcov_type (basic_block *bbs, int nbbs, gcov_type num,
+ gcov_type den)
{
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
- copies. */
-static htab_t bb_original;
-static htab_t bb_copy;
-static alloc_pool original_copy_bb_pool;
+/* Helper types for hash tables. */
struct htab_bb_copy_original_entry
{
int index2;
};
-static hashval_t
-bb_copy_original_hash (const void *p)
+struct bb_copy_hasher : nofree_ptr_hash <htab_bb_copy_original_entry>
{
- struct htab_bb_copy_original_entry *data
- = ((struct htab_bb_copy_original_entry *)p);
+ static inline hashval_t hash (const htab_bb_copy_original_entry *);
+ static inline bool equal (const htab_bb_copy_original_entry *existing,
+ const htab_bb_copy_original_entry * candidate);
+};
+inline hashval_t
+bb_copy_hasher::hash (const htab_bb_copy_original_entry *data)
+{
return data->index1;
}
-static int
-bb_copy_original_eq (const void *p, const void *q)
-{
- struct htab_bb_copy_original_entry *data
- = ((struct htab_bb_copy_original_entry *)p);
- struct htab_bb_copy_original_entry *data2
- = ((struct htab_bb_copy_original_entry *)q);
+inline bool
+bb_copy_hasher::equal (const htab_bb_copy_original_entry *data,
+ const htab_bb_copy_original_entry *data2)
+{
return data->index1 == data2->index1;
}
+/* Data structures used to maintain mapping between basic blocks and
+ copies. */
+static hash_table<bb_copy_hasher> *bb_original;
+static hash_table<bb_copy_hasher> *bb_copy;
+
+/* And between loops and copies. */
+static hash_table<bb_copy_hasher> *loop_copy;
+static object_allocator<htab_bb_copy_original_entry> *original_copy_bb_pool;
+
/* Initialize the data structures to maintain mapping between blocks
and its copies. */
void
initialize_original_copy_tables (void)
{
- gcc_assert (!original_copy_bb_pool);
- original_copy_bb_pool
- = create_alloc_pool ("original_copy",
- sizeof (struct htab_bb_copy_original_entry), 10);
- bb_original = htab_create (10, bb_copy_original_hash,
- bb_copy_original_eq, NULL);
- bb_copy = htab_create (10, bb_copy_original_hash, bb_copy_original_eq, NULL);
+ original_copy_bb_pool = new object_allocator<htab_bb_copy_original_entry>
+ ("original_copy");
+ bb_original = new hash_table<bb_copy_hasher> (10);
+ bb_copy = new hash_table<bb_copy_hasher> (10);
+ loop_copy = new hash_table<bb_copy_hasher> (10);
}
/* Free the data structures to maintain mapping between blocks and
free_original_copy_tables (void)
{
gcc_assert (original_copy_bb_pool);
- htab_delete (bb_copy);
- htab_delete (bb_original);
- free_alloc_pool (original_copy_bb_pool);
+ delete bb_copy;
bb_copy = NULL;
- bb_original = NULL;
+ delete bb_original;
+ bb_copy = NULL;
+ delete loop_copy;
+ loop_copy = NULL;
+ delete original_copy_bb_pool;
original_copy_bb_pool = NULL;
}
+/* Removes the value associated with OBJ from table TAB. */
+
+static void
+copy_original_table_clear (hash_table<bb_copy_hasher> *tab, unsigned obj)
+{
+ htab_bb_copy_original_entry **slot;
+ struct htab_bb_copy_original_entry key, *elt;
+
+ if (!original_copy_bb_pool)
+ return;
+
+ key.index1 = obj;
+ slot = tab->find_slot (&key, NO_INSERT);
+ if (!slot)
+ return;
+
+ elt = *slot;
+ tab->clear_slot (slot);
+ original_copy_bb_pool->remove (elt);
+}
+
+/* Sets the value associated with OBJ in table TAB to VAL.
+ Do nothing when data structures are not initialized. */
+
+static void
+copy_original_table_set (hash_table<bb_copy_hasher> *tab,
+ unsigned obj, unsigned val)
+{
+ struct htab_bb_copy_original_entry **slot;
+ struct htab_bb_copy_original_entry key;
+
+ if (!original_copy_bb_pool)
+ return;
+
+ key.index1 = obj;
+ slot = tab->find_slot (&key, INSERT);
+ if (!*slot)
+ {
+ *slot = original_copy_bb_pool->allocate ();
+ (*slot)->index1 = obj;
+ }
+ (*slot)->index2 = val;
+}
+
/* Set original for basic block. Do nothing when data structures are not
initialized so passes not needing this don't need to care. */
void
set_bb_original (basic_block bb, basic_block original)
{
- if (original_copy_bb_pool)
- {
- struct htab_bb_copy_original_entry **slot;
- struct htab_bb_copy_original_entry key;
-
- key.index1 = bb->index;
- slot =
- (struct htab_bb_copy_original_entry **) htab_find_slot (bb_original,
- &key, INSERT);
- if (*slot)
- (*slot)->index2 = original->index;
- else
- {
- *slot = pool_alloc (original_copy_bb_pool);
- (*slot)->index1 = bb->index;
- (*slot)->index2 = original->index;
- }
- }
+ copy_original_table_set (bb_original, bb->index, original->index);
}
/* Get the original basic block. */
gcc_assert (original_copy_bb_pool);
key.index1 = bb->index;
- entry = (struct htab_bb_copy_original_entry *) htab_find (bb_original, &key);
+ entry = bb_original->find (&key);
if (entry)
- return BASIC_BLOCK (entry->index2);
+ return BASIC_BLOCK_FOR_FN (cfun, entry->index2);
else
return NULL;
}
void
set_bb_copy (basic_block bb, basic_block copy)
{
- if (original_copy_bb_pool)
- {
- struct htab_bb_copy_original_entry **slot;
- struct htab_bb_copy_original_entry key;
-
- key.index1 = bb->index;
- slot =
- (struct htab_bb_copy_original_entry **) htab_find_slot (bb_copy,
- &key, INSERT);
- if (*slot)
- (*slot)->index2 = copy->index;
- else
- {
- *slot = pool_alloc (original_copy_bb_pool);
- (*slot)->index1 = bb->index;
- (*slot)->index2 = copy->index;
- }
- }
+ copy_original_table_set (bb_copy, bb->index, copy->index);
}
/* Get the copy of basic block. */
gcc_assert (original_copy_bb_pool);
key.index1 = bb->index;
- entry = (struct htab_bb_copy_original_entry *) htab_find (bb_copy, &key);
+ entry = bb_copy->find (&key);
+ if (entry)
+ return BASIC_BLOCK_FOR_FN (cfun, entry->index2);
+ else
+ return NULL;
+}
+
+/* Set copy for LOOP to COPY. Do nothing when data structures are not
+ initialized so passes not needing this don't need to care. */
+
+void
+set_loop_copy (struct loop *loop, struct loop *copy)
+{
+ if (!copy)
+ copy_original_table_clear (loop_copy, loop->num);
+ else
+ copy_original_table_set (loop_copy, loop->num, copy->num);
+}
+
+/* Get the copy of LOOP. */
+
+struct loop *
+get_loop_copy (struct loop *loop)
+{
+ struct htab_bb_copy_original_entry *entry;
+ struct htab_bb_copy_original_entry key;
+
+ gcc_assert (original_copy_bb_pool);
+
+ key.index1 = loop->num;
+ entry = loop_copy->find (&key);
if (entry)
- return BASIC_BLOCK (entry->index2);
+ return get_loop (cfun, entry->index2);
else
return NULL;
}
projects / gcc.git / blobdiff