/* Inline functions for tree-flow.h
- Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2003, 2005, 2006, 2007, 2008 Free Software
+ Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
GNU General Public License for more details.
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. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#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. */
-/* 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
-var_ann (tree t)
+/* 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 (const struct function *fun)
{
- gcc_assert (t);
- gcc_assert (DECL_P (t));
- gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
+ return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
+}
- return (var_ann_t) t->common.ann;
+/* 'true' after aliases have been computed (see compute_may_aliases). */
+static inline bool
+gimple_aliases_computed_p (const struct function *fun)
+{
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->aliases_computed_p;
}
-/* Return the variable annotation for T, which must be a _DECL node.
- Create the variable annotation if it doesn't exist. */
-static inline var_ann_t
-get_var_ann (tree var)
+/* 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 (const struct function *fun)
{
- var_ann_t ann = var_ann (var);
- return (ann) ? ann : create_var_ann (var);
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->addressable_vars;
}
-/* 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
-stmt_ann (tree t)
+/* 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 (const struct function *fun)
{
-#ifdef ENABLE_CHECKING
- gcc_assert (is_gimple_stmt (t));
-#endif
- return (stmt_ann_t) t->common.ann;
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->call_clobbered_vars;
}
-/* Return the statement annotation for T, which must be a statement
- node. Create the statement annotation if it doesn't exist. */
-static inline stmt_ann_t
-get_stmt_ann (tree stmt)
+/* Call-used variables in the function. If bit I is set, then
+ REFERENCED_VARS (I) is call-used at pure function call-sites. */
+static inline bitmap
+gimple_call_used_vars (const struct function *fun)
{
- stmt_ann_t ann = stmt_ann (stmt);
- return (ann) ? ann : create_stmt_ann (stmt);
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->call_used_vars;
}
+/* Array of all variables referenced in the function. */
+static inline htab_t
+gimple_referenced_vars (const struct function *fun)
+{
+ if (!fun->gimple_df)
+ return NULL;
+ return fun->gimple_df->referenced_vars;
+}
-/* Return the annotation type for annotation ANN. */
-static inline enum tree_ann_type
-ann_type (tree_ann_t ann)
+/* Artificial variable used to model the effects of function calls. */
+static inline tree
+gimple_global_var (const struct function *fun)
{
- return ann->common.type;
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->global_var;
}
-/* Return the basic block for statement T. */
-static inline basic_block
-bb_for_stmt (tree t)
+/* Artificial variable used to model the effects of nonlocal
+ variables. */
+static inline tree
+gimple_nonlocal_all (const struct function *fun)
{
- stmt_ann_t ann;
+ gcc_assert (fun && fun->gimple_df);
+ return fun->gimple_df->nonlocal_all;
+}
- if (TREE_CODE (t) == PHI_NODE)
- return PHI_BB (t);
+/* Initialize the hashtable iterator HTI to point to hashtable TABLE */
- ann = stmt_ann (t);
- return ann ? ann->bb : NULL;
+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 the may_aliases varray for variable VAR, or NULL if it has
- no may aliases. */
-static inline varray_type
-may_aliases (tree var)
+/* 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 (const htab_iterator *hti)
{
- var_ann_t ann = var_ann (var);
- return ann ? ann->may_aliases : NULL;
+ if (hti->slot >= hti->limit)
+ return true;
+ return false;
}
-/* Return the line number for EXPR, or return -1 if we have no line
- number information for it. */
-static inline int
-get_lineno (tree expr)
+/* Advance the hashtable iterator pointed to by HTI to the next element of the
+ hashtable. */
+
+static inline void *
+next_htab_element (htab_iterator *hti)
{
- if (expr == NULL_TREE)
- return -1;
+ while (++(hti->slot) < hti->limit)
+ {
+ PTR x = *(hti->slot);
+ if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
+ return x;
+ };
+ return NULL;
+}
- if (TREE_CODE (expr) == COMPOUND_EXPR)
- expr = TREE_OPERAND (expr, 0);
+/* Initialize ITER to point to the first referenced variable in the
+ referenced_vars hashtable, and return that variable. */
- if (! EXPR_HAS_LOCATION (expr))
- return -1;
+static inline tree
+first_referenced_var (referenced_var_iterator *iter)
+{
+ return (tree) first_htab_element (&iter->hti,
+ gimple_referenced_vars (cfun));
+}
+
+/* Return true if we have hit the end of the referenced variables ITER is
+ iterating through. */
+
+static inline bool
+end_referenced_vars_p (const 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)
+{
+ return (tree) next_htab_element (&iter->hti);
+}
+
+/* Fill up VEC with the variables in the referenced vars hashtable. */
- return EXPR_LINENO (expr);
+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 file name for EXPR, or return "???" if we have no
- filename information. */
-static inline const char *
-get_filename (tree expr)
+/* 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
+var_ann (const_tree t)
{
- const char *filename;
- if (expr == NULL_TREE)
- return "???";
+ var_ann_t ann;
- if (TREE_CODE (expr) == COMPOUND_EXPR)
- expr = TREE_OPERAND (expr, 0);
+ if (!t->base.ann)
+ return NULL;
+ ann = (var_ann_t) t->base.ann;
- if (EXPR_HAS_LOCATION (expr) && (filename = EXPR_FILENAME (expr)))
- return filename;
- else
- return "???";
+ gcc_assert (ann->common.type == VAR_ANN);
+
+ return ann;
}
-/* Return true if T is a noreturn call. */
-static inline bool
-noreturn_call_p (tree t)
+/* Return the variable annotation for T, which must be a _DECL node.
+ Create the variable annotation if it doesn't exist. */
+static inline var_ann_t
+get_var_ann (tree var)
{
- tree call = get_call_expr_in (t);
- return call != 0 && (call_expr_flags (call) & ECF_NORETURN) != 0;
+ var_ann_t ann = var_ann (var);
+ return (ann) ? ann : create_var_ann (var);
}
-/* Mark statement T as modified. */
-static inline void
-mark_stmt_modified (tree t)
+/* Return the function annotation for T, which must be a FUNCTION_DECL node.
+ Return NULL if the function annotation doesn't already exist. */
+static inline function_ann_t
+function_ann (const_tree t)
{
- stmt_ann_t ann;
- if (TREE_CODE (t) == PHI_NODE)
- return;
+ gcc_assert (t);
+ gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
+ gcc_assert (!t->base.ann
+ || t->base.ann->common.type == FUNCTION_ANN);
- 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);
- ann->modified = 1;
+ return (function_ann_t) t->base.ann;
}
-/* Mark statement T as modified, and update it. */
-static inline void
-update_stmt (tree t)
+/* Return the function annotation for T, which must be a FUNCTION_DECL node.
+ Create the function annotation if it doesn't exist. */
+static inline function_ann_t
+get_function_ann (tree var)
{
- if (TREE_CODE (t) == PHI_NODE)
- return;
- mark_stmt_modified (t);
- update_stmt_operands (t);
+ function_ann_t ann = function_ann (var);
+ gcc_assert (!var->base.ann || var->base.ann->common.type == FUNCTION_ANN);
+ return (ann) ? ann : create_function_ann (var);
}
+/* Get the number of the next statement uid to be allocated. */
+static inline unsigned int
+gimple_stmt_max_uid (struct function *fn)
+{
+ return fn->last_stmt_uid;
+}
+
+/* Set the number of the next statement uid to be allocated. */
static inline void
-update_stmt_if_modified (tree t)
+set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
{
- if (stmt_modified_p (t))
- update_stmt_operands (t);
+ fn->last_stmt_uid = maxid;
}
-/* Return true if T is marked as modified, false otherwise. */
-static inline bool
-stmt_modified_p (tree t)
+/* Set the number of the next statement uid to be allocated. */
+static inline unsigned int
+inc_gimple_stmt_max_uid (struct function *fn)
+{
+ return fn->last_stmt_uid++;
+}
+
+/* Return the annotation type for annotation ANN. */
+static inline enum tree_ann_type
+ann_type (tree_ann_t ann)
{
- stmt_ann_t ann = stmt_ann (t);
+ return ann->common.type;
+}
+
+/* Return the may_aliases bitmap for variable VAR, or NULL if it has
+ no may aliases. */
+static inline bitmap
+may_aliases (const_tree var)
+{
+ return MTAG_ALIASES (var);
+}
+
+/* Return the line number for EXPR, or return -1 if we have no line
+ number information for it. */
+static inline int
+get_lineno (const_gimple stmt)
+{
+ location_t loc;
+
+ if (!stmt)
+ return -1;
+
+ loc = gimple_location (stmt);
+ if (loc != UNKNOWN_LOCATION)
+ return -1;
- /* Note that if the statement doesn't yet have an annotation, we consider it
- modified. This will force the next call to update_stmt_operands to scan
- the statement. */
- return ann ? ann->modified : true;
+ return LOCATION_LINE (loc);
}
/* Delink an immediate_uses node from its chain. */
}
}
-/* Set the value of a use pointed by USE to VAL. */
+/* Set the value of a use pointed to by USE to VAL. */
static inline void
set_ssa_use_from_ptr (use_operand_p use, tree val)
{
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)
+link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt)
{
if (stmt)
link_imm_use (linknode, def);
else
link_imm_use (linknode, NULL);
- linknode->stmt = stmt;
+ linknode->loc.stmt = stmt;
}
/* Relink a new node in place of an old node in the list. */
}
}
-/* 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)
+relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old,
+ gimple stmt)
{
if (stmt)
relink_imm_use (linknode, old);
else
link_imm_use (linknode, NULL);
- linknode->stmt = stmt;
-}
-
-/* Finished the traverse of an immediate use list IMM by removing it from
- the list. */
-static inline void
-end_safe_imm_use_traverse (imm_use_iterator *imm)
-{
- delink_imm_use (&(imm->iter_node));
+ linknode->loc.stmt = stmt;
}
-/* Return true if IMM is at the end of the list. */
-static inline bool
-end_safe_imm_use_p (imm_use_iterator *imm)
-{
- return (imm->imm_use == imm->end_p);
-}
-
-/* Initialize iterator IMM to process the list for VAR. */
-static inline use_operand_p
-first_safe_imm_use (imm_use_iterator *imm, tree var)
-{
- /* Set up and link the iterator node into the linked list for VAR. */
- imm->iter_node.use = NULL;
- imm->iter_node.stmt = NULL_TREE;
- imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
- /* Check if there are 0 elements. */
- if (imm->end_p->next == imm->end_p)
- {
- imm->imm_use = imm->end_p;
- return NULL_USE_OPERAND_P;
- }
-
- link_imm_use (&(imm->iter_node), var);
- imm->imm_use = imm->iter_node.next;
- return imm->imm_use;
-}
-
-/* Bump IMM to the next use in the list. */
-static inline use_operand_p
-next_safe_imm_use (imm_use_iterator *imm)
-{
- ssa_use_operand_t *ptr;
- use_operand_p old;
-
- old = imm->imm_use;
- /* If the next node following the iter_node is still the one referred to by
- imm_use, then the list hasn't changed, go to the next node. */
- if (imm->iter_node.next == imm->imm_use)
- {
- ptr = &(imm->iter_node);
- /* Remove iternode from the list. */
- delink_imm_use (ptr);
- imm->imm_use = imm->imm_use->next;
- if (! end_safe_imm_use_p (imm))
- {
- /* This isn't the end, link iternode before the next use. */
- ptr->prev = imm->imm_use->prev;
- ptr->next = imm->imm_use;
- imm->imm_use->prev->next = ptr;
- imm->imm_use->prev = ptr;
- }
- else
- return old;
- }
- else
- {
- /* If the 'next' value after the iterator isn't the same as it was, then
- a node has been deleted, so we simply proceed to the node following
- where the iterator is in the list. */
- imm->imm_use = imm->iter_node.next;
- if (end_safe_imm_use_p (imm))
- {
- end_safe_imm_use_traverse (imm);
- return old;
- }
- }
-
- return imm->imm_use;
-}
/* Return true is IMM has reached the end of the immediate use list. */
static inline bool
-end_readonly_imm_use_p (imm_use_iterator *imm)
+end_readonly_imm_use_p (const imm_use_iterator *imm)
{
return (imm->imm_use == imm->end_p);
}
use_operand_p old = imm->imm_use;
#ifdef ENABLE_CHECKING
- /* If this assertion fails, it indicates the 'next' pointer has changed
- since we the last bump. This indicates that the list is being modified
+ /* If this assertion fails, it indicates the 'next' pointer has changed
+ since the last bump. This indicates that the list is being modified
via stmt changes, or SET_USE, or somesuch thing, and you need to be
using the SAFE version of the iterator. */
gcc_assert (imm->iter_node.next == old->next);
imm->imm_use = old->next;
if (end_readonly_imm_use_p (imm))
- return old;
+ return NULL_USE_OPERAND_P;
return imm->imm_use;
}
/* Return true if VAR has no uses. */
static inline bool
-has_zero_uses (tree var)
+has_zero_uses (const_tree var)
{
- ssa_use_operand_t *ptr;
- ptr = &(SSA_NAME_IMM_USE_NODE (var));
+ const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
/* A single use means there is no items in the list. */
return (ptr == ptr->next);
}
/* Return true if VAR has a single use. */
static inline bool
-has_single_use (tree var)
+has_single_use (const_tree var)
{
- ssa_use_operand_t *ptr;
- ptr = &(SSA_NAME_IMM_USE_NODE (var));
+ const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
/* A single use means there is one item in the list. */
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
-single_imm_use (tree var, use_operand_p *use_p, tree *stmt)
+single_imm_use (const_tree var, use_operand_p *use_p, gimple *stmt)
{
- ssa_use_operand_t *ptr;
-
- ptr = &(SSA_NAME_IMM_USE_NODE (var));
+ const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
if (ptr != ptr->next && ptr == ptr->next->next)
{
*use_p = ptr->next;
- *stmt = ptr->next->stmt;
+ *stmt = ptr->next->loc.stmt;
return true;
}
*use_p = NULL_USE_OPERAND_P;
- *stmt = NULL_TREE;
+ *stmt = NULL;
return false;
}
/* Return the number of immediate uses of VAR. */
static inline unsigned int
-num_imm_uses (tree var)
+num_imm_uses (const_tree var)
{
- ssa_use_operand_t *ptr, *start;
- unsigned int num;
+ const ssa_use_operand_t *const start = &(SSA_NAME_IMM_USE_NODE (var));
+ const ssa_use_operand_t *ptr;
+ unsigned int num = 0;
- start = &(SSA_NAME_IMM_USE_NODE (var));
- num = 0;
for (ptr = start->next; ptr != start; ptr = ptr->next)
num++;
return num;
}
-
-/* Return the tree pointer 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 pointer to by DEF. */
+/* Return the tree pointed-to by DEF. */
static inline tree
get_def_from_ptr (def_operand_p def)
{
return *def;
}
-/* Return a def_operand_p pointer for the result of PHI. */
-static inline def_operand_p
-get_phi_result_ptr (tree phi)
+/* Return a use_operand_p pointer for argument I of PHI node GS. */
+
+static inline use_operand_p
+gimple_phi_arg_imm_use_ptr (gimple gs, int i)
{
- return &(PHI_RESULT_TREE (phi));
+ return &gimple_phi_arg (gs, i)->imm_use;
}
-/* Return a use_operand_p pointer for argument I of phinode PHI. */
-static inline use_operand_p
-get_phi_arg_def_ptr (tree phi, int i)
+/* Return the tree operand for argument I of PHI node GS. */
+
+static inline tree
+gimple_phi_arg_def (gimple gs, size_t index)
{
- return &(PHI_ARG_IMM_USE_NODE (phi,i));
+ struct phi_arg_d *pd = gimple_phi_arg (gs, index);
+ return get_use_from_ptr (&pd->imm_use);
}
+/* Return a pointer to the tree operand for argument I of PHI node GS. */
-/* Return the bitmap of addresses taken by STMT, or NULL if it takes
- no addresses. */
-static inline bitmap
-addresses_taken (tree stmt)
+static inline tree *
+gimple_phi_arg_def_ptr (gimple gs, size_t index)
{
- stmt_ann_t ann = stmt_ann (stmt);
- return ann ? ann->addresses_taken : NULL;
+ return &gimple_phi_arg (gs, index)->def;
}
-/* Return the basic_block annotation for BB. */
-static inline bb_ann_t
-bb_ann (basic_block bb)
+/* Return the edge associated with argument I of phi node GS. */
+
+static inline edge
+gimple_phi_arg_edge (gimple gs, size_t i)
{
- return (bb_ann_t)bb->tree_annotations;
+ return EDGE_PRED (gimple_bb (gs), i);
}
/* Return the PHI nodes for basic block BB, or NULL if there are no
PHI nodes. */
-static inline tree
-phi_nodes (basic_block bb)
+static inline gimple_seq
+phi_nodes (const_basic_block bb)
{
- return bb_ann (bb)->phi_nodes;
+ gcc_assert (!(bb->flags & BB_RTL));
+ if (!bb->il.gimple)
+ return NULL;
+ return bb->il.gimple->phi_nodes;
}
-/* Set list of phi nodes of a basic block BB to L. */
+/* Set PHI nodes of a basic block BB to SEQ. */
static inline void
-set_phi_nodes (basic_block bb, tree l)
+set_phi_nodes (basic_block bb, gimple_seq seq)
{
- tree phi;
+ gimple_stmt_iterator i;
- bb_ann (bb)->phi_nodes = l;
- for (phi = l; phi; phi = PHI_CHAIN (phi))
- set_bb_for_stmt (phi, bb);
+ gcc_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))
+ gimple_set_bb (gsi_stmt (i), bb);
}
/* Return the phi argument which contains the specified use. */
phi_arg_index_from_use (use_operand_p use)
{
struct phi_arg_d *element, *root;
- int index;
- tree phi;
+ size_t index;
+ gimple phi;
/* Since the use is the first thing in a PHI argument element, we can
calculate its index based on casting it to an argument, and performing
pointer arithmetic. */
phi = USE_STMT (use);
- gcc_assert (TREE_CODE (phi) == PHI_NODE);
+ gcc_assert (gimple_code (phi) == GIMPLE_PHI);
element = (struct phi_arg_d *)use;
- root = &(PHI_ARG_ELT (phi, 0));
+ root = gimple_phi_arg (phi, 0);
index = element - root;
#ifdef ENABLE_CHECKING
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 >= 0 && index < PHI_ARG_CAPACITY (phi));
+ gcc_assert (index < gimple_phi_capacity (phi));
#endif
return index;
}
-/* ----------------------------------------------------------------------- */
-
-/* Return true if T is an executable statement. */
-static inline bool
-is_exec_stmt (tree t)
-{
- return (t && !IS_EMPTY_STMT (t) && t != error_mark_node);
-}
-
+/* Return true if T (assumed to be a DECL) is a global variable. */
-/* Return true if this stmt can be the target of a control transfer stmt such
- as a goto. */
static inline bool
-is_label_stmt (tree t)
-{
- if (t)
- switch (TREE_CODE (t))
- {
- case LABEL_DECL:
- case LABEL_EXPR:
- case CASE_LABEL_EXPR:
- return true;
- default:
- return false;
- }
- return false;
-}
-
-/* Set the default definition for VAR to DEF. */
-static inline void
-set_default_def (tree var, tree def)
+is_global_var (const_tree t)
{
- var_ann_t ann = get_var_ann (var);
- ann->default_def = def;
-}
-
-/* Return the default definition for variable VAR, or NULL if none
- exists. */
-static inline tree
-default_def (tree var)
-{
- var_ann_t ann = var_ann (var);
- return ann ? ann->default_def : NULL_TREE;
+ if (MTAG_P (t))
+ return MTAG_GLOBAL (t);
+ else
+ return (TREE_STATIC (t) || DECL_EXTERNAL (t));
}
/* PHI nodes should contain only ssa_names and invariants. A test
slip in in the meantime. */
static inline bool
-phi_ssa_name_p (tree t)
+phi_ssa_name_p (const_tree t)
{
if (TREE_CODE (t) == SSA_NAME)
return true;
return false;
}
-/* ----------------------------------------------------------------------- */
-
-/* Return a block_stmt_iterator that points to beginning of basic
- block BB. */
-static inline block_stmt_iterator
-bsi_start (basic_block bb)
-{
- block_stmt_iterator bsi;
- if (bb->stmt_list)
- bsi.tsi = tsi_start (bb->stmt_list);
- else
- {
- gcc_assert (bb->index < 0);
- bsi.tsi.ptr = NULL;
- bsi.tsi.container = NULL;
- }
- bsi.bb = bb;
- return bsi;
-}
-/* Return a block statement iterator that points to the last label in
- block BB. */
+/* Returns the loop of the statement STMT. */
-static inline block_stmt_iterator
-bsi_after_labels (basic_block bb)
+static inline struct loop *
+loop_containing_stmt (gimple stmt)
{
- block_stmt_iterator bsi;
- tree_stmt_iterator next;
-
- bsi.bb = bb;
-
- if (!bb->stmt_list)
- {
- gcc_assert (bb->index < 0);
- bsi.tsi.ptr = NULL;
- bsi.tsi.container = NULL;
- return bsi;
- }
-
- bsi.tsi = tsi_start (bb->stmt_list);
- if (tsi_end_p (bsi.tsi))
- return bsi;
-
- /* Ensure that there are some labels. The rationale is that we want
- to insert after the bsi that is returned, and these insertions should
- 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. */
- gcc_assert (TREE_CODE (tsi_stmt (bsi.tsi)) == LABEL_EXPR);
+ basic_block bb = gimple_bb (stmt);
+ if (!bb)
+ return NULL;
- next = bsi.tsi;
- tsi_next (&next);
+ return bb->loop_father;
+}
- while (!tsi_end_p (next)
- && TREE_CODE (tsi_stmt (next)) == LABEL_EXPR)
- {
- bsi.tsi = next;
- tsi_next (&next);
- }
- return bsi;
-}
+/* Return the memory partition tag associated with symbol SYM. */
-/* Return a block statement iterator that points to the end of basic
- block BB. */
-static inline block_stmt_iterator
-bsi_last (basic_block bb)
+static inline tree
+memory_partition (tree sym)
{
- block_stmt_iterator bsi;
- if (bb->stmt_list)
- bsi.tsi = tsi_last (bb->stmt_list);
- else
- {
- gcc_assert (bb->index < 0);
- bsi.tsi.ptr = NULL;
- bsi.tsi.container = NULL;
- }
- bsi.bb = bb;
- return bsi;
-}
+ tree tag;
-/* Return true if block statement iterator I has reached the end of
- the basic block. */
-static inline bool
-bsi_end_p (block_stmt_iterator i)
-{
- return tsi_end_p (i.tsi);
-}
+ /* MPTs belong to their own partition. */
+ if (TREE_CODE (sym) == MEMORY_PARTITION_TAG)
+ return sym;
-/* Modify block statement iterator I so that it is at the next
- statement in the basic block. */
-static inline void
-bsi_next (block_stmt_iterator *i)
-{
- tsi_next (&i->tsi);
-}
+ gcc_assert (!is_gimple_reg (sym));
+ /* Autoparallelization moves statements from the original function (which has
+ aliases computed) to the new one (which does not). When rebuilding
+ operands for the statement in the new function, we do not want to
+ record the memory partition tags of the original function. */
+ if (!gimple_aliases_computed_p (cfun))
+ return NULL_TREE;
+ tag = get_var_ann (sym)->mpt;
-/* Modify block statement iterator I so that it is at the previous
- statement in the basic block. */
-static inline void
-bsi_prev (block_stmt_iterator *i)
-{
- tsi_prev (&i->tsi);
-}
+#if defined ENABLE_CHECKING
+ if (tag)
+ gcc_assert (TREE_CODE (tag) == MEMORY_PARTITION_TAG);
+#endif
-/* Return the statement that block statement iterator I is currently
- at. */
-static inline tree
-bsi_stmt (block_stmt_iterator i)
-{
- return tsi_stmt (i.tsi);
+ return tag;
}
-/* Return a pointer to the statement that block statement iterator I
- is currently at. */
-static inline tree *
-bsi_stmt_ptr (block_stmt_iterator i)
+/* 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 (const_tree name)
{
- return tsi_stmt_ptr (i.tsi);
+ return TREE_CODE (SSA_NAME_VAR (name)) == MEMORY_PARTITION_TAG;
}
-/* Returns the loop of the statement STMT. */
-
-static inline struct loop *
-loop_containing_stmt (tree stmt)
+/* Return true if VAR is used by function calls. */
+static inline bool
+is_call_used (const_tree var)
{
- basic_block bb = bb_for_stmt (stmt);
- if (!bb)
- return NULL;
-
- return bb->loop_father;
+ return (var_ann (var)->call_clobbered
+ || bitmap_bit_p (gimple_call_used_vars (cfun), DECL_UID (var)));
}
-/* Return true if VAR is a clobbered by function calls. */
+/* Return true if VAR is clobbered by function calls. */
static inline bool
-is_call_clobbered (tree var)
+is_call_clobbered (const_tree var)
{
- return is_global_var (var)
- || bitmap_bit_p (call_clobbered_vars, var_ann (var)->uid);
+ return var_ann (var)->call_clobbered;
}
/* Mark variable VAR as being clobbered by function calls. */
static inline void
-mark_call_clobbered (tree var)
+mark_call_clobbered (tree var, unsigned int escape_type)
{
- var_ann_t ann = var_ann (var);
- /* 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 && ann->mem_tag_kind != STRUCT_FIELD)
- DECL_EXTERNAL (var) = 1;
- bitmap_set_bit (call_clobbered_vars, ann->uid);
- ssa_call_clobbered_cache_valid = false;
- ssa_ro_call_cache_valid = false;
+ var_ann (var)->escape_mask |= escape_type;
+ 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. */
clear_call_clobbered (tree var)
{
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);
- ssa_call_clobbered_cache_valid = false;
- ssa_ro_call_cache_valid = false;
-}
-
-/* Mark variable VAR as being non-addressable. */
-static inline void
-mark_non_addressable (tree var)
-{
- bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
- TREE_ADDRESSABLE (var) = 0;
- ssa_call_clobbered_cache_valid = false;
- ssa_ro_call_cache_valid = false;
+ ann->escape_mask = 0;
+ if (MTAG_P (var))
+ MTAG_GLOBAL (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
doesn't already exist. */
-static inline tree_ann_t
-tree_ann (tree t)
+static inline tree_ann_common_t
+tree_common_ann (const_tree t)
{
- return t->common.ann;
+ /* 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
doesn't exist. */
-static inline tree_ann_t
-get_tree_ann (tree t)
+static inline tree_ann_common_t
+get_tree_common_ann (tree t)
{
- tree_ann_t ann = tree_ann (t);
- return (ann) ? ann : create_tree_ann (t);
+ tree_ann_common_t ann = tree_common_ann (t);
+ return (ann) ? ann : create_tree_common_ann (t);
}
/* ----------------------------------------------------------------------- */
/* Return true if PTR is finished iterating. */
static inline bool
-op_iter_done (ssa_op_iter *ptr)
+op_iter_done (const ssa_op_iter *ptr)
{
return ptr->done;
}
}
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)
+ if (ptr->vdefs)
{
- val = MUSTDEF_RESULT (ptr->mustdefs);
- ptr->mustdefs = ptr->mustdefs->next;
- return val;
- }
- if (ptr->maydefs)
- {
- val = MAYDEF_RESULT (ptr->maydefs);
- ptr->maydefs = ptr->maydefs->next;
+ val = VDEF_RESULT (ptr->vdefs);
+ ptr->vdefs = ptr->vdefs->next;
return val;
}
}
-/* This functiins clears the iterator PTR, and marks it done. This is normally
- used to prevent warnings in the compile about might be uninitailzied
+/* This functions clears the iterator PTR, and marks it done. This is normally
+ used to prevent warnings in the compile about might be uninitialized
components. */
static inline void
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->phi_stmt = NULL;
ptr->done = true;
+ ptr->vuse_index = 0;
+ ptr->mayuse_index = 0;
}
/* Initialize the iterator PTR to the virtual defs in STMT. */
static inline void
-op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
+op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags)
{
-#ifdef ENABLE_CHECKING
- gcc_assert (stmt_ann (stmt));
-#endif
-
- 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->defs = (flags & SSA_OP_DEF) ? gimple_def_ops (stmt) : NULL;
+ ptr->uses = (flags & SSA_OP_USE) ? gimple_use_ops (stmt) : NULL;
+ ptr->vuses = (flags & SSA_OP_VUSE) ? gimple_vuse_ops (stmt) : NULL;
+ ptr->vdefs = (flags & SSA_OP_VDEF) ? gimple_vdef_ops (stmt) : NULL;
+ ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? gimple_vdef_ops (stmt) : NULL;
ptr->done = false;
ptr->phi_i = 0;
ptr->num_phi = 0;
- ptr->phi_stmt = NULL_TREE;
+ ptr->phi_stmt = NULL;
+ ptr->vuse_index = 0;
+ ptr->mayuse_index = 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_use (ssa_op_iter *ptr, gimple 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);
/* 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_def (ssa_op_iter *ptr, gimple stmt, int flags)
{
+ 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);
/* 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_tree (ssa_op_iter *ptr, gimple stmt, int flags)
{
op_iter_init (ptr, stmt, flags);
ptr->iter_type = ssa_op_iter_tree;
/* 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, gimple stmt, vuse_vec_p *use,
def_operand_p *def)
{
- gcc_assert (TREE_CODE (stmt) != PHI_NODE);
+ gcc_assert (gimple_code (stmt) != GIMPLE_PHI);
- 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 opernad in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
+ return NULL. */
static inline tree
-single_ssa_tree_operand (tree stmt, int flags)
+single_ssa_tree_operand (gimple stmt, int flags)
{
tree var;
ssa_op_iter iter;
}
-/* If there is a single opernad in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
+ return NULL. */
static inline use_operand_p
-single_ssa_use_operand (tree stmt, int flags)
+single_ssa_use_operand (gimple stmt, int flags)
{
use_operand_p var;
ssa_op_iter iter;
-/* If there is a single opernad in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+/* If there is a single operand in STMT matching FLAGS, return it. Otherwise
+ return NULL. */
static inline def_operand_p
-single_ssa_def_operand (tree stmt, int flags)
+single_ssa_def_operand (gimple stmt, int flags)
{
def_operand_p var;
ssa_op_iter iter;
}
-/* If there is a single opernad in STMT matching FLAGS, return it. Otherwise
- return NULL. PTR is the iterator to use. */
+/* 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)
+zero_ssa_operands (gimple stmt, int flags)
{
ssa_op_iter iter;
}
-/* Return the number of opernads mathcing FLAGS in STMT. */
+/* Return the number of operands matching FLAGS in STMT. */
static inline int
-num_ssa_operands (tree stmt, int flags)
+num_ssa_operands (gimple 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)
- num++;
- for ( ; iter.maydefs; iter.maydefs = iter.maydefs->next)
- num++;
- for ( ; iter.mayuses; iter.mayuses = iter.mayuses->next)
+ FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
num++;
- for ( ; iter.mustdefs; iter.mustdefs = iter.mustdefs->next)
- num++;
- for ( ; iter.mustkills; iter.mustkills = iter.mustkills->next)
- num++;
-
return num;
}
/* Delink all immediate_use information for STMT. */
static inline void
-delink_stmt_imm_use (tree stmt)
+delink_stmt_imm_use (gimple stmt)
{
ssa_op_iter iter;
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);
}
/* This routine will compare all the operands matching FLAGS in STMT1 to those
in STMT2. TRUE is returned if they are the same. STMTs can be NULL. */
static inline bool
-compare_ssa_operands_equal (tree stmt1, tree stmt2, int flags)
+compare_ssa_operands_equal (gimple stmt1, gimple stmt2, int flags)
{
ssa_op_iter iter1, iter2;
tree op1 = NULL_TREE;
if (stmt1 == stmt2)
return true;
- look1 = stmt1 && stmt_ann (stmt1);
- look2 = stmt2 && stmt_ann (stmt2);
+ look1 = stmt1 != NULL;
+ look2 = stmt2 != NULL;
if (look1)
{
/* If there is a single DEF in the PHI node which matches FLAG, return it.
Otherwise return NULL_DEF_OPERAND_P. */
static inline tree
-single_phi_def (tree stmt, int flags)
+single_phi_def (gimple stmt, int flags)
{
tree def = PHI_RESULT (stmt);
if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
}
/* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should
- be either SSA_OP_USES or SAS_OP_VIRTUAL_USES. */
+ be either SSA_OP_USES or SSA_OP_VIRTUAL_USES. */
static inline use_operand_p
-op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
+op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags)
{
- tree phi_def = PHI_RESULT (phi);
+ tree phi_def = gimple_phi_result (phi);
int comp;
clear_and_done_ssa_iter (ptr);
comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
- /* if the PHI node deosn't the operand type we care about, we're done. */
+ /* If the PHI node doesn't the operand type we care about, we're done. */
if ((flags & comp) == 0)
{
ptr->done = true;
}
ptr->phi_stmt = phi;
- ptr->num_phi = PHI_NUM_ARGS (phi);
+ ptr->num_phi = gimple_phi_num_args (phi);
ptr->iter_type = ssa_op_iter_use;
return op_iter_next_use (ptr);
}
-/* Start an iterator for a PHI defintion. */
+/* Start an iterator for a PHI definition. */
static inline def_operand_p
-op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags)
+op_iter_init_phidef (ssa_op_iter *ptr, gimple phi, int flags)
{
tree phi_def = PHI_RESULT (phi);
int comp;
comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
- /* if the PHI node deosn't the operand type we care about, we're done. */
+ /* If the PHI node doesn't the operand type we care about, we're done. */
if ((flags & comp) == 0)
{
ptr->done = true;
return PHI_RESULT_PTR (phi);
}
+/* Return true is IMM has reached the end of the immediate use stmt list. */
+static inline bool
+end_imm_use_stmt_p (const imm_use_iterator *imm)
+{
+ return (imm->imm_use == imm->end_p);
+}
-/* Return true if VAR cannot be modified by the program. */
+/* Finished the traverse of an immediate use stmt list IMM by removing the
+ placeholder node from the list. */
-static inline bool
-unmodifiable_var_p (tree var)
+static inline void
+end_imm_use_stmt_traverse (imm_use_iterator *imm)
{
- if (TREE_CODE (var) == SSA_NAME)
- var = SSA_NAME_VAR (var);
- return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
+ delink_imm_use (&(imm->iter_node));
}
-/* Return true if REF, a COMPONENT_REF, has an ARRAY_REF somewhere in it. */
+/* 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
+ returned. */
-static inline bool
-ref_contains_array_ref (tree ref)
+static inline use_operand_p
+move_use_after_head (use_operand_p use_p, use_operand_p head,
+ use_operand_p last_p)
{
- while (handled_component_p (ref))
+ gcc_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head));
+ /* Skip head when we find it. */
+ if (use_p != head)
{
- if (TREE_CODE (ref) == ARRAY_REF)
- return true;
- ref = TREE_OPERAND (ref, 0);
+ /* If use_p is already linked in after last_p, continue. */
+ if (last_p->next == use_p)
+ last_p = use_p;
+ else
+ {
+ /* Delink from current location, and link in at last_p. */
+ delink_imm_use (use_p);
+ link_imm_use_to_list (use_p, last_p);
+ last_p = use_p;
+ }
}
- return false;
+ return last_p;
}
-/* Given a variable VAR, lookup and return a pointer to the list of
- subvariables for it. */
-static inline subvar_t *
-lookup_subvars_for_var (tree var)
+/* This routine will relink all uses with the same stmt as HEAD into the list
+ immediately following HEAD for iterator IMM. */
+
+static inline void
+link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
{
- var_ann_t ann = var_ann (var);
- gcc_assert (ann);
- return &ann->subvars;
+ use_operand_p use_p;
+ use_operand_p last_p = head;
+ gimple head_stmt = USE_STMT (head);
+ tree use = USE_FROM_PTR (head);
+ ssa_op_iter op_iter;
+ int flag;
+
+ /* Only look at virtual or real uses, depending on the type of HEAD. */
+ flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
+
+ if (gimple_code (head_stmt) == GIMPLE_PHI)
+ {
+ FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag)
+ if (USE_FROM_PTR (use_p) == use)
+ last_p = move_use_after_head (use_p, head, last_p);
+ }
+ else
+ {
+ FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag)
+ if (USE_FROM_PTR (use_p) == use)
+ last_p = move_use_after_head (use_p, head, last_p);
+ }
+ /* Link iter node in after last_p. */
+ if (imm->iter_node.prev != NULL)
+ delink_imm_use (&imm->iter_node);
+ link_imm_use_to_list (&(imm->iter_node), last_p);
}
-/* Given a variable VAR, return a linked list of subvariables for VAR, or
- NULL, if there are no subvariables. */
+/* Initialize IMM to traverse over uses of VAR. Return the first statement. */
+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;
+
+ /* iter_node is used as a marker within the immediate use list to indicate
+ where the end of the current stmt's uses are. Initialize it to NULL
+ stmt and use, which indicates a marker node. */
+ imm->iter_node.prev = NULL_USE_OPERAND_P;
+ imm->iter_node.next = NULL_USE_OPERAND_P;
+ imm->iter_node.loc.stmt = NULL;
+ imm->iter_node.use = NULL_USE_OPERAND_P;
+
+ if (end_imm_use_stmt_p (imm))
+ return NULL;
-static inline subvar_t
-get_subvars_for_var (tree var)
+ link_use_stmts_after (imm->imm_use, imm);
+
+ return USE_STMT (imm->imm_use);
+}
+
+/* Bump IMM to the next stmt which has a use of var. */
+
+static inline gimple
+next_imm_use_stmt (imm_use_iterator *imm)
{
- subvar_t subvars;
+ imm->imm_use = imm->iter_node.next;
+ if (end_imm_use_stmt_p (imm))
+ {
+ if (imm->iter_node.prev != NULL)
+ delink_imm_use (&imm->iter_node);
+ return NULL;
+ }
- gcc_assert (SSA_VAR_P (var));
-
- if (TREE_CODE (var) == SSA_NAME)
- subvars = *(lookup_subvars_for_var (SSA_NAME_VAR (var)));
- else
- subvars = *(lookup_subvars_for_var (var));
- return subvars;
+ link_use_stmts_after (imm->imm_use, imm);
+ return USE_STMT (imm->imm_use);
}
-/* Return true if V is a tree that we can have subvars for.
- Normally, this is any aggregate type, however, due to implementation
- limitations ATM, we exclude array types as well. */
+/* This routine will return the first use on the stmt IMM currently refers
+ to. */
-static inline bool
-var_can_have_subvars (tree v)
+static inline use_operand_p
+first_imm_use_on_stmt (imm_use_iterator *imm)
{
- return (AGGREGATE_TYPE_P (TREE_TYPE (v)) &&
- TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE);
+ imm->next_imm_name = imm->imm_use->next;
+ return imm->imm_use;
}
-
-/* Return true if OFFSET and SIZE define a range that overlaps with some
- portion of the range of SV, a subvar. If there was an exact overlap,
- *EXACT will be set to true upon return. */
+/* Return TRUE if the last use on the stmt IMM refers to has been visited. */
static inline bool
-overlap_subvar (HOST_WIDE_INT offset, HOST_WIDE_INT size,
- subvar_t sv, bool *exact)
-{
- /* There are three possible cases of overlap.
- 1. We can have an exact overlap, like so:
- |offset, offset + size |
- |sv->offset, sv->offset + sv->size |
-
- 2. We can have offset starting after sv->offset, like so:
-
- |offset, offset + size |
- |sv->offset, sv->offset + sv->size |
-
- 3. We can have offset starting before sv->offset, like so:
-
- |offset, offset + size |
- |sv->offset, sv->offset + sv->size|
- */
-
- if (exact)
- *exact = false;
- if (offset == sv->offset && size == sv->size)
- {
- if (exact)
- *exact = true;
- return true;
- }
- else if (offset >= sv->offset && offset < (sv->offset + sv->size))
+end_imm_use_on_stmt_p (const imm_use_iterator *imm)
+{
+ return (imm->imm_use == &(imm->iter_node));
+}
+
+/* Bump to the next use on the stmt IMM refers to, return NULL if done. */
+
+static inline use_operand_p
+next_imm_use_on_stmt (imm_use_iterator *imm)
+{
+ imm->imm_use = imm->next_imm_name;
+ if (end_imm_use_on_stmt_p (imm))
+ return NULL_USE_OPERAND_P;
+ else
{
- return true;
+ imm->next_imm_name = imm->imm_use->next;
+ return imm->imm_use;
}
- else if (offset < sv->offset && (offset + size > sv->offset))
- {
+}
+
+/* Return true if VAR cannot be modified by the program. */
+
+static inline bool
+unmodifiable_var_p (const_tree var)
+{
+ if (TREE_CODE (var) == SSA_NAME)
+ var = SSA_NAME_VAR (var);
+
+ if (MTAG_P (var))
+ return false;
+
+ 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));
+
+ do {
+ if (TREE_CODE (ref) == ARRAY_REF)
return true;
- }
+ ref = TREE_OPERAND (ref, 0);
+ } while (handled_component_p (ref));
+
+ return false;
+}
+
+/* Return true, if the two ranges [POS1, SIZE1] and [POS2, SIZE2]
+ overlap. SIZE1 and/or SIZE2 can be (unsigned)-1 in which case the
+ range is open-ended. Otherwise return false. */
+
+static inline bool
+ranges_overlap_p (unsigned HOST_WIDE_INT pos1,
+ unsigned HOST_WIDE_INT size1,
+ unsigned HOST_WIDE_INT pos2,
+ unsigned HOST_WIDE_INT size2)
+{
+ if (pos1 >= pos2
+ && (size2 == (unsigned HOST_WIDE_INT)-1
+ || pos1 < (pos2 + size2)))
+ return true;
+ if (pos2 >= pos1
+ && (size1 == (unsigned HOST_WIDE_INT)-1
+ || pos2 < (pos1 + size1)))
+ 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;
+}
+
+/* Accessor to tree-ssa-operands.c caches. */
+static inline struct ssa_operands *
+gimple_ssa_operands (const struct function *fun)
+{
+ return &fun->gimple_df->ssa_operands;
+}
+
+/* Map describing reference statistics for function FN. */
+static inline struct mem_ref_stats_d *
+gimple_mem_ref_stats (const struct function *fn)
+{
+ return &fn->gimple_df->mem_ref_stats;
+}
+
+/* Given an edge_var_map V, return the PHI arg definition. */
+
+static inline tree
+redirect_edge_var_map_def (edge_var_map *v)
+{
+ return v->def;
+}
+
+/* Given an edge_var_map V, return the PHI result. */
+
+static inline tree
+redirect_edge_var_map_result (edge_var_map *v)
+{
+ return v->result;
+}
+
+
+/* Return an SSA_NAME node for variable VAR defined in statement STMT
+ in function cfun. */
+
+static inline tree
+make_ssa_name (tree var, gimple stmt)
+{
+ return make_ssa_name_fn (cfun, var, stmt);
}
#endif /* _TREE_FLOW_INLINE_H */
OSDN Git Service
