CbC/CbC_gcc: gcc/modulo-sched.c comparison

comparison gcc/modulo-sched.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 its own iv, not otherwise used in the loop (at-least for now), which
 initializes a register before the loop to the number of iterations.
 Currently SMS relies on the do-loop pattern to recognize such loops,
 where (1) the control part comprises of all insns defining and/or
 using a certain 'count' register and (2) the loop count can be
 adjusted by modifying this register prior to the loop.
 TODO: Rely on cfgloop analysis instead.  */
 /* This page defines partial-schedule structures and functions for
 modulo scheduling.  */
 rtx new_reg;
 struct undo_replace_buff_elem *next;
 };
 static partial_schedule_ptr create_partial_schedule (int ii, ddg_ptr, int history);
 static void free_partial_schedule (partial_schedule_ptr);
 static void reset_partial_schedule (partial_schedule_ptr, int new_ii);
 void print_partial_schedule (partial_schedule_ptr, FILE *);
 static void verify_partial_schedule (partial_schedule_ptr, sbitmap);
 NULL,
 NULL,
 NULL,
 sms_print_insn,
 NULL,
+NULL, /* insn_finishes_block_p */
 NULL, NULL,
 NULL, NULL,
 0, 0,
 NULL, NULL, NULL,
 0
 };
 /* Given HEAD and TAIL which are the first and last insns in a loop;
 return the register which controls the loop.  Return zero if it has
 return NULL_RTX;
 get_ebb_head_tail (pre_header, pre_header, &head, &tail);
 for (insn = tail; insn != PREV_INSN (head); insn = PREV_INSN (insn))
-if (INSN_P (insn) && single_set (insn) &&
+if (NONDEBUG_INSN_P (insn) && single_set (insn) &&
 	rtx_equal_p (count_reg, SET_DEST (single_set (insn))))
 {
 	rtx pat = single_set (insn);
-	if (GET_CODE (SET_SRC (pat)) == CONST_INT)
+	if (CONST_INT_P (SET_SRC (pat)))
 	  {
 	    *count = INTVAL (SET_SRC (pat));
 	    return insn;
 	  }
 utilization of various units.  */
 static int
 res_MII (ddg_ptr g)
 {
 if (targetm.sched.sms_res_mii)
 return targetm.sched.sms_res_mii (g);
-return (g->num_nodes / issue_rate);
+return ((g->num_nodes - g->num_debug) / issue_rate);
 }
 /* Points to the array that contains the sched data for each node.  */
 static node_sched_params_ptr node_sched_params;
 rtx count_reg, rtx count_init)
 {
 int i;
 int last_stage = PS_STAGE_COUNT (ps) - 1;
 edge e;
 /* Generate the prolog, inserting its insns on the loop-entry edge.  */
 start_sequence ();
 if (!count_init)
 {
 emit_move_insn (count_reg, sub_reg);
 }
 for (i = 0; i < last_stage; i++)
 duplicate_insns_of_cycles (ps, 0, i, 1, count_reg);
 /* Put the prolog on the entry edge.  */
 e = loop_preheader_edge (loop);
 split_edge_and_insert (e, get_insns ());
 end_sequence ();
 /* Generate the epilog, inserting its insns on the loop-exit edge.  */
 start_sequence ();
 for (i = 0; i < last_stage; i++)
 duplicate_insns_of_cycles (ps, i + 1, last_stage, 0, count_reg);
 /* Put the epilogue on the exit edge.  */
 gcc_assert (single_exit (loop));
 e = single_exit (loop);
 split_edge_and_insert (e, get_insns ());
 end_sequence ();
 have only notes labels or jumps.  */
 get_ebb_head_tail (bbs[i], bbs[i], &head, &tail);
 for (; head != NEXT_INSN (tail); head = NEXT_INSN (head))
 {
 if (NOTE_P (head) || LABEL_P (head)
-	      || (INSN_P (head) && JUMP_P (head)))
+	      || (INSN_P (head) && (DEBUG_INSN_P (head) || JUMP_P (head))))
 	    continue;
 	  empty_bb = false;
 	  break;
 }
 if (!single_exit (loop))
 {
 if (dump_file)
 	{
 	  rtx insn = BB_END (loop->header);
 	  fprintf (dump_file, "SMS loop many exits ");
 	  	  fprintf (dump_file, " %s %d (file, line)\n",
 			   insn_file (insn), insn_line (insn));
 	}
 return false;
 if (! SIMPLE_SMS_LOOP_P (loop) && ! loop_single_full_bb_p (loop))
 {
 if (dump_file)
 	{
 	  rtx insn = BB_END (loop->header);
 	  fprintf (dump_file, "SMS loop many BBs. ");
 	  fprintf (dump_file, " %s %d (file, line)\n",
 		   insn_file (insn), insn_line (insn));
 	}
 return false;
 	continue;
 }
 /* Don't handle BBs with calls or barriers, or !single_set insns,
 or auto-increment insns (to avoid creating invalid reg-moves
 for the auto-increment insns).
 ??? Should handle auto-increment insns.
 ??? Should handle insns defining subregs.  */
 for (insn = head; insn != NEXT_INSN (tail); insn = NEXT_INSN (insn))
 {
 rtx set;
 if (CALL_P (insn)
 || BARRIER_P (insn)
-|| (INSN_P (insn) && !JUMP_P (insn)
+|| (NONDEBUG_INSN_P (insn) && !JUMP_P (insn)
 && !single_set (insn) && GET_CODE (PATTERN (insn)) != USE)
 || (FIND_REG_INC_NOTE (insn, NULL_RTX) != 0)
 || (INSN_P (insn) && (set = single_set (insn))
 && GET_CODE (SET_DEST (set)) == SUBREG))
 break;
 		fprintf (dump_file, "SMS loop-with-call\n");
 	      else if (BARRIER_P (insn))
 		fprintf (dump_file, "SMS loop-with-barrier\n");
 else if (FIND_REG_INC_NOTE (insn, NULL_RTX) != 0)
 fprintf (dump_file, "SMS reg inc\n");
-else if ((INSN_P (insn) && !JUMP_P (insn)
+else if ((NONDEBUG_INSN_P (insn) && !JUMP_P (insn)
 && !single_set (insn) && GET_CODE (PATTERN (insn)) != USE))
 fprintf (dump_file, "SMS loop-with-not-single-set\n");
 else
 fprintf (dump_file, "SMS loop with subreg in lhs\n");
 	      print_rtl_single (dump_file, insn);
 	 ASAP.  */
 set_node_sched_params (g);
 ps = sms_schedule_by_order (g, mii, maxii, node_order);
-if (ps)
+if (ps){
 	stage_count = PS_STAGE_COUNT (ps);
+gcc_assert(stage_count >= 1);
+}
 /* Stage count of 1 means that there is no interleaving between
 iterations, let the scheduling passes do the job.  */
-if (stage_count < 1
+if (stage_count <= 1
 	  || (count_init && (loop_count <= stage_count))
 	  || (flag_branch_probabilities && (trip_count <= stage_count)))
 	{
 	  if (dump_file)
 	    {
 	  /* Set the stage boundaries.  If the DDG is built with closing_branch_deps,
 	     the closing_branch was scheduled and should appear in the last (ii-1)
 	     row.  Otherwise, we are free to schedule the branch, and we let nodes
 	     that were scheduled at the first PS_MIN_CYCLE cycle appear in the first
 	     row; this should reduce stage_count to minimum.
 TODO: Revisit the issue of scheduling the insns of the
 control part relative to the branch when the control part
 has more than one insn.  */
 	  normalize_sched_times (ps);
 	  rotate_partial_schedule (ps, PS_MIN_CYCLE (ps));
 	  set_columns_for_ps (ps);
 	  canon_loop (loop);
 /* case the BCT count is not known , Do loop-versioning */
 	  if (count_reg && ! count_init)
 {
 	  reg_move_replaces = generate_reg_moves (ps, true);
 	  if (dump_file)
 	    print_node_sched_params (dump_file, g->num_nodes, g);
 	  /* Generate prolog and epilog.  */
 generate_prolog_epilog (ps, loop, count_reg, count_init);
 	  free_undo_replace_buff (reg_move_replaces);
 	}
 free_partial_schedule (ps);
 free (node_sched_params);
 for (e = u_node->in; e != 0; e = e->next_in)
 	{
 	  ddg_node_ptr v_node = e->src;
 if (dump_file)
 {
 	      fprintf (dump_file, "\nProcessing edge: ");
 print_ddg_edge (dump_file, e);
 	      fprintf (dump_file,
 		       "\nScheduling %d (%d) in psp_not_empty,"
 		       " checking p %d (%d): ", u_node->cuid,
 early_start =
 MAX (early_start, p_st + e->latency - (e->distance * ii));
 if (dump_file)
 fprintf (dump_file,
 "pred st = %d; early_start = %d; latency: %d",
 p_st, early_start, e->latency);
 	      if (e->data_type == MEM_DEP)
 		end = MIN (end, SCHED_TIME (v_node) + ii - 1);
 late_start = MIN (late_start,
 s_st - e->latency + (e->distance * ii));
 if (dump_file)
 fprintf (dump_file,
 "succ st = %d; late_start = %d; latency = %d",
 s_st, late_start, e->latency);
 	      if (e->data_type == MEM_DEP)
 		end = MAX (end, SCHED_TIME (v_node) - ii + 1);
 	      early_start = MAX (early_start,
 				 p_st + e->latency
 				 - (e->distance * ii));
 if (dump_file)
 fprintf (dump_file,
 "pred st = %d; early_start = %d; latency = %d",
 p_st, early_start, e->latency);
 if (e->type == TRUE_DEP && e->data_type == REG_DEP)
 count_preds++;
 	      late_start = MIN (late_start,
 				s_st - e->latency
 				+ (e->distance * ii));
 if (dump_file)
 fprintf (dump_file,
 "succ st = %d; late_start = %d; latency = %d",
 s_st, late_start, e->latency);
 if (e->type == TRUE_DEP && e->data_type == REG_DEP)
 count_succs++;
 && ((SCHED_TIME (e->dest) - e->latency + (e->distance * ii)) ==
 last_cycle_in_window)
 && e->latency == 0
 we use the fact that latency is non-negative:
 SCHED_TIME (e->dest) + (e->distance * ii) >=
 SCHED_TIME (e->dest) - e->latency + (e->distance * ii)) >=
 last_cycle_in_window
 and check only if
 SCHED_TIME (e->dest) + (e->distance * ii) == last_cycle_in_window  */
 for (e = u_node->out; e != 0; e = e->next_out)
 if (TEST_BIT (sched_nodes, e->dest->cuid)
 	{
 	  int u = nodes_order[i];
 	  ddg_node_ptr u_node = &ps->g->nodes[u];
 	  rtx insn = u_node->insn;
-	  if (!INSN_P (insn))
+	  if (!NONDEBUG_INSN_P (insn))
 	    {
 	      RESET_BIT (tobe_scheduled, u);
 	      continue;
 	    }
 verify_partial_schedule (ps, sched_nodes);
 break;
 }
 num_splits++;
+/* The scheduling window is exclusive of 'end'
+whereas compute_split_window() expects an inclusive,
+ordered range.  */
 if (step == 1)
-split_row = compute_split_row (sched_nodes, start, end,
+split_row = compute_split_row (sched_nodes, start, end - 1,
 ps->ii, u_node);
 else
-split_row = compute_split_row (sched_nodes, end, start,
+split_row = compute_split_row (sched_nodes, end + 1, start,
 ps->ii, u_node);
 ps_insert_empty_row (ps, split_row, sched_nodes);
 i--;              /* Go back and retry node i.  */
 fprintf (dump_file, "%d ", u);
 gcc_assert (u < num_nodes && u >= 0 && !TEST_BIT (tmp, u));
 SET_BIT (tmp, u);
 }
 if (dump_file)
 fprintf (dump_file, "\n");
 sbitmap_free (tmp);
 }
 /* Order the nodes of G for scheduling and pass the result in
 NODE_ORDER.  Also set aux.count of each node to ASAP.
 return true;
 }
 /* Advances the PS_INSN one column in its current row; returns false
 in failure and true in success.  Bit N is set in MUST_FOLLOW if
 the node with cuid N must be come after the node pointed to by
 PS_I when scheduled in the same cycle.  */
 static int
 ps_insn_advance_column (partial_schedule_ptr ps, ps_insn_ptr ps_i,
 			sbitmap must_follow)
 {
 return true;
 }
 /* Inserts a DDG_NODE to the given partial schedule at the given cycle.
 Returns 0 if this is not possible and a PS_INSN otherwise.  Bit N is
 set in MUST_PRECEDE/MUST_FOLLOW if the node with cuid N must be come
 before/after (respectively) the node pointed to by PS_I when scheduled
 in the same cycle.  */
 static ps_insn_ptr
 add_node_to_ps (partial_schedule_ptr ps, ddg_node_ptr node, int cycle,
 		sbitmap must_precede, sbitmap must_follow)
 {
 	   crr_insn;
 	   crr_insn = crr_insn->next_in_row)
 	{
 	  rtx insn = crr_insn->node->insn;
-	  if (!INSN_P (insn))
+	  if (!NONDEBUG_INSN_P (insn))
 	    continue;
 	  /* Check if there is room for the current insn.  */
 	  if (!can_issue_more || state_dead_lock_p (curr_state))
 	    return true;
 return false;
 }
 /* Checks if the given node causes resource conflicts when added to PS at
 cycle C.  If not the node is added to PS and returned; otherwise zero
 is returned.  Bit N is set in MUST_PRECEDE/MUST_FOLLOW if the node with
 cuid N must be come before/after (respectively) the node pointed to by
 PS_I when scheduled in the same cycle.  */
 ps_insn_ptr
 ps_add_node_check_conflicts (partial_schedule_ptr ps, ddg_node_ptr n,
 			     int c, sbitmap must_precede,
 			     sbitmap must_follow)

Mercurial > hg > CbC > CbC_gcc

comparison gcc/modulo-sched.c @ 55:77e2b8dfacca gcc-4.4.5