CbC/CbC_gcc: gcc/cfgloopanal.c comparison

comparison gcc/cfgloopanal.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Natural loop analysis code for GNU compiler.
-Copyright (C) 2002-2018 Free Software Foundation, Inc.
+Copyright (C) 2002-2020 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
 #include "emit-rtl.h"
 #include "cfgloop.h"
 #include "explow.h"
 #include "expr.h"
 #include "graphds.h"
-#include "params.h"
 #include "sreal.h"
+#include "regs.h"
+#include "function-abi.h"
 struct target_cfgloop default_target_cfgloop;
 #if SWITCHABLE_TARGET
 struct target_cfgloop *this_target_cfgloop = &default_target_cfgloop;
 #endif
 /* Checks whether BB is executed exactly once in each LOOP iteration.  */
 bool
-just_once_each_iteration_p (const struct loop *loop, const_basic_block bb)
+just_once_each_iteration_p (const class loop *loop, const_basic_block bb)
 {
 /* It must be executed at least once each iteration.  */
 if (!dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
 return false;
 edge_iterator ei;
 int src, dest;
 unsigned depth;
 struct graph *g;
 int num = number_of_loops (cfun);
-struct loop *cloop;
+class loop *cloop;
 bool irred_loop_found = false;
 int i;
 gcc_assert (current_loops != NULL);
 return irred_loop_found;
 }
 /* Counts number of insns inside LOOP.  */
 int
-num_loop_insns (const struct loop *loop)
+num_loop_insns (const class loop *loop)
 {
 basic_block *bbs, bb;
 unsigned i, ninsns = 0;
 rtx_insn *insn;
 return ninsns;
 }
 /* Counts number of insns executed on average per iteration LOOP.  */
 int
-average_num_loop_insns (const struct loop *loop)
+average_num_loop_insns (const class loop *loop)
 {
 basic_block *bbs, bb;
 unsigned i, binsns;
 sreal ninsns;
 rtx_insn *insn;
 	  binsns++;
 ninsns += (sreal)binsns * bb->count.to_sreal_scale (loop->header->count);
 /* Avoid overflows.   */
 if (ninsns > 1000000)
-	return 100000;
+	{
+	  free (bbs);
+	  return 1000000;
+	}
 }
 free (bbs);
 int64_t ret = ninsns.to_int ();
 if (!ret)
 information is not good enough to derive osmething.
 If BY_PROFILE_ONLY is set, this logic is bypassed and function
 return -1 in those scenarios.  */
 gcov_type
-expected_loop_iterations_unbounded (const struct loop *loop,
+expected_loop_iterations_unbounded (const class loop *loop,
 				    bool *read_profile_p,
 				    bool by_profile_only)
 {
 edge e;
 edge_iterator ei;
 /* If we have no profile at all, use AVG_LOOP_NITER.  */
 if (profile_status_for_fn (cfun) == PROFILE_ABSENT)
 {
 if (by_profile_only)
 	return -1;
-expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+expected = param_avg_loop_niter;
 }
 else if (loop->latch && (loop->latch->count.initialized_p ()
 			   || loop->header->count.initialized_p ()))
 {
 profile_count count_in = profile_count::zero (),
 if (!count_latch.initialized_p ())
 	{
 if (by_profile_only)
 	    return -1;
-	  expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+	  expected = param_avg_loop_niter;
 	}
 else if (!count_in.nonzero_p ())
 	{
 if (by_profile_only)
 	    return -1;
 }
 else
 {
 if (by_profile_only)
 	return -1;
-expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+expected = param_avg_loop_niter;
 }
 if (!by_profile_only)
 {
 HOST_WIDE_INT max = get_max_loop_iterations_int (loop);
 /* Returns expected number of LOOP iterations.  The returned value is bounded
 by REG_BR_PROB_BASE.  */
 unsigned
-expected_loop_iterations (struct loop *loop)
+expected_loop_iterations (class loop *loop)
 {
 gcov_type expected = expected_loop_iterations_unbounded (loop);
 return (expected > REG_BR_PROB_BASE ? REG_BR_PROB_BASE : expected);
 }
 /* Returns the maximum level of nesting of subloops of LOOP.  */
 unsigned
-get_loop_level (const struct loop *loop)
+get_loop_level (const class loop *loop)
 {
-const struct loop *ploop;
+const class loop *ploop;
 unsigned mx = 0, l;
 for (ploop = loop->inner; ploop; ploop = ploop->next)
 {
 l = get_loop_level (ploop);
 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 if (TEST_HARD_REG_BIT (reg_class_contents[GENERAL_REGS], i)
 	&& !fixed_regs[i])
 {
 	target_avail_regs++;
-	if (call_used_regs[i])
+	/* ??? This is only a rough heuristic.  It doesn't cope well
+	   with alternative ABIs, but that's an optimization rather than
+	   correctness issue.  */
+	if (default_function_abi.clobbers_full_reg_p (i))
 	  target_clobbered_regs++;
 }
 target_res_regs = 3;
 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 (cfun) <= (unsigned) IRA_MAX_LOOPS_NUM)
+&& number_of_loops (cfun) <= (unsigned) param_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;
 /* 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)
+single_likely_exit (class loop *loop, vec<edge> exits)
 {
 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.
 	  || ex->probability <= profile_probability::very_unlikely ())
 	continue;
 if (!found)
 	found = ex;
 else
-	{
+	return NULL;
-	  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)
+get_loop_hot_path (const class loop *loop)
 {
 basic_block bb = loop->header;
 vec<basic_block> path = vNULL;
 bitmap visited = BITMAP_ALLOC (NULL);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfgloopanal.c @ 145:1830386684a0