/* Inline functions for tree-flow.h
- Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2003, 2005, 2006 Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
return false;
}
-/* Advance the hashtable iterator pointed by HTI to the next element of the
+/* Advance the hashtable iterator pointed to by HTI to the next element of the
hashtable. */
static inline void *
first_referenced_var (referenced_var_iterator *iter)
{
struct int_tree_map *itm;
- itm = first_htab_element (&iter->hti, referenced_vars);
+ itm = (struct int_tree_map *) first_htab_element (&iter->hti,
+ referenced_vars);
if (!itm)
return NULL;
return itm->to;
next_referenced_var (referenced_var_iterator *iter)
{
struct int_tree_map *itm;
- itm = next_htab_element (&iter->hti);
+ itm = (struct int_tree_map *) next_htab_element (&iter->hti);
if (!itm)
return NULL;
return itm->to;
}
-
+
+/* Fill up VEC with the variables in the referenced vars hashtable. */
+
+static inline void
+fill_referenced_var_vec (VEC (tree, heap) **vec)
+{
+ referenced_var_iterator rvi;
+ tree var;
+ *vec = NULL;
+ FOR_EACH_REFERENCED_VAR (var, rvi)
+ VEC_safe_push (tree, heap, *vec, var);
+}
+
/* Return the variable annotation for T, which must be a _DECL node.
Return NULL if the variable annotation doesn't already exist. */
static inline var_ann_t
{
gcc_assert (t);
gcc_assert (DECL_P (t));
+ gcc_assert (TREE_CODE (t) != FUNCTION_DECL);
gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
return (var_ann_t) t->common.ann;
return (ann) ? ann : create_var_ann (var);
}
+/* Return the function annotation for T, which must be a FUNCTION_DECL node.
+ Return NULL if the function annotation doesn't already exist. */
+static inline function_ann_t
+function_ann (tree t)
+{
+ gcc_assert (t);
+ gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
+ gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
+
+ return (function_ann_t) t->common.ann;
+}
+
+/* Return the function annotation for T, which must be a FUNCTION_DECL node.
+ Create the function annotation if it doesn't exist. */
+static inline function_ann_t
+get_function_ann (tree var)
+{
+ function_ann_t ann = function_ann (var);
+ gcc_assert (!var->common.ann || var->common.ann->common.type == FUNCTION_ANN);
+ return (ann) ? ann : create_function_ann (var);
+}
+
/* Return the statement annotation for T, which must be a statement
node. Return NULL if the statement annotation doesn't exist. */
static inline stmt_ann_t
#ifdef ENABLE_CHECKING
gcc_assert (is_gimple_stmt (t));
#endif
+ gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
return (stmt_ann_t) t->common.ann;
}
/* Return the may_aliases varray for variable VAR, or NULL if it has
no may aliases. */
-static inline varray_type
+static inline VEC(tree, gc) *
may_aliases (tree var)
{
var_ann_t ann = var_ann (var);
}
}
-/* Set the value of a use pointed by USE to VAL. */
+/* Set the value of a use pointed to by USE to VAL. */
static inline void
set_ssa_use_from_ptr (use_operand_p use, tree val)
{
linknode->stmt = stmt;
}
-/* Finished the traverse of an immediate use list IMM by removing it from
- the list. */
-static inline void
-end_safe_imm_use_traverse (imm_use_iterator *imm)
-{
- delink_imm_use (&(imm->iter_node));
-}
-
-/* Return true if IMM is at the end of the list. */
-static inline bool
-end_safe_imm_use_p (imm_use_iterator *imm)
-{
- return (imm->imm_use == imm->end_p);
-}
-
-/* Initialize iterator IMM to process the list for VAR. */
-static inline use_operand_p
-first_safe_imm_use (imm_use_iterator *imm, tree var)
-{
- /* Set up and link the iterator node into the linked list for VAR. */
- imm->iter_node.use = NULL;
- imm->iter_node.stmt = NULL_TREE;
- imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
- /* Check if there are 0 elements. */
- if (imm->end_p->next == imm->end_p)
- {
- imm->imm_use = imm->end_p;
- return NULL_USE_OPERAND_P;
- }
-
- link_imm_use (&(imm->iter_node), var);
- imm->imm_use = imm->iter_node.next;
- return imm->imm_use;
-}
-
-/* Bump IMM to the next use in the list. */
-static inline use_operand_p
-next_safe_imm_use (imm_use_iterator *imm)
-{
- ssa_use_operand_t *ptr;
- use_operand_p old;
-
- old = imm->imm_use;
- /* If the next node following the iter_node is still the one referred to by
- imm_use, then the list hasn't changed, go to the next node. */
- if (imm->iter_node.next == imm->imm_use)
- {
- ptr = &(imm->iter_node);
- /* Remove iternode from the list. */
- delink_imm_use (ptr);
- imm->imm_use = imm->imm_use->next;
- if (! end_safe_imm_use_p (imm))
- {
- /* This isn't the end, link iternode before the next use. */
- ptr->prev = imm->imm_use->prev;
- ptr->next = imm->imm_use;
- imm->imm_use->prev->next = ptr;
- imm->imm_use->prev = ptr;
- }
- else
- return old;
- }
- else
- {
- /* If the 'next' value after the iterator isn't the same as it was, then
- a node has been deleted, so we simply proceed to the node following
- where the iterator is in the list. */
- imm->imm_use = imm->iter_node.next;
- if (end_safe_imm_use_p (imm))
- {
- end_safe_imm_use_traverse (imm);
- return old;
- }
- }
-
- return imm->imm_use;
-}
/* Return true is IMM has reached the end of the immediate use list. */
static inline bool
return false;
}
-/* Set the default definition for VAR to DEF. */
-static inline void
-set_default_def (tree var, tree def)
-{
- var_ann_t ann = get_var_ann (var);
- ann->default_def = def;
-}
-
-/* Return the default definition for variable VAR, or NULL if none
- exists. */
-static inline tree
-default_def (tree var)
-{
- var_ann_t ann = var_ann (var);
- return ann ? ann->default_def : NULL_TREE;
-}
-
/* PHI nodes should contain only ssa_names and invariants. A test
for ssa_name is definitely simpler; don't let invalid contents
slip in in the meantime. */
bsi.tsi = tsi_start (bb->stmt_list);
else
{
- gcc_assert (bb->index < 0);
+ gcc_assert (bb->index < NUM_FIXED_BLOCKS);
bsi.tsi.ptr = NULL;
bsi.tsi.container = NULL;
}
return bsi;
}
-/* Return a block statement iterator that points to the last label in
- block BB. */
+/* Return a block statement iterator that points to the first non-label
+ statement in block BB. */
static inline block_stmt_iterator
bsi_after_labels (basic_block bb)
{
- block_stmt_iterator bsi;
- tree_stmt_iterator next;
+ block_stmt_iterator bsi = bsi_start (bb);
- bsi.bb = bb;
-
- if (!bb->stmt_list)
- {
- gcc_assert (bb->index < 0);
- bsi.tsi.ptr = NULL;
- bsi.tsi.container = NULL;
- return bsi;
- }
-
- bsi.tsi = tsi_start (bb->stmt_list);
- if (tsi_end_p (bsi.tsi))
- return bsi;
-
- /* Ensure that there are some labels. The rationale is that we want
- to insert after the bsi that is returned, and these insertions should
- be placed at the start of the basic block. This would not work if the
- first statement was not label; rather fail here than enable the user
- proceed in wrong way. */
- gcc_assert (TREE_CODE (tsi_stmt (bsi.tsi)) == LABEL_EXPR);
-
- next = bsi.tsi;
- tsi_next (&next);
-
- while (!tsi_end_p (next)
- && TREE_CODE (tsi_stmt (next)) == LABEL_EXPR)
- {
- bsi.tsi = next;
- tsi_next (&next);
- }
+ while (!bsi_end_p (bsi) && TREE_CODE (bsi_stmt (bsi)) == LABEL_EXPR)
+ bsi_next (&bsi);
return bsi;
}
bsi.tsi = tsi_last (bb->stmt_list);
else
{
- gcc_assert (bb->index < 0);
+ gcc_assert (bb->index < NUM_FIXED_BLOCKS);
bsi.tsi.ptr = NULL;
bsi.tsi.container = NULL;
}
static inline bool
is_call_clobbered (tree var)
{
- return is_global_var (var)
- || bitmap_bit_p (call_clobbered_vars, DECL_UID (var));
+ if (!MTAG_P (var))
+ return DECL_CALL_CLOBBERED (var);
+ else
+ return bitmap_bit_p (call_clobbered_vars, DECL_UID (var));
}
/* Mark variable VAR as being clobbered by function calls. */
static inline void
-mark_call_clobbered (tree var)
+mark_call_clobbered (tree var, unsigned int escape_type)
{
- var_ann_t ann = var_ann (var);
- /* If VAR is a memory tag, then we need to consider it a global
- variable. This is because the pointer that VAR represents has
- been found to point to either an arbitrary location or to a known
- location in global memory. */
- if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
- DECL_EXTERNAL (var) = 1;
+ var_ann (var)->escape_mask |= escape_type;
+ if (!MTAG_P (var))
+ DECL_CALL_CLOBBERED (var) = true;
bitmap_set_bit (call_clobbered_vars, DECL_UID (var));
- ssa_call_clobbered_cache_valid = false;
- ssa_ro_call_cache_valid = false;
}
/* Clear the call-clobbered attribute from variable VAR. */
clear_call_clobbered (tree var)
{
var_ann_t ann = var_ann (var);
- if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
- DECL_EXTERNAL (var) = 0;
+ ann->escape_mask = 0;
+ if (MTAG_P (var) && TREE_CODE (var) != STRUCT_FIELD_TAG)
+ MTAG_GLOBAL (var) = 0;
+ if (!MTAG_P (var))
+ DECL_CALL_CLOBBERED (var) = false;
bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
- ssa_call_clobbered_cache_valid = false;
- ssa_ro_call_cache_valid = false;
}
/* Mark variable VAR as being non-addressable. */
static inline void
mark_non_addressable (tree var)
{
+ if (!MTAG_P (var))
+ DECL_CALL_CLOBBERED (var) = false;
bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
TREE_ADDRESSABLE (var) = 0;
- ssa_call_clobbered_cache_valid = false;
- ssa_ro_call_cache_valid = false;
}
/* Return the common annotation for T. Return NULL if the annotation
doesn't already exist. */
-static inline tree_ann_t
-tree_ann (tree t)
+static inline tree_ann_common_t
+tree_common_ann (tree t)
{
- return t->common.ann;
+ return &t->common.ann->common;
}
/* Return a common annotation for T. Create the constant annotation if it
doesn't exist. */
-static inline tree_ann_t
-get_tree_ann (tree t)
+static inline tree_ann_common_t
+get_tree_common_ann (tree t)
{
- tree_ann_t ann = tree_ann (t);
- return (ann) ? ann : create_tree_ann (t);
+ tree_ann_common_t ann = tree_common_ann (t);
+ return (ann) ? ann : create_tree_common_ann (t);
}
/* ----------------------------------------------------------------------- */
/* This functions clears the iterator PTR, and marks it done. This is normally
- used to prevent warnings in the compile about might be uninitailzied
+ used to prevent warnings in the compile about might be uninitialized
components. */
static inline void
/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+ return NULL. */
static inline tree
single_ssa_tree_operand (tree stmt, int flags)
{
/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+ return NULL. */
static inline use_operand_p
single_ssa_use_operand (tree stmt, int flags)
{
/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+ return NULL. */
static inline def_operand_p
single_ssa_def_operand (tree stmt, int flags)
{
/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+ return NULL. */
static inline bool
zero_ssa_operands (tree stmt, int flags)
{
}
/* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should
- be either SSA_OP_USES or SAS_OP_VIRTUAL_USES. */
+ be either SSA_OP_USES or SSA_OP_VIRTUAL_USES. */
static inline use_operand_p
op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
{
return PHI_RESULT_PTR (phi);
}
+/* Return true is IMM has reached the end of the immediate use stmt list. */
+static inline bool
+end_imm_use_stmt_p (imm_use_iterator *imm)
+{
+ return (imm->imm_use == imm->end_p);
+}
+
+/* Finished the traverse of an immediate use stmt list IMM by removing the
+ placeholder node from the list. */
+
+static inline void
+end_imm_use_stmt_traverse (imm_use_iterator *imm)
+{
+ delink_imm_use (&(imm->iter_node));
+}
+
+/* Immediate use traversal of uses within a stmt require that all the
+ uses on a stmt be sequentially listed. This routine is used to build up
+ this sequential list by adding USE_P to the end of the current list
+ currently delimited by HEAD and LAST_P. The new LAST_P value is
+ returned. */
+
+static inline use_operand_p
+move_use_after_head (use_operand_p use_p, use_operand_p head,
+ use_operand_p last_p)
+{
+ gcc_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head));
+ /* Skip head when we find it. */
+ if (use_p != head)
+ {
+ /* If use_p is already linked in after last_p, continue. */
+ if (last_p->next == use_p)
+ last_p = use_p;
+ else
+ {
+ /* Delink from current location, and link in at last_p. */
+ delink_imm_use (use_p);
+ link_imm_use_to_list (use_p, last_p);
+ last_p = use_p;
+ }
+ }
+ return last_p;
+}
+
+
+/* This routine will relink all uses with the same stmt as HEAD into the list
+ immediately following HEAD for iterator IMM. */
+
+static inline void
+link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
+{
+ use_operand_p use_p;
+ use_operand_p last_p = head;
+ tree head_stmt = USE_STMT (head);
+ tree use = USE_FROM_PTR (head);
+ ssa_op_iter op_iter;
+ int flag;
+
+ /* Only look at virtual or real uses, depending on the type of HEAD. */
+ flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
+
+ if (TREE_CODE (head_stmt) == PHI_NODE)
+ {
+ FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag)
+ if (USE_FROM_PTR (use_p) == use)
+ last_p = move_use_after_head (use_p, head, last_p);
+ }
+ else
+ {
+ FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag)
+ if (USE_FROM_PTR (use_p) == use)
+ last_p = move_use_after_head (use_p, head, last_p);
+ }
+ /* LInk iter node in after last_p. */
+ if (imm->iter_node.prev != NULL)
+ delink_imm_use (&imm->iter_node);
+ link_imm_use_to_list (&(imm->iter_node), last_p);
+}
+
+/* Initialize IMM to traverse over uses of VAR. Return the first statement. */
+static inline tree
+first_imm_use_stmt (imm_use_iterator *imm, tree var)
+{
+ gcc_assert (TREE_CODE (var) == SSA_NAME);
+
+ imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
+ imm->imm_use = imm->end_p->next;
+ imm->next_imm_name = NULL_USE_OPERAND_P;
+
+ /* iter_node is used as a marker within the immediate use list to indicate
+ where the end of the current stmt's uses are. Initialize it to NULL
+ stmt and use, which indicates a marker node. */
+ imm->iter_node.prev = NULL_USE_OPERAND_P;
+ imm->iter_node.next = NULL_USE_OPERAND_P;
+ imm->iter_node.stmt = NULL_TREE;
+ imm->iter_node.use = NULL_USE_OPERAND_P;
+
+ if (end_imm_use_stmt_p (imm))
+ return NULL_TREE;
+
+ link_use_stmts_after (imm->imm_use, imm);
+
+ return USE_STMT (imm->imm_use);
+}
+
+/* Bump IMM to the next stmt which has a use of var. */
+
+static inline tree
+next_imm_use_stmt (imm_use_iterator *imm)
+{
+ imm->imm_use = imm->iter_node.next;
+ if (end_imm_use_stmt_p (imm))
+ {
+ if (imm->iter_node.prev != NULL)
+ delink_imm_use (&imm->iter_node);
+ return NULL_TREE;
+ }
+
+ link_use_stmts_after (imm->imm_use, imm);
+ return USE_STMT (imm->imm_use);
+
+}
+
+/* This routine will return the first use on the stmt IMM currently refers
+ to. */
+
+static inline use_operand_p
+first_imm_use_on_stmt (imm_use_iterator *imm)
+{
+ imm->next_imm_name = imm->imm_use->next;
+ return imm->imm_use;
+}
+
+/* Return TRUE if the last use on the stmt IMM refers to has been visited. */
+
+static inline bool
+end_imm_use_on_stmt_p (imm_use_iterator *imm)
+{
+ return (imm->imm_use == &(imm->iter_node));
+}
+
+/* Bump to the next use on the stmt IMM refers to, return NULL if done. */
+
+static inline use_operand_p
+next_imm_use_on_stmt (imm_use_iterator *imm)
+{
+ imm->imm_use = imm->next_imm_name;
+ if (end_imm_use_on_stmt_p (imm))
+ return NULL_USE_OPERAND_P;
+ else
+ {
+ imm->next_imm_name = imm->imm_use->next;
+ return imm->imm_use;
+ }
+}
/* Return true if VAR cannot be modified by the program. */
{
if (TREE_CODE (var) == SSA_NAME)
var = SSA_NAME_VAR (var);
+
+ if (MTAG_P (var))
+ return TREE_READONLY (var) && (TREE_STATIC (var) || MTAG_GLOBAL (var));
+
return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
}
-/* Return true if REF, a COMPONENT_REF, has an ARRAY_REF somewhere in it. */
+/* Return true if REF, an ARRAY_REF, has an INDIRECT_REF somewhere in it. */
+
+static inline bool
+array_ref_contains_indirect_ref (tree ref)
+{
+ gcc_assert (TREE_CODE (ref) == ARRAY_REF);
+
+ do {
+ ref = TREE_OPERAND (ref, 0);
+ } while (handled_component_p (ref));
+
+ return TREE_CODE (ref) == INDIRECT_REF;
+}
+
+/* Return true if REF, a handled component reference, has an ARRAY_REF
+ somewhere in it. */
static inline bool
ref_contains_array_ref (tree ref)
{
- while (handled_component_p (ref))
- {
- if (TREE_CODE (ref) == ARRAY_REF)
- return true;
- ref = TREE_OPERAND (ref, 0);
- }
+ gcc_assert (handled_component_p (ref));
+
+ do {
+ if (TREE_CODE (ref) == ARRAY_REF)
+ return true;
+ ref = TREE_OPERAND (ref, 0);
+ } while (handled_component_p (ref));
+
return false;
}
return subvars;
}
+/* Return the subvariable of VAR at offset OFFSET. */
+
+static inline tree
+get_subvar_at (tree var, unsigned HOST_WIDE_INT offset)
+{
+ subvar_t sv;
+
+ for (sv = get_subvars_for_var (var); sv; sv = sv->next)
+ if (SFT_OFFSET (sv->var) == offset)
+ return sv->var;
+
+ return NULL_TREE;
+}
+
/* Return true if V is a tree that we can have subvars for.
- Normally, this is any aggregate type, however, due to implementation
- limitations ATM, we exclude array types as well. */
+ Normally, this is any aggregate type. Also complex
+ types which are not gimple registers can have subvars. */
static inline bool
var_can_have_subvars (tree v)
{
- return (AGGREGATE_TYPE_P (TREE_TYPE (v)) &&
- TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE);
+ /* Volatile variables should never have subvars. */
+ if (TREE_THIS_VOLATILE (v))
+ return false;
+
+ /* Non decls or memory tags can never have subvars. */
+ if (!DECL_P (v) || MTAG_P (v))
+ return false;
+
+ /* Aggregates can have subvars. */
+ if (AGGREGATE_TYPE_P (TREE_TYPE (v)))
+ return true;
+
+ /* Complex types variables which are not also a gimple register can
+ have subvars. */
+ if (TREE_CODE (TREE_TYPE (v)) == COMPLEX_TYPE
+ && !DECL_COMPLEX_GIMPLE_REG_P (v))
+ return true;
+
+ return false;
}
*EXACT will be set to true upon return. */
static inline bool
-overlap_subvar (HOST_WIDE_INT offset, HOST_WIDE_INT size,
- subvar_t sv, bool *exact)
+overlap_subvar (unsigned HOST_WIDE_INT offset, unsigned HOST_WIDE_INT size,
+ tree sv, bool *exact)
{
/* There are three possible cases of overlap.
1. We can have an exact overlap, like so:
if (exact)
*exact = false;
- if (offset == sv->offset && size == sv->size)
+ if (offset == SFT_OFFSET (sv) && size == SFT_SIZE (sv))
{
if (exact)
*exact = true;
return true;
}
- else if (offset >= sv->offset && offset < (sv->offset + sv->size))
+ else if (offset >= SFT_OFFSET (sv)
+ && offset < (SFT_OFFSET (sv) + SFT_SIZE (sv)))
{
return true;
}
- else if (offset < sv->offset && (offset + size > sv->offset))
+ else if (offset < SFT_OFFSET (sv)
+ && (size > SFT_OFFSET (sv) - offset))
{
return true;
}