You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#ifndef _TREE_FLOW_INLINE_H
#define _TREE_FLOW_INLINE_H 1
/* Inline functions for manipulating various data structures defined in
tree-flow.h. See tree-flow.h for documentation. */
+/* Initialize the hashtable iterator HTI to point to hashtable TABLE */
+
+static inline void *
+first_htab_element (htab_iterator *hti, htab_t table)
+{
+ hti->htab = table;
+ hti->slot = table->entries;
+ hti->limit = hti->slot + htab_size (table);
+ do
+ {
+ PTR x = *(hti->slot);
+ 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;
+}
+
+/* Return current non-empty/deleted slot of the hashtable pointed to by HTI,
+ or NULL if we have reached the end. */
+
+static inline bool
+end_htab_p (htab_iterator *hti)
+{
+ if (hti->slot >= hti->limit)
+ return true;
+ return false;
+}
+
+/* Advance the hashtable iterator pointed by HTI to the next element of the
+ hashtable. */
+
+static inline void *
+next_htab_element (htab_iterator *hti)
+{
+ while (++(hti->slot) < hti->limit)
+ {
+ PTR x = *(hti->slot);
+ if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
+ return x;
+ };
+ return NULL;
+}
+
+/* Initialize ITER to point to the first referenced variable in the
+ referenced_vars hashtable, and return that variable. */
+
+static inline tree
+first_referenced_var (referenced_var_iterator *iter)
+{
+ struct int_tree_map *itm;
+ itm = first_htab_element (&iter->hti, referenced_vars);
+ if (!itm)
+ return NULL;
+ return itm->to;
+}
+
+/* Return true if we have hit the end of the referenced variables ITER is
+ iterating through. */
+
+static inline bool
+end_referenced_vars_p (referenced_var_iterator *iter)
+{
+ return end_htab_p (&iter->hti);
+}
+
+/* Make ITER point to the next referenced_var in the referenced_var hashtable,
+ and return that variable. */
+
+static inline tree
+next_referenced_var (referenced_var_iterator *iter)
+{
+ struct int_tree_map *itm;
+ itm = next_htab_element (&iter->hti);
+ if (!itm)
+ return NULL;
+ return itm->to;
+}
+
/* 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
return (ann) ? ann : create_stmt_ann (stmt);
}
-
/* Return the annotation type for annotation ANN. */
static inline enum tree_ann_type
ann_type (tree_ann_t ann)
link_imm_use (use, val);
}
-/* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occuring
+/* 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, tree stmt)
}
}
-/* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occuring
+/* 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, tree stmt)
return ann ? ann->addresses_taken : NULL;
}
-/* Return the basic_block annotation for BB. */
-static inline bb_ann_t
-bb_ann (basic_block bb)
-{
- return (bb_ann_t)bb->tree_annotations;
-}
-
/* Return the PHI nodes for basic block BB, or NULL if there are no
PHI nodes. */
static inline tree
phi_nodes (basic_block bb)
{
- return bb_ann (bb)->phi_nodes;
+ return bb->phi_nodes;
}
/* Set list of phi nodes of a basic block BB to L. */
{
tree phi;
- bb_ann (bb)->phi_nodes = l;
+ bb->phi_nodes = l;
for (phi = l; phi; phi = PHI_CHAIN (phi))
set_bb_for_stmt (phi, bb);
}
is_call_clobbered (tree var)
{
return is_global_var (var)
- || bitmap_bit_p (call_clobbered_vars, var_ann (var)->uid);
+ || bitmap_bit_p (call_clobbered_vars, DECL_UID (var));
}
/* Mark variable VAR as being clobbered by function calls. */
location in global memory. */
if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
DECL_EXTERNAL (var) = 1;
- bitmap_set_bit (call_clobbered_vars, ann->uid);
+ bitmap_set_bit (call_clobbered_vars, DECL_UID (var));
ssa_call_clobbered_cache_valid = false;
ssa_ro_call_cache_valid = false;
}
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;
- bitmap_clear_bit (call_clobbered_vars, ann->uid);
+ bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
ssa_call_clobbered_cache_valid = false;
ssa_ro_call_cache_valid = false;
}
static inline void
mark_non_addressable (tree var)
{
- bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
+ 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;
static inline use_operand_p
op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
{
+ gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0);
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, tree stmt, int flags)
{
+ gcc_assert ((flags & (SSA_OP_ALL_USES | SSA_OP_VIRTUAL_KILLS)) == 0);
op_iter_init (ptr, stmt, flags);
ptr->iter_type = ssa_op_iter_def;
return op_iter_next_def (ptr);
num_ssa_operands (tree stmt, int flags)
{
ssa_op_iter iter;
+ tree t;
int num = 0;
- op_iter_init (&iter, stmt, flags);
- for ( ; iter.defs; iter.defs = iter.defs->next)
- num++;
- for ( ; iter.uses; iter.uses = iter.uses->next)
- num++;
- for ( ; iter.vuses; iter.vuses = iter.vuses->next)
+ FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
num++;
- for ( ; iter.maydefs; iter.maydefs = iter.maydefs->next)
- num++;
- for ( ; iter.mayuses; iter.mayuses = iter.mayuses->next)
- num++;
- for ( ; iter.mustdefs; iter.mustdefs = iter.mustdefs->next)
- num++;
- for ( ; iter.mustkills; iter.mustkills = iter.mustkills->next)
- num++;
-
return num;
}
OSDN Git Service
