CbC/CbC_gcc: gcc/cfgcleanup.c comparison

comparison gcc/cfgcleanup.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
 /* Control flow optimization code for GNU compiler.
-Copyright (C) 1987-2018 Free Software Foundation, Inc.
+Copyright (C) 1987-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 "memmodel.h"
 #include "tm_p.h"
 #include "insn-config.h"
 #include "emit-rtl.h"
 #include "cselib.h"
-#include "params.h"
 #include "tree-pass.h"
 #include "cfgloop.h"
 #include "cfgrtl.h"
 #include "cfganal.h"
 #include "cfgbuild.h"
 #include "cfgcleanup.h"
 #include "dce.h"
 #include "dbgcnt.h"
 #include "rtl-iter.h"
+#include "regs.h"
+#include "function-abi.h"
 #define FORWARDER_BLOCK_P(BB) ((BB)->flags & BB_FORWARDER_BLOCK)
 /* Set to true when we are running first pass of try_optimize_cfg loop.  */
 static bool first_pass;
 unsigned i;
 regset nonequal;
 bool failed = false;
 reg_set_iterator rsi;
+/* Jump threading may cause fixup_partitions to introduce new crossing edges,
+which is not allowed after reload.  */
+gcc_checking_assert (!reload_completed || !crtl->has_bb_partition);
 if (b->flags & BB_NONTHREADABLE_BLOCK)
 return NULL;
 /* At the moment, we do handle only conditional jumps, but later we may
 want to extend this code to tablejumps and others.  */
 ??? This is far too pessimistic.  We should allow swapped operands,
 different CCmodes, or for example comparisons for interval, that
 dominate even when operands are not equivalent.  */
 if (!rtx_equal_p (XEXP (cond1, 0), XEXP (cond2, 0))
 || !rtx_equal_p (XEXP (cond1, 1), XEXP (cond2, 1)))
+return NULL;
+/* Punt if BB_END (e->src) is doloop-like conditional jump that modifies
+the registers used in cond1.  */
+if (modified_in_p (cond1, BB_END (e->src)))
 return NULL;
 /* Short circuit cases where block B contains some side effects, as we can't
 safely bypass it.  */
 for (insn = NEXT_INSN (BB_HEAD (b)); insn != NEXT_INSN (BB_END (b));
 for (insn = NEXT_INSN (BB_HEAD (b));
 insn != NEXT_INSN (BB_END (b)) && !failed;
 insn = NEXT_INSN (insn))
 {
+/* cond2 must not mention any register that is not equal to the
+	 former block.  Check this before processing that instruction,
+	 as BB_END (b) could contain also clobbers.  */
+if (insn == BB_END (b)
+	  && mentions_nonequal_regs (cond2, nonequal))
+	goto failed_exit;
 if (INSN_P (insn))
 	{
 	  rtx pat = PATTERN (insn);
 	  if (GET_CODE (pat) == PARALLEL)
 if (failed)
 {
 b->flags |= BB_NONTHREADABLE_BLOCK;
 goto failed_exit;
 }
-/* cond2 must not mention any register that is not equal to the
-former block.  */
-if (mentions_nonequal_regs (cond2, nonequal))
-goto failed_exit;
 EXECUTE_IF_SET_IN_REG_SET (nonequal, 0, i, rsi)
 goto failed_exit;
 BITMAP_FREE (nonequal);
 			 <= BUILT_IN_ASAN_STOREN)
 		    return dir_none;
 		}
 	    }
 	}
+if (insn_callee_abi (i1) != insn_callee_abi (i2))
+return dir_none;
 }
 /* If both i1 and i2 are frame related, verify all the CFA notes
 in the same order and with the same content.  */
 if (RTX_FRAME_RELATED_P (i1) && !insns_have_identical_cfa_notes (i1, i2))
 for (note = REG_NOTES (i2); note; note = XEXP (note, 1))
 	if (REG_NOTE_KIND (note) == REG_DEAD && STACK_REG_P (XEXP (note, 0)))
 	  SET_HARD_REG_BIT (i2_regset, REGNO (XEXP (note, 0)));
-if (!hard_reg_set_equal_p (i1_regset, i2_regset))
+if (i1_regset != i2_regset)
 	return dir_none;
 }
 #endif
 if (reload_completed
 whether they went through the prologue.  Sibcalls are fine, we know
 that we either didn't need or inserted an epilogue before them.  */
 if (crtl->shrink_wrapped
 && single_succ_p (bb1)
 && single_succ (bb1) == EXIT_BLOCK_PTR_FOR_FN (cfun)
-&& !JUMP_P (BB_END (bb1))
+&& (!JUMP_P (BB_END (bb1))
+	  /* Punt if the only successor is a fake edge to exit, the jump
+	     must be some weird one.  */
+	  || (single_succ_edge (bb1)->flags & EDGE_FAKE) != 0)
 && !(CALL_P (BB_END (bb1)) && SIBLING_CALL_P (BB_END (bb1))))
 return false;
 /* If BB1 has only one successor, we may be looking at either an
 unconditional jump, or a fake edge to exit.  */
 if (single_succ_p (bb1)
 && (single_succ_edge (bb1)->flags & (EDGE_COMPLEX | EDGE_FAKE)) == 0
 && (!JUMP_P (BB_END (bb1)) || simplejump_p (BB_END (bb1))))
 /* Don't proceed with the crossjump unless we found a sufficient number
 of matching instructions or the 'from' block was totally matched
 (such that its predecessors will hopefully be redirected and the
 block removed).  */
-if ((nmatch < PARAM_VALUE (PARAM_MIN_CROSSJUMP_INSNS))
+if ((nmatch < param_min_crossjump_insns)
 && (newpos1 != BB_HEAD (src1)))
 return false;
 /* Avoid deleting preserve label when redirecting ABNORMAL edges.  */
 if (block_has_preserve_label (e1->dest)
 /* It is always cheapest to redirect a block that ends in a branch to
 a block that falls through into BB, as that adds no branches to the
 program.  We'll try that combination first.  */
 fallthru = NULL;
-max = PARAM_VALUE (PARAM_MAX_CROSSJUMP_EDGES);
+max = param_max_crossjump_edges;
 if (EDGE_COUNT (bb->preds) > max)
 return false;
 fallthru = find_fallthru_edge (bb->preds);
 		      edge e;
 		      edge_iterator ei;
 		      if (current_ir_type () == IR_RTL_CFGLAYOUT)
 			{
-			  if (BB_FOOTER (b)
+			  rtx_insn *insn;
-			      && BARRIER_P (BB_FOOTER (b)))
+			  for (insn = BB_FOOTER (b);
+			       insn; insn = NEXT_INSN (insn))
+			    if (BARRIER_P (insn))
+			      break;
+			  if (insn)
 			    FOR_EACH_EDGE (e, ei, b->preds)
-			      if ((e->flags & EDGE_FALLTHRU)
+			      if ((e->flags & EDGE_FALLTHRU))
-				  && BB_FOOTER (e->src) == NULL)
 				{
-				  if (BB_FOOTER (b))
+				  if (BB_FOOTER (b)
+				      && BB_FOOTER (e->src) == NULL)
 				    {
 				      BB_FOOTER (e->src) = BB_FOOTER (b);
 				      BB_FOOTER (b) = NULL;
 				    }
 				  else
-				    {
+				    emit_barrier_after_bb (e->src);
-				      start_sequence ();
-				      BB_FOOTER (e->src) = emit_barrier ();
-				      end_sequence ();
-				    }
 				}
 			}
 		      else
 			{
 			  rtx_insn *last = get_last_bb_insn (b);
 	     is good enough.  */
 	  if ((mode & CLEANUP_EXPENSIVE) && !reload_completed
 	      && !delete_trivially_dead_insns (get_insns (), max_reg_num ()))
 	    break;
 	  if ((mode & CLEANUP_CROSSJUMP) && crossjumps_occurred)
-	    run_fast_dce ();
+	    {
+	      run_fast_dce ();
+	      mode &= ~CLEANUP_FORCE_FAST_DCE;
+	    }
 	}
 else
 	break;
 }
 if (mode & CLEANUP_CROSSJUMP)
 remove_fake_exit_edges ();
+if (mode & CLEANUP_FORCE_FAST_DCE)
+run_fast_dce ();
 /* Don't call delete_dead_jumptables in cfglayout mode, because
 that function assumes that jump tables are in the insns stream.
 But we also don't _have_ to delete dead jumptables in cfglayout
 mode because we shouldn't even be looking at things that are
 return new pass_jump (ctxt);
 }
 namespace {
+const pass_data pass_data_jump_after_combine =
+{
+RTL_PASS, /* type */
+"jump_after_combine", /* name */
+OPTGROUP_NONE, /* optinfo_flags */
+TV_JUMP, /* tv_id */
+0, /* properties_required */
+0, /* properties_provided */
+0, /* properties_destroyed */
+0, /* todo_flags_start */
+0, /* todo_flags_finish */
+};
+class pass_jump_after_combine : public rtl_opt_pass
+{
+public:
+pass_jump_after_combine (gcc::context *ctxt)
+: rtl_opt_pass (pass_data_jump_after_combine, ctxt)
+{}
+/* opt_pass methods: */
+virtual bool gate (function *) { return flag_thread_jumps; }
+virtual unsigned int execute (function *);
+}; // class pass_jump_after_combine
+unsigned int
+pass_jump_after_combine::execute (function *)
+{
+/* Jump threading does not keep dominators up-to-date.  */
+free_dominance_info (CDI_DOMINATORS);
+cleanup_cfg (CLEANUP_THREADING);
+return 0;
+}
+} // anon namespace
+rtl_opt_pass *
+make_pass_jump_after_combine (gcc::context *ctxt)
+{
+return new pass_jump_after_combine (ctxt);
+}
+namespace {
 const pass_data pass_data_jump2 =
 {
 RTL_PASS, /* type */
 "jump2", /* name */
 OPTGROUP_NONE, /* optinfo_flags */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfgcleanup.c @ 145:1830386684a0