/* 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)
{
- gcc_assert (fun && fun->gimple_df);
+ gcc_checking_assert (fun && fun->gimple_df);
return fun->gimple_df->vop;
}
return NULL;
}
+/* Get the variable with uid UID from the list of referenced vars. */
+
+static inline tree
+referenced_var (unsigned int uid)
+{
+ tree var = referenced_var_lookup (uid);
+ gcc_assert (var || uid == 0);
+ return var;
+}
+
/* Initialize ITER to point to the first referenced variable in the
referenced_vars hashtable, and return that variable. */
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.
Return NULL if the variable annotation doesn't already exist. */
static inline var_ann_t
get_var_ann (tree var)
{
var_ann_t *p = DECL_VAR_ANN_PTR (var);
- gcc_assert (p);
+ gcc_checking_assert (p);
return *p ? *p : create_var_ann (var);
}
root = &(SSA_NAME_IMM_USE_NODE (def));
#ifdef ENABLE_CHECKING
if (linknode->use)
- gcc_assert (*(linknode->use) == def);
+ gcc_checking_assert (*(linknode->use) == def);
#endif
link_imm_use_to_list (linknode, root);
}
relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
{
/* The node one had better be in the same list. */
- gcc_assert (*(old->use) == *(node->use));
+ gcc_checking_assert (*(old->use) == *(node->use));
node->prev = old->prev;
node->next = old->next;
if (old->prev)
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
static inline gimple_seq
phi_nodes (const_basic_block bb)
{
- gcc_assert (!(bb->flags & BB_RTL));
+ gcc_checking_assert (!(bb->flags & BB_RTL));
if (!bb->il.gimple)
return NULL;
return bb->il.gimple->phi_nodes;
{
gimple_stmt_iterator i;
- gcc_assert (!(bb->flags & BB_RTL));
+ gcc_checking_assert (!(bb->flags & BB_RTL));
bb->il.gimple->phi_nodes = seq;
if (seq)
for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
pointer arithmetic. */
phi = USE_STMT (use);
- gcc_assert (gimple_code (phi) == GIMPLE_PHI);
element = (struct phi_arg_d *)use;
root = gimple_phi_arg (phi, 0);
#ifdef ENABLE_CHECKING
/* 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
op_iter_next_use (ssa_op_iter *ptr)
{
use_operand_p use_p;
-#ifdef ENABLE_CHECKING
- gcc_assert (ptr->iter_type == ssa_op_iter_use);
-#endif
+ gcc_checking_assert (ptr->iter_type == ssa_op_iter_use);
if (ptr->uses)
{
use_p = USE_OP_PTR (ptr->uses);
op_iter_next_def (ssa_op_iter *ptr)
{
def_operand_p def_p;
-#ifdef ENABLE_CHECKING
- gcc_assert (ptr->iter_type == ssa_op_iter_def);
-#endif
+ gcc_checking_assert (ptr->iter_type == ssa_op_iter_def);
if (ptr->defs)
{
def_p = DEF_OP_PTR (ptr->defs);
op_iter_next_tree (ssa_op_iter *ptr)
{
tree val;
-#ifdef ENABLE_CHECKING
- gcc_assert (ptr->iter_type == ssa_op_iter_tree);
-#endif
+ gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree);
if (ptr->uses)
{
val = USE_OP (ptr->uses);
{
/* We do not support iterating over virtual defs or uses without
iterating over defs or uses at the same time. */
- gcc_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
- && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
+ gcc_checking_assert ((!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
+ && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
ptr->defs = (flags & (SSA_OP_DEF|SSA_OP_VDEF)) ? gimple_def_ops (stmt) : NULL;
if (!(flags & SSA_OP_VDEF)
&& ptr->defs
static inline use_operand_p
op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
{
- gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0
- && (flags & SSA_OP_USE));
+ gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0
+ && (flags & SSA_OP_USE));
op_iter_init (ptr, stmt, flags);
ptr->iter_type = ssa_op_iter_use;
return op_iter_next_use (ptr);
static inline def_operand_p
op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
{
- gcc_assert ((flags & SSA_OP_ALL_USES) == 0
- && (flags & SSA_OP_DEF));
+ gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0
+ && (flags & SSA_OP_DEF));
op_iter_init (ptr, stmt, flags);
ptr->iter_type = ssa_op_iter_def;
return op_iter_next_def (ptr);
clear_and_done_ssa_iter (ptr);
ptr->done = false;
- gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
+ gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
clear_and_done_ssa_iter (ptr);
ptr->done = false;
- gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
+ gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
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;
return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
}
-/* Return true if REF, an ARRAY_REF, has an INDIRECT_REF somewhere in it. */
-
-static inline bool
-array_ref_contains_indirect_ref (const_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 (const_tree ref)
{
- gcc_assert (handled_component_p (ref));
+ gcc_checking_assert (handled_component_p (ref));
do {
if (TREE_CODE (ref) == ARRAY_REF)
OSDN Git Service
