gcc/gcc/haifa-sched.c

808   dep_t dep;
820   FOR_EACH_DEP (pair->i2, SD_LIST_BACK, sd_it, dep)
822       rtx_insn *pro = DEP_PRO (dep);
1162       dep_t dep;
1164       FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
1165 	DEP_STATUS (dep) &= ~DEP_CANCELLED;
1183   dep_t dep;
1189   while (sd_iterator_cond (&sd_it, &dep))
1191       DEP_COST (dep) = UNKNOWN_DEP_COST;
1230   dep_t dep, modify_dep = NULL;
1253   FOR_EACH_DEP (next, SD_LIST_BACK, sd_it, dep)
1255       rtx_insn *pro = DEP_PRO (dep);
1256       ds_t ds = DEP_STATUS (dep) & SPECULATIVE;
1273       else if (DEP_TYPE (dep) == REG_DEP_CONTROL)
1278 	      modify_dep = dep;
1280 	  DEP_STATUS (dep) &= ~DEP_CANCELLED;
1282       else if (DEP_REPLACE (dep) != NULL)
1287 	      modify_dep = dep;
1289 	  DEP_STATUS (dep) &= ~DEP_CANCELLED;
1297       FOR_EACH_DEP (next, SD_LIST_BACK, sd_it, dep)
1299 	  struct dep_replacement *desc = DEP_REPLACE (dep);
1305 		  apply_replacement (dep, true);
1307 	      DEP_STATUS (dep) |= DEP_CANCELLED;
1580 contributes_to_priority_p (dep_t dep)
1582   if (DEBUG_INSN_P (DEP_CON (dep))
1583       || DEBUG_INSN_P (DEP_PRO (dep)))
1587   if (!current_sched_info->contributes_to_priority (DEP_CON (dep),
1588 						    DEP_PRO (dep)))
1591   if (DEP_REPLACE (dep) != NULL)
1602       && (DEP_STATUS (dep) & SPECULATIVE))
1614   dep_t dep;
1620   FOR_EACH_DEP (insn, list, sd_it, dep)
1622       if (DEBUG_INSN_P (DEP_CON (dep)))
1624       else if (!DEBUG_INSN_P (DEP_PRO (dep)))
1690 	      dep_t dep;
1692 	      FOR_EACH_DEP (twin, SD_LIST_FORW, sd_it, dep)
1697 		  next = DEP_CON (dep);
1703 		      if (!contributes_to_priority_p (dep))
1707 			cost = dep_cost (dep);
2294 must_restore_pattern_p (rtx_insn *next, dep_t dep)
2299   if (DEP_TYPE (dep) == REG_DEP_CONTROL)
2302       gcc_assert (next == DEP_CON (dep));
2306       struct dep_replacement *desc = DEP_REPLACE (dep);
3535   dep_t dep;
3546 	FOR_EACH_DEP (iter, SD_LIST_FORW, sd_it, dep)
3548 	    con = MODEL_INSN_INFO (DEP_CON (dep));
3678   dep_t dep;
3680   FOR_EACH_DEP (insn->insn, SD_LIST_FORW, sd_it, dep)
3682       con = MODEL_INSN_INFO (DEP_CON (dep));
3691 	  if (DEP_TYPE (dep) == REG_DEP_TRUE && con->depth < insn->depth + 1)
3721   dep_t dep;
3733       FOR_EACH_DEP (insn->insn, SD_LIST_HARD_BACK, sd_it, dep)
3735 	  pro = MODEL_INSN_INFO (DEP_PRO (dep));
4021   dep_t dep;
4065 	 sd_iterator_cond (&sd_it, &dep);)
4067 	rtx_insn *dbg = DEP_PRO (dep);
4070 	if (DEP_STATUS (dep) & DEP_CANCELLED)
4153        sd_iterator_cond (&sd_it, &dep); sd_iterator_next (&sd_it))
4155       struct dep_replacement *desc = DEP_REPLACE (dep);
4156       rtx_insn *pro = DEP_PRO (dep);
4159 	apply_replacement (dep, false);
4164        sd_iterator_cond (&sd_it, &dep);)
4166       rtx_insn *next = DEP_CON (dep);
4167       bool cancelled = (DEP_STATUS (dep) & DEP_CANCELLED) != 0;
4170 	 sd_resolve_dep () moves current dep to another list thus
4176 	  if (must_restore_pattern_p (next, dep))
4177 	    restore_pattern (dep, false);
4362   dep_t dep;
4363   FOR_EACH_DEP (insn, SD_LIST_HARD_BACK, sd_it, dep)
4365       FEEDS_BACKTRACK_INSN (DEP_PRO (dep)) = set_p;
4447   dep_t dep;
4453 	FOR_EACH_DEP (first[i], SD_LIST_BACK, sd_it, dep)
4454 	  if (!DEBUG_INSN_P (DEP_PRO (dep)))
4457 		DEP_STATUS (dep) |= DEP_CANCELLED;
4459 		DEP_STATUS (dep) &= ~DEP_CANCELLED;
4469 	  FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
4470 	    if (!DEBUG_INSN_P (DEP_PRO (dep)))
4473 		  DEP_STATUS (dep) |= DEP_CANCELLED;
4475 		  DEP_STATUS (dep) &= ~DEP_CANCELLED;
4488       dep_t dep = save->replacement_deps.pop ();
4492 	restore_pattern (dep, true);
4494 	apply_replacement (dep, true);
4515       dep_t dep;
4529 	   sd_iterator_cond (&sd_it, &dep);)
4531 	  rtx_insn *con = DEP_CON (dep);
4734 apply_replacement (dep_t dep, bool immediately)
4736   struct dep_replacement *desc = DEP_REPLACE (dep);
4739       next_cycle_replace_deps.safe_push (dep);
4762 	  backtrack_queue->replacement_deps.safe_push (dep);
4773 restore_pattern (dep_t dep, bool immediately)
4775   rtx_insn *next = DEP_CON (dep);
4785       next_cycle_replace_deps.safe_push (dep);
4791   if (DEP_TYPE (dep) == REG_DEP_CONTROL)
4800       struct dep_replacement *desc = DEP_REPLACE (dep);
4813 	  backtrack_queue->replacement_deps.safe_push (dep);
4833   dep_t dep;
4834   FOR_EACH_VEC_ELT (next_cycle_replace_deps, i, dep)
4838 	apply_replacement (dep, true);
4840 	restore_pattern (dep, true);
4855   dep_t dep;
4858   FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
4860       rtx_insn *pro = DEP_PRO (dep);
4863       if (DEP_STATUS (dep) & DEP_CANCELLED)
4867 	gcc_assert (INSN_TICK (pro) + dep_cost (dep) <= INSN_TICK (insn));
4870 	  int cost = dep_cost (dep);
4918   dep_t dep;
4935        sd_iterator_cond (&sd_it, &dep);)
4937       rtx_insn *next = DEP_CON (dep);
4944 	 sd_resolve_dep () moves current dep to another list thus
5115       dep_t dep;
5119 	   sd_iterator_cond (&sd_it, &dep); sd_iterator_next (&sd_it))
5121 	  struct dep_replacement *desc = DEP_REPLACE (dep);
5251    back, with default Y=1; The flag -fsched-stalled-insns-dep=Y allows
5274 		  dep_t dep;
5276 		  dep = sd_find_dep_between (prev_insn, insn, true);
5278 		  if (dep != NULL)
5280 		      cost = dep_cost (dep);
5282 		      if (targetm.sched.is_costly_dependence (dep, cost,
7283   /* More problems needed for interloop dep calculation in SMS.  */
7451 	  dep_t dep;
7470 	  FOR_EACH_DEP (head, SD_LIST_RES_FORW, sd_it, dep)
7474 	      next = DEP_CON (dep);
7648       dep_t dep;
7656       FOR_EACH_DEP (next, SD_LIST_RES_BACK, sd_it, dep)
7658           rtx_insn *pro = DEP_PRO (dep);
7663           tick1 = INSN_TICK (pro) + dep_cost (dep);
7829   dep_t dep;
7831   FOR_EACH_DEP (insn, SD_LIST_FORW, sd_it, dep)
7836       consumer = DEP_CON (dep);
7838       ds = DEP_STATUS (dep);
7840       if (/* If we want to create speculative dep.  */
7842 	  /* And we can do that because this is a true dep.  */
7847 	  if (/* If this dep can be overcome with 'begin speculation'.  */
7849 	    /* Then we have a choice: keep the dep 'begin speculative'
7855 		     probability of the speculative dep to decrease.  */
7870 	    /* Mark the dep as 'be in speculative'.  */
7877 	init_dep_1 (new_dep, twin, consumer, DEP_TYPE (dep), ds);
7905   dep_t dep;
7924        sd_iterator_cond (&sd_it, &dep);)
7926       rtx_insn *check = DEP_PRO (dep);
7950       if (!sd_iterator_cond (&sd_it, &dep))
7954       gcc_assert ((DEP_STATUS (dep) & BEGIN_SPEC) == 0
7955 		  && (DEP_STATUS (dep) & BE_IN_SPEC) != 0
7956 		  && (DEP_STATUS (dep) & DEP_TYPES) == DEP_TRUE);
7958       check = DEP_PRO (dep);
7980       FOR_EACH_DEP (insn, SD_LIST_SPEC_BACK, sd_it, dep)
7982 	  rtx_insn *pro = DEP_PRO (dep);
7984 	  gcc_assert (DEP_TYPE (dep) == REG_DEP_TRUE);
8002 	   sd_iterator_cond (&sd_it, &dep);)
8004 	  rtx_insn *pro = DEP_PRO (dep);
8277   dep_t dep;
8346       dep_t dep;
8348       FOR_EACH_DEP (insn, SD_LIST_RES_BACK, sd_it, dep)
8349 	if ((DEP_STATUS (dep) & DEP_OUTPUT) != 0)
8353 	    init_dep (dep2, DEP_PRO (dep), check, REG_DEP_TRUE);
8402   FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
8404       rtx_insn *pro = DEP_PRO (dep);
8422       ds = DEP_STATUS (dep);
8430       init_dep_1 (new_dep, pro, check, DEP_TYPE (dep), ds);
8442        sd_iterator_cond (&sd_it, &dep);)
8444       if ((DEP_STATUS (dep) & BEGIN_SPEC)
8446 	/* We can delete this dep because we overcome it with
8507 	    while (sd_iterator_cond (&sd_it, &dep))
8565       dep_t dep;
8568 	   sd_iterator_cond (&sd_it, &dep);)
8570 	  rtx_insn *consumer = DEP_CON (dep);
8581 	      gcc_assert ((DEP_STATUS (dep) & DEP_TYPES) == DEP_TRUE);
8871   dep_t dep;
8876   FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
8878       rtx_insn *pro = DEP_PRO (dep);
8885 	  if (contributes_to_priority_p (dep))