static inline var_ann_t
var_ann (tree t)
{
-#if defined ENABLE_CHECKING
- if (t == NULL_TREE
- || !DECL_P (t)
- || (t->common.ann
- && t->common.ann->common.type != VAR_ANN))
- abort ();
-#endif
+ gcc_assert (t);
+ gcc_assert (DECL_P (t));
+ gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
return (var_ann_t) t->common.ann;
}
static inline stmt_ann_t
stmt_ann (tree t)
{
-#if defined ENABLE_CHECKING
- if (!is_gimple_stmt (t))
- abort ();
+#ifdef ENABLE_CHECKING
+ gcc_assert (is_gimple_stmt (t));
#endif
-
return (stmt_ann_t) t->common.ann;
}
static inline basic_block
bb_for_stmt (tree t)
{
- stmt_ann_t ann = stmt_ann (t);
+ stmt_ann_t ann;
+
+ if (TREE_CODE (t) == PHI_NODE)
+ return PHI_BB (t);
+
+ ann = stmt_ann (t);
return ann ? ann->bb : NULL;
}
return ann ? ann->may_aliases : NULL;
}
-/* Return true if VAR has a hidden use, false if it does not. */
-static inline bool
-has_hidden_use (tree var)
-{
- var_ann_t ann = var_ann (var);
- return ann ? ann->has_hidden_use : false;
-}
-
-/* Set the hidden use flag on VAR. */
-static inline void
-set_has_hidden_use (tree var)
-{
- var_ann_t ann = var_ann (var);
- if (ann == NULL)
- ann = create_var_ann (var);
- ann->has_hidden_use = 1;
-}
-
/* Return the line number for EXPR, or return -1 if we have no line
number information for it. */
static inline int
static inline def_optype
get_def_ops (stmt_ann_t ann)
{
- return ann ? ann->def_ops : NULL;
+ return ann ? ann->operands.def_ops : NULL;
}
/* Return the uses present in ANN, a statement annotation.
static inline use_optype
get_use_ops (stmt_ann_t ann)
{
- return ann ? ann->use_ops : NULL;
+ return ann ? ann->operands.use_ops : NULL;
}
/* Return the virtual may-defs present in ANN, a statement
static inline v_may_def_optype
get_v_may_def_ops (stmt_ann_t ann)
{
- return ann ? ann->v_may_def_ops : NULL;
+ return ann ? ann->operands.v_may_def_ops : NULL;
}
/* Return the virtual uses present in ANN, a statement annotation.
static inline vuse_optype
get_vuse_ops (stmt_ann_t ann)
{
- return ann ? ann->vuse_ops : NULL;
+ return ann ? ann->operands.vuse_ops : NULL;
}
/* Return the virtual must-defs present in ANN, a statement
static inline v_must_def_optype
get_v_must_def_ops (stmt_ann_t ann)
{
- return ann ? ann->v_must_def_ops : NULL;
+ return ann ? ann->operands.v_must_def_ops : NULL;
}
/* Return the tree pointer to by USE. */
static inline use_operand_p
get_use_op_ptr (use_optype uses, unsigned int index)
{
-#ifdef ENABLE_CHECKING
- if (index >= uses->num_uses)
- abort();
-#endif
+ gcc_assert (index < uses->num_uses);
return uses->uses[index];
}
static inline def_operand_p
get_def_op_ptr (def_optype defs, unsigned int index)
{
-#ifdef ENABLE_CHECKING
- if (index >= defs->num_defs)
- abort();
-#endif
+ gcc_assert (index < defs->num_defs);
return defs->defs[index];
}
get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index)
{
def_operand_p op;
-#ifdef ENABLE_CHECKING
- if (index >= v_may_defs->num_v_may_defs)
- abort();
-#endif
- op.def = &(v_may_defs->v_may_defs[index * 2]);
+ gcc_assert (index < v_may_defs->num_v_may_defs);
+ op.def = &(v_may_defs->v_may_defs[index].def);
return op;
}
get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index)
{
use_operand_p op;
-#ifdef ENABLE_CHECKING
- if (index >= v_may_defs->num_v_may_defs)
- abort();
-#endif
- op.use = &(v_may_defs->v_may_defs[index * 2 + 1]);
+ gcc_assert (index < v_may_defs->num_v_may_defs);
+ op.use = &(v_may_defs->v_may_defs[index].use);
return op;
}
get_vuse_op_ptr(vuse_optype vuses, unsigned int index)
{
use_operand_p op;
-#ifdef ENABLE_CHECKING
- if (index >= vuses->num_vuses)
- abort();
-#endif
+ gcc_assert (index < vuses->num_vuses);
op.use = &(vuses->vuses[index]);
return op;
}
get_v_must_def_op_ptr (v_must_def_optype v_must_defs, unsigned int index)
{
def_operand_p op;
-#ifdef ENABLE_CHECKING
- if (index >= v_must_defs->num_v_must_defs)
- abort();
-#endif
+ gcc_assert (index < v_must_defs->num_v_must_defs);
op.def = &(v_must_defs->v_must_defs[index]);
return op;
}
return op;
}
-/* Mark the beginning of changes to the SSA operands for STMT. */
-static inline void
-start_ssa_stmt_operands (tree stmt ATTRIBUTE_UNUSED)
-{
-#ifdef ENABLE_CHECKING
- verify_start_operands (stmt);
-#endif
-}
-
/* Return the bitmap of addresses taken by STMT, or NULL if it takes
no addresses. */
static inline bitmap
static dataflow_t
get_immediate_uses (tree stmt)
{
- stmt_ann_t ann = stmt_ann (stmt);
+ stmt_ann_t ann;
+
+ if (TREE_CODE (stmt) == PHI_NODE)
+ return PHI_DF (stmt);
+
+ ann = stmt_ann (stmt);
return ann ? ann->df : NULL;
}
return NULL_TREE;
#ifdef ENABLE_CHECKING
- if (num >= num_immediate_uses (df))
- abort ();
+ gcc_assert (num < num_immediate_uses (df));
#endif
if (num < 2)
return df->uses[num];
phi_arg_from_edge (tree phi, edge e)
{
int i;
-#if defined ENABLE_CHECKING
- if (!phi || TREE_CODE (phi) != PHI_NODE)
- abort();
-#endif
+ gcc_assert (phi);
+ gcc_assert (TREE_CODE (phi) == PHI_NODE);
for (i = 0; i < PHI_NUM_ARGS (phi); i++)
if (PHI_ARG_EDGE (phi, i) == e)
return -1;
}
+/* Mark VAR as used, so that it'll be preserved during rtl expansion. */
+
+static inline void
+set_is_used (tree var)
+{
+ var_ann_t ann = get_var_ann (var);
+ ann->used = 1;
+}
+
+
/* ----------------------------------------------------------------------- */
/* Return true if T is an executable statement. */
static inline void
set_default_def (tree var, tree def)
{
- var_ann_t ann = var_ann (var);
- if (ann == NULL)
- ann = create_var_ann (var);
+ var_ann_t ann = get_var_ann (var);
ann->default_def = def;
}
if (TREE_CODE (t) == SSA_NAME)
return true;
#ifdef ENABLE_CHECKING
- if (!is_gimple_min_invariant (t))
- abort ();
+ gcc_assert (is_gimple_min_invariant (t));
#endif
return false;
}
bsi.tsi = tsi_start (bb->stmt_list);
else
{
-#ifdef ENABLE_CHECKING
- if (bb->index >= 0)
- abort ();
-#endif
+ gcc_assert (bb->index < 0);
bsi.tsi.ptr = NULL;
bsi.tsi.container = NULL;
}
if (!bb->stmt_list)
{
-#ifdef ENABLE_CHECKING
- if (bb->index >= 0)
- abort ();
-#endif
+ gcc_assert (bb->index < 0);
bsi.tsi.ptr = NULL;
bsi.tsi.container = NULL;
return bsi;
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. */
- if (TREE_CODE (tsi_stmt (bsi.tsi)) != LABEL_EXPR)
- abort ();
+ gcc_assert (TREE_CODE (tsi_stmt (bsi.tsi)) == LABEL_EXPR);
next = bsi.tsi;
tsi_next (&next);
bsi.tsi = tsi_last (bb->stmt_list);
else
{
-#ifdef ENABLE_CHECKING
- if (bb->index >= 0)
- abort ();
-#endif
+ gcc_assert (bb->index < 0);
bsi.tsi.ptr = NULL;
bsi.tsi.container = NULL;
}
return bb->loop_father;
}
-/* Return true if VAR may be aliased. */
-static inline bool
-may_be_aliased (tree var)
-{
- return (TREE_ADDRESSABLE (var)
- || decl_function_context (var) != current_function_decl);
-}
-
/* Return true if VAR is a clobbered by function calls. */
static inline bool
is_call_clobbered (tree var)
{
- return needs_to_live_in_memory (var)
+ return is_global_var (var)
|| bitmap_bit_p (call_clobbered_vars, var_ann (var)->uid);
}
mark_call_clobbered (tree var)
{
var_ann_t ann = var_ann (var);
- /* Call-clobbered variables need to live in memory. */
- DECL_NEEDS_TO_LIVE_IN_MEMORY_INTERNAL (var) = 1;
+ /* 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)
+ DECL_EXTERNAL (var) = 1;
bitmap_set_bit (call_clobbered_vars, ann->uid);
}
mark_non_addressable (tree var)
{
bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
- DECL_NEEDS_TO_LIVE_IN_MEMORY_INTERNAL (var) = 0;
TREE_ADDRESSABLE (var) = 0;
}
return (ann) ? ann : create_tree_ann (t);
}
+/* ----------------------------------------------------------------------- */
+
+/* The following set of routines are used to iterator over various type of
+ SSA operands. */
+
+/* Return true if PTR is finished iterating. */
+static inline bool
+op_iter_done (ssa_op_iter *ptr)
+{
+ return ptr->done;
+}
+
+/* Get the next iterator use value for PTR. */
+static inline use_operand_p
+op_iter_next_use (ssa_op_iter *ptr)
+{
+ if (ptr->use_i < ptr->num_use)
+ {
+ return USE_OP_PTR (ptr->ops->use_ops, (ptr->use_i)++);
+ }
+ if (ptr->vuse_i < ptr->num_vuse)
+ {
+ return VUSE_OP_PTR (ptr->ops->vuse_ops, (ptr->vuse_i)++);
+ }
+ if (ptr->v_mayu_i < ptr->num_v_mayu)
+ {
+ return V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops,
+ (ptr->v_mayu_i)++);
+ }
+ ptr->done = true;
+ return NULL_USE_OPERAND_P;
+}
+
+/* Get the next iterator def value for PTR. */
+static inline def_operand_p
+op_iter_next_def (ssa_op_iter *ptr)
+{
+ if (ptr->def_i < ptr->num_def)
+ {
+ return DEF_OP_PTR (ptr->ops->def_ops, (ptr->def_i)++);
+ }
+ if (ptr->v_must_i < ptr->num_v_must)
+ {
+ return V_MUST_DEF_OP_PTR (ptr->ops->v_must_def_ops,
+ (ptr->v_must_i)++);
+ }
+ if (ptr->v_mayd_i < ptr->num_v_mayd)
+ {
+ return V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops,
+ (ptr->v_mayd_i)++);
+ }
+ ptr->done = true;
+ return NULL_DEF_OPERAND_P;
+}
+
+/* Get the next iterator tree value for PTR. */
+static inline tree
+op_iter_next_tree (ssa_op_iter *ptr)
+{
+ if (ptr->use_i < ptr->num_use)
+ {
+ return USE_OP (ptr->ops->use_ops, (ptr->use_i)++);
+ }
+ if (ptr->vuse_i < ptr->num_vuse)
+ {
+ return VUSE_OP (ptr->ops->vuse_ops, (ptr->vuse_i)++);
+ }
+ if (ptr->v_mayu_i < ptr->num_v_mayu)
+ {
+ return V_MAY_DEF_OP (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
+ }
+ if (ptr->def_i < ptr->num_def)
+ {
+ return DEF_OP (ptr->ops->def_ops, (ptr->def_i)++);
+ }
+ if (ptr->v_must_i < ptr->num_v_must)
+ {
+ return V_MUST_DEF_OP (ptr->ops->v_must_def_ops,
+ (ptr->v_must_i)++);
+ }
+ if (ptr->v_mayd_i < ptr->num_v_mayd)
+ {
+ return V_MAY_DEF_RESULT (ptr->ops->v_may_def_ops,
+ (ptr->v_mayd_i)++);
+ }
+ ptr->done = true;
+ return NULL;
+}
+
+/* Initialize the iterator PTR to the virtual defs in STMT. */
+static inline void
+op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
+{
+ stmt_operands_p ops;
+ stmt_ann_t ann = get_stmt_ann (stmt);
+
+ ops = &(ann->operands);
+ ptr->done = false;
+ ptr->ops = ops;
+ ptr->num_def = (flags & SSA_OP_DEF) ? NUM_DEFS (ops->def_ops) : 0;
+ ptr->num_use = (flags & SSA_OP_USE) ? NUM_USES (ops->use_ops) : 0;
+ ptr->num_vuse = (flags & SSA_OP_VUSE) ? NUM_VUSES (ops->vuse_ops) : 0;
+ ptr->num_v_mayu = (flags & SSA_OP_VMAYUSE)
+ ? NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
+ ptr->num_v_mayd = (flags & SSA_OP_VMAYDEF)
+ ? NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
+ ptr->num_v_must = (flags & SSA_OP_VMUSTDEF)
+ ? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0;
+ ptr->def_i = 0;
+ ptr->use_i = 0;
+ ptr->vuse_i = 0;
+ ptr->v_mayu_i = 0;
+ ptr->v_mayd_i = 0;
+ ptr->v_must_i = 0;
+}
+
+/* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
+ the first use. */
+static inline use_operand_p
+op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
+{
+ op_iter_init (ptr, stmt, flags);
+ return op_iter_next_use (ptr);
+}
+
+/* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
+ the first def. */
+static inline def_operand_p
+op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
+{
+ op_iter_init (ptr, stmt, flags);
+ return op_iter_next_def (ptr);
+}
+
+/* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
+ the first operand as a tree. */
+static inline tree
+op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags)
+{
+ op_iter_init (ptr, stmt, flags);
+ return op_iter_next_tree (ptr);
+}
+
+/* Get the next iterator maydef value for PTR, returning the maydef values in
+ USE and DEF. */
+static inline void
+op_iter_next_maydef (use_operand_p *use, def_operand_p *def, ssa_op_iter *ptr)
+{
+ if (ptr->v_mayu_i < ptr->num_v_mayu)
+ {
+ *def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
+ *use = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
+ return;
+ }
+ else
+ {
+ *def = NULL_DEF_OPERAND_P;
+ *use = NULL_USE_OPERAND_P;
+ }
+ 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_init (ptr, stmt, SSA_OP_VMAYUSE);
+ op_iter_next_maydef (use, def, ptr);
+}
#endif /* _TREE_FLOW_INLINE_H */
OSDN Git Service
