CbC/CbC_gcc: gcc/shrink-wrap.c comparison

comparison gcc/shrink-wrap.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Shrink-wrapping related optimizations.
-Copyright (C) 1987-2017 Free Software Foundation, Inc.
+Copyright (C) 1987-2018 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
 			   const HARD_REG_SET defs,
 			   bool *split_p,
 			   struct dead_debug_local *debug)
 {
 rtx set, src, dest;
-bitmap live_out, live_in, bb_uses, bb_defs;
+bitmap live_out, live_in, bb_uses = NULL, bb_defs = NULL;
 unsigned int i, dregno, end_dregno;
 unsigned int sregno = FIRST_PSEUDO_REGISTER;
 unsigned int end_sregno = FIRST_PSEUDO_REGISTER;
 basic_block next_block;
 edge live_edge;
 /* At this point we are committed to moving INSN, but let's try to
 move it as far as we can.  */
 do
 {
-if (MAY_HAVE_DEBUG_INSNS)
+if (MAY_HAVE_DEBUG_BIND_INSNS)
 	{
 	  FOR_BB_INSNS_REVERSE (bb, dinsn)
-	    if (DEBUG_INSN_P (dinsn))
+	    if (DEBUG_BIND_INSN_P (dinsn))
 	      {
 		df_ref use;
 		FOR_EACH_INSN_USE (use, dinsn)
 		  if (refers_to_regno_p (dregno, end_dregno,
 					 DF_REF_REG (use), (rtx *) NULL))
 bb = next_block;
 /* Check whether BB uses DEST or clobbers DEST.  We need to add
 	 INSN to BB if so.  Either way, DEST is no longer live on entry,
 	 except for any part that overlaps SRC (next loop).  */
-bb_uses = &DF_LR_BB_INFO (bb)->use;
+if (!*split_p)
-bb_defs = &DF_LR_BB_INFO (bb)->def;
+	{
+	  bb_uses = &DF_LR_BB_INFO (bb)->use;
+	  bb_defs = &DF_LR_BB_INFO (bb)->def;
+	}
 if (df_live)
 	{
 	  for (i = dregno; i < end_dregno; i++)
 	    {
 	      if (*split_p
 basic_block new_bb = create_basic_block (note, note, old_bb);
 BB_COPY_PARTITION (new_bb, old_bb);
 BB_END (old_bb) = end;
 redirect_edge_succ (e, new_bb);
-new_bb->frequency = EDGE_FREQUENCY (e);
+new_bb->count = e->count ();
 e->flags |= EDGE_FALLTHRU;
 e = make_single_succ_edge (new_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
 }
 /* Compute what fraction of the frequency and count of the blocks that run
 both with and without prologue are for running with prologue.  This gives
 the correct answer for reducible flow graphs; for irreducible flow graphs
 our profile is messed up beyond repair anyway.  */
-gcov_type num = 0;
+profile_count num = profile_count::zero ();
-gcov_type den = 0;
+profile_count den = profile_count::zero ();
 FOR_EACH_EDGE (e, ei, pro->preds)
 if (!dominated_by_p (CDI_DOMINATORS, e->src, pro))
 {
-	num += EDGE_FREQUENCY (e);
+	if (e->count ().initialized_p ())
-	den += e->src->frequency;
+	  num += e->count ();
+	if (e->src->count.initialized_p ())
+	  den += e->src->count;
 }
-if (den == 0)
-den = 1;
 /* All is okay, so do it.  */
 crtl->shrink_wrapped = true;
 if (dump_file)
 	if (EDGE_COUNT (dup->succs) == 0)
 	  emit_barrier_after_bb (dup);
 	if (dump_file)
 	  fprintf (dump_file, "Duplicated %d to %d\n", bb->index, dup->index);
-	bb->frequency = RDIV (num * bb->frequency, den);
+	if (num == profile_count::zero () || den.nonzero_p ())
-	dup->frequency -= bb->frequency;
+	  bb->count = bb->count.apply_scale (num, den);
-	bb->count = bb->count.apply_scale (num, den);
 	dup->count -= bb->count;
 }
 /* Now change the edges to point to the copies, where appropriate.  */
 	{
 	  ei_next (&ei);
 	  continue;
 	}
-new_bb->count += e->src->count.apply_probability (e->probability);
+new_bb->count += e->count ();
-new_bb->frequency += EDGE_FREQUENCY (e);
 redirect_edge_and_branch_force (e, new_bb);
 if (dump_file)
 	fprintf (dump_file, "Redirected edge from %d\n", e->src->index);
 }
 	     that does not come from backedges.  Calculating this by simply
 	     adding the cost of all edges that aren't backedges does not
 	     work: this does not always add up to the block frequency at
 	     all, and even if it does, rounding error makes for bad
 	     decisions.  */
-	  SW (bb)->own_cost = bb->frequency;
+	  SW (bb)->own_cost = bb->count.to_frequency (cfun);
 	  edge e;
 	  edge_iterator ei;
 	  FOR_EACH_EDGE (e, ei, bb->preds)
 	    if (dominated_by_p (CDI_DOMINATORS, e->src, bb))
 }
 /* Set HAS_COMPONENTS in every block to the maximum it can be set to without
 setting it on any path from entry to exit where it was not already set
 somewhere (or, for blocks that have no path to the exit, consider only
-paths from the entry to the block itself).  */
+paths from the entry to the block itself).  Return whether any changes
-static void
+were made to some HAS_COMPONENTS.  */
+static bool
 spread_components (sbitmap components)
 {
 basic_block entry_block = ENTRY_BLOCK_PTR_FOR_FN (cfun);
 basic_block exit_block = EXIT_BLOCK_PTR_FOR_FN (cfun);
 	    todo.quick_push (e->src);
 bitmap_clear_bit (seen, bb->index);
 }
+todo.release ();
 /* Finally, mark everything not not needed both forwards and backwards.  */
+bool did_changes = false;
 FOR_EACH_BB_FN (bb, cfun)
 {
+bitmap_copy (old, SW (bb)->has_components);
 bitmap_and (SW (bb)->head_components, SW (bb)->head_components,
 		  SW (bb)->tail_components);
 bitmap_and_compl (SW (bb)->has_components, components,
 			SW (bb)->head_components);
+if (!did_changes && !bitmap_equal_p (old, SW (bb)->has_components))
+	did_changes = true;
 }
 FOR_ALL_BB_FN (bb, cfun)
 {
 if (dump_file)
 	  fprintf (dump_file, "bb %d components:", bb->index);
 	  dump_components ("has", SW (bb)->has_components);
 	  fprintf (dump_file, "\n");
 	}
 }
+return did_changes;
 }
 /* If we cannot handle placing some component's prologues or epilogues where
 we decided we should place them, unmark that component in COMPONENTS so
 that it is not wrapped separately.  */
 sbitmap_iterator sbi;
 unsigned int j;
 EXECUTE_IF_SET_IN_BITMAP (components, 0, j, sbi)
 place_prologue_for_one_component (j, first_bb);
-spread_components (components);
+/* Try to minimize the number of saves and restores.  Do this as long as
+it changes anything.  This does not iterate more than a few times.  */
+int spread_times = 0;
+while (spread_components (components))
+{
+spread_times++;
+if (dump_file)
+	fprintf (dump_file, "Now spread %d times.\n", spread_times);
+}
 disqualify_problematic_components (components);
 /* Don't separately shrink-wrap anything where the "main" prologue will
 go; the target code can often optimize things if it is presented with

Mercurial > hg > CbC > CbC_gcc

comparison gcc/shrink-wrap.c @ 131:84e7813d76e9