/* Instruction scheduling pass. This file computes dependencies between
instructions.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
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
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
\f
#include "config.h"
#include "system.h"
#include "sched-int.h"
#include "params.h"
#include "cselib.h"
-#include "df.h"
#ifdef ENABLE_CHECKING
#define CHECK (true)
/* Functions to operate with dependence information container - dep_t. */
/* Init DEP with the arguments. */
-static void
-init_dep_1 (dep_t dep, rtx pro, rtx con, enum reg_note kind, ds_t ds)
+void
+init_dep_1 (dep_t dep, rtx pro, rtx con, enum reg_note type, ds_t ds)
{
DEP_PRO (dep) = pro;
DEP_CON (dep) = con;
- DEP_KIND (dep) = kind;
+ DEP_TYPE (dep) = type;
DEP_STATUS (dep) = ds;
}
{
ds_t ds;
- if ((current_sched_info->flags & USE_DEPS_LIST) != 0)
+ if ((current_sched_info->flags & USE_DEPS_LIST))
ds = dk_to_ds (kind);
else
ds = -1;
memcpy (to, from, sizeof (*to));
}
-/* Functions to operate with a single link from the dependencies lists -
- dep_link_t. */
+static void dump_ds (FILE *, ds_t);
-/* Return true if dep_link L is consistent. */
-static bool
-dep_link_consistent_p (dep_link_t l)
+/* Define flags for dump_dep (). */
+
+/* Dump producer of the dependence. */
+#define DUMP_DEP_PRO (2)
+
+/* Dump consumer of the dependence. */
+#define DUMP_DEP_CON (4)
+
+/* Dump type of the dependence. */
+#define DUMP_DEP_TYPE (8)
+
+/* Dump status of the dependence. */
+#define DUMP_DEP_STATUS (16)
+
+/* Dump all information about the dependence. */
+#define DUMP_DEP_ALL (DUMP_DEP_PRO | DUMP_DEP_CON | DUMP_DEP_TYPE \
+ |DUMP_DEP_STATUS)
+
+/* Dump DEP to DUMP.
+ FLAGS is a bit mask specifying what information about DEP needs
+ to be printed.
+ If FLAGS has the very first bit set, then dump all information about DEP
+ and propagate this bit into the callee dump functions. */
+static void
+dump_dep (FILE *dump, dep_t dep, int flags)
{
- dep_link_t next = DEP_LINK_NEXT (l);
+ if (flags & 1)
+ flags |= DUMP_DEP_ALL;
+
+ fprintf (dump, "<");
+
+ if (flags & DUMP_DEP_PRO)
+ fprintf (dump, "%d; ", INSN_UID (DEP_PRO (dep)));
+
+ if (flags & DUMP_DEP_CON)
+ fprintf (dump, "%d; ", INSN_UID (DEP_CON (dep)));
+
+ if (flags & DUMP_DEP_TYPE)
+ {
+ char t;
+ enum reg_note type = DEP_TYPE (dep);
+
+ switch (type)
+ {
+ case REG_DEP_TRUE:
+ t = 't';
+ break;
+
+ case REG_DEP_OUTPUT:
+ t = 'o';
+ break;
- return (next == NULL
- || &DEP_LINK_NEXT (l) == DEP_LINK_PREV_NEXTP (next));
+ case REG_DEP_ANTI:
+ t = 'a';
+ break;
+
+ default:
+ gcc_unreachable ();
+ break;
+ }
+
+ fprintf (dump, "%c; ", t);
+ }
+
+ if (flags & DUMP_DEP_STATUS)
+ {
+ if (current_sched_info->flags & USE_DEPS_LIST)
+ dump_ds (dump, DEP_STATUS (dep));
+ }
+
+ fprintf (dump, ">");
+}
+
+/* Default flags for dump_dep (). */
+static int dump_dep_flags = (DUMP_DEP_PRO | DUMP_DEP_CON);
+
+/* Dump all fields of DEP to STDERR. */
+void
+sd_debug_dep (dep_t dep)
+{
+ dump_dep (stderr, dep, 1);
+ fprintf (stderr, "\n");
}
+/* Functions to operate with a single link from the dependencies lists -
+ dep_link_t. */
+
/* Attach L to appear after link X whose &DEP_LINK_NEXT (X) is given by
PREV_NEXT_P. */
static void
add_to_deps_list (dep_link_t link, deps_list_t l)
{
attach_dep_link (link, &DEPS_LIST_FIRST (l));
+
+ ++DEPS_LIST_N_LINKS (l);
}
/* Detach dep_link L from the list. */
if (next != NULL)
DEP_LINK_PREV_NEXTP (next) = prev_nextp;
- /* Though this is property is not used anywhere but in the assert in
- attach_dep_link (), this can prevent latent errors. */
DEP_LINK_PREV_NEXTP (l) = NULL;
DEP_LINK_NEXT (l) = NULL;
}
-/* Move LINK from whatever list it is now to L. */
-void
-move_dep_link (dep_link_t link, deps_list_t l)
+/* Remove link LINK from list LIST. */
+static void
+remove_from_deps_list (dep_link_t link, deps_list_t list)
{
detach_dep_link (link);
- add_to_deps_list (link, l);
-}
-/* Check L's and its successors' consistency.
- This is, potentially, an expensive check, hence it should be guarded by
- ENABLE_CHECKING at all times. */
-static bool
-dep_links_consistent_p (dep_link_t l)
-{
- while (l != NULL)
- {
- if (dep_link_consistent_p (l))
- l = DEP_LINK_NEXT (l);
- else
- return false;
- }
-
- return true;
+ --DEPS_LIST_N_LINKS (list);
}
-/* Dump dep_nodes starting from l. */
+/* Move link LINK from list FROM to list TO. */
static void
-dump_dep_links (FILE *dump, dep_link_t l)
+move_dep_link (dep_link_t link, deps_list_t from, deps_list_t to)
{
- while (l != NULL)
- {
- dep_t d = DEP_LINK_DEP (l);
-
- fprintf (dump, "%d%c>%d ", INSN_UID (DEP_PRO (d)),
- dep_link_consistent_p (l) ? '-' : '!', INSN_UID (DEP_CON (d)));
-
- l = DEP_LINK_NEXT (l);
- }
-
- fprintf (dump, "\n");
+ remove_from_deps_list (link, from);
+ add_to_deps_list (link, to);
}
-/* Dump dep_nodes starting from L to stderr. */
-void
-debug_dep_links (dep_link_t l)
+/* Return true of LINK is not attached to any list. */
+static bool
+dep_link_is_detached_p (dep_link_t link)
{
- dump_dep_links (stderr, l);
+ return DEP_LINK_PREV_NEXTP (link) == NULL;
}
-/* Obstack to allocate dep_nodes and deps_lists on. */
-static struct obstack deps_obstack;
+/* Pool to hold all dependency nodes (dep_node_t). */
+static alloc_pool dn_pool;
-/* Obstack to hold forward dependencies lists (deps_list_t). */
-static struct obstack *dl_obstack = &deps_obstack;
+/* Number of dep_nodes out there. */
+static int dn_pool_diff = 0;
-/* Obstack to hold all dependency nodes (dep_node_t). */
-static struct obstack *dn_obstack = &deps_obstack;
+/* Create a dep_node. */
+static dep_node_t
+create_dep_node (void)
+{
+ dep_node_t n = (dep_node_t) pool_alloc (dn_pool);
+ dep_link_t back = DEP_NODE_BACK (n);
+ dep_link_t forw = DEP_NODE_FORW (n);
-/* Functions to operate with dependences lists - deps_list_t. */
+ DEP_LINK_NODE (back) = n;
+ DEP_LINK_NEXT (back) = NULL;
+ DEP_LINK_PREV_NEXTP (back) = NULL;
-/* Allocate deps_list.
+ DEP_LINK_NODE (forw) = n;
+ DEP_LINK_NEXT (forw) = NULL;
+ DEP_LINK_PREV_NEXTP (forw) = NULL;
- If ON_OBSTACK_P is true, allocate the list on the obstack. This is done for
- INSN_FORW_DEPS lists because they should live till the end of scheduling.
+ ++dn_pool_diff;
- INSN_BACK_DEPS and INSN_RESOLVED_BACK_DEPS lists are allocated on the free
- store and are being freed in haifa-sched.c: schedule_insn (). */
-static deps_list_t
-alloc_deps_list (bool on_obstack_p)
-{
- if (on_obstack_p)
- return obstack_alloc (dl_obstack, sizeof (struct _deps_list));
- else
- return xmalloc (sizeof (struct _deps_list));
+ return n;
}
-/* Initialize deps_list L. */
+/* Delete dep_node N. N must not be connected to any deps_list. */
static void
-init_deps_list (deps_list_t l)
+delete_dep_node (dep_node_t n)
{
- DEPS_LIST_FIRST (l) = NULL;
-}
-
-/* Create (allocate and init) deps_list.
- The meaning of ON_OBSTACK_P is the same as in alloc_deps_list (). */
-deps_list_t
-create_deps_list (bool on_obstack_p)
-{
- deps_list_t l = alloc_deps_list (on_obstack_p);
-
- init_deps_list (l);
- return l;
-}
+ gcc_assert (dep_link_is_detached_p (DEP_NODE_BACK (n))
+ && dep_link_is_detached_p (DEP_NODE_FORW (n)));
-/* Free dep_data_nodes that present in L. */
-static void
-clear_deps_list (deps_list_t l)
-{
- /* All dep_nodes are allocated on the dn_obstack. They'll be freed with
- the obstack. */
+ --dn_pool_diff;
- DEPS_LIST_FIRST (l) = NULL;
+ pool_free (dn_pool, n);
}
-/* Free deps_list L. */
-void
-free_deps_list (deps_list_t l)
-{
- gcc_assert (deps_list_empty_p (l));
- free (l);
-}
+/* Pool to hold dependencies lists (deps_list_t). */
+static alloc_pool dl_pool;
-/* Delete (clear and free) deps_list L. */
-void
-delete_deps_list (deps_list_t l)
-{
- clear_deps_list (l);
- free_deps_list (l);
-}
+/* Number of deps_lists out there. */
+static int dl_pool_diff = 0;
-/* Return true if L is empty. */
-bool
-deps_list_empty_p (deps_list_t l)
-{
- return DEPS_LIST_FIRST (l) == NULL;
-}
+/* Functions to operate with dependences lists - deps_list_t. */
-/* Check L's consistency.
- This is, potentially, an expensive check, hence it should be guarded by
- ENABLE_CHECKING at all times. */
+/* Return true if list L is empty. */
static bool
-deps_list_consistent_p (deps_list_t l)
-{
- dep_link_t first = DEPS_LIST_FIRST (l);
-
- return (first == NULL
- || (&DEPS_LIST_FIRST (l) == DEP_LINK_PREV_NEXTP (first)
- && dep_links_consistent_p (first)));
-}
-
-/* Dump L to F. */
-static void
-dump_deps_list (FILE *f, deps_list_t l)
-{
- dump_dep_links (f, DEPS_LIST_FIRST (l));
-}
-
-/* Dump L to STDERR. */
-void
-debug_deps_list (deps_list_t l)
+deps_list_empty_p (deps_list_t l)
{
- dump_deps_list (stderr, l);
+ return DEPS_LIST_N_LINKS (l) == 0;
}
-/* Add a dependency described by DEP to the list L.
- L should be either INSN_BACK_DEPS or INSN_RESOLVED_BACK_DEPS. */
-void
-add_back_dep_to_deps_list (deps_list_t l, dep_t dep_from)
+/* Create a new deps_list. */
+static deps_list_t
+create_deps_list (void)
{
- dep_node_t n = (dep_node_t) obstack_alloc (dn_obstack,
- sizeof (*n));
- dep_t dep_to = DEP_NODE_DEP (n);
- dep_link_t back = DEP_NODE_BACK (n);
- dep_link_t forw = DEP_NODE_FORW (n);
-
- copy_dep (dep_to, dep_from);
-
- DEP_LINK_NODE (back) = n;
- DEP_LINK_NODE (forw) = n;
+ deps_list_t l = (deps_list_t) pool_alloc (dl_pool);
- /* There is no particular need to initialize these four fields except to make
- assert in attach_dep_link () happy. */
- DEP_LINK_NEXT (back) = NULL;
- DEP_LINK_PREV_NEXTP (back) = NULL;
- DEP_LINK_NEXT (forw) = NULL;
- DEP_LINK_PREV_NEXTP (forw) = NULL;
+ DEPS_LIST_FIRST (l) = NULL;
+ DEPS_LIST_N_LINKS (l) = 0;
- add_to_deps_list (back, l);
+ ++dl_pool_diff;
+ return l;
}
-/* Find the dep_link with producer PRO in deps_list L. */
-dep_link_t
-find_link_by_pro_in_deps_list (deps_list_t l, rtx pro)
+/* Free deps_list L. */
+static void
+free_deps_list (deps_list_t l)
{
- dep_link_t link;
+ gcc_assert (deps_list_empty_p (l));
- FOR_EACH_DEP_LINK (link, l)
- if (DEP_LINK_PRO (link) == pro)
- return link;
+ --dl_pool_diff;
- return NULL;
+ pool_free (dl_pool, l);
}
-/* Find the dep_link with consumer CON in deps_list L. */
-dep_link_t
-find_link_by_con_in_deps_list (deps_list_t l, rtx con)
+/* Return true if there is no dep_nodes and deps_lists out there.
+ After the region is scheduled all the depedency nodes and lists
+ should [generally] be returned to pool. */
+bool
+deps_pools_are_empty_p (void)
{
- dep_link_t link;
-
- FOR_EACH_DEP_LINK (link, l)
- if (DEP_LINK_CON (link) == con)
- return link;
-
- return NULL;
+ return dn_pool_diff == 0 && dl_pool_diff == 0;
}
-/* Make a copy of FROM in TO with substituting consumer with CON.
- TO and FROM should be RESOLVED_BACK_DEPS lists. */
-void
-copy_deps_list_change_con (deps_list_t to, deps_list_t from, rtx con)
+/* Remove all elements from L. */
+static void
+clear_deps_list (deps_list_t l)
{
- dep_link_t l;
+ do
+ {
+ dep_link_t link = DEPS_LIST_FIRST (l);
- gcc_assert (deps_list_empty_p (to));
+ if (link == NULL)
+ break;
- FOR_EACH_DEP_LINK (l, from)
- {
- add_back_dep_to_deps_list (to, DEP_LINK_DEP (l));
- DEP_LINK_CON (DEPS_LIST_FIRST (to)) = con;
+ remove_from_deps_list (link, l);
}
+ while (1);
}
static regset reg_pending_sets;
static bitmap_head *spec_dependency_cache;
static int cache_size;
-/* To speed up checking consistency of formed forward insn
- dependencies we use the following cache. Another possible solution
- could be switching off checking duplication of insns in forward
- dependencies. */
-#ifdef ENABLE_CHECKING
-static bitmap_head *forward_dependency_cache;
-#endif
-
static int deps_may_trap_p (rtx);
static void add_dependence_list (rtx, rtx, int, enum reg_note);
static void add_dependence_list_and_free (rtx, rtx *, int, enum reg_note);
static rtx sched_get_condition (rtx);
static int conditions_mutex_p (rtx, rtx);
-static enum DEPS_ADJUST_RESULT maybe_add_or_update_back_dep_1 (rtx, rtx,
- enum reg_note, ds_t, rtx, rtx, dep_link_t **);
-static enum DEPS_ADJUST_RESULT add_or_update_back_dep_1 (rtx, rtx,
- enum reg_note, ds_t, rtx, rtx, dep_link_t **);
-static void add_back_dep (rtx, rtx, enum reg_note, ds_t);
+static enum DEPS_ADJUST_RESULT maybe_add_or_update_dep_1 (dep_t, bool,
+ rtx, rtx);
+static enum DEPS_ADJUST_RESULT add_or_update_dep_1 (dep_t, bool, rtx, rtx);
-static void adjust_add_sorted_back_dep (rtx, dep_link_t, dep_link_t *);
-static void adjust_back_add_forw_dep (rtx, dep_link_t *);
-static void delete_forw_dep (dep_link_t);
static dw_t estimate_dep_weak (rtx, rtx);
#ifdef INSN_SCHEDULING
#ifdef ENABLE_CHECKING
-static void check_dep_status (enum reg_note, ds_t, bool);
+static void check_dep (dep_t, bool);
#endif
#endif
\f
{
rtx cond1, cond2;
- /* flow.c doesn't handle conditional lifetimes entirely correctly;
+ /* df doesn't handle conditional lifetimes entirely correctly;
calls mess up the conditional lifetimes. */
if (!CALL_P (insn1) && !CALL_P (insn2))
{
return false;
}
\f
-/* Add ELEM wrapped in an dep_link with reg note kind DEP_TYPE to the
- INSN_BACK_DEPS (INSN), if it is not already there. DEP_TYPE indicates the
- type of dependence that this link represents. DS, if nonzero,
- indicates speculations, through which this dependence can be overcome.
- MEM1 and MEM2, if non-null, corresponds to memory locations in case of
- data speculation. The function returns a value indicating if an old entry
- has been changed or a new entry has been added to insn's backward deps.
- In case of changed entry CHANGED_LINKPP sets to its address.
- See also the definition of enum DEPS_ADJUST_RESULT in sched-int.h.
- Actual manipulation of dependence data structures is performed in
- add_or_update_back_dep_1. */
+/* Initialize LIST_PTR to point to one of the lists present in TYPES_PTR,
+ initialize RESOLVED_P_PTR with true if that list consists of resolved deps,
+ and remove the type of returned [through LIST_PTR] list from TYPES_PTR.
+ This function is used to switch sd_iterator to the next list.
+ !!! For internal use only. Might consider moving it to sched-int.h. */
+void
+sd_next_list (rtx insn, sd_list_types_def *types_ptr,
+ deps_list_t *list_ptr, bool *resolved_p_ptr)
+{
+ sd_list_types_def types = *types_ptr;
+
+ if (types & SD_LIST_HARD_BACK)
+ {
+ *list_ptr = INSN_HARD_BACK_DEPS (insn);
+ *resolved_p_ptr = false;
+ *types_ptr = types & ~SD_LIST_HARD_BACK;
+ }
+ else if (types & SD_LIST_SPEC_BACK)
+ {
+ *list_ptr = INSN_SPEC_BACK_DEPS (insn);
+ *resolved_p_ptr = false;
+ *types_ptr = types & ~SD_LIST_SPEC_BACK;
+ }
+ else if (types & SD_LIST_FORW)
+ {
+ *list_ptr = INSN_FORW_DEPS (insn);
+ *resolved_p_ptr = false;
+ *types_ptr = types & ~SD_LIST_FORW;
+ }
+ else if (types & SD_LIST_RES_BACK)
+ {
+ *list_ptr = INSN_RESOLVED_BACK_DEPS (insn);
+ *resolved_p_ptr = true;
+ *types_ptr = types & ~SD_LIST_RES_BACK;
+ }
+ else if (types & SD_LIST_RES_FORW)
+ {
+ *list_ptr = INSN_RESOLVED_FORW_DEPS (insn);
+ *resolved_p_ptr = true;
+ *types_ptr = types & ~SD_LIST_RES_FORW;
+ }
+ else
+ {
+ *list_ptr = NULL;
+ *resolved_p_ptr = false;
+ *types_ptr = SD_LIST_NONE;
+ }
+}
+
+/* Return the summary size of INSN's lists defined by LIST_TYPES. */
+int
+sd_lists_size (rtx insn, sd_list_types_def list_types)
+{
+ int size = 0;
+
+ while (list_types != SD_LIST_NONE)
+ {
+ deps_list_t list;
+ bool resolved_p;
+
+ sd_next_list (insn, &list_types, &list, &resolved_p);
+ size += DEPS_LIST_N_LINKS (list);
+ }
+
+ return size;
+}
+
+/* Return true if INSN's lists defined by LIST_TYPES are all empty. */
+bool
+sd_lists_empty_p (rtx insn, sd_list_types_def list_types)
+{
+ return sd_lists_size (insn, list_types) == 0;
+}
+
+/* Initialize data for INSN. */
+void
+sd_init_insn (rtx insn)
+{
+ INSN_HARD_BACK_DEPS (insn) = create_deps_list ();
+ INSN_SPEC_BACK_DEPS (insn) = create_deps_list ();
+ INSN_RESOLVED_BACK_DEPS (insn) = create_deps_list ();
+ INSN_FORW_DEPS (insn) = create_deps_list ();
+ INSN_RESOLVED_FORW_DEPS (insn) = create_deps_list ();
+
+ /* ??? It would be nice to allocate dependency caches here. */
+}
+
+/* Free data for INSN. */
+void
+sd_finish_insn (rtx insn)
+{
+ /* ??? It would be nice to deallocate dependency caches here. */
+
+ free_deps_list (INSN_HARD_BACK_DEPS (insn));
+ INSN_HARD_BACK_DEPS (insn) = NULL;
+
+ free_deps_list (INSN_SPEC_BACK_DEPS (insn));
+ INSN_SPEC_BACK_DEPS (insn) = NULL;
+
+ free_deps_list (INSN_RESOLVED_BACK_DEPS (insn));
+ INSN_RESOLVED_BACK_DEPS (insn) = NULL;
+
+ free_deps_list (INSN_FORW_DEPS (insn));
+ INSN_FORW_DEPS (insn) = NULL;
+
+ free_deps_list (INSN_RESOLVED_FORW_DEPS (insn));
+ INSN_RESOLVED_FORW_DEPS (insn) = NULL;
+}
+
+/* Find a dependency between producer PRO and consumer CON.
+ Search through resolved dependency lists if RESOLVED_P is true.
+ If no such dependency is found return NULL,
+ overwise return the dependency and initialize SD_IT_PTR [if it is nonnull]
+ with an iterator pointing to it. */
+static dep_t
+sd_find_dep_between_no_cache (rtx pro, rtx con, bool resolved_p,
+ sd_iterator_def *sd_it_ptr)
+{
+ sd_list_types_def pro_list_type;
+ sd_list_types_def con_list_type;
+ sd_iterator_def sd_it;
+ dep_t dep;
+ bool found_p = false;
+
+ if (resolved_p)
+ {
+ pro_list_type = SD_LIST_RES_FORW;
+ con_list_type = SD_LIST_RES_BACK;
+ }
+ else
+ {
+ pro_list_type = SD_LIST_FORW;
+ con_list_type = SD_LIST_BACK;
+ }
+
+ /* Walk through either back list of INSN or forw list of ELEM
+ depending on which one is shorter. */
+ if (sd_lists_size (con, con_list_type) < sd_lists_size (pro, pro_list_type))
+ {
+ /* Find the dep_link with producer PRO in consumer's back_deps. */
+ FOR_EACH_DEP (con, con_list_type, sd_it, dep)
+ if (DEP_PRO (dep) == pro)
+ {
+ found_p = true;
+ break;
+ }
+ }
+ else
+ {
+ /* Find the dep_link with consumer CON in producer's forw_deps. */
+ FOR_EACH_DEP (pro, pro_list_type, sd_it, dep)
+ if (DEP_CON (dep) == con)
+ {
+ found_p = true;
+ break;
+ }
+ }
+
+ if (found_p)
+ {
+ if (sd_it_ptr != NULL)
+ *sd_it_ptr = sd_it;
+
+ return dep;
+ }
+
+ return NULL;
+}
+
+/* Find a dependency between producer PRO and consumer CON.
+ Use dependency [if available] to check if dependency is present at all.
+ Search through resolved dependency lists if RESOLVED_P is true.
+ If the dependency or NULL if none found. */
+dep_t
+sd_find_dep_between (rtx pro, rtx con, bool resolved_p)
+{
+ if (true_dependency_cache != NULL)
+ /* Avoiding the list walk below can cut compile times dramatically
+ for some code. */
+ {
+ int elem_luid = INSN_LUID (pro);
+ int insn_luid = INSN_LUID (con);
+
+ gcc_assert (output_dependency_cache != NULL
+ && anti_dependency_cache != NULL);
+
+ if (!bitmap_bit_p (&true_dependency_cache[insn_luid], elem_luid)
+ && !bitmap_bit_p (&output_dependency_cache[insn_luid], elem_luid)
+ && !bitmap_bit_p (&anti_dependency_cache[insn_luid], elem_luid))
+ return NULL;
+ }
+
+ return sd_find_dep_between_no_cache (pro, con, resolved_p, NULL);
+}
+
+/* Add or update a dependence described by DEP.
+ MEM1 and MEM2, if non-null, correspond to memory locations in case of
+ data speculation.
+
+ The function returns a value indicating if an old entry has been changed
+ or a new entry has been added to insn's backward deps.
+
+ This function merely checks if producer and consumer is the same insn
+ and doesn't create a dep in this case. Actual manipulation of
+ dependence data structures is performed in add_or_update_dep_1. */
static enum DEPS_ADJUST_RESULT
-maybe_add_or_update_back_dep_1 (rtx insn, rtx elem, enum reg_note dep_type,
- ds_t ds, rtx mem1, rtx mem2,
- dep_link_t **changed_linkpp)
+maybe_add_or_update_dep_1 (dep_t dep, bool resolved_p, rtx mem1, rtx mem2)
{
+ rtx elem = DEP_PRO (dep);
+ rtx insn = DEP_CON (dep);
+
gcc_assert (INSN_P (insn) && INSN_P (elem));
/* Don't depend an insn on itself. */
/* INSN has an internal dependence, which we can't overcome. */
HAS_INTERNAL_DEP (insn) = 1;
#endif
- return 0;
+
+ return DEP_NODEP;
}
- return add_or_update_back_dep_1 (insn, elem, dep_type,
- ds, mem1, mem2, changed_linkpp);
+ return add_or_update_dep_1 (dep, resolved_p, mem1, mem2);
}
-/* This function has the same meaning of parameters and return values
- as maybe_add_or_update_back_dep_1. The only difference between these
- two functions is that INSN and ELEM are guaranteed not to be the same
- in this one. */
+#ifdef INSN_SCHEDULING
+/* Ask dependency caches what needs to be done for dependence DEP.
+ Return DEP_CREATED if new dependence should be created and there is no
+ need to try to find one searching the dependencies lists.
+ Return DEP_PRESENT if there already is a dependence described by DEP and
+ hence nothing is to be done.
+ Return DEP_CHANGED if there already is a dependence, but it should be
+ updated to incorporate additional information from DEP. */
static enum DEPS_ADJUST_RESULT
-add_or_update_back_dep_1 (rtx insn, rtx elem, enum reg_note dep_type,
- ds_t ds ATTRIBUTE_UNUSED,
- rtx mem1 ATTRIBUTE_UNUSED, rtx mem2 ATTRIBUTE_UNUSED,
- dep_link_t **changed_linkpp ATTRIBUTE_UNUSED)
+ask_dependency_caches (dep_t dep)
{
- bool maybe_present_p = true, present_p = false;
+ int elem_luid = INSN_LUID (DEP_PRO (dep));
+ int insn_luid = INSN_LUID (DEP_CON (dep));
- gcc_assert (INSN_P (insn) && INSN_P (elem) && insn != elem);
-
-#ifdef INSN_SCHEDULING
+ gcc_assert (true_dependency_cache != NULL
+ && output_dependency_cache != NULL
+ && anti_dependency_cache != NULL);
-#ifdef ENABLE_CHECKING
- check_dep_status (dep_type, ds, mem1 != NULL);
-#endif
+ if (!(current_sched_info->flags & USE_DEPS_LIST))
+ {
+ enum reg_note present_dep_type;
+
+ if (bitmap_bit_p (&true_dependency_cache[insn_luid], elem_luid))
+ present_dep_type = REG_DEP_TRUE;
+ else if (bitmap_bit_p (&output_dependency_cache[insn_luid], elem_luid))
+ present_dep_type = REG_DEP_OUTPUT;
+ else if (bitmap_bit_p (&anti_dependency_cache[insn_luid], elem_luid))
+ present_dep_type = REG_DEP_ANTI;
+ else
+ /* There is no existing dep so it should be created. */
+ return DEP_CREATED;
+
+ if ((int) DEP_TYPE (dep) >= (int) present_dep_type)
+ /* DEP does not add anything to the existing dependence. */
+ return DEP_PRESENT;
+ }
+ else
+ {
+ ds_t present_dep_types = 0;
+
+ if (bitmap_bit_p (&true_dependency_cache[insn_luid], elem_luid))
+ present_dep_types |= DEP_TRUE;
+ if (bitmap_bit_p (&output_dependency_cache[insn_luid], elem_luid))
+ present_dep_types |= DEP_OUTPUT;
+ if (bitmap_bit_p (&anti_dependency_cache[insn_luid], elem_luid))
+ present_dep_types |= DEP_ANTI;
+
+ if (present_dep_types == 0)
+ /* There is no existing dep so it should be created. */
+ return DEP_CREATED;
+
+ if (!(current_sched_info->flags & DO_SPECULATION)
+ || !bitmap_bit_p (&spec_dependency_cache[insn_luid], elem_luid))
+ {
+ if ((present_dep_types | (DEP_STATUS (dep) & DEP_TYPES))
+ == present_dep_types)
+ /* DEP does not add anything to the existing dependence. */
+ return DEP_PRESENT;
+ }
+ else
+ {
+ /* Only true dependencies can be data speculative and
+ only anti dependencies can be control speculative. */
+ gcc_assert ((present_dep_types & (DEP_TRUE | DEP_ANTI))
+ == present_dep_types);
+
+ /* if (DEP is SPECULATIVE) then
+ ..we should update DEP_STATUS
+ else
+ ..we should reset existing dep to non-speculative. */
+ }
+ }
+
+ return DEP_CHANGED;
+}
+
+/* Set dependency caches according to DEP. */
+static void
+set_dependency_caches (dep_t dep)
+{
+ int elem_luid = INSN_LUID (DEP_PRO (dep));
+ int insn_luid = INSN_LUID (DEP_CON (dep));
+
+ if (!(current_sched_info->flags & USE_DEPS_LIST))
+ {
+ switch (DEP_TYPE (dep))
+ {
+ case REG_DEP_TRUE:
+ bitmap_set_bit (&true_dependency_cache[insn_luid], elem_luid);
+ break;
+
+ case REG_DEP_OUTPUT:
+ bitmap_set_bit (&output_dependency_cache[insn_luid], elem_luid);
+ break;
+
+ case REG_DEP_ANTI:
+ bitmap_set_bit (&anti_dependency_cache[insn_luid], elem_luid);
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+ }
+ else
+ {
+ ds_t ds = DEP_STATUS (dep);
+
+ if (ds & DEP_TRUE)
+ bitmap_set_bit (&true_dependency_cache[insn_luid], elem_luid);
+ if (ds & DEP_OUTPUT)
+ bitmap_set_bit (&output_dependency_cache[insn_luid], elem_luid);
+ if (ds & DEP_ANTI)
+ bitmap_set_bit (&anti_dependency_cache[insn_luid], elem_luid);
+
+ if (ds & SPECULATIVE)
+ {
+ gcc_assert (current_sched_info->flags & DO_SPECULATION);
+ bitmap_set_bit (&spec_dependency_cache[insn_luid], elem_luid);
+ }
+ }
+}
+
+/* Type of dependence DEP have changed from OLD_TYPE. Update dependency
+ caches accordingly. */
+static void
+update_dependency_caches (dep_t dep, enum reg_note old_type)
+{
+ int elem_luid = INSN_LUID (DEP_PRO (dep));
+ int insn_luid = INSN_LUID (DEP_CON (dep));
+
+ /* Clear corresponding cache entry because type of the link
+ may have changed. Keep them if we use_deps_list. */
+ if (!(current_sched_info->flags & USE_DEPS_LIST))
+ {
+ switch (old_type)
+ {
+ case REG_DEP_OUTPUT:
+ bitmap_clear_bit (&output_dependency_cache[insn_luid], elem_luid);
+ break;
+
+ case REG_DEP_ANTI:
+ bitmap_clear_bit (&anti_dependency_cache[insn_luid], elem_luid);
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+ }
+
+ set_dependency_caches (dep);
+}
+
+/* Convert a dependence pointed to by SD_IT to be non-speculative. */
+static void
+change_spec_dep_to_hard (sd_iterator_def sd_it)
+{
+ dep_node_t node = DEP_LINK_NODE (*sd_it.linkp);
+ dep_link_t link = DEP_NODE_BACK (node);
+ dep_t dep = DEP_NODE_DEP (node);
+ rtx elem = DEP_PRO (dep);
+ rtx insn = DEP_CON (dep);
+
+ move_dep_link (link, INSN_SPEC_BACK_DEPS (insn), INSN_HARD_BACK_DEPS (insn));
+
+ DEP_STATUS (dep) &= ~SPECULATIVE;
- /* If we already have a dependency for ELEM, then we do not need to
- do anything. Avoiding the list walk below can cut compile times
- dramatically for some code. */
if (true_dependency_cache != NULL)
+ /* Clear the cache entry. */
+ bitmap_clear_bit (&spec_dependency_cache[INSN_LUID (insn)],
+ INSN_LUID (elem));
+}
+#endif
+
+/* Update DEP to incorporate information from NEW_DEP.
+ SD_IT points to DEP in case it should be moved to another list.
+ MEM1 and MEM2, if nonnull, correspond to memory locations in case if
+ data-speculative dependence should be updated. */
+static enum DEPS_ADJUST_RESULT
+update_dep (dep_t dep, dep_t new_dep,
+ sd_iterator_def sd_it, rtx mem1, rtx mem2)
+{
+ enum DEPS_ADJUST_RESULT res = DEP_PRESENT;
+ enum reg_note old_type = DEP_TYPE (dep);
+
+ /* If this is a more restrictive type of dependence than the
+ existing one, then change the existing dependence to this
+ type. */
+ if ((int) DEP_TYPE (new_dep) < (int) old_type)
{
- enum reg_note present_dep_type;
-
- gcc_assert (output_dependency_cache);
- gcc_assert (anti_dependency_cache);
- if (!(current_sched_info->flags & USE_DEPS_LIST))
- {
- if (bitmap_bit_p (&true_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem)))
- present_dep_type = REG_DEP_TRUE;
- else if (bitmap_bit_p (&output_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem)))
- present_dep_type = REG_DEP_OUTPUT;
- else if (bitmap_bit_p (&anti_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem)))
- present_dep_type = REG_DEP_ANTI;
- else
- maybe_present_p = false;
-
- if (maybe_present_p)
+ DEP_TYPE (dep) = DEP_TYPE (new_dep);
+ res = DEP_CHANGED;
+ }
+
+#ifdef INSN_SCHEDULING
+ if (current_sched_info->flags & USE_DEPS_LIST)
+ /* Update DEP_STATUS. */
+ {
+ ds_t dep_status = DEP_STATUS (dep);
+ ds_t ds = DEP_STATUS (new_dep);
+ ds_t new_status = ds | dep_status;
+
+ if (new_status & SPECULATIVE)
+ /* Either existing dep or a dep we're adding or both are
+ speculative. */
+ {
+ if (!(ds & SPECULATIVE)
+ || !(dep_status & SPECULATIVE))
+ /* The new dep can't be speculative. */
{
- if ((int) dep_type >= (int) present_dep_type)
- return DEP_PRESENT;
-
- present_p = true;
+ new_status &= ~SPECULATIVE;
+
+ if (dep_status & SPECULATIVE)
+ /* The old dep was speculative, but now it
+ isn't. */
+ change_spec_dep_to_hard (sd_it);
}
- }
- else
- {
- ds_t present_dep_types = 0;
-
- if (bitmap_bit_p (&true_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem)))
- present_dep_types |= DEP_TRUE;
- if (bitmap_bit_p (&output_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem)))
- present_dep_types |= DEP_OUTPUT;
- if (bitmap_bit_p (&anti_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem)))
- present_dep_types |= DEP_ANTI;
-
- if (present_dep_types)
+ else
{
- if (!(current_sched_info->flags & DO_SPECULATION)
- || !bitmap_bit_p (&spec_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem)))
+ /* Both are speculative. Merge probabilities. */
+ if (mem1 != NULL)
{
- if ((present_dep_types | (ds & DEP_TYPES))
- == present_dep_types)
- /* We already have all these bits. */
- return DEP_PRESENT;
- }
- else
- {
- /* Only true dependencies can be data speculative and
- only anti dependencies can be control speculative. */
- gcc_assert ((present_dep_types & (DEP_TRUE | DEP_ANTI))
- == present_dep_types);
-
- /* if (additional dep is SPECULATIVE) then
- we should update DEP_STATUS
- else
- we should reset existing dep to non-speculative. */
+ dw_t dw;
+
+ dw = estimate_dep_weak (mem1, mem2);
+ ds = set_dep_weak (ds, BEGIN_DATA, dw);
}
-
- present_p = true;
+
+ new_status = ds_merge (dep_status, ds);
}
- else
- maybe_present_p = false;
- }
+ }
+
+ ds = new_status;
+
+ if (dep_status != ds)
+ {
+ DEP_STATUS (dep) = ds;
+ res = DEP_CHANGED;
+ }
+ }
+
+ if (true_dependency_cache != NULL
+ && res == DEP_CHANGED)
+ update_dependency_caches (dep, old_type);
+#endif
+
+ return res;
+}
+
+/* Add or update a dependence described by DEP.
+ MEM1 and MEM2, if non-null, correspond to memory locations in case of
+ data speculation.
+
+ The function returns a value indicating if an old entry has been changed
+ or a new entry has been added to insn's backward deps or nothing has
+ been updated at all. */
+static enum DEPS_ADJUST_RESULT
+add_or_update_dep_1 (dep_t new_dep, bool resolved_p,
+ rtx mem1 ATTRIBUTE_UNUSED, rtx mem2 ATTRIBUTE_UNUSED)
+{
+ bool maybe_present_p = true;
+ bool present_p = false;
+
+ gcc_assert (INSN_P (DEP_PRO (new_dep)) && INSN_P (DEP_CON (new_dep))
+ && DEP_PRO (new_dep) != DEP_CON (new_dep));
+
+#ifdef INSN_SCHEDULING
+
+#ifdef ENABLE_CHECKING
+ check_dep (new_dep, mem1 != NULL);
+#endif
+
+ if (true_dependency_cache != NULL)
+ {
+ switch (ask_dependency_caches (new_dep))
+ {
+ case DEP_PRESENT:
+ return DEP_PRESENT;
+
+ case DEP_CHANGED:
+ maybe_present_p = true;
+ present_p = true;
+ break;
+
+ case DEP_CREATED:
+ maybe_present_p = false;
+ present_p = false;
+ break;
+
+ default:
+ gcc_unreachable ();
+ break;
+ }
}
#endif
/* Check that we don't already have this dependence. */
if (maybe_present_p)
{
- dep_link_t *linkp;
-
- for (linkp = &DEPS_LIST_FIRST (INSN_BACK_DEPS (insn));
- *linkp != NULL;
- linkp = &DEP_LINK_NEXT (*linkp))
- {
- dep_t link = DEP_LINK_DEP (*linkp);
-
- gcc_assert (true_dependency_cache == 0 || present_p);
-
- if (DEP_PRO (link) == elem)
- {
- enum DEPS_ADJUST_RESULT changed_p = DEP_PRESENT;
-
-#ifdef INSN_SCHEDULING
- if (current_sched_info->flags & USE_DEPS_LIST)
- {
- ds_t new_status = ds | DEP_STATUS (link);
-
- if (new_status & SPECULATIVE)
- {
- if (!(ds & SPECULATIVE)
- || !(DEP_STATUS (link) & SPECULATIVE))
- /* Then this dep can't be speculative. */
- {
- new_status &= ~SPECULATIVE;
- if (true_dependency_cache
- && (DEP_STATUS (link) & SPECULATIVE))
- bitmap_clear_bit (&spec_dependency_cache
- [INSN_LUID (insn)],
- INSN_LUID (elem));
- }
- else
- {
- /* Both are speculative. Merging probabilities. */
- if (mem1)
- {
- dw_t dw;
-
- dw = estimate_dep_weak (mem1, mem2);
- ds = set_dep_weak (ds, BEGIN_DATA, dw);
- }
-
- new_status = ds_merge (DEP_STATUS (link), ds);
- }
- }
+ dep_t present_dep;
+ sd_iterator_def sd_it;
- ds = new_status;
- }
+ gcc_assert (true_dependency_cache == NULL || present_p);
- /* Clear corresponding cache entry because type of the link
- may have changed. Keep them if we use_deps_list. */
- if (true_dependency_cache != NULL
- && !(current_sched_info->flags & USE_DEPS_LIST))
- {
- enum reg_note kind = DEP_KIND (link);
-
- switch (kind)
- {
- case REG_DEP_OUTPUT:
- bitmap_clear_bit (&output_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- break;
- case REG_DEP_ANTI:
- bitmap_clear_bit (&anti_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- break;
- default:
- gcc_unreachable ();
- }
- }
-
- if ((current_sched_info->flags & USE_DEPS_LIST)
- && DEP_STATUS (link) != ds)
- {
- DEP_STATUS (link) = ds;
- changed_p = DEP_CHANGED;
- }
-#endif
+ present_dep = sd_find_dep_between_no_cache (DEP_PRO (new_dep),
+ DEP_CON (new_dep),
+ resolved_p, &sd_it);
- /* If this is a more restrictive type of dependence than the
- existing one, then change the existing dependence to this
- type. */
- if ((int) dep_type < (int) DEP_KIND (link))
- {
- DEP_KIND (link) = dep_type;
- changed_p = DEP_CHANGED;
- }
-
-#ifdef INSN_SCHEDULING
- /* If we are adding a dependency to INSN's LOG_LINKs, then
- note that in the bitmap caches of dependency information. */
- if (true_dependency_cache != NULL)
- {
- if (!(current_sched_info->flags & USE_DEPS_LIST))
- {
- if (DEP_KIND (link) == REG_DEP_TRUE)
- bitmap_set_bit (&true_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- else if (DEP_KIND (link) == REG_DEP_OUTPUT)
- bitmap_set_bit (&output_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- else if (DEP_KIND (link) == REG_DEP_ANTI)
- bitmap_set_bit (&anti_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- }
- else
- {
- if (ds & DEP_TRUE)
- bitmap_set_bit (&true_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- if (ds & DEP_OUTPUT)
- bitmap_set_bit (&output_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- if (ds & DEP_ANTI)
- bitmap_set_bit (&anti_dependency_cache
- [INSN_LUID (insn)], INSN_LUID (elem));
- /* Note, that dep can become speculative only
- at the moment of creation. Thus, we don't need to
- check for it here. */
- }
- }
-
- if (changed_linkpp && changed_p == DEP_CHANGED)
- *changed_linkpp = linkp;
-#endif
- return changed_p;
- }
- }
- /* We didn't find a dep. It shouldn't be present in the cache. */
- gcc_assert (!present_p);
+ if (present_dep != NULL)
+ /* We found an existing dependency between ELEM and INSN. */
+ return update_dep (present_dep, new_dep, sd_it, mem1, mem2);
+ else
+ /* We didn't find a dep, it shouldn't present in the cache. */
+ gcc_assert (!present_p);
}
/* Might want to check one level of transitivity to save conses.
- This check should be done in maybe_add_or_update_back_dep_1.
- Since we made it to add_or_update_back_dep_1, we must create
+ This check should be done in maybe_add_or_update_dep_1.
+ Since we made it to add_or_update_dep_1, we must create
(or update) a link. */
- if (mem1)
+ if (mem1 != NULL_RTX)
{
gcc_assert (current_sched_info->flags & DO_SPECULATION);
- ds = set_dep_weak (ds, BEGIN_DATA, estimate_dep_weak (mem1, mem2));
+ DEP_STATUS (new_dep) = set_dep_weak (DEP_STATUS (new_dep), BEGIN_DATA,
+ estimate_dep_weak (mem1, mem2));
}
-
- add_back_dep (insn, elem, dep_type, ds);
+
+ sd_add_dep (new_dep, resolved_p);
return DEP_CREATED;
}
-/* This function creates a link between INSN and ELEM under any
- conditions. DS describes speculative status of the link. */
+/* Initialize BACK_LIST_PTR with consumer's backward list and
+ FORW_LIST_PTR with producer's forward list. If RESOLVED_P is true
+ initialize with lists that hold resolved deps. */
static void
-add_back_dep (rtx insn, rtx elem, enum reg_note dep_type, ds_t ds)
+get_back_and_forw_lists (dep_t dep, bool resolved_p,
+ deps_list_t *back_list_ptr,
+ deps_list_t *forw_list_ptr)
{
- struct _dep _dep, *dep = &_dep;
+ rtx con = DEP_CON (dep);
- gcc_assert (INSN_P (insn) && INSN_P (elem) && insn != elem);
+ if (!resolved_p)
+ {
+ if ((current_sched_info->flags & DO_SPECULATION)
+ && (DEP_STATUS (dep) & SPECULATIVE))
+ *back_list_ptr = INSN_SPEC_BACK_DEPS (con);
+ else
+ *back_list_ptr = INSN_HARD_BACK_DEPS (con);
- if (current_sched_info->flags & USE_DEPS_LIST)
- init_dep_1 (dep, elem, insn, dep_type, ds);
+ *forw_list_ptr = INSN_FORW_DEPS (DEP_PRO (dep));
+ }
else
- init_dep_1 (dep, elem, insn, dep_type, -1);
+ {
+ *back_list_ptr = INSN_RESOLVED_BACK_DEPS (con);
+ *forw_list_ptr = INSN_RESOLVED_FORW_DEPS (DEP_PRO (dep));
+ }
+}
+
+/* Add dependence described by DEP.
+ If RESOLVED_P is true treat the dependence as a resolved one. */
+void
+sd_add_dep (dep_t dep, bool resolved_p)
+{
+ dep_node_t n = create_dep_node ();
+ deps_list_t con_back_deps;
+ deps_list_t pro_forw_deps;
+ rtx elem = DEP_PRO (dep);
+ rtx insn = DEP_CON (dep);
+
+ gcc_assert (INSN_P (insn) && INSN_P (elem) && insn != elem);
- add_back_dep_to_deps_list (INSN_BACK_DEPS (insn), dep);
+ if ((current_sched_info->flags & DO_SPECULATION)
+ && !sched_insn_is_legitimate_for_speculation_p (insn, DEP_STATUS (dep)))
+ DEP_STATUS (dep) &= ~SPECULATIVE;
+
+ copy_dep (DEP_NODE_DEP (n), dep);
+
+ get_back_and_forw_lists (dep, resolved_p, &con_back_deps, &pro_forw_deps);
+
+ add_to_deps_list (DEP_NODE_BACK (n), con_back_deps);
#ifdef INSN_SCHEDULING
#ifdef ENABLE_CHECKING
- check_dep_status (dep_type, ds, false);
+ check_dep (dep, false);
#endif
+ add_to_deps_list (DEP_NODE_FORW (n), pro_forw_deps);
+
/* If we are adding a dependency to INSN's LOG_LINKs, then note that
in the bitmap caches of dependency information. */
if (true_dependency_cache != NULL)
+ set_dependency_caches (dep);
+#endif
+}
+
+/* Add or update backward dependence between INSN and ELEM
+ with given type DEP_TYPE and dep_status DS.
+ This function is a convenience wrapper. */
+enum DEPS_ADJUST_RESULT
+sd_add_or_update_dep (dep_t dep, bool resolved_p)
+{
+ return add_or_update_dep_1 (dep, resolved_p, NULL_RTX, NULL_RTX);
+}
+
+/* Resolved dependence pointed to by SD_IT.
+ SD_IT will advance to the next element. */
+void
+sd_resolve_dep (sd_iterator_def sd_it)
+{
+ dep_node_t node = DEP_LINK_NODE (*sd_it.linkp);
+ dep_t dep = DEP_NODE_DEP (node);
+ rtx pro = DEP_PRO (dep);
+ rtx con = DEP_CON (dep);
+
+ if ((current_sched_info->flags & DO_SPECULATION)
+ && (DEP_STATUS (dep) & SPECULATIVE))
+ move_dep_link (DEP_NODE_BACK (node), INSN_SPEC_BACK_DEPS (con),
+ INSN_RESOLVED_BACK_DEPS (con));
+ else
+ move_dep_link (DEP_NODE_BACK (node), INSN_HARD_BACK_DEPS (con),
+ INSN_RESOLVED_BACK_DEPS (con));
+
+ move_dep_link (DEP_NODE_FORW (node), INSN_FORW_DEPS (pro),
+ INSN_RESOLVED_FORW_DEPS (pro));
+}
+
+/* Make TO depend on all the FROM's producers.
+ If RESOLVED_P is true add dependencies to the resolved lists. */
+void
+sd_copy_back_deps (rtx to, rtx from, bool resolved_p)
+{
+ sd_list_types_def list_type;
+ sd_iterator_def sd_it;
+ dep_t dep;
+
+ list_type = resolved_p ? SD_LIST_RES_BACK : SD_LIST_BACK;
+
+ FOR_EACH_DEP (from, list_type, sd_it, dep)
{
- if (!(current_sched_info->flags & USE_DEPS_LIST))
- {
- if (dep_type == REG_DEP_TRUE)
- bitmap_set_bit (&true_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem));
- else if (dep_type == REG_DEP_OUTPUT)
- bitmap_set_bit (&output_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem));
- else if (dep_type == REG_DEP_ANTI)
- bitmap_set_bit (&anti_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem));
- }
- else
- {
- if (ds & DEP_TRUE)
- bitmap_set_bit (&true_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem));
- if (ds & DEP_OUTPUT)
- bitmap_set_bit (&output_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem));
- if (ds & DEP_ANTI)
- bitmap_set_bit (&anti_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem));
- if (ds & SPECULATIVE)
- {
- gcc_assert (current_sched_info->flags & DO_SPECULATION);
- bitmap_set_bit (&spec_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (elem));
- }
- }
+ dep_def _new_dep, *new_dep = &_new_dep;
+
+ copy_dep (new_dep, dep);
+ DEP_CON (new_dep) = to;
+ sd_add_dep (new_dep, resolved_p);
}
-#endif
+}
+
+/* Remove a dependency referred to by SD_IT.
+ SD_IT will point to the next dependence after removal. */
+void
+sd_delete_dep (sd_iterator_def sd_it)
+{
+ dep_node_t n = DEP_LINK_NODE (*sd_it.linkp);
+ dep_t dep = DEP_NODE_DEP (n);
+ rtx pro = DEP_PRO (dep);
+ rtx con = DEP_CON (dep);
+ deps_list_t con_back_deps;
+ deps_list_t pro_forw_deps;
+
+ if (true_dependency_cache != NULL)
+ {
+ int elem_luid = INSN_LUID (pro);
+ int insn_luid = INSN_LUID (con);
+
+ bitmap_clear_bit (&true_dependency_cache[insn_luid], elem_luid);
+ bitmap_clear_bit (&anti_dependency_cache[insn_luid], elem_luid);
+ bitmap_clear_bit (&output_dependency_cache[insn_luid], elem_luid);
+
+ if (current_sched_info->flags & DO_SPECULATION)
+ bitmap_clear_bit (&spec_dependency_cache[insn_luid], elem_luid);
+ }
+
+ get_back_and_forw_lists (dep, sd_it.resolved_p,
+ &con_back_deps, &pro_forw_deps);
+
+ remove_from_deps_list (DEP_NODE_BACK (n), con_back_deps);
+ remove_from_deps_list (DEP_NODE_FORW (n), pro_forw_deps);
+
+ delete_dep_node (n);
+}
+
+/* Dump size of the lists. */
+#define DUMP_LISTS_SIZE (2)
+
+/* Dump dependencies of the lists. */
+#define DUMP_LISTS_DEPS (4)
+
+/* Dump all information about the lists. */
+#define DUMP_LISTS_ALL (DUMP_LISTS_SIZE | DUMP_LISTS_DEPS)
+
+/* Dump deps_lists of INSN specified by TYPES to DUMP.
+ FLAGS is a bit mask specifying what information about the lists needs
+ to be printed.
+ If FLAGS has the very first bit set, then dump all information about
+ the lists and propagate this bit into the callee dump functions. */
+static void
+dump_lists (FILE *dump, rtx insn, sd_list_types_def types, int flags)
+{
+ sd_iterator_def sd_it;
+ dep_t dep;
+ int all;
+
+ all = (flags & 1);
+
+ if (all)
+ flags |= DUMP_LISTS_ALL;
+
+ fprintf (dump, "[");
+
+ if (flags & DUMP_LISTS_SIZE)
+ fprintf (dump, "%d; ", sd_lists_size (insn, types));
+
+ if (flags & DUMP_LISTS_DEPS)
+ {
+ FOR_EACH_DEP (insn, types, sd_it, dep)
+ {
+ dump_dep (dump, dep, dump_dep_flags | all);
+ fprintf (dump, " ");
+ }
+ }
+}
+
+/* Dump all information about deps_lists of INSN specified by TYPES
+ to STDERR. */
+void
+sd_debug_lists (rtx insn, sd_list_types_def types)
+{
+ dump_lists (stderr, insn, types, 1);
+ fprintf (stderr, "\n");
}
/* A convenience wrapper to operate on an entire list. */
}
/* Clear all dependencies for an insn. */
-
static void
delete_all_dependences (rtx insn)
{
- /* Clear caches, if they exist, as well as free the dependence. */
+ sd_iterator_def sd_it;
+ dep_t dep;
-#ifdef INSN_SCHEDULING
- if (true_dependency_cache != NULL)
- {
- bitmap_clear (&true_dependency_cache[INSN_LUID (insn)]);
- bitmap_clear (&output_dependency_cache[INSN_LUID (insn)]);
- bitmap_clear (&anti_dependency_cache[INSN_LUID (insn)]);
- /* We don't have to clear forward_dependency_cache here,
- because it is formed later. */
- if (current_sched_info->flags & DO_SPECULATION)
- bitmap_clear (&spec_dependency_cache[INSN_LUID (insn)]);
- }
-#endif
+ /* The below cycle can be optimized to clear the caches and back_deps
+ in one call but that would provoke duplication of code from
+ delete_dep (). */
- clear_deps_list (INSN_BACK_DEPS (insn));
+ for (sd_it = sd_iterator_start (insn, SD_LIST_BACK);
+ sd_iterator_cond (&sd_it, &dep);)
+ sd_delete_dep (sd_it);
}
/* All insns in a scheduling group except the first should only have
static void
fixup_sched_groups (rtx insn)
{
- dep_link_t link;
+ sd_iterator_def sd_it;
+ dep_t dep;
rtx prev_nonnote;
- FOR_EACH_DEP_LINK (link, INSN_BACK_DEPS (insn))
+ FOR_EACH_DEP (insn, SD_LIST_BACK, sd_it, dep)
{
rtx i = insn;
- dep_t dep = DEP_LINK_DEP (link);
rtx pro = DEP_PRO (dep);
do
} while (SCHED_GROUP_P (i));
if (! sched_insns_conditions_mutex_p (i, pro))
- add_dependence (i, pro, DEP_KIND (dep));
+ add_dependence (i, pro, DEP_TYPE (dep));
next_link:;
}
t, rtx_varies_p)
&& ! sched_insns_conditions_mutex_p (insn, XEXP (pending, 0)))
{
- if (current_sched_info->flags & DO_SPECULATION)
- maybe_add_or_update_back_dep_1 (insn, XEXP (pending, 0),
- REG_DEP_TRUE,
- BEGIN_DATA | DEP_TRUE,
- XEXP (pending_mem, 0), t, 0);
+ if ((current_sched_info->flags & DO_SPECULATION)
+ && (spec_info->mask & BEGIN_DATA))
+ /* Create a data-speculative dependence between producer
+ and consumer. */
+ {
+ dep_def _dep, *dep = &_dep;
+
+ init_dep_1 (dep, XEXP (pending, 0), insn, REG_DEP_TRUE,
+ BEGIN_DATA | DEP_TRUE);
+
+ maybe_add_or_update_dep_1 (dep, false,
+ XEXP (pending_mem, 0), t);
+ }
else
add_dependence (insn, XEXP (pending, 0), REG_DEP_TRUE);
}
/* Fixup the dependencies in the sched group. */
if (SCHED_GROUP_P (insn))
fixup_sched_groups (insn);
+
+ if ((current_sched_info->flags & DO_SPECULATION)
+ && !sched_insn_is_legitimate_for_speculation_p (insn, 0))
+ /* INSN has an internal dependency (e.g. r14 = [r14]) and thus cannot
+ be speculated. */
+ {
+ sd_iterator_def sd_it;
+ dep_t dep;
+
+ for (sd_it = sd_iterator_start (insn, SD_LIST_SPEC_BACK);
+ sd_iterator_cond (&sd_it, &dep);)
+ change_spec_dep_to_hard (sd_it);
+ }
}
/* Analyze every insn between HEAD and TAIL inclusive, creating backward
if (INSN_P (insn))
{
- /* Clear out the stale LOG_LINKS from flow. */
- free_INSN_LIST_list (&LOG_LINKS (insn));
-
- /* These two lists will be freed in schedule_insn (). */
- INSN_BACK_DEPS (insn) = create_deps_list (false);
- INSN_RESOLVED_BACK_DEPS (insn) = create_deps_list (false);
-
- /* This one should be allocated on the obstack because it should live
- till the scheduling ends. */
- INSN_FORW_DEPS (insn) = create_deps_list (true);
+ /* And initialize deps_lists. */
+ sd_init_insn (insn);
}
if (NONJUMP_INSN_P (insn) || JUMP_P (insn))
}
gcc_unreachable ();
}
-\f
-
-/* The following function adds forward dependence (FROM, TO) with
- given DEP_TYPE. The forward dependence should be not exist before. */
-void
-add_forw_dep (dep_link_t link)
+/* Helper for sched_free_deps ().
+ Delete INSN's (RESOLVED_P) backward dependencies. */
+static void
+delete_dep_nodes_in_back_deps (rtx insn, bool resolved_p)
{
- dep_t dep = DEP_LINK_DEP (link);
- rtx to = DEP_CON (dep);
- rtx from = DEP_PRO (dep);
+ sd_iterator_def sd_it;
+ dep_t dep;
+ sd_list_types_def types;
-#ifdef ENABLE_CHECKING
- /* If add_dependence is working properly there should never
- be notes, deleted insns or duplicates in the backward
- links. Thus we need not check for them here.
-
- However, if we have enabled checking we might as well go
- ahead and verify that add_dependence worked properly. */
- gcc_assert (INSN_P (from));
- gcc_assert (!INSN_DELETED_P (from));
- if (true_dependency_cache)
+ if (resolved_p)
+ types = SD_LIST_RES_BACK;
+ else
+ types = SD_LIST_BACK;
+
+ for (sd_it = sd_iterator_start (insn, types);
+ sd_iterator_cond (&sd_it, &dep);)
{
- gcc_assert (!bitmap_bit_p (&forward_dependency_cache[INSN_LUID (from)],
- INSN_LUID (to)));
- bitmap_set_bit (&forward_dependency_cache[INSN_LUID (from)],
- INSN_LUID (to));
+ dep_link_t link = *sd_it.linkp;
+ dep_node_t node = DEP_LINK_NODE (link);
+ deps_list_t back_list;
+ deps_list_t forw_list;
+
+ get_back_and_forw_lists (dep, resolved_p, &back_list, &forw_list);
+ remove_from_deps_list (link, back_list);
+ delete_dep_node (node);
}
-
- gcc_assert (find_link_by_con_in_deps_list (INSN_FORW_DEPS (from), to)
- == NULL);
-#endif
-
- add_to_deps_list (DEP_NODE_FORW (DEP_LINK_NODE (link)),
- INSN_FORW_DEPS (from));
-
- INSN_DEP_COUNT (to) += 1;
}
-/* Examine insns in the range [ HEAD, TAIL ] and Use the backward
- dependences from INSN_BACK_DEPS list to build forward dependences in
- INSN_FORW_DEPS. */
-
+/* Delete (RESOLVED_P) dependencies between HEAD and TAIL together with
+ deps_lists. */
void
-compute_forward_dependences (rtx head, rtx tail)
+sched_free_deps (rtx head, rtx tail, bool resolved_p)
{
rtx insn;
- rtx next_tail;
+ rtx next_tail = NEXT_INSN (tail);
- next_tail = NEXT_INSN (tail);
for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
- {
- dep_link_t link;
-
- if (! INSN_P (insn))
- continue;
-
- if (current_sched_info->flags & DO_SPECULATION)
- {
- /* We will add links, preserving order, from INSN_BACK_DEPS to
- NEW. */
- dep_link_t new = NULL;
-
- link = DEPS_LIST_FIRST (INSN_BACK_DEPS (insn));
-
- while (link != NULL)
- {
- dep_link_t next = DEP_LINK_NEXT (link);
-
- detach_dep_link (link);
- adjust_add_sorted_back_dep (insn, link, &new);
-
- link = next;
- }
-
- /* Attach NEW to be the list of backward dependencies. */
- if (new != NULL)
- {
- DEP_LINK_PREV_NEXTP (new)
- = &DEPS_LIST_FIRST (INSN_BACK_DEPS (insn));
+ if (INSN_P (insn) && INSN_LUID (insn) > 0)
+ {
+ /* Clear resolved back deps together with its dep_nodes. */
+ delete_dep_nodes_in_back_deps (insn, resolved_p);
- DEPS_LIST_FIRST (INSN_BACK_DEPS (insn)) = new;
- }
- }
+ /* Clear forward deps and leave the dep_nodes to the
+ corresponding back_deps list. */
+ if (resolved_p)
+ clear_deps_list (INSN_RESOLVED_FORW_DEPS (insn));
+ else
+ clear_deps_list (INSN_FORW_DEPS (insn));
- FOR_EACH_DEP_LINK (link, INSN_BACK_DEPS (insn))
- add_forw_dep (link);
- }
+ sd_finish_insn (insn);
+ }
}
\f
/* Initialize variables for region data dependence analysis.
void
init_dependency_caches (int luid)
{
+ /* Average number of insns in the basic block.
+ '+ 1' is used to make it nonzero. */
+ int insns_in_block = luid / n_basic_blocks + 1;
+
/* ?!? We could save some memory by computing a per-region luid mapping
which could reduce both the number of vectors in the cache and the size
of each vector. Instead we just avoid the cache entirely unless the
average number of instructions in a basic block is very high. See
the comment before the declaration of true_dependency_cache for
what we consider "very high". */
- if (luid / n_basic_blocks > 100 * 5)
+ if (insns_in_block > 100 * 5)
{
cache_size = 0;
extend_dependency_caches (luid, true);
}
- /* Lifetime of this obstack is whole function scheduling (not single region
- scheduling) because some dependencies can be manually generated for
- outside regions. See dont_calc_deps in sched-{rgn, ebb}.c .
+ dl_pool = create_alloc_pool ("deps_list", sizeof (struct _deps_list),
+ /* Allocate lists for one block at a time. */
+ insns_in_block);
- Possible solution would be to have two obstacks:
- * the big one for regular dependencies with region scheduling lifetime,
- * and the small one for manually generated dependencies with function
- scheduling lifetime. */
- gcc_obstack_init (&deps_obstack);
+ dn_pool = create_alloc_pool ("dep_node", sizeof (struct _dep_node),
+ /* Allocate nodes for one block at a time.
+ We assume that average insn has
+ 5 producers. */
+ 5 * insns_in_block);
}
/* Create or extend (depending on CREATE_P) dependency caches to
output_dependency_cache, luid);
anti_dependency_cache = XRESIZEVEC (bitmap_head, anti_dependency_cache,
luid);
-#ifdef ENABLE_CHECKING
- forward_dependency_cache = XRESIZEVEC (bitmap_head,
- forward_dependency_cache, luid);
-#endif
+
if (current_sched_info->flags & DO_SPECULATION)
spec_dependency_cache = XRESIZEVEC (bitmap_head, spec_dependency_cache,
luid);
bitmap_initialize (&true_dependency_cache[i], 0);
bitmap_initialize (&output_dependency_cache[i], 0);
bitmap_initialize (&anti_dependency_cache[i], 0);
-#ifdef ENABLE_CHECKING
- bitmap_initialize (&forward_dependency_cache[i], 0);
-#endif
+
if (current_sched_info->flags & DO_SPECULATION)
bitmap_initialize (&spec_dependency_cache[i], 0);
}
void
free_dependency_caches (void)
{
- obstack_free (&deps_obstack, NULL);
+ gcc_assert (deps_pools_are_empty_p ());
+ free_alloc_pool_if_empty (&dn_pool);
+ free_alloc_pool_if_empty (&dl_pool);
+ gcc_assert (dn_pool == NULL && dl_pool == NULL);
if (true_dependency_cache)
{
bitmap_clear (&true_dependency_cache[i]);
bitmap_clear (&output_dependency_cache[i]);
bitmap_clear (&anti_dependency_cache[i]);
-#ifdef ENABLE_CHECKING
- bitmap_clear (&forward_dependency_cache[i]);
-#endif
+
if (current_sched_info->flags & DO_SPECULATION)
bitmap_clear (&spec_dependency_cache[i]);
}
output_dependency_cache = NULL;
free (anti_dependency_cache);
anti_dependency_cache = NULL;
-#ifdef ENABLE_CHECKING
- free (forward_dependency_cache);
- forward_dependency_cache = NULL;
-#endif
+
if (current_sched_info->flags & DO_SPECULATION)
{
free (spec_dependency_cache);
FREE_REG_SET (reg_pending_uses);
}
-/* Insert LINK into the dependence chain pointed to by LINKP and
- maintain the sort order. */
-static void
-adjust_add_sorted_back_dep (rtx insn, dep_link_t link, dep_link_t *linkp)
-{
- gcc_assert (current_sched_info->flags & DO_SPECULATION);
-
- /* If the insn cannot move speculatively, but the link is speculative,
- make it hard dependence. */
- if (HAS_INTERNAL_DEP (insn)
- && (DEP_LINK_STATUS (link) & SPECULATIVE))
- {
- DEP_LINK_STATUS (link) &= ~SPECULATIVE;
-
- if (true_dependency_cache)
- bitmap_clear_bit (&spec_dependency_cache[INSN_LUID (insn)],
- INSN_LUID (DEP_LINK_PRO (link)));
- }
-
- /* Non-speculative links go at the head of deps_list, followed by
- speculative links. */
- if (DEP_LINK_STATUS (link) & SPECULATIVE)
- while (*linkp && !(DEP_LINK_STATUS (*linkp) & SPECULATIVE))
- linkp = &DEP_LINK_NEXT (*linkp);
-
- attach_dep_link (link, linkp);
-
- if (CHECK)
- gcc_assert (deps_list_consistent_p (INSN_BACK_DEPS (insn)));
-}
-
-/* Move the dependence pointed to by LINKP to the back dependencies
- of INSN, and also add this dependence to the forward ones. All dep_links,
- except one pointed to by LINKP, must be sorted. */
-static void
-adjust_back_add_forw_dep (rtx insn, dep_link_t *linkp)
-{
- dep_link_t link;
-
- gcc_assert (current_sched_info->flags & DO_SPECULATION);
-
- link = *linkp;
- detach_dep_link (link);
-
- adjust_add_sorted_back_dep (insn, link,
- &DEPS_LIST_FIRST (INSN_BACK_DEPS (insn)));
- add_forw_dep (link);
-}
-
-/* Remove forward dependence described by L. */
-static void
-delete_forw_dep (dep_link_t l)
-{
- gcc_assert (current_sched_info->flags & DO_SPECULATION);
-
-#ifdef ENABLE_CHECKING
- if (true_dependency_cache)
- bitmap_clear_bit (&forward_dependency_cache[INSN_LUID (DEP_LINK_PRO (l))],
- INSN_LUID (DEP_LINK_CON (l)));
-#endif
-
- detach_dep_link (l);
-
- INSN_DEP_COUNT (DEP_LINK_CON (l))--;
-}
-
/* Estimate the weakness of dependence between MEM1 and MEM2. */
static dw_t
estimate_dep_weak (rtx mem1, rtx mem2)
void
add_dependence (rtx insn, rtx elem, enum reg_note dep_type)
{
- ds_t ds;
-
- if (dep_type == REG_DEP_TRUE)
- ds = DEP_TRUE;
- else if (dep_type == REG_DEP_OUTPUT)
- ds = DEP_OUTPUT;
- else if (dep_type == REG_DEP_ANTI)
- ds = DEP_ANTI;
- else
- gcc_unreachable ();
-
- maybe_add_or_update_back_dep_1 (insn, elem, dep_type, ds, 0, 0, 0);
-}
-
-/* Add or update backward dependence between INSN and ELEM
- with given type DEP_TYPE and dep_status DS.
- This function is a convenience wrapper. */
-enum DEPS_ADJUST_RESULT
-add_or_update_back_dep (rtx insn, rtx elem, enum reg_note dep_type, ds_t ds)
-{
- return add_or_update_back_dep_1 (insn, elem, dep_type, ds, 0, 0, 0);
-}
-
-/* Add or update both backward and forward dependencies between INSN and ELEM
- with given type DEP_TYPE and dep_status DS. */
-void
-add_or_update_back_forw_dep (rtx insn, rtx elem, enum reg_note dep_type,
- ds_t ds)
-{
- enum DEPS_ADJUST_RESULT res;
- dep_link_t *linkp;
-
- res = add_or_update_back_dep_1 (insn, elem, dep_type, ds, 0, 0, &linkp);
-
- if (res == DEP_CHANGED || res == DEP_CREATED)
- {
- if (res == DEP_CHANGED)
- delete_forw_dep (DEP_NODE_FORW (DEP_LINK_NODE (*linkp)));
- else if (res == DEP_CREATED)
- linkp = &DEPS_LIST_FIRST (INSN_BACK_DEPS (insn));
-
- adjust_back_add_forw_dep (insn, linkp);
- }
-}
-
-/* Add both backward and forward dependencies between INSN and ELEM
- with given type DEP_TYPE and dep_status DS. */
-void
-add_back_forw_dep (rtx insn, rtx elem, enum reg_note dep_type, ds_t ds)
-{
- add_back_dep (insn, elem, dep_type, ds);
- adjust_back_add_forw_dep (insn, &DEPS_LIST_FIRST (INSN_BACK_DEPS (insn)));
-
- if (CHECK)
- gcc_assert (deps_list_consistent_p (INSN_BACK_DEPS (insn)));
-}
-
-/* Remove a dependency referred to by L. */
-void
-delete_back_forw_dep (dep_link_t l)
-{
- dep_node_t n = DEP_LINK_NODE (l);
-
- gcc_assert (current_sched_info->flags & DO_SPECULATION);
-
- if (true_dependency_cache != NULL)
- {
- dep_t dep = DEP_NODE_DEP (n);
- int elem_luid = INSN_LUID (DEP_PRO (dep));
- int insn_luid = INSN_LUID (DEP_CON (dep));
-
- bitmap_clear_bit (&true_dependency_cache[insn_luid], elem_luid);
- bitmap_clear_bit (&anti_dependency_cache[insn_luid], elem_luid);
- bitmap_clear_bit (&output_dependency_cache[insn_luid], elem_luid);
- bitmap_clear_bit (&spec_dependency_cache[insn_luid], elem_luid);
- }
+ dep_def _dep, *dep = &_dep;
- delete_forw_dep (DEP_NODE_FORW (n));
- detach_dep_link (DEP_NODE_BACK (n));
+ init_dep (dep, elem, insn, dep_type);
+ maybe_add_or_update_dep_1 (dep, false, NULL_RTX, NULL_RTX);
}
/* Return weakness of speculative type TYPE in the dep_status DS. */
-dw_t
-get_dep_weak (ds_t ds, ds_t type)
+static dw_t
+get_dep_weak_1 (ds_t ds, ds_t type)
{
ds = ds & type;
switch (type)
default: gcc_unreachable ();
}
- gcc_assert (MIN_DEP_WEAK <= ds && ds <= MAX_DEP_WEAK);
return (dw_t) ds;
}
+/* Return weakness of speculative type TYPE in the dep_status DS. */
+dw_t
+get_dep_weak (ds_t ds, ds_t type)
+{
+ dw_t dw = get_dep_weak_1 (ds, type);
+
+ gcc_assert (MIN_DEP_WEAK <= dw && dw <= MAX_DEP_WEAK);
+
+ return dw;
+}
+
/* Return the dep_status, which has the same parameters as DS, except for
speculative type TYPE, that will have weakness DW. */
ds_t
return ds;
}
+/* Dump information about the dependence status S. */
+static void
+dump_ds (FILE *f, ds_t s)
+{
+ fprintf (f, "{");
+
+ if (s & BEGIN_DATA)
+ fprintf (f, "BEGIN_DATA: %d; ", get_dep_weak_1 (s, BEGIN_DATA));
+ if (s & BE_IN_DATA)
+ fprintf (f, "BE_IN_DATA: %d; ", get_dep_weak_1 (s, BE_IN_DATA));
+ if (s & BEGIN_CONTROL)
+ fprintf (f, "BEGIN_CONTROL: %d; ", get_dep_weak_1 (s, BEGIN_CONTROL));
+ if (s & BE_IN_CONTROL)
+ fprintf (f, "BE_IN_CONTROL: %d; ", get_dep_weak_1 (s, BE_IN_CONTROL));
+
+ if (s & HARD_DEP)
+ fprintf (f, "HARD_DEP; ");
+
+ if (s & DEP_TRUE)
+ fprintf (f, "DEP_TRUE; ");
+ if (s & DEP_ANTI)
+ fprintf (f, "DEP_ANTI; ");
+ if (s & DEP_OUTPUT)
+ fprintf (f, "DEP_OUTPUT; ");
+
+ fprintf (f, "}");
+}
+
+void
+debug_ds (ds_t s)
+{
+ dump_ds (stderr, s);
+ fprintf (stderr, "\n");
+}
+
#ifdef INSN_SCHEDULING
#ifdef ENABLE_CHECKING
/* Verify that dependence type and status are consistent.
If RELAXED_P is true, then skip dep_weakness checks. */
static void
-check_dep_status (enum reg_note dt, ds_t ds, bool relaxed_p)
+check_dep (dep_t dep, bool relaxed_p)
{
+ enum reg_note dt = DEP_TYPE (dep);
+ ds_t ds = DEP_STATUS (dep);
+
+ gcc_assert (DEP_PRO (dep) != DEP_CON (dep));
+
+ if (!(current_sched_info->flags & USE_DEPS_LIST))
+ {
+ gcc_assert (ds == -1);
+ return;
+ }
+
/* Check that dependence type contains the same bits as the status. */
if (dt == REG_DEP_TRUE)
gcc_assert (ds & DEP_TRUE);
OSDN Git Service
