/* Inline functions for tree-flow.h
- Copyright (C) 2001, 2003, 2005, 2006, 2007, 2008 Free Software
- Foundation, Inc.
+ Copyright (C) 2001, 2003, 2005, 2006, 2007, 2008, 2010
+ Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
return fun->gimple_df->referenced_vars;
}
-/* Artificial variable used to model the effects of nonlocal
- variables. */
-static inline tree
-gimple_nonlocal_all (const struct function *fun)
-{
- gcc_assert (fun && fun->gimple_df);
- return fun->gimple_df->nonlocal_all;
-}
-
/* Artificial variable used for the virtual operand FUD chain. */
static inline tree
gimple_vop (const struct function *fun)
if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
break;
} while (++(hti->slot) < hti->limit);
-
+
if (hti->slot < hti->limit)
return *(hti->slot);
return NULL;
next_referenced_var (referenced_var_iterator *iter)
{
return (tree) next_htab_element (&iter->hti);
-}
-
-/* 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.
static inline void
link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list)
{
- /* Link the new node at the head of the list. If we are in the process of
+ /* Link the new node at the head of the list. If we are in the process of
traversing the list, we won't visit any new nodes added to it. */
linknode->prev = list;
linknode->next = list->next;
link_imm_use (use, val);
}
-/* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring
+/* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring
in STMT. */
static inline void
link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt)
}
}
-/* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring
+/* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring
in STMT. */
static inline void
relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old,
static inline use_operand_p
first_readonly_imm_use (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;
#ifdef ENABLE_CHECKING
return num;
}
-/* Return the tree pointed-to by USE. */
+/* Return the tree pointed-to by USE. */
static inline tree
get_use_from_ptr (use_operand_p use)
-{
+{
return *(use->use);
-}
+}
/* Return the tree pointed-to by DEF. */
static inline tree
index = element - root;
#ifdef ENABLE_CHECKING
- /* Make sure the calculation doesn't have any leftover bytes. If it does,
+ /* Make sure the calculation doesn't have any leftover bytes. If it does,
then imm_use is likely not the first element in phi_arg_d. */
- gcc_assert (
- (((char *)element - (char *)root) % sizeof (struct phi_arg_d)) == 0);
- gcc_assert (index < gimple_phi_capacity (phi));
+ gcc_assert ((((char *)element - (char *)root)
+ % sizeof (struct phi_arg_d)) == 0
+ && index < gimple_phi_capacity (phi));
#endif
-
+
return index;
}
}
-/* Return true if VAR is clobbered by function calls. */
-static inline bool
-is_call_clobbered (const_tree var)
-{
- return (is_global_var (var)
- || (may_be_aliased (var)
- && pt_solution_includes (&cfun->gimple_df->escaped, var)));
-}
-
-/* Return true if VAR is used by function calls. */
-static inline bool
-is_call_used (const_tree var)
-{
- return (is_call_clobbered (var)
- || (may_be_aliased (var)
- && pt_solution_includes (&cfun->gimple_df->callused, var)));
-}
-
/* ----------------------------------------------------------------------- */
/* The following set of routines are used to iterator over various type of
}
-/* Return true if there are zero operands in STMT matching the type
+/* Return true if there are zero operands in STMT matching the type
given in FLAGS. */
static inline bool
zero_ssa_operands (gimple stmt, int flags)
single_phi_def (gimple stmt, int flags)
{
tree def = PHI_RESULT (stmt);
- if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
+ if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
return def;
if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
return def;
gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
-
+
/* If the PHI node doesn't the operand type we care about, we're done. */
if ((flags & comp) == 0)
{
gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
-
+
/* If the PHI node doesn't have the operand type we care about,
we're done. */
if ((flags & comp) == 0)
/* 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
+ 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,
+move_use_after_head (use_operand_p use_p, use_operand_p head,
use_operand_p last_p)
{
+#ifdef ENABLE_CHECKING
gcc_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head));
+#endif
/* Skip head when we find it. */
if (use_p != head)
{
static inline gimple
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;
OSDN Git Service
