CbC/CbC_gcc: gcc/cfgrtl.c comparison

comparison gcc/cfgrtl.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	84e7813d76e9
children	1830386684a0

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Control flow graph manipulation code for GNU compiler.
-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
 are already contiguous.  */
 static void
 rtl_merge_blocks (basic_block a, basic_block b)
 {
+/* If B is a forwarder block whose outgoing edge has no location, we'll
+propagate the locus of the edge between A and B onto it.  */
+const bool forward_edge_locus
+= (b->flags & BB_FORWARDER_BLOCK) != 0
+&& LOCATION_LOCUS (EDGE_SUCC (b, 0)->goto_locus) == UNKNOWN_LOCATION;
 rtx_insn *b_head = BB_HEAD (b), *b_end = BB_END (b), *a_end = BB_END (a);
 rtx_insn *del_first = NULL, *del_last = NULL;
 rtx_insn *b_debug_start = b_end, *b_debug_end = b_end;
-bool forwarder_p = (b->flags & BB_FORWARDER_BLOCK) != 0;
 int b_empty = 0;
 if (dump_file)
 fprintf (dump_file, "Merging block %d into block %d...\n", b->index,
 	     a->index);
 hanging out between the two blocks.  */
 BB_END (a) = a_end;
 BB_HEAD (b) = b_empty ? NULL : b_head;
 delete_insn_chain (del_first, del_last, true);
-/* When not optimizing and the edge is the only place in RTL which holds
+/* If not optimizing, preserve the locus of the single edge between
-some unique locus, emit a nop with that locus in between.  */
+blocks A and B if necessary by emitting a nop.  */
-if (!optimize)
+if (!optimize
+&& !forward_edge_locus
+&& !DECL_IGNORED_P (current_function_decl))
 {
 emit_nop_for_unique_locus_between (a, b);
 a_end = BB_END (a);
 }
 BB_END (a) = b_debug_end;
 }
 df_bb_delete (b->index);
-/* If B was a forwarder block, propagate the locus on the edge.  */
+if (forward_edge_locus)
-if (forwarder_p
-&& LOCATION_LOCUS (EDGE_SUCC (b, 0)->goto_locus) == UNKNOWN_LOCATION)
 EDGE_SUCC (b, 0)->goto_locus = EDGE_SUCC (a, 0)->goto_locus;
 if (dump_file)
 fprintf (dump_file, "Merged blocks %d and %d.\n", a->index, b->index);
 }
 	 simple jump and remove its associated CODE_LABEL
 	 and ADDR_VEC or ADDR_DIFF_VEC.  */
 if (tablejump_p (insn, &label, &table))
 	delete_insn_chain (label, table, false);
-barrier = next_nonnote_insn (BB_END (src));
+barrier = next_nonnote_nondebug_insn (BB_END (src));
 if (!barrier || !BARRIER_P (barrier))
 	emit_barrier_after (BB_END (src));
 else
 	{
 	  if (barrier != NEXT_INSN (BB_END (src)))
 But make sure reg crossing note doesn't already exist before
 inserting.  */
 if (BB_PARTITION (e->src) != BB_PARTITION (e->dest))
 {
 e->flags |= EDGE_CROSSING;
-if (JUMP_P (BB_END (e->src))
+if (JUMP_P (BB_END (e->src)))
-	  && !CROSSING_JUMP_P (BB_END (e->src)))
 	CROSSING_JUMP_P (BB_END (e->src)) = 1;
 }
 else if (BB_PARTITION (e->src) == BB_PARTITION (e->dest))
 {
 e->flags &= ~EDGE_CROSSING;
 	  edge_iterator ei;
 	  bool found = false;
 	  basic_block bb = create_basic_block (BB_HEAD (e->dest), NULL,
 					       ENTRY_BLOCK_PTR_FOR_FN (cfun));
+	  bb->count = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
+	  /* Make sure new block ends up in correct hot/cold section.  */
+	  BB_COPY_PARTITION (bb, e->dest);
 	  /* Change the existing edge's source to be the new block, and add
 	     a new edge from the entry block to the new block.  */
 	  e->src = bb;
 	  for (ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
 	new_head = BB_END (e->src);
 new_head = NEXT_INSN (new_head);
 jump_block = create_basic_block (new_head, NULL, e->src);
 jump_block->count = count;
-jump_block->frequency = EDGE_FREQUENCY (e);
 /* Make sure new block ends up in correct hot/cold section.  */
 BB_COPY_PARTITION (jump_block, e->src);
 	 add also edge from asm goto bb to target.  */
 if (asm_goto_edge)
 	{
 	  new_edge->probability = new_edge->probability.apply_scale (1, 2);
 	  jump_block->count = jump_block->count.apply_scale (1, 2);
-	  jump_block->frequency /= 2;
 	  edge new_edge2 = make_edge (new_edge->src, target,
 				      e->flags & ~EDGE_FALLTHRU);
 	  new_edge2->probability = probability - new_edge->probability;
 	}
 So search through a sequence of barriers, labels, and notes for
 the head of block C and assert that we really do fall through.  */
 for (q = NEXT_INSN (BB_END (b)); q != BB_HEAD (c); q = NEXT_INSN (q))
-if (INSN_P (q))
+if (NONDEBUG_INSN_P (q))
 return;
 /* Remove what will soon cease being the jump insn from the source block.
 If block B consisted only of this single jump, turn it into a deleted
 note.  */
 		    break;
 		}
 	    }
 	}
-for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
+for (tmp_rtx = rtx_first; tmp_rtx != NULL; tmp_rtx = NEXT_INSN (tmp_rtx))
 	{
 	  if (flags & TDF_BLOCKS)
 	    {
 	      bb = start[INSN_UID (tmp_rtx)];
 	      if (bb != NULL)
 void
 update_br_prob_note (basic_block bb)
 {
 rtx note;
+note = find_reg_note (BB_END (bb), REG_BR_PROB, NULL_RTX);
 if (!JUMP_P (BB_END (bb)) || !BRANCH_EDGE (bb)->probability.initialized_p ())
-return;
+{
-note = find_reg_note (BB_END (bb), REG_BR_PROB, NULL_RTX);
+if (note)
+	{
+	  rtx *note_link, this_rtx;
+	  note_link = &REG_NOTES (BB_END (bb));
+	  for (this_rtx = *note_link; this_rtx; this_rtx = XEXP (this_rtx, 1))
+	    if (this_rtx == note)
+	      {
+		*note_link = XEXP (this_rtx, 1);
+		break;
+	      }
+	}
+return;
+}
 if (!note
 || XINT (note, 0) == BRANCH_EDGE (bb)->probability.to_reg_br_prob_note ())
 return;
 XINT (note, 0) = BRANCH_EDGE (bb)->probability.to_reg_br_prob_note ();
 }
 /* Include any jump table following the basic block.  */
 if (tablejump_p (end, NULL, &table))
 end = table;
 /* Include any barriers that may follow the basic block.  */
-tmp = next_nonnote_insn_bb (end);
+tmp = next_nonnote_nondebug_insn_bb (end);
 while (tmp && BARRIER_P (tmp))
 {
 end = tmp;
-tmp = next_nonnote_insn_bb (end);
+tmp = next_nonnote_nondebug_insn_bb (end);
 }
 return end;
 }
 	  if (e->flags & EDGE_ABNORMAL)
 	    n_abnormal++;
 	}
 if (!has_crossing_edge
-	    && JUMP_P (BB_END (bb))
+	  && JUMP_P (BB_END (bb))
-	    && CROSSING_JUMP_P (BB_END (bb)))
+	  && CROSSING_JUMP_P (BB_END (bb)))
-{
+	{
-	    print_rtl_with_bb (stderr, get_insns (), TDF_BLOCKS | TDF_DETAILS);
+	  print_rtl_with_bb (stderr, get_insns (), TDF_BLOCKS | TDF_DETAILS);
-error ("Region crossing jump across same section in bb %i",
+	  error ("Region crossing jump across same section in bb %i",
-bb->index);
+		 bb->index);
-err = 1;
+	  err = 1;
-}
+	}
 if (n_eh && !find_reg_note (BB_END (bb), REG_EH_REGION, NULL_RTX))
 	{
 	  error ("missing REG_EH_REGION note at the end of bb %i", bb->index);
 	  err = 1;
 	      || any_uncondjump_p (BB_END (bb))))
 	{
 	  error ("abnormal edges for no purpose in bb %i", bb->index);
 	  err = 1;
 	}
+int has_eh = -1;
+FOR_EACH_EDGE (e, ei, bb->preds)
+	{
+	  if (has_eh == -1)
+	    has_eh = (e->flags & EDGE_EH);
+	  if ((e->flags & EDGE_EH) == has_eh)
+	    continue;
+	  error ("EH incoming edge mixed with non-EH incoming edges "
+		 "in bb %i", bb->index);
+	  err = 1;
+	  break;
+	}
 }
 /* If there are partitions, do a sanity check on them: A basic block in
   a cold partition cannot dominate a basic block in a hot partition.  */
-if (crtl->has_bb_partition && !err)
+if (crtl->has_bb_partition && !err
+&& current_ir_type () == IR_RTL_CFGLAYOUT)
 {
 vec<basic_block> bbs_to_fix = find_partition_fixes (true);
 err = !bbs_to_fix.is_empty ();
 }
 	      err = 1;
 	    }
 	  else
 	    for (insn = NEXT_INSN (BB_END (e->src)); insn != BB_HEAD (e->dest);
 		 insn = NEXT_INSN (insn))
-	      if (BARRIER_P (insn) || INSN_P (insn))
+	      if (BARRIER_P (insn) || NONDEBUG_INSN_P (insn))
 		{
 		  error ("verify_flow_info: Incorrect fallthru %i->%i",
 			 e->src->index, e->dest->index);
 		  fatal_insn ("wrong insn in the fallthru edge", insn);
 		  err = 1;
 static int
 rtl_verify_bb_layout (void)
 {
 basic_block bb;
 int err = 0;
-rtx_insn *x;
+rtx_insn *x, *y;
 int num_bb_notes;
 rtx_insn * const rtx_first = get_insns ();
 basic_block last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun), curr_bb = NULL;
 num_bb_notes = 0;
 	    }
 	}
 if (JUMP_P (x)
 	  && returnjump_p (x) && ! condjump_p (x)
-	  && ! (next_nonnote_insn (x) && BARRIER_P (next_nonnote_insn (x))))
+	  && ! ((y = next_nonnote_nondebug_insn (x))
+		&& BARRIER_P (y)))
 	    fatal_insn ("return not followed by barrier", x);
 if (curr_bb && x == BB_END (curr_bb))
 	curr_bb = NULL;
 }
 	  else if (forwarder_block_p (bb)
 		   && !LABEL_P (BB_HEAD (bb)))
 	    fprintf (dump_file, "compensation ");
 	  else
 	    fprintf (dump_file, "bb %i ", bb->index);
-	  fprintf (dump_file, " [%i]\n", bb->frequency);
 	}
 }
 /* Now reorder the blocks.  */
 prev_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
 if (e && !can_fallthru (e->src, e->dest))
 	force_nonfallthru (e);
 }
-/* Ensure goto_locus from edges has some instructions with that locus
+/* Ensure goto_locus from edges has some instructions with that locus in RTL
-in RTL.  */
+when not optimizing.  */
-if (!optimize)
+if (!optimize && !DECL_IGNORED_P (current_function_decl))
 FOR_EACH_BB_FN (bb, cfun)
 {
 edge e;
 edge_iterator ei;
 {
 switch (GET_CODE (insn))
 	{
 	case DEBUG_INSN:
 	  /* Don't duplicate label debug insns.  */
-	  if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn)) == LABEL_DECL)
+	  if (DEBUG_BIND_INSN_P (insn)
+	      && TREE_CODE (INSN_VAR_LOCATION_DECL (insn)) == LABEL_DECL)
 	    break;
 	  /* FALLTHRU */
 	case INSN:
 	case CALL_INSN:
 	case JUMP_INSN:
 by aux pointers, enter compensation code, rebuild scope forest.  */
 void
 cfg_layout_finalize (void)
 {
-checking_verify_flow_info ();
 free_dominance_info (CDI_DOMINATORS);
 force_one_exit_fallthru ();
 rtl_register_cfg_hooks ();
 if (reload_completed && !targetm.have_epilogue ())
 fixup_fallthru_exit_predecessor ();
 if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
 return NULL;
 if (e->dest == dest)
 return e;
+if (e->flags & EDGE_CROSSING
+&& BB_PARTITION (e->src) == BB_PARTITION (dest)
+&& simplejump_p (BB_END (src)))
+{
+if (dump_file)
+	fprintf (dump_file,
+	  	 "Removing crossing jump while redirecting edge form %i to %i\n",
+		 e->src->index, dest->index);
+delete_insn (BB_END (src));
+e->flags |= EDGE_FALLTHRU;
+}
 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
 && (ret = try_redirect_by_replacing_jump (e, dest, true)))
 {
 df_set_bb_dirty (src);
 ret = redirect_edge_succ_nodup (e, dest);
 }
 else
 ret = redirect_branch_edge (e, dest);
+fixup_partition_crossing (ret);
 /* We don't want simplejumps in the insn stream during cfglayout.  */
-gcc_assert (!simplejump_p (BB_END (src)));
+gcc_assert (!simplejump_p (BB_END (src)) || CROSSING_JUMP_P (BB_END (src)));
 df_set_bb_dirty (src);
 return ret;
 }
 /* Merge block A and B.  The blocks must be mergeable.  */
 static void
 cfg_layout_merge_blocks (basic_block a, basic_block b)
 {
-bool forwarder_p = (b->flags & BB_FORWARDER_BLOCK) != 0;
+/* If B is a forwarder block whose outgoing edge has no location, we'll
+propagate the locus of the edge between A and B onto it.  */
+const bool forward_edge_locus
+= (b->flags & BB_FORWARDER_BLOCK) != 0
+&& LOCATION_LOCUS (EDGE_SUCC (b, 0)->goto_locus) == UNKNOWN_LOCATION;
 rtx_insn *insn;
 gcc_checking_assert (cfg_layout_can_merge_blocks_p (a, b));
 if (dump_file)
 it cleaned up.  */
 if (JUMP_P (BB_END (a)))
 try_redirect_by_replacing_jump (EDGE_SUCC (a, 0), b, true);
 gcc_assert (!JUMP_P (BB_END (a)));
-/* When not optimizing and the edge is the only place in RTL which holds
+/* If not optimizing, preserve the locus of the single edge between
-some unique locus, emit a nop with that locus in between.  */
+blocks A and B if necessary by emitting a nop.  */
-if (!optimize)
+if (!optimize
+&& !forward_edge_locus
+&& !DECL_IGNORED_P (current_function_decl))
 emit_nop_for_unique_locus_between (a, b);
 /* Move things from b->footer after a->footer.  */
 if (BB_FOOTER (b))
 {
 BB_HEAD (b) = BB_END (b) = NULL;
 delete_insn (insn);
 df_bb_delete (b->index);
-/* If B was a forwarder block, propagate the locus on the edge.  */
+if (forward_edge_locus)
-if (forwarder_p
-&& LOCATION_LOCUS (EDGE_SUCC (b, 0)->goto_locus) == UNKNOWN_LOCATION)
 EDGE_SUCC (b, 0)->goto_locus = EDGE_SUCC (a, 0)->goto_locus;
 if (dump_file)
 fprintf (dump_file, "Merged blocks %d and %d.\n", a->index, b->index);
 }
 	if (bb->count.initialized_p ())
 	  record->time[after_pass]
 	    += insn_cost (insn, true) * bb->count.to_gcov_type ();
 	else if (profile_status_for_fn (cfun) == PROFILE_GUESSED)
 	  record->time[after_pass]
-	    += insn_cost (insn, true) * bb->frequency;
+	    += insn_cost (insn, true) * bb->count.to_frequency (cfun);
 }
 }
 /* Implementation of CFG manipulation for linearized RTL.  */
 struct cfg_hooks rtl_cfg_hooks = {

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfgrtl.c @ 132:d34655255c78