/* Inline functions for manipulating various data structures defined in
tree-flow.h. See tree-flow.h for documentation. */
+/* Return true when gimple SSA form was built.
+ gimple_in_ssa_p is queried by gimplifier in various early stages before SSA
+ infrastructure is initialized. Check for presence of the datastructures
+ at first place. */
+static inline bool
+gimple_in_ssa_p (struct function *fun)
+{
+ return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
+}
+
+/* 'true' after aliases have been computed (see compute_may_aliases). */
+static inline bool
+gimple_aliases_computed_p (struct function *fun)
+{
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->aliases_computed_p;
+}
+
+/* Addressable variables in the function. If bit I is set, then
+ REFERENCED_VARS (I) has had its address taken. Note that
+ CALL_CLOBBERED_VARS and ADDRESSABLE_VARS are not related. An
+ addressable variable is not necessarily call-clobbered (e.g., a
+ local addressable whose address does not escape) and not all
+ call-clobbered variables are addressable (e.g., a local static
+ variable). */
+static inline bitmap
+gimple_addressable_vars (struct function *fun)
+{
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->addressable_vars;
+}
+
+/* Call clobbered variables in the function. If bit I is set, then
+ REFERENCED_VARS (I) is call-clobbered. */
+static inline bitmap
+gimple_call_clobbered_vars (struct function *fun)
+{
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->call_clobbered_vars;
+}
+
+/* Array of all variables referenced in the function. */
+static inline htab_t
+gimple_referenced_vars (struct function *fun)
+{
+ if (!fun->gimple_df)
+ return NULL;
+ return fun->gimple_df->referenced_vars;
+}
+
+/* Artificial variable used to model the effects of function calls. */
+static inline tree
+gimple_global_var (struct function *fun)
+{
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->global_var;
+}
+
+/* Artificial variable used to model the effects of nonlocal
+ variables. */
+static inline tree
+gimple_nonlocal_all (struct function *fun)
+{
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->nonlocal_all;
+}
+
+/* Hashtable of variables annotations. Used for static variables only;
+ local variables have direct pointer in the tree node. */
+static inline htab_t
+gimple_var_anns (struct function *fun)
+{
+ return fun->gimple_df->var_anns;
+}
+
/* Initialize the hashtable iterator HTI to point to hashtable TABLE */
static inline void *
{
struct int_tree_map *itm;
itm = (struct int_tree_map *) first_htab_element (&iter->hti,
- referenced_vars);
+ gimple_referenced_vars
+ (cfun));
if (!itm)
return NULL;
return itm->to;
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);
+ if (!MTAG_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t)))
+ {
+ struct static_var_ann_d *sann
+ = ((struct static_var_ann_d *)
+ htab_find_with_hash (gimple_var_anns (cfun), t, DECL_UID (t)));
+ if (!sann)
+ return NULL;
+ gcc_assert (sann->ann.common.type = VAR_ANN);
+ return &sann->ann;
+ }
+ gcc_assert (!t->base.ann
+ || t->base.ann->common.type == VAR_ANN);
- return (var_ann_t) t->common.ann;
+ return (var_ann_t) t->base.ann;
}
/* Return the variable annotation for T, which must be a _DECL node.
{
gcc_assert (t);
gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
- gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
+ gcc_assert (!t->base.ann
+ || t->base.ann->common.type == FUNCTION_ANN);
- return (function_ann_t) t->common.ann;
+ return (function_ann_t) t->base.ann;
}
/* Return the function annotation for T, which must be a FUNCTION_DECL node.
get_function_ann (tree var)
{
function_ann_t ann = function_ann (var);
- gcc_assert (!var->common.ann || var->common.ann->common.type == FUNCTION_ANN);
+ gcc_assert (!var->base.ann || var->base.ann->common.type == FUNCTION_ANN);
return (ann) ? ann : create_function_ann (var);
}
+/* Return true if T has a statement annotation attached to it. */
+
+static inline bool
+has_stmt_ann (tree t)
+{
+#ifdef ENABLE_CHECKING
+ gcc_assert (is_gimple_stmt (t));
+#endif
+ return t->base.ann && t->base.ann->common.type == STMT_ANN;
+}
+
/* 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;
+ gcc_assert (!t->base.ann || t->base.ann->common.type == STMT_ANN);
+ return (stmt_ann_t) t->base.ann;
}
/* Return the statement annotation for T, which must be a statement
return ann ? ann->bb : NULL;
}
-/* Return the may_aliases varray for variable VAR, or NULL if it has
+/* Return the may_aliases bitmap for variable VAR, or NULL if it has
no may aliases. */
-static inline VEC(tree, gc) *
+static inline bitmap
may_aliases (tree var)
{
- var_ann_t ann = var_ann (var);
- return ann ? ann->may_aliases : NULL;
+ return MTAG_ALIASES (var);
}
/* Return the line number for EXPR, or return -1 if we have no line
ann = stmt_ann (t);
if (ann == NULL)
ann = create_stmt_ann (t);
- else if (noreturn_call_p (t))
- VEC_safe_push (tree, gc, modified_noreturn_calls, t);
+ else if (noreturn_call_p (t) && cfun->gimple_df)
+ VEC_safe_push (tree, gc, MODIFIED_NORETURN_CALLS (cfun), t);
ann->modified = 1;
}
return (ptr != ptr->next && ptr == ptr->next->next);
}
+
/* If VAR has only a single immediate use, return true, and set USE_P and STMT
to the use pointer and stmt of occurrence. */
static inline bool
return num;
}
-
/* Return the tree pointer to by USE. */
static inline tree
get_use_from_ptr (use_operand_p use)
ann->used = 1;
}
-
-/* ----------------------------------------------------------------------- */
-
/* Return true if T is an executable statement. */
static inline bool
is_exec_stmt (tree t)
return false;
}
+/* Return true if T (assumed to be a DECL) is a global variable. */
+
+static inline bool
+is_global_var (tree t)
+{
+ if (MTAG_P (t))
+ return (TREE_STATIC (t) || MTAG_GLOBAL (t));
+ else
+ return (TREE_STATIC (t) || DECL_EXTERNAL (t));
+}
+
/* 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. */
return bb->loop_father;
}
+
+/* Return the memory partition tag associated with symbol SYM. */
+
+static inline tree
+memory_partition (tree sym)
+{
+ tree tag;
+
+ /* MPTs belong to their own partition. */
+ if (TREE_CODE (sym) == MEMORY_PARTITION_TAG)
+ return sym;
+
+ gcc_assert (!is_gimple_reg (sym));
+ tag = get_var_ann (sym)->mpt;
+
+#if defined ENABLE_CHECKING
+ if (tag)
+ gcc_assert (TREE_CODE (tag) == MEMORY_PARTITION_TAG);
+#endif
+
+ return tag;
+}
+
+
+/* Set MPT to be the memory partition associated with symbol SYM. */
+
+static inline void
+set_memory_partition (tree sym, tree mpt)
+{
+#if defined ENABLE_CHECKING
+ if (mpt)
+ gcc_assert (TREE_CODE (mpt) == MEMORY_PARTITION_TAG
+ && !is_gimple_reg (sym));
+#endif
+ var_ann (sym)->mpt = mpt;
+ if (mpt)
+ {
+ bitmap_set_bit (MPT_SYMBOLS (mpt), DECL_UID (sym));
+
+ /* MPT inherits the call-clobbering attributes from SYM. */
+ if (is_call_clobbered (sym))
+ {
+ MTAG_GLOBAL (mpt) = 1;
+ mark_call_clobbered (mpt, ESCAPE_IS_GLOBAL);
+ }
+ }
+}
+
+/* Return true if NAME is a memory factoring SSA name (i.e., an SSA
+ name for a memory partition. */
+
+static inline bool
+factoring_name_p (tree name)
+{
+ return TREE_CODE (SSA_NAME_VAR (name)) == MEMORY_PARTITION_TAG;
+}
+
/* Return true if VAR is a clobbered by function calls. */
static inline bool
is_call_clobbered (tree var)
{
if (!MTAG_P (var))
- return DECL_CALL_CLOBBERED (var);
+ return var_ann (var)->call_clobbered;
else
- return bitmap_bit_p (call_clobbered_vars, DECL_UID (var));
+ return bitmap_bit_p (gimple_call_clobbered_vars (cfun), DECL_UID (var));
}
/* Mark variable VAR as being clobbered by function calls. */
{
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));
+ var_ann (var)->call_clobbered = true;
+ bitmap_set_bit (gimple_call_clobbered_vars (cfun), DECL_UID (var));
}
/* Clear the call-clobbered attribute from variable VAR. */
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));
-}
-
-/* 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;
+ var_ann (var)->call_clobbered = false;
+ bitmap_clear_bit (gimple_call_clobbered_vars (cfun), DECL_UID (var));
}
/* Return the common annotation for T. Return NULL if the annotation
static inline tree_ann_common_t
tree_common_ann (tree t)
{
- return &t->common.ann->common;
+ /* Watch out static variables with unshared annotations. */
+ if (DECL_P (t) && TREE_CODE (t) == VAR_DECL)
+ return &var_ann (t)->common;
+ return &t->base.ann->common;
}
/* Return a common annotation for T. Create the constant annotation if it
}
if (ptr->vuses)
{
- use_p = VUSE_OP_PTR (ptr->vuses);
- ptr->vuses = ptr->vuses->next;
+ use_p = VUSE_OP_PTR (ptr->vuses, ptr->vuse_index);
+ if (++(ptr->vuse_index) >= VUSE_NUM (ptr->vuses))
+ {
+ ptr->vuse_index = 0;
+ ptr->vuses = ptr->vuses->next;
+ }
return use_p;
}
if (ptr->mayuses)
{
- use_p = MAYDEF_OP_PTR (ptr->mayuses);
- ptr->mayuses = ptr->mayuses->next;
- return use_p;
- }
- if (ptr->mustkills)
- {
- use_p = MUSTDEF_KILL_PTR (ptr->mustkills);
- ptr->mustkills = ptr->mustkills->next;
+ use_p = VDEF_OP_PTR (ptr->mayuses, ptr->mayuse_index);
+ if (++(ptr->mayuse_index) >= VDEF_NUM (ptr->mayuses))
+ {
+ ptr->mayuse_index = 0;
+ ptr->mayuses = ptr->mayuses->next;
+ }
return use_p;
}
if (ptr->phi_i < ptr->num_phi)
ptr->defs = ptr->defs->next;
return def_p;
}
- if (ptr->mustdefs)
- {
- def_p = MUSTDEF_RESULT_PTR (ptr->mustdefs);
- ptr->mustdefs = ptr->mustdefs->next;
- return def_p;
- }
- if (ptr->maydefs)
+ if (ptr->vdefs)
{
- def_p = MAYDEF_RESULT_PTR (ptr->maydefs);
- ptr->maydefs = ptr->maydefs->next;
+ def_p = VDEF_RESULT_PTR (ptr->vdefs);
+ ptr->vdefs = ptr->vdefs->next;
return def_p;
}
ptr->done = true;
}
if (ptr->vuses)
{
- val = VUSE_OP (ptr->vuses);
- ptr->vuses = ptr->vuses->next;
+ val = VUSE_OP (ptr->vuses, ptr->vuse_index);
+ if (++(ptr->vuse_index) >= VUSE_NUM (ptr->vuses))
+ {
+ ptr->vuse_index = 0;
+ ptr->vuses = ptr->vuses->next;
+ }
return val;
}
if (ptr->mayuses)
{
- val = MAYDEF_OP (ptr->mayuses);
- ptr->mayuses = ptr->mayuses->next;
- return val;
- }
- if (ptr->mustkills)
- {
- val = MUSTDEF_KILL (ptr->mustkills);
- ptr->mustkills = ptr->mustkills->next;
+ val = VDEF_OP (ptr->mayuses, ptr->mayuse_index);
+ if (++(ptr->mayuse_index) >= VDEF_NUM (ptr->mayuses))
+ {
+ ptr->mayuse_index = 0;
+ ptr->mayuses = ptr->mayuses->next;
+ }
return val;
}
if (ptr->defs)
ptr->defs = ptr->defs->next;
return val;
}
- if (ptr->mustdefs)
- {
- val = MUSTDEF_RESULT (ptr->mustdefs);
- ptr->mustdefs = ptr->mustdefs->next;
- return val;
- }
- if (ptr->maydefs)
+ if (ptr->vdefs)
{
- val = MAYDEF_RESULT (ptr->maydefs);
- ptr->maydefs = ptr->maydefs->next;
+ val = VDEF_RESULT (ptr->vdefs);
+ ptr->vdefs = ptr->vdefs->next;
return val;
}
ptr->defs = NULL;
ptr->uses = NULL;
ptr->vuses = NULL;
- ptr->maydefs = NULL;
+ ptr->vdefs = NULL;
ptr->mayuses = NULL;
- ptr->mustdefs = NULL;
- ptr->mustkills = NULL;
ptr->iter_type = ssa_op_iter_none;
ptr->phi_i = 0;
ptr->num_phi = 0;
ptr->phi_stmt = NULL_TREE;
ptr->done = true;
+ ptr->vuse_index = 0;
+ ptr->mayuse_index = 0;
}
/* Initialize the iterator PTR to the virtual defs in STMT. */
ptr->defs = (flags & SSA_OP_DEF) ? DEF_OPS (stmt) : NULL;
ptr->uses = (flags & SSA_OP_USE) ? USE_OPS (stmt) : NULL;
ptr->vuses = (flags & SSA_OP_VUSE) ? VUSE_OPS (stmt) : NULL;
- ptr->maydefs = (flags & SSA_OP_VMAYDEF) ? MAYDEF_OPS (stmt) : NULL;
- ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? MAYDEF_OPS (stmt) : NULL;
- ptr->mustdefs = (flags & SSA_OP_VMUSTDEF) ? MUSTDEF_OPS (stmt) : NULL;
- ptr->mustkills = (flags & SSA_OP_VMUSTKILL) ? MUSTDEF_OPS (stmt) : NULL;
+ ptr->vdefs = (flags & SSA_OP_VDEF) ? VDEF_OPS (stmt) : NULL;
+ ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? VDEF_OPS (stmt) : NULL;
ptr->done = false;
ptr->phi_i = 0;
ptr->num_phi = 0;
ptr->phi_stmt = NULL_TREE;
+ ptr->vuse_index = 0;
+ ptr->mayuse_index = 0;
}
/* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
static inline def_operand_p
op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
{
- gcc_assert ((flags & (SSA_OP_ALL_USES | SSA_OP_VIRTUAL_KILLS)) == 0);
+ gcc_assert ((flags & SSA_OP_ALL_USES) == 0);
op_iter_init (ptr, stmt, flags);
ptr->iter_type = ssa_op_iter_def;
return op_iter_next_def (ptr);
/* Get the next iterator mustdef value for PTR, returning the mustdef values in
KILL and DEF. */
static inline void
-op_iter_next_maymustdef (use_operand_p *use, def_operand_p *def,
+op_iter_next_vdef (vuse_vec_p *use, def_operand_p *def,
ssa_op_iter *ptr)
{
#ifdef ENABLE_CHECKING
- gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef);
+ gcc_assert (ptr->iter_type == ssa_op_iter_vdef);
#endif
if (ptr->mayuses)
{
- *def = MAYDEF_RESULT_PTR (ptr->mayuses);
- *use = MAYDEF_OP_PTR (ptr->mayuses);
+ *def = VDEF_RESULT_PTR (ptr->mayuses);
+ *use = VDEF_VECT (ptr->mayuses);
ptr->mayuses = ptr->mayuses->next;
return;
}
- if (ptr->mustkills)
- {
- *def = MUSTDEF_RESULT_PTR (ptr->mustkills);
- *use = MUSTDEF_KILL_PTR (ptr->mustkills);
- ptr->mustkills = ptr->mustkills->next;
- return;
- }
-
*def = NULL_DEF_OPERAND_P;
- *use = NULL_USE_OPERAND_P;
+ *use = NULL;
ptr->done = true;
return;
}
-/* Initialize iterator PTR to the operands in STMT. Return the first operands
- in USE and DEF. */
static inline void
-op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use,
- def_operand_p *def)
+op_iter_next_mustdef (use_operand_p *use, def_operand_p *def,
+ ssa_op_iter *ptr)
{
- gcc_assert (TREE_CODE (stmt) != PHI_NODE);
-
- op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
- ptr->iter_type = ssa_op_iter_maymustdef;
- op_iter_next_maymustdef (use, def, ptr);
+ vuse_vec_p vp;
+ op_iter_next_vdef (&vp, def, ptr);
+ if (vp != NULL)
+ {
+ gcc_assert (VUSE_VECT_NUM_ELEM (*vp) == 1);
+ *use = VUSE_ELEMENT_PTR (*vp, 0);
+ }
+ else
+ *use = NULL_USE_OPERAND_P;
}
-
/* Initialize iterator PTR to the operands in STMT. Return the first operands
- in KILL and DEF. */
+ in USE and DEF. */
static inline void
-op_iter_init_mustdef (ssa_op_iter *ptr, tree stmt, use_operand_p *kill,
+op_iter_init_vdef (ssa_op_iter *ptr, tree stmt, vuse_vec_p *use,
def_operand_p *def)
{
gcc_assert (TREE_CODE (stmt) != PHI_NODE);
- op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL);
- ptr->iter_type = ssa_op_iter_maymustdef;
- op_iter_next_maymustdef (kill, def, ptr);
-}
-
-/* Initialize iterator PTR to the operands in STMT. Return the first operands
- in KILL and DEF. */
-static inline void
-op_iter_init_must_and_may_def (ssa_op_iter *ptr, tree stmt,
- use_operand_p *kill, def_operand_p *def)
-{
- gcc_assert (TREE_CODE (stmt) != PHI_NODE);
-
- op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL|SSA_OP_VMAYUSE);
- ptr->iter_type = ssa_op_iter_maymustdef;
- op_iter_next_maymustdef (kill, def, ptr);
+ op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
+ ptr->iter_type = ssa_op_iter_vdef;
+ op_iter_next_vdef (use, def, ptr);
}
}
-/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
- return NULL. */
+/* Return true if there are zero operands in STMT matching the type
+ given in FLAGS. */
static inline bool
zero_ssa_operands (tree stmt, int flags)
{
use_operand_p use_p;
if (ssa_operands_active ())
- FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
- (SSA_OP_ALL_USES | SSA_OP_ALL_KILLS))
+ FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
delink_imm_use (use_p);
}
/* 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))
+ && !DECL_GIMPLE_REG_P (v))
return true;
return false;
}
+/* Return the memory tag associated with symbol SYM. */
+
+static inline tree
+symbol_mem_tag (tree sym)
+{
+ tree tag = get_var_ann (sym)->symbol_mem_tag;
+
+#if defined ENABLE_CHECKING
+ if (tag)
+ gcc_assert (TREE_CODE (tag) == SYMBOL_MEMORY_TAG);
+#endif
+
+ return tag;
+}
+
+
+/* Set the memory tag associated with symbol SYM. */
+
+static inline void
+set_symbol_mem_tag (tree sym, tree tag)
+{
+#if defined ENABLE_CHECKING
+ if (tag)
+ gcc_assert (TREE_CODE (tag) == SYMBOL_MEMORY_TAG);
+#endif
+
+ get_var_ann (sym)->symbol_mem_tag = tag;
+}
+
+/* Get the value handle of EXPR. This is the only correct way to get
+ the value handle for a "thing". If EXPR does not have a value
+ handle associated, it returns NULL_TREE.
+ NB: If EXPR is min_invariant, this function is *required* to return
+ EXPR. */
+
+static inline tree
+get_value_handle (tree expr)
+{
+ if (TREE_CODE (expr) == SSA_NAME)
+ return SSA_NAME_VALUE (expr);
+ else if (DECL_P (expr) || TREE_CODE (expr) == TREE_LIST
+ || TREE_CODE (expr) == CONSTRUCTOR)
+ {
+ tree_ann_common_t ann = tree_common_ann (expr);
+ return ((ann) ? ann->value_handle : NULL_TREE);
+ }
+ else if (is_gimple_min_invariant (expr))
+ return expr;
+ else if (EXPR_P (expr))
+ {
+ tree_ann_common_t ann = tree_common_ann (expr);
+ return ((ann) ? ann->value_handle : NULL_TREE);
+ }
+ else
+ gcc_unreachable ();
+}
+
+/* Accessor to tree-ssa-operands.c caches. */
+static inline struct ssa_operands *
+gimple_ssa_operands (struct function *fun)
+{
+ return &fun->gimple_df->ssa_operands;
+}
#endif /* _TREE_FLOW_INLINE_H */
OSDN Git Service
