gcc/gcc/sched-deps.c

121 init_dep_1 (dep_t dep, rtx_insn *pro, rtx_insn *con, enum reg_note type, ds_t ds)
123   DEP_PRO (dep) = pro;
124   DEP_CON (dep) = con;
125   DEP_TYPE (dep) = type;
126   DEP_STATUS (dep) = ds;
127   DEP_COST (dep) = UNKNOWN_DEP_COST;
128   DEP_NONREG (dep) = 0;
129   DEP_MULTIPLE (dep) = 0;
130   DEP_REPLACE (dep) = NULL;
137 init_dep (dep_t dep, rtx_insn *pro, rtx_insn *con, enum reg_note kind)
146   init_dep_1 (dep, pro, con, kind, ds);
182 dump_dep (FILE *dump, dep_t dep, int flags)
190     fprintf (dump, "%d; ", INSN_UID (DEP_PRO (dep)));
193     fprintf (dump, "%d; ", INSN_UID (DEP_CON (dep)));
198       enum reg_note type = DEP_TYPE (dep);
229 	dump_ds (dump, DEP_STATUS (dep));
240 sd_debug_dep (dep_t dep)
242   dump_dep (stderr, dep, 1);
250 depl_on_debug_p (dep_link_t dep)
252   return (DEBUG_INSN_P (DEP_LINK_PRO (dep))
253 	  && !DEBUG_INSN_P (DEP_LINK_CON (dep)));
446 dep_spec_p (dep_t dep)
450       if (DEP_STATUS (dep) & SPECULATIVE)
455       if (DEP_TYPE (dep) == REG_DEP_CONTROL)
458   if (DEP_REPLACE (dep) != NULL)
868   dep_t dep;
887       FOR_EACH_DEP (con, con_list_type, sd_it, dep)
888 	if (DEP_PRO (dep) == pro)
897       FOR_EACH_DEP (pro, pro_list_type, sd_it, dep)
898 	if (DEP_CON (dep) == con)
910       return dep;
948    and doesn't create a dep in this case.  Actual manipulation of
951 maybe_add_or_update_dep_1 (dep_t dep, bool resolved_p, rtx mem1, rtx mem2)
953   rtx_insn *elem = DEP_PRO (dep);
954   rtx_insn *insn = DEP_CON (dep);
968   return add_or_update_dep_1 (dep, resolved_p, mem1, mem2);
979 ask_dependency_caches (dep_t dep)
981   int elem_luid = INSN_LUID (DEP_PRO (dep));
982   int insn_luid = INSN_LUID (DEP_CON (dep));
1002 	/* There is no existing dep so it should be created.  */
1005       if ((int) DEP_TYPE (dep) >= (int) present_dep_type)
1023 	/* There is no existing dep so it should be created.  */
1029 	  if ((present_dep_types | (DEP_STATUS (dep) & DEP_TYPES))
1044 	     ..we should reset existing dep to non-speculative.  */
1053 set_dependency_caches (dep_t dep)
1055   int elem_luid = INSN_LUID (DEP_PRO (dep));
1056   int insn_luid = INSN_LUID (DEP_CON (dep));
1060       switch (DEP_TYPE (dep))
1084       ds_t ds = DEP_STATUS (dep);
1106 update_dependency_caches (dep_t dep, enum reg_note old_type)
1108   int elem_luid = INSN_LUID (DEP_PRO (dep));
1109   int insn_luid = INSN_LUID (DEP_CON (dep));
1134   set_dependency_caches (dep);
1143   dep_t dep = DEP_NODE_DEP (node);
1144   rtx_insn *elem = DEP_PRO (dep);
1145   rtx_insn *insn = DEP_CON (dep);
1149   DEP_STATUS (dep) &= ~SPECULATIVE;
1162 update_dep (dep_t dep, dep_t new_dep,
1168   enum reg_note old_type = DEP_TYPE (dep);
1169   bool was_spec = dep_spec_p (dep);
1171   DEP_NONREG (dep) |= DEP_NONREG (new_dep);
1172   DEP_MULTIPLE (dep) = 1;
1179       DEP_TYPE (dep) = DEP_TYPE (new_dep);
1186       ds_t dep_status = DEP_STATUS (dep);
1192 	  /* Either existing dep or a dep we're adding or both are
1196 	    /* The new dep can't be speculative.  */
1217 	  DEP_STATUS (dep) = ds;
1222   if (was_spec && !dep_spec_p (dep))
1223     /* The old dep was speculative, but now it isn't.  */
1228     update_dependency_caches (dep, old_type);
1300 	/* We didn't find a dep, it shouldn't present in the cache.  */
1325 get_back_and_forw_lists (dep_t dep, bool resolved_p,
1329   rtx_insn *con = DEP_CON (dep);
1333       if (dep_spec_p (dep))
1338       *forw_list_ptr = INSN_FORW_DEPS (DEP_PRO (dep));
1343       *forw_list_ptr = INSN_RESOLVED_FORW_DEPS (DEP_PRO (dep));
1350 sd_add_dep (dep_t dep, bool resolved_p)
1355   rtx_insn *elem = DEP_PRO (dep);
1356   rtx_insn *insn = DEP_CON (dep);
1361       || !sched_insn_is_legitimate_for_speculation_p (insn, DEP_STATUS (dep)))
1362     DEP_STATUS (dep) &= ~SPECULATIVE;
1364   copy_dep (DEP_NODE_DEP (n), dep);
1366   get_back_and_forw_lists (dep, resolved_p, &con_back_deps, &pro_forw_deps);
1371   check_dep (dep, false);
1379     set_dependency_caches (dep);
1386 sd_add_or_update_dep (dep_t dep, bool resolved_p)
1388   return add_or_update_dep_1 (dep, resolved_p, NULL_RTX, NULL_RTX);
1397   dep_t dep = DEP_NODE_DEP (node);
1398   rtx_insn *pro = DEP_PRO (dep);
1399   rtx_insn *con = DEP_CON (dep);
1401   if (dep_spec_p (dep))
1418   dep_t dep = DEP_NODE_DEP (node);
1419   rtx_insn *pro = DEP_PRO (dep);
1420   rtx_insn *con = DEP_CON (dep);
1422   if (dep_spec_p (dep))
1440   dep_t dep;
1444   FOR_EACH_DEP (from, list_type, sd_it, dep)
1448       copy_dep (new_dep, dep);
1460   dep_t dep = DEP_NODE_DEP (n);
1461   rtx_insn *pro = DEP_PRO (dep);
1462   rtx_insn *con = DEP_CON (dep);
1480   get_back_and_forw_lists (dep, sd_it.resolved_p,
1507   dep_t dep;
1522       FOR_EACH_DEP (insn, types, sd_it, dep)
1524 	  dump_dep (dump, dep, dump_dep_flags | all);
1679   dep_t dep;
1686        sd_iterator_cond (&sd_it, &dep);)
1700   dep_t dep;
1703   FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
1706       rtx_insn *pro = DEP_PRO (dep);
1717 	add_dependence (i, pro, DEP_TYPE (dep));
1883     dep_def _dep, *dep = &_dep;
1885     init_dep_1 (dep, pending_insn, cur_insn, ds_to_dt (ds),
1887     DEP_NONREG (dep) = 1;
1888     maybe_add_or_update_dep_1 (dep, false, pending_mem, mem);
1897   dep_t dep = &_dep;
1899   init_dep (dep, elem, cur_insn, ds_to_dt (ds));
1901     DEP_NONREG (dep) = 1;
1902   maybe_add_or_update_dep_1 (dep, false, NULL_RTX, NULL_RTX);
3530           dep_t dep;
3533                sd_iterator_cond (&sd_it, &dep);)
3764 	 And I will answer: "Basic principles (one dep per insn) are always
3870   dep_t dep;
3879        sd_iterator_cond (&sd_it, &dep);)
3886       get_back_and_forw_lists (dep, resolved_p, &back_list, &forw_list);
4414 	/* Then this dep can't be speculative.  */
4491 /* Return a dep status that contains all speculation types of DS.  */
4507 /* Return a dep status that contains maximal weakness for each speculation
4565 check_dep (dep_t dep, bool relaxed_p)
4567   enum reg_note dt = DEP_TYPE (dep);
4568   ds_t ds = DEP_STATUS (dep);
4570   gcc_assert (DEP_PRO (dep) != DEP_CON (dep));
4652    instruction involved is subject to only one dep that can cause a pattern
4779   dep_t dep;
4783   while (sd_iterator_cond (&sd_it, &dep))
4786       rtx_insn *pro = DEP_PRO (dep);
4787       rtx_insn *con = DEP_CON (dep);
4789       if (DEP_NONREG (dep) || DEP_MULTIPLE (dep))
4825 	  DEP_REPLACE (dep) = desc;
4834 	      FOR_EACH_DEP (mii->inc_insn, SD_LIST_BACK, sd_it, dep)
4835 		add_dependence_1 (mii->mem_insn, DEP_PRO (dep),
4840 	      FOR_EACH_DEP (mii->inc_insn, SD_LIST_FORW, sd_it, dep)
4841 		add_dependence_1 (DEP_CON (dep), mii->mem_insn,