CbC/CbC_gcc: gcc/cfgloopanal.c comparison

comparison gcc/cfgloopanal.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Natural loop analysis code for GNU compiler.
-Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+Copyright (C) 2002-2017 Free Software Foundation, Inc.
-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
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
 #include "rtl.h"
-#include "hard-reg-set.h"
+#include "tree.h"
-#include "obstack.h"
+#include "predict.h"
-#include "basic-block.h"
+#include "memmodel.h"
+#include "emit-rtl.h"
 #include "cfgloop.h"
+#include "explow.h"
 #include "expr.h"
-#include "output.h"
 #include "graphds.h"
 #include "params.h"
 struct target_cfgloop default_target_cfgloop;
 #if SWITCHABLE_TARGET
 each cycle, we want to mark blocks that belong directly to innermost
 loop containing the whole cycle.
 LOOPS is the loop tree.  */
-#define LOOP_REPR(LOOP) ((LOOP)->num + last_basic_block)
+#define LOOP_REPR(LOOP) ((LOOP)->num + last_basic_block_for_fn (cfun))
 #define BB_REPR(BB) ((BB)->index + 1)
 bool
 mark_irreducible_loops (void)
 {
 edge e;
 edge_iterator ei;
 int src, dest;
 unsigned depth;
 struct graph *g;
-int num = number_of_loops ();
+int num = number_of_loops (cfun);
 struct loop *cloop;
 bool irred_loop_found = false;
 int i;
 gcc_assert (current_loops != NULL);
 /* Reset the flags.  */
-FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
+FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR_FOR_FN (cfun),
+		  EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
 {
 act->flags &= ~BB_IRREDUCIBLE_LOOP;
 FOR_EACH_EDGE (e, ei, act->succs)
 	e->flags &= ~EDGE_IRREDUCIBLE_LOOP;
 }
 /* Create the edge lists.  */
-g = new_graph (last_basic_block + num);
+g = new_graph (last_basic_block_for_fn (cfun) + num);
-FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
+FOR_BB_BETWEEN (act, ENTRY_BLOCK_PTR_FOR_FN (cfun),
+		  EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
 FOR_EACH_EDGE (e, ei, act->succs)
 {
 	/* Ignore edges to exit.  */
-	if (e->dest == EXIT_BLOCK_PTR)
+	if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
 	  continue;
 	src = BB_REPR (act);
 	dest = BB_REPR (e->dest);
 	    depth = 1 + loop_depth (find_common_loop (act->loop_father,
 						      e->dest->loop_father));
 	    if (depth == loop_depth (act->loop_father))
 	      cloop = act->loop_father;
 	    else
-	      cloop = VEC_index (loop_p, act->loop_father->superloops, depth);
+	      cloop = (*act->loop_father->superloops)[depth];
 	    src = LOOP_REPR (cloop);
 	  }
 	add_edge (g, src, dest)->data = e;
 int
 num_loop_insns (const struct loop *loop)
 {
 basic_block *bbs, bb;
 unsigned i, ninsns = 0;
-rtx insn;
+rtx_insn *insn;
 bbs = get_loop_body (loop);
 for (i = 0; i < loop->num_nodes; i++)
 {
 bb = bbs[i];
 int
 average_num_loop_insns (const struct loop *loop)
 {
 basic_block *bbs, bb;
 unsigned i, binsns, ninsns, ratio;
-rtx insn;
+rtx_insn *insn;
 ninsns = 0;
 bbs = get_loop_body (loop);
 for (i = 0; i < loop->num_nodes; i++)
 {
 /* Returns expected number of iterations of LOOP, according to
 measured or guessed profile.  No bounding is done on the
 value.  */
 gcov_type
-expected_loop_iterations_unbounded (const struct loop *loop)
+expected_loop_iterations_unbounded (const struct loop *loop,
+				    bool *read_profile_p)
 {
 edge e;
 edge_iterator ei;
+gcov_type expected = -1;
-if (loop->latch->count || loop->header->count)
-{
+if (read_profile_p)
-gcov_type count_in, count_latch, expected;
+*read_profile_p = false;
-count_in = 0;
+/* If we have no profile at all, use AVG_LOOP_NITER.  */
-count_latch = 0;
+if (profile_status_for_fn (cfun) == PROFILE_ABSENT)
+expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+else if (loop->latch && (loop->latch->count.reliable_p ()
+			   || loop->header->count.reliable_p ()))
+{
+profile_count count_in = profile_count::zero (),
+		    count_latch = profile_count::zero ();
 FOR_EACH_EDGE (e, ei, loop->header->preds)
 	if (e->src == loop->latch)
-	  count_latch = e->count;
+	  count_latch = e->count ();
 	else
-	  count_in += e->count;
+	  count_in += e->count ();
-if (count_in == 0)
+if (!count_latch.initialized_p ())
-	expected = count_latch * 2;
+	;
+else if (!(count_in > profile_count::zero ()))
+	expected = count_latch.to_gcov_type () * 2;
 else
-	expected = (count_latch + count_in - 1) / count_in;
+	{
+	  expected = (count_latch.to_gcov_type () + count_in.to_gcov_type ()
-return expected;
+		      - 1) / count_in.to_gcov_type ();
-}
+	  if (read_profile_p)
-else
+	    *read_profile_p = true;
+	}
+}
+if (expected == -1)
 {
 int freq_in, freq_latch;
 freq_in = 0;
 freq_latch = 0;
 FOR_EACH_EDGE (e, ei, loop->header->preds)
-	if (e->src == loop->latch)
+	if (flow_bb_inside_loop_p (loop, e->src))
-	  freq_latch = EDGE_FREQUENCY (e);
+	  freq_latch += EDGE_FREQUENCY (e);
 	else
 	  freq_in += EDGE_FREQUENCY (e);
 if (freq_in == 0)
-	return freq_latch * 2;
+	{
+	  /* If we have no profile at all, use AVG_LOOP_NITER iterations.  */
-return (freq_latch + freq_in - 1) / freq_in;
+	  if (!freq_latch)
-}
+	    expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+	  else
+	    expected = freq_latch * 2;
+	}
+else
+expected = (freq_latch + freq_in - 1) / freq_in;
+}
+HOST_WIDE_INT max = get_max_loop_iterations_int (loop);
+if (max != -1 && max < expected)
+return max;
+return expected;
 }
 /* Returns expected number of LOOP iterations.  The returned value is bounded
 by REG_BR_PROB_BASE.  */
 unsigned
-expected_loop_iterations (const struct loop *loop)
+expected_loop_iterations (struct loop *loop)
 {
 gcov_type expected = expected_loop_iterations_unbounded (loop);
 return (expected > REG_BR_PROB_BASE ? REG_BR_PROB_BASE : expected);
 }
 	mx = l + 1;
 }
 return mx;
 }
-/* Returns estimate on cost of computing SEQ.  */
-static unsigned
-seq_cost (const_rtx seq, bool speed)
-{
-unsigned cost = 0;
-rtx set;
-for (; seq; seq = NEXT_INSN (seq))
-{
-set = single_set (seq);
-if (set)
-	cost += rtx_cost (set, SET, speed);
-else
-	cost++;
-}
-return cost;
-}
 /* Initialize the constants for computing set costs.  */
 void
 init_set_costs (void)
 {
 int speed;
-rtx seq;
+rtx_insn *seq;
-rtx reg1 = gen_raw_REG (SImode, FIRST_PSEUDO_REGISTER);
+rtx reg1 = gen_raw_REG (SImode, LAST_VIRTUAL_REGISTER + 1);
-rtx reg2 = gen_raw_REG (SImode, FIRST_PSEUDO_REGISTER + 1);
+rtx reg2 = gen_raw_REG (SImode, LAST_VIRTUAL_REGISTER + 2);
-rtx addr = gen_raw_REG (Pmode, FIRST_PSEUDO_REGISTER + 2);
+rtx addr = gen_raw_REG (Pmode, LAST_VIRTUAL_REGISTER + 3);
 rtx mem = validize_mem (gen_rtx_MEM (SImode, addr));
 unsigned i;
 target_avail_regs = 0;
 target_clobbered_regs = 0;
 one.  */
 cost = target_spill_cost [speed] * n_new;
 if (optimize && (flag_ira_region == IRA_REGION_ALL
 		   || flag_ira_region == IRA_REGION_MIXED)
-&& number_of_loops () <= (unsigned) IRA_MAX_LOOPS_NUM)
+&& number_of_loops (cfun) <= (unsigned) IRA_MAX_LOOPS_NUM)
 /* IRA regional allocation deals with high register pressure
 better.  So decrease the cost (to do more accurate the cost
 calculation for IRA, we need to know how many registers lives
 through the loop transparently).  */
 cost /= 2;
 mark_loop_exit_edges (void)
 {
 basic_block bb;
 edge e;
-if (number_of_loops () <= 1)
+if (number_of_loops (cfun) <= 1)
 return;
-FOR_EACH_BB (bb)
+FOR_EACH_BB_FN (bb, cfun)
 {
 edge_iterator ei;
 FOR_EACH_EDGE (e, ei, bb->succs)
 	{
 	    e->flags &= ~EDGE_LOOP_EXIT;
 	}
 }
 }
+/* Return exit edge if loop has only one exit that is likely
+to be executed on runtime (i.e. it is not EH or leading
+to noreturn call.  */
+edge
+single_likely_exit (struct loop *loop)
+{
+edge found = single_exit (loop);
+vec<edge> exits;
+unsigned i;
+edge ex;
+if (found)
+return found;
+exits = get_loop_exit_edges (loop);
+FOR_EACH_VEC_ELT (exits, i, ex)
+{
+if (probably_never_executed_edge_p (cfun, ex)
+	  /* We want to rule out paths to noreturns but not low probabilities
+	     resulting from adjustments or combining.
+	     FIXME: once we have better quality tracking, make this more
+	     robust.  */
+	  || ex->probability <= profile_probability::very_unlikely ())
+	continue;
+if (!found)
+	found = ex;
+else
+	{
+	  exits.release ();
+	  return NULL;
+	}
+}
+exits.release ();
+return found;
+}
+/* Gets basic blocks of a LOOP.  Header is the 0-th block, rest is in dfs
+order against direction of edges from latch.  Specially, if
+header != latch, latch is the 1-st block.  */
+vec<basic_block>
+get_loop_hot_path (const struct loop *loop)
+{
+basic_block bb = loop->header;
+vec<basic_block> path = vNULL;
+bitmap visited = BITMAP_ALLOC (NULL);
+while (true)
+{
+edge_iterator ei;
+edge e;
+edge best = NULL;
+path.safe_push (bb);
+bitmap_set_bit (visited, bb->index);
+FOR_EACH_EDGE (e, ei, bb->succs)
+if ((!best || e->probability > best->probability)
+	    && !loop_exit_edge_p (loop, e)
+	    && !bitmap_bit_p (visited, e->dest->index))
+	  best = e;
+if (!best || best->dest == loop->header)
+	break;
+bb = best->dest;
+}
+BITMAP_FREE (visited);
+return path;
+}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfgloopanal.c @ 111:04ced10e8804