Daily bump.

[pf3gnuchains/gcc-fork.git] / gcc / tree-flow-inline.h

diff --git a/gcc/tree-flow-inline.h b/gcc/tree-flow-inline.h
index 58684bd..fdb3337 100644 (file)
--- a/gcc/tree-flow-inline.h
+++ b/gcc/tree-flow-inline.h
@@ -1,12 +1,13 @@
 /* Inline functions for tree-flow.h
 /* 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
    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,
 any later version.
 
 GCC is distributed in the hope that it will be useful,


@@ -15,9 +16,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 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, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, 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
 
 #ifndef _TREE_FLOW_INLINE_H
 #define _TREE_FLOW_INLINE_H 1


@@ -25,6 +25,42 @@ Boston, MA 02110-1301, USA.  */
 /* Inline functions for manipulating various data structures defined in
    tree-flow.h.  See tree-flow.h for documentation.  */
 
 /* 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 (const struct function *fun)
+{
+  return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
+}
+
+/* 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;
+}
+
+/* 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);
+  return fun->gimple_df->vop;
+}
+

 /* Initialize the hashtable iterator HTI to point to hashtable TABLE */
 
 static inline void *
 /* Initialize the hashtable iterator HTI to point to hashtable TABLE */
 
 static inline void *


@@ -49,7 +85,7 @@ first_htab_element (htab_iterator *hti, htab_t table)
    or NULL if we have  reached the end.  */
 
 static inline bool
    or NULL if we have  reached the end.  */
 
 static inline bool

-end_htab_p (htab_iterator *hti)
+end_htab_p (const htab_iterator *hti)

 {
   if (hti->slot >= hti->limit)
     return true;
 {
   if (hti->slot >= hti->limit)
     return true;


@@ -77,19 +113,15 @@ next_htab_element (htab_iterator *hti)
 static inline tree
 first_referenced_var (referenced_var_iterator *iter)
 {
 static inline tree
 first_referenced_var (referenced_var_iterator *iter)
 {

-  struct int_tree_map *itm;
-  itm = (struct int_tree_map *) first_htab_element (&iter->hti,
-                                                    referenced_vars);
-  if (!itm) 
-    return NULL;
-  return itm->to;
+  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
 }
 
 /* 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)
+end_referenced_vars_p (const referenced_var_iterator *iter)

 {
   return end_htab_p (&iter->hti);
 }
 {
   return end_htab_p (&iter->hti);
 }


@@ -100,11 +132,7 @@ end_referenced_vars_p (referenced_var_iterator *iter)
 static inline tree
 next_referenced_var (referenced_var_iterator *iter)
 {
 static inline tree
 next_referenced_var (referenced_var_iterator *iter)
 {

-  struct int_tree_map *itm;
-  itm = (struct int_tree_map *) next_htab_element (&iter->hti);
-  if (!itm) 
-    return NULL;
-  return itm->to;
+  return (tree) next_htab_element (&iter->hti);

 } 
 
 /* Fill up VEC with the variables in the referenced vars hashtable.  */
 } 
 
 /* Fill up VEC with the variables in the referenced vars hashtable.  */


@@ -122,14 +150,17 @@ fill_referenced_var_vec (VEC (tree, heap) **vec)
 /* 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 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)
+var_ann (const_tree t)

 {
 {

-  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);
+  var_ann_t ann;
+
+  if (!t->base.ann)
+    return NULL;
+  ann = (var_ann_t) t->base.ann;
+
+  gcc_assert (ann->common.type == VAR_ANN);

 
 

-  return (var_ann_t) t->common.ann;
+  return ann;

 }
 
 /* Return the variable annotation for T, which must be a _DECL node.
 }
 
 /* Return the variable annotation for T, which must be a _DECL node.


@@ -141,45 +172,25 @@ get_var_ann (tree var)
   return (ann) ? ann : create_var_ann (var);
 }
 
   return (ann) ? ann : create_var_ann (var);
 }
 

-/* 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 (tree t)
+/* Get the number of the next statement uid to be allocated.  */
+static inline unsigned int
+gimple_stmt_max_uid (struct function *fn)

 {
 {

-  gcc_assert (t);
-  gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
-  gcc_assert (!t->common.ann || t->common.ann->common.type == FUNCTION_ANN);
-
-  return (function_ann_t) t->common.ann;
+  return fn->last_stmt_uid;

 }
 
 }
 

-/* 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)
+/* Set the number of the next statement uid to be allocated.  */
+static inline void
+set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)

 {
 {

-  function_ann_t ann = function_ann (var);
-  return (ann) ? ann : create_function_ann (var);
+  fn->last_stmt_uid = maxid;

 }
 
 }
 

-/* 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)
-{
-#ifdef ENABLE_CHECKING
-  gcc_assert (is_gimple_stmt (t));
-#endif
-  return (stmt_ann_t) t->common.ann;
-}
-
-/* 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)
+/* Set the number of the next statement uid to be allocated.  */
+static inline unsigned int
+inc_gimple_stmt_max_uid (struct function *fn)

 {
 {

-  stmt_ann_t ann = stmt_ann (stmt);
-  return (ann) ? ann : create_stmt_ann (stmt);
+  return fn->last_stmt_uid++;

 }
 
 /* Return the annotation type for annotation ANN.  */
 }
 
 /* Return the annotation type for annotation ANN.  */


@@ -189,114 +200,21 @@ ann_type (tree_ann_t ann)
   return ann->common.type;
 }
 
   return ann->common.type;
 }
 

-/* Return the basic block for statement T.  */
-static inline basic_block
-bb_for_stmt (tree 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 the may_aliases varray for variable VAR, or NULL if it has
-   no may aliases.  */
-static inline VEC(tree, gc) *
-may_aliases (tree var)
-{
-  var_ann_t ann = var_ann (var);
-  return ann ? ann->may_aliases : NULL;
-}
-

 /* Return the line number for EXPR, or return -1 if we have no line
    number information for it.  */
 static inline int
 /* 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)
+get_lineno (const_gimple stmt)

 {
 {

-  if (expr == NULL_TREE)
-    return -1;
+  location_t loc;

 
 

-  if (TREE_CODE (expr) == COMPOUND_EXPR)
-    expr = TREE_OPERAND (expr, 0);
-
-  if (! EXPR_HAS_LOCATION (expr))
+  if (!stmt)

     return -1;
 
     return -1;
 

-  return EXPR_LINENO (expr);
-}
-
-/* Return the file name for EXPR, or return "???" if we have no
-   filename information.  */
-static inline const char *
-get_filename (tree expr)
-{
-  const char *filename;
-  if (expr == NULL_TREE)
-    return "???";
-
-  if (TREE_CODE (expr) == COMPOUND_EXPR)
-    expr = TREE_OPERAND (expr, 0);
-
-  if (EXPR_HAS_LOCATION (expr) && (filename = EXPR_FILENAME (expr)))
-    return filename;
-  else
-    return "???";
-}
-
-/* Return true if T is a noreturn call.  */
-static inline bool
-noreturn_call_p (tree t)
-{
-  tree call = get_call_expr_in (t);
-  return call != 0 && (call_expr_flags (call) & ECF_NORETURN) != 0;
-}
-
-/* Mark statement T as modified.  */
-static inline void
-mark_stmt_modified (tree t)
-{
-  stmt_ann_t ann;
-  if (TREE_CODE (t) == PHI_NODE)
-    return;
-
-  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;
-}
-
-/* Mark statement T as modified, and update it.  */
-static inline void
-update_stmt (tree t)
-{
-  if (TREE_CODE (t) == PHI_NODE)
-    return;
-  mark_stmt_modified (t);
-  update_stmt_operands (t);
-}
-
-static inline void
-update_stmt_if_modified (tree t)
-{
-  if (stmt_modified_p (t))
-    update_stmt_operands (t);
-}
-
-/* Return true if T is marked as modified, false otherwise.  */
-static inline bool
-stmt_modified_p (tree t)
-{
-  stmt_ann_t ann = stmt_ann (t);
+  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.  */
 }
 
 /* Delink an immediate_uses node from its chain.  */


@@ -356,13 +274,13 @@ set_ssa_use_from_ptr (use_operand_p use, tree val)
 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring 
    in STMT.  */
 static inline void
 /* 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);
 {
   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 a new node in place of an old node in the list.  */


@@ -385,19 +303,20 @@ relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring 
    in STMT.  */
 static inline void
 /* 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);
 {
   if (stmt)
     relink_imm_use (linknode, old);
   else
     link_imm_use (linknode, NULL);

-  linknode->stmt = stmt;
+  linknode->loc.stmt = stmt;

 }
 
 
 /* Return true is IMM has reached the end of the immediate use list.  */
 static inline bool
 }
 
 
 /* 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);
 }
 {
   return (imm->imm_use == imm->end_p);
 }


@@ -425,8 +344,8 @@ next_readonly_imm_use (imm_use_iterator *imm)
   use_operand_p old = imm->imm_use;
 
 #ifdef ENABLE_CHECKING
   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);
      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);


@@ -435,121 +354,213 @@ next_readonly_imm_use (imm_use_iterator *imm)
 
   imm->imm_use = old->next;
   if (end_readonly_imm_use_p (imm))
 
   imm->imm_use = old->next;
   if (end_readonly_imm_use_p (imm))

-    return old;
+    return NULL_USE_OPERAND_P;

   return imm->imm_use;
 }
 
   return imm->imm_use;
 }
 

-/* Return true if VAR has no uses.  */
+/* tree-cfg.c */
+extern bool has_zero_uses_1 (const ssa_use_operand_t *head);
+extern bool single_imm_use_1 (const ssa_use_operand_t *head,
+                             use_operand_p *use_p, gimple *stmt);
+
+/* Return true if VAR has no nondebug uses.  */

 static inline bool
 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));
-  /* A single use means there is no items in the list.  */
-  return (ptr == ptr->next);
+  const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
+
+  /* A single use_operand means there is no items in the list.  */
+  if (ptr == ptr->next)
+    return true;
+
+  /* If there are debug stmts, we have to look at each use and see
+     whether there are any nondebug uses.  */
+  if (!MAY_HAVE_DEBUG_STMTS)
+    return false;
+
+  return has_zero_uses_1 (ptr);

 }
 
 }
 

-/* Return true if VAR has a single use.  */
+/* Return true if VAR has a single nondebug use.  */

 static inline bool
 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));
-  /* A single use means there is one item in the list.  */
-  return (ptr != ptr->next && ptr == ptr->next->next);
+  const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
+
+  /* If there aren't any uses whatsoever, we're done.  */
+  if (ptr == ptr->next)
+    return false;
+
+  /* If there's a single use, check that it's not a debug stmt.  */
+  if (ptr == ptr->next->next)
+    return !is_gimple_debug (USE_STMT (ptr->next));
+
+  /* If there are debug stmts, we have to look at each of them.  */
+  if (!MAY_HAVE_DEBUG_STMTS)
+    return false;
+
+  return single_imm_use_1 (ptr, NULL, NULL);

 }
 
 }
 

-/* If VAR has only a single immediate use, return true, and set USE_P and STMT
-   to the use pointer and stmt of occurrence.  */
+
+/* If VAR has only a single immediate nondebug use, return true, and
+   set USE_P and STMT to the use pointer and stmt of occurrence.  */

 static inline bool
 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;
+  const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));

 
 

-  ptr = &(SSA_NAME_IMM_USE_NODE (var));
-  if (ptr != ptr->next && ptr == ptr->next->next)
+  /* If there aren't any uses whatsoever, we're done.  */
+  if (ptr == ptr->next)

     {
     {

-      *use_p = ptr->next;
-      *stmt = ptr->next->stmt;
-      return true;
+    return_false:
+      *use_p = NULL_USE_OPERAND_P;
+      *stmt = NULL;
+      return false;

     }
     }

-  *use_p = NULL_USE_OPERAND_P;
-  *stmt = NULL_TREE;
-  return false;
+
+  /* If there's a single use, check that it's not a debug stmt.  */
+  if (ptr == ptr->next->next)
+    {
+      if (!is_gimple_debug (USE_STMT (ptr->next)))
+       {
+         *use_p = ptr->next;
+         *stmt = ptr->next->loc.stmt;
+         return true;
+       }
+      else
+       goto return_false;
+    }
+
+  /* If there are debug stmts, we have to look at each of them.  */
+  if (!MAY_HAVE_DEBUG_STMTS)
+    goto return_false;
+
+  return single_imm_use_1 (ptr, use_p, stmt);

 }
 
 }
 

-/* Return the number of immediate uses of VAR.  */
+/* Return the number of nondebug immediate uses of VAR.  */

 static inline unsigned int
 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++;
+  if (!MAY_HAVE_DEBUG_STMTS)
+    for (ptr = start->next; ptr != start; ptr = ptr->next)
+      num++;
+  else
+    for (ptr = start->next; ptr != start; ptr = ptr->next)
+      if (!is_gimple_debug (USE_STMT (ptr)))
+       num++;

 
   return 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);
 } 
 
 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;
 }
 
 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)
+{
+  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.  */
+
+static inline tree *
+gimple_phi_arg_def_ptr (gimple gs, size_t index)

 {
 {

-  return &(PHI_ARG_IMM_USE_NODE (phi,i));
+  return &gimple_phi_arg (gs, index)->def;

 }
 
 }
 

+/* Return the edge associated with 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 edge
+gimple_phi_arg_edge (gimple gs, size_t i)

 {
 {

-  stmt_ann_t ann = stmt_ann (stmt);
-  return ann ? ann->addresses_taken : NULL;
+  return EDGE_PRED (gimple_bb (gs), i);

 }
 
 }
 

+/* Return the source location of gimple argument I of phi node GS.  */
+
+static inline source_location
+gimple_phi_arg_location (gimple gs, size_t i)
+{
+  return gimple_phi_arg (gs, i)->locus;
+}
+
+/* Return the source location of the argument on edge E of phi node GS.  */
+
+static inline source_location
+gimple_phi_arg_location_from_edge (gimple gs, edge e)
+{
+  return gimple_phi_arg (gs, e->dest_idx)->locus;
+}
+
+/* Set the source location of gimple argument I of phi node GS to LOC.  */
+
+static inline void
+gimple_phi_arg_set_location (gimple gs, size_t i, source_location loc)
+{
+  gimple_phi_arg (gs, i)->locus = loc;
+}
+
+/* Return TRUE if argument I of phi node GS has a location record.  */
+
+static inline bool
+gimple_phi_arg_has_location (gimple gs, size_t i)
+{
+  return gimple_phi_arg_location (gs, i) != UNKNOWN_LOCATION;
+}
+
+

 /* Return the PHI nodes for basic block BB, or NULL if there are no
    PHI nodes.  */
 /* 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->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
 
 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->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.  */
 }
 
 /* Return the phi argument which contains the specified use.  */


@@ -558,18 +569,18 @@ static inline int
 phi_arg_index_from_use (use_operand_p use)
 {
   struct phi_arg_d *element, *root;
 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);
 
   /* 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;
 
   element = (struct phi_arg_d *)use;

-  root = &(PHI_ARG_ELT (phi, 0));
+  root = gimple_phi_arg (phi, 0);

   index = element - root;
 
 #ifdef ENABLE_CHECKING
   index = element - root;
 
 #ifdef ENABLE_CHECKING


@@ -577,7 +588,7 @@ phi_arg_index_from_use (use_operand_p use)
      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);
      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;
 #endif
  
  return index;


@@ -593,40 +604,39 @@ set_is_used (tree var)
 }
 
 
 }
 
 

-/*  -----------------------------------------------------------------------  */
+/* Return true if T (assumed to be a DECL) is a global variable.
+   A variable is considered global if its storage is not automatic.  */

 
 

-/* Return true if T is an executable statement.  */

 static inline bool
 static inline bool

-is_exec_stmt (tree t)
+is_global_var (const_tree t)

 {
 {

-  return (t && !IS_EMPTY_STMT (t) && t != error_mark_node);
+  return (TREE_STATIC (t) || DECL_EXTERNAL (t));

 }
 
 
 }
 
 

-/* Return true if this stmt can be the target of a control transfer stmt such
-   as a goto.  */
+/* Return true if VAR may be aliased.  A variable is considered as
+   maybe aliased if it has its address taken by the local TU
+   or possibly by another TU and might be modified through a pointer.  */
+

 static inline bool
 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;
+may_be_aliased (const_tree var)
+{
+  return (TREE_CODE (var) != CONST_DECL
+         && !((TREE_STATIC (var) || TREE_PUBLIC (var) || DECL_EXTERNAL (var))
+              && TREE_READONLY (var)
+              && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (var)))
+         && (TREE_PUBLIC (var)
+             || DECL_EXTERNAL (var)
+             || TREE_ADDRESSABLE (var)));

 }
 
 }
 

+

 /* 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.  */
 
 static inline bool
 /* 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.  */
 
 static inline bool

-phi_ssa_name_p (tree t)
+phi_ssa_name_p (const_tree t)

 {
   if (TREE_CODE (t) == SSA_NAME)
     return true;
 {
   if (TREE_CODE (t) == SSA_NAME)
     return true;


@@ -636,168 +646,56 @@ phi_ssa_name_p (tree t)
   return false;
 }
 
   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 < NUM_FIXED_BLOCKS);
-      bsi.tsi.ptr = NULL;
-      bsi.tsi.container = NULL;
-    }
-  bsi.bb = bb;
-  return bsi;
-}
-
-/* Return a block statement iterator that points to the first non-label
-   statement in block BB.  */
-
-static inline block_stmt_iterator
-bsi_after_labels (basic_block bb)
-{
-  block_stmt_iterator bsi = bsi_start (bb);
-
-  while (!bsi_end_p (bsi) && TREE_CODE (bsi_stmt (bsi)) == LABEL_EXPR)
-    bsi_next (&bsi);
-
-  return bsi;
-}
-
-/* Return a block statement iterator that points to the end of basic
-   block BB.  */
-static inline block_stmt_iterator
-bsi_last (basic_block bb)
-{
-  block_stmt_iterator bsi;
-  if (bb->stmt_list)
-    bsi.tsi = tsi_last (bb->stmt_list);
-  else
-    {
-      gcc_assert (bb->index < NUM_FIXED_BLOCKS);
-      bsi.tsi.ptr = NULL;
-      bsi.tsi.container = NULL;
-    }
-  bsi.bb = bb;
-  return bsi;
-}
-
-/* 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);
-}
-
-/* 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);
-}
-
-/* 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);
-}
-
-/* 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 a pointer to the statement that block statement iterator I
-   is currently at.  */
-static inline tree *
-bsi_stmt_ptr (block_stmt_iterator i)
-{
-  return tsi_stmt_ptr (i.tsi);
-}

 
 /* Returns the loop of the statement STMT.  */
 
 static inline struct loop *
 
 /* Returns the loop of the statement STMT.  */
 
 static inline struct loop *

-loop_containing_stmt (tree stmt)
+loop_containing_stmt (gimple stmt)

 {
 {

-  basic_block bb = bb_for_stmt (stmt);
+  basic_block bb = gimple_bb (stmt);

   if (!bb)
     return NULL;
 
   return bb->loop_father;
 }
 
   if (!bb)
     return NULL;
 
   return bb->loop_father;
 }
 

-/* 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);
-  else
-    return bitmap_bit_p (call_clobbered_vars, DECL_UID (var)); 
-}
-
-/* Mark variable VAR as being clobbered by function calls.  */
-static inline void
-mark_call_clobbered (tree var, unsigned int escape_type)
-{
-  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));
-}

 
 

-/* Clear the call-clobbered attribute from variable VAR.  */
-static inline void
-clear_call_clobbered (tree var)
+/* Return true if VAR is clobbered by function calls.  */
+static inline bool
+is_call_clobbered (const_tree var)

 {
 {

-  var_ann_t ann = var_ann (var);
-  ann->escape_mask = 0;
-  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));
+  return (is_global_var (var)
+         || (may_be_aliased (var)
+             && pt_solution_includes (&cfun->gimple_df->escaped, var)));

 }
 
 }
 

-/* Mark variable VAR as being non-addressable.  */
-static inline void
-mark_non_addressable (tree var)
+/* Return true if VAR is used by function calls.  */
+static inline bool
+is_call_used (const_tree var)

 {
 {

-  if (!MTAG_P (var))
-    DECL_CALL_CLOBBERED (var) = false;
-  bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
-  TREE_ADDRESSABLE (var) = 0;
+  return (is_call_clobbered (var)
+         || (may_be_aliased (var)
+             && pt_solution_includes (&cfun->gimple_df->callused, var)));

 }
 
 /* Return the common annotation for T.  Return NULL if the annotation
    doesn't already exist.  */
 }
 
 /* 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.  */
 }
 
 /* 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);

 }
 
 /*  -----------------------------------------------------------------------  */
 }
 
 /*  -----------------------------------------------------------------------  */


@@ -807,7 +705,7 @@ get_tree_ann (tree t)
 
 /* Return true if PTR is finished iterating.  */
 static inline bool
 
 /* 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;
 }
 {
   return ptr->done;
 }


@@ -826,24 +724,6 @@ op_iter_next_use (ssa_op_iter *ptr)
       ptr->uses = ptr->uses->next;
       return use_p;
     }
       ptr->uses = ptr->uses->next;
       return use_p;
     }

-  if (ptr->vuses)
-    {
-      use_p = VUSE_OP_PTR (ptr->vuses);
-      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;
-      return use_p;
-    }

   if (ptr->phi_i < ptr->num_phi)
     {
       return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);
   if (ptr->phi_i < ptr->num_phi)
     {
       return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);


@@ -866,18 +746,6 @@ op_iter_next_def (ssa_op_iter *ptr)
       ptr->defs = ptr->defs->next;
       return def_p;
     }
       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)
-    {
-      def_p = MAYDEF_RESULT_PTR (ptr->maydefs);
-      ptr->maydefs = ptr->maydefs->next;
-      return def_p;
-    }

   ptr->done = true;
   return NULL_DEF_OPERAND_P;
 }
   ptr->done = true;
   return NULL_DEF_OPERAND_P;
 }


@@ -896,42 +764,12 @@ op_iter_next_tree (ssa_op_iter *ptr)
       ptr->uses = ptr->uses->next;
       return val;
     }
       ptr->uses = ptr->uses->next;
       return val;
     }

-  if (ptr->vuses)
-    {
-      val = VUSE_OP (ptr->vuses);
-      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;
-      return val;
-    }

   if (ptr->defs)
     {
       val = DEF_OP (ptr->defs);
       ptr->defs = ptr->defs->next;
       return val;
     }
   if (ptr->defs)
     {
       val = DEF_OP (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)
-    {
-      val = MAYDEF_RESULT (ptr->maydefs);
-      ptr->maydefs = ptr->maydefs->next;
-      return val;
-    }

 
   ptr->done = true;
   return NULL_TREE;
 
   ptr->done = true;
   return NULL_TREE;


@@ -948,46 +786,45 @@ clear_and_done_ssa_iter (ssa_op_iter *ptr)
 {
   ptr->defs = NULL;
   ptr->uses = NULL;
 {
   ptr->defs = NULL;
   ptr->uses = NULL;

-  ptr->vuses = NULL;
-  ptr->maydefs = 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->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;
 }
 
 /* Initialize the iterator PTR to the virtual defs in STMT.  */
 static inline void
   ptr->done = true;
 }
 
 /* Initialize the iterator PTR to the virtual defs in STMT.  */
 static inline void

-op_iter_init (ssa_op_iter *ptr, tree 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;
+op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags)
+{
+  /* 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)));
+  ptr->defs = (flags & (SSA_OP_DEF|SSA_OP_VDEF)) ? gimple_def_ops (stmt) : NULL;
+  if (!(flags & SSA_OP_VDEF)
+      && ptr->defs
+      && gimple_vdef (stmt) != NULL_TREE)
+    ptr->defs = ptr->defs->next;
+  ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL;
+  if (!(flags & SSA_OP_VUSE)
+      && ptr->uses
+      && gimple_vuse (stmt) != NULL_TREE)
+    ptr->uses = ptr->uses->next;

   ptr->done = false;
 
   ptr->phi_i = 0;
   ptr->num_phi = 0;
   ptr->done = false;
 
   ptr->phi_i = 0;
   ptr->num_phi = 0;

-  ptr->phi_stmt = NULL_TREE;
+  ptr->phi_stmt = NULL;

 }
 
 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
    the first use.  */
 static inline use_operand_p
 }
 
 /* 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);
+  gcc_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);
   op_iter_init (ptr, stmt, flags);
   ptr->iter_type = ssa_op_iter_use;
   return op_iter_next_use (ptr);


@@ -996,9 +833,10 @@ op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
    the first def.  */
 static inline def_operand_p
 /* 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 | SSA_OP_VIRTUAL_KILLS)) == 0);
+  gcc_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);
   op_iter_init (ptr, stmt, flags);
   ptr->iter_type = ssa_op_iter_def;
   return op_iter_next_def (ptr);


@@ -1007,90 +845,18 @@ op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
    the first operand as a tree.  */
 static inline tree
 /* 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;
   return op_iter_next_tree (ptr);
 }
 
 {
   op_iter_init (ptr, stmt, flags);
   ptr->iter_type = ssa_op_iter_tree;
   return op_iter_next_tree (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, 
-                        ssa_op_iter *ptr)
-{
-#ifdef ENABLE_CHECKING
-  gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef);
-#endif
-  if (ptr->mayuses)
-    {
-      *def = MAYDEF_RESULT_PTR (ptr->mayuses);
-      *use = MAYDEF_OP_PTR (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;
-  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)
-{
-  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);
-}
-
-
-/* Initialize iterator PTR to the operands in STMT.  Return the first operands
-   in KILL and DEF.  */
-static inline void
-op_iter_init_mustdef (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);
-  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);
-}
-

 
 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
    return NULL.  */
 static inline tree
 
 /* 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;
 {
   tree var;
   ssa_op_iter iter;


@@ -1108,7 +874,7 @@ single_ssa_tree_operand (tree stmt, int flags)
 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
    return NULL.  */
 static inline use_operand_p
 /* 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;
 {
   use_operand_p var;
   ssa_op_iter iter;


@@ -1127,7 +893,7 @@ single_ssa_use_operand (tree stmt, int flags)
 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
    return NULL.  */
 static inline def_operand_p
 /* 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;
 {
   def_operand_p var;
   ssa_op_iter iter;


@@ -1142,10 +908,10 @@ single_ssa_def_operand (tree stmt, int flags)
 }
 
 
 }
 
 

-/* 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
 static inline bool

-zero_ssa_operands (tree stmt, int flags)
+zero_ssa_operands (gimple stmt, int flags)

 {
   ssa_op_iter iter;
 
 {
   ssa_op_iter iter;
 


@@ -1156,7 +922,7 @@ zero_ssa_operands (tree stmt, int flags)
 
 /* Return the number of operands matching FLAGS in STMT.  */
 static inline int
 
 /* 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;
 {
   ssa_op_iter iter;
   tree t;


@@ -1170,68 +936,21 @@ num_ssa_operands (tree stmt, int flags)
 
 /* Delink all immediate_use information for STMT.  */
 static inline void
 
 /* 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 ())
 {
    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);
 }
 
 
        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)
-{
-  ssa_op_iter iter1, iter2;
-  tree op1 = NULL_TREE;
-  tree op2 = NULL_TREE;
-  bool look1, look2;
-
-  if (stmt1 == stmt2)
-    return true;
-
-  look1 = stmt1 && stmt_ann (stmt1);
-  look2 = stmt2 && stmt_ann (stmt2);
-
-  if (look1)
-    {
-      op1 = op_iter_init_tree (&iter1, stmt1, flags);
-      if (!look2)
-        return op_iter_done (&iter1);
-    }
-  else
-    clear_and_done_ssa_iter (&iter1);
-
-  if (look2)
-    {
-      op2 = op_iter_init_tree (&iter2, stmt2, flags);
-      if (!look1)
-        return op_iter_done (&iter2);
-    }
-  else
-    clear_and_done_ssa_iter (&iter2);
-
-  while (!op_iter_done (&iter1) && !op_iter_done (&iter2))
-    {
-      if (op1 != op2)
-       return false;
-      op1 = op_iter_next_tree (&iter1);
-      op2 = op_iter_next_tree (&iter2);
-    }
-
-  return (op_iter_done (&iter1) && op_iter_done (&iter2));
-}
-
-

 /* If there is a single DEF in the PHI node which matches FLAG, return it.
    Otherwise return NULL_DEF_OPERAND_P.  */
 static inline tree
 /* 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)) 
 {
   tree def = PHI_RESULT (stmt);
   if ((flags & SSA_OP_DEF) && is_gimple_reg (def)) 


@@ -1242,11 +961,11 @@ single_phi_def (tree stmt, int flags)
 }
 
 /* Initialize the iterator PTR for uses matching FLAGS in PHI.  FLAGS should
 }
 
 /* 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
 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);
   int comp;
 
   clear_and_done_ssa_iter (ptr);


@@ -1264,7 +983,7 @@ op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
     }
 
   ptr->phi_stmt = phi;
     }
 
   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);
 }
   ptr->iter_type = ssa_op_iter_use;
   return op_iter_next_use (ptr);
 }


@@ -1273,7 +992,7 @@ op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
 /* Start an iterator for a PHI definition.  */
 
 static inline def_operand_p
 /* 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;
 {
   tree phi_def = PHI_RESULT (phi);
   int comp;


@@ -1285,11 +1004,12 @@ op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags)
 
   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
     
 
   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
     

-  /* If the PHI node doesn't the operand type we care about, we're done.  */
+  /* If the PHI node doesn't have the operand type we care about,
+     we're done.  */

   if ((flags & comp) == 0)
     {
       ptr->done = true;
   if ((flags & comp) == 0)
     {
       ptr->done = true;

-      return NULL_USE_OPERAND_P;
+      return NULL_DEF_OPERAND_P;

     }
 
   ptr->iter_type = ssa_op_iter_def;
     }
 
   ptr->iter_type = ssa_op_iter_def;


@@ -1302,7 +1022,7 @@ op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags)
 /* Return true is IMM has reached the end of the immediate use stmt list.  */
 
 static inline bool
 /* Return true is IMM has reached the end of the immediate use stmt list.  */
 
 static inline bool

-end_imm_use_stmt_p (imm_use_iterator *imm)
+end_imm_use_stmt_p (const imm_use_iterator *imm)

 {
   return (imm->imm_use == imm->end_p);
 }
 {
   return (imm->imm_use == imm->end_p);
 }


@@ -1353,7 +1073,7 @@ link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
 {
   use_operand_p use_p;
   use_operand_p last_p = head;
 {
   use_operand_p use_p;
   use_operand_p last_p = head;

-  tree head_stmt = USE_STMT (head);
+  gimple head_stmt = USE_STMT (head);

   tree use = USE_FROM_PTR (head);
   ssa_op_iter op_iter;
   int flag;
   tree use = USE_FROM_PTR (head);
   ssa_op_iter op_iter;
   int flag;


@@ -1361,7 +1081,7 @@ link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
   /* 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);
 
   /* 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 (TREE_CODE (head_stmt) == PHI_NODE)
+  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)
     {
       FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag)
        if (USE_FROM_PTR (use_p) == use)


@@ -1369,18 +1089,26 @@ link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
     }
   else
     {
     }
   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);
+      if (flag == SSA_OP_USE)
+       {
+         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);
+       }
+      else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P)
+       {
+         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.  */
+  /* 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);
 }
 
 /* Initialize IMM to traverse over uses of VAR.  Return the first statement.  */
   if (imm->iter_node.prev != NULL)
     delink_imm_use (&imm->iter_node);
   link_imm_use_to_list (&(imm->iter_node), last_p);
 }
 
 /* Initialize IMM to traverse over uses of VAR.  Return the first statement.  */

-static inline tree
+static inline gimple

 first_imm_use_stmt (imm_use_iterator *imm, tree var)
 {
   gcc_assert (TREE_CODE (var) == SSA_NAME);
 first_imm_use_stmt (imm_use_iterator *imm, tree var)
 {
   gcc_assert (TREE_CODE (var) == SSA_NAME);


@@ -1390,15 +1118,15 @@ first_imm_use_stmt (imm_use_iterator *imm, tree var)
   imm->next_imm_name = NULL_USE_OPERAND_P;
 
   /* iter_node is used as a marker within the immediate use list to indicate
   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.  Iintialize it to NULL
-     stmt and use, which indicateds a marker node.  */
+     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.prev = NULL_USE_OPERAND_P;
   imm->iter_node.next = NULL_USE_OPERAND_P;

-  imm->iter_node.stmt = NULL_TREE;
-  imm->iter_node.use = NULL_USE_OPERAND_P;
+  imm->iter_node.loc.stmt = NULL;
+  imm->iter_node.use = NULL;

 
   if (end_imm_use_stmt_p (imm))
 
   if (end_imm_use_stmt_p (imm))

-    return NULL_TREE;
+    return NULL;

 
   link_use_stmts_after (imm->imm_use, imm);
 
 
   link_use_stmts_after (imm->imm_use, imm);
 


@@ -1407,7 +1135,7 @@ first_imm_use_stmt (imm_use_iterator *imm, tree var)
 
 /* Bump IMM to the next stmt which has a use of var.  */
 
 
 /* Bump IMM to the next stmt which has a use of var.  */
 

-static inline tree
+static inline gimple

 next_imm_use_stmt (imm_use_iterator *imm)
 {
   imm->imm_use = imm->iter_node.next;
 next_imm_use_stmt (imm_use_iterator *imm)
 {
   imm->imm_use = imm->iter_node.next;


@@ -1415,12 +1143,11 @@ next_imm_use_stmt (imm_use_iterator *imm)
     {
       if (imm->iter_node.prev != NULL)
        delink_imm_use (&imm->iter_node);
     {
       if (imm->iter_node.prev != NULL)
        delink_imm_use (&imm->iter_node);

-      return NULL_TREE;
+      return NULL;

     }
 
   link_use_stmts_after (imm->imm_use, imm);
   return USE_STMT (imm->imm_use);
     }
 
   link_use_stmts_after (imm->imm_use, imm);
   return USE_STMT (imm->imm_use);

-

 }
 
 /* This routine will return the first use on the stmt IMM currently refers
 }
 
 /* This routine will return the first use on the stmt IMM currently refers


@@ -1436,7 +1163,7 @@ first_imm_use_on_stmt (imm_use_iterator *imm)
 /*  Return TRUE if the last use on the stmt IMM refers to has been visited.  */
 
 static inline bool
 /*  Return TRUE if the last use on the stmt IMM refers to has been visited.  */
 
 static inline bool

-end_imm_use_on_stmt_p (imm_use_iterator *imm)
+end_imm_use_on_stmt_p (const imm_use_iterator *imm)

 {
   return (imm->imm_use == &(imm->iter_node));
 }
 {
   return (imm->imm_use == &(imm->iter_node));
 }


@@ -1459,21 +1186,18 @@ next_imm_use_on_stmt (imm_use_iterator *imm)
 /* Return true if VAR cannot be modified by the program.  */
 
 static inline bool
 /* Return true if VAR cannot be modified by the program.  */
 
 static inline bool

-unmodifiable_var_p (tree var)
+unmodifiable_var_p (const_tree var)

 {
   if (TREE_CODE (var) == SSA_NAME)
     var = SSA_NAME_VAR (var);
 
 {
   if (TREE_CODE (var) == SSA_NAME)
     var = SSA_NAME_VAR (var);
 

-  if (MTAG_P (var))
-    return TREE_READONLY (var) && (TREE_STATIC (var) || MTAG_GLOBAL (var));
-

   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
   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 (tree ref)
+array_ref_contains_indirect_ref (const_tree ref)

 {
   gcc_assert (TREE_CODE (ref) == ARRAY_REF);
 
 {
   gcc_assert (TREE_CODE (ref) == ARRAY_REF);
 


@@ -1488,7 +1212,7 @@ array_ref_contains_indirect_ref (tree ref)
    somewhere in it.  */
 
 static inline bool
    somewhere in it.  */
 
 static inline bool

-ref_contains_array_ref (tree ref)
+ref_contains_array_ref (const_tree ref)

 {
   gcc_assert (handled_component_p (ref));
 
 {
   gcc_assert (handled_component_p (ref));
 


@@ -1501,121 +1225,82 @@ ref_contains_array_ref (tree ref)
   return false;
 }
 
   return false;
 }
 

-/* Given a variable VAR, lookup and return a pointer to the list of
-   subvariables for it.  */
+/* Return true if REF has an VIEW_CONVERT_EXPR somewhere in it.  */

 
 

-static inline subvar_t *
-lookup_subvars_for_var (tree var)
+static inline bool
+contains_view_convert_expr_p (const_tree ref)

 {
 {

-  var_ann_t ann = var_ann (var);
-  gcc_assert (ann);
-  return &ann->subvars;
+  while (handled_component_p (ref))
+    {
+      if (TREE_CODE (ref) == VIEW_CONVERT_EXPR)
+       return true;
+      ref = TREE_OPERAND (ref, 0);
+    }
+
+  return false;

 }
 
 }
 

-/* Given a variable VAR, return a linked list of subvariables for VAR, or
-   NULL, if there are no subvariables.  */
+/* 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 subvar_t
-get_subvars_for_var (tree var)
-{
-  subvar_t subvars;
+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;

 
 

-  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;
+  return false;

 }
 
 }
 

-/* Return the subvariable of VAR at offset OFFSET.  */
-
-static inline tree
-get_subvar_at (tree var, unsigned HOST_WIDE_INT offset)
+/* Accessor to tree-ssa-operands.c caches.  */
+static inline struct ssa_operands *
+gimple_ssa_operands (const struct function *fun)

 {
 {

-  subvar_t sv;
-
-  for (sv = get_subvars_for_var (var); sv; sv = sv->next)
-    if (SFT_OFFSET (sv->var) == offset)
-      return sv->var;
-
-  return NULL_TREE;
+  return &fun->gimple_df->ssa_operands;

 }
 
 }
 

-/* Return true if V is a tree that we can have subvars for.
-   Normally, this is any aggregate type.  Also complex
-   types which are not gimple registers can have subvars.  */
+/* Given an edge_var_map V, return the PHI arg definition.  */

 
 

-static inline bool
-var_can_have_subvars (tree v)
+static inline tree
+redirect_edge_var_map_def (edge_var_map *v)

 {
 {

-  /* Volatile variables should never have subvars.  */
-  if (TREE_THIS_VOLATILE (v))
-    return false;
+  return v->def;
+}

 
 

-  /* Non decls or memory tags can never have subvars.  */
-  if (!DECL_P (v) || MTAG_P (v))
-    return false;
+/* Given an edge_var_map V, return the PHI result.  */

 
 

-  /* Aggregates can have subvars.  */
-  if (AGGREGATE_TYPE_P (TREE_TYPE (v)))
-    return true;
+static inline tree
+redirect_edge_var_map_result (edge_var_map *v)
+{
+  return v->result;
+}

 
 

-  /* 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))
-    return true;
+/* Given an edge_var_map V, return the PHI arg location.  */

 
 

-  return false;
+static inline source_location
+redirect_edge_var_map_location (edge_var_map *v)
+{
+  return v->locus;

 }
 
 }
 

-  
-/* 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. */

 
 

-static inline bool
-overlap_subvar (unsigned HOST_WIDE_INT offset, unsigned HOST_WIDE_INT size,
-               tree 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 == SFT_OFFSET (sv) && size == SFT_SIZE (sv))
-    {
-      if (exact)
-       *exact = true;
-      return true;
-    }
-  else if (offset >= SFT_OFFSET (sv) 
-          && offset < (SFT_OFFSET (sv) + SFT_SIZE (sv)))
-    {
-      return true;
-    }
-  else if (offset < SFT_OFFSET (sv) 
-          && (size > SFT_OFFSET (sv) - offset))
-    {
-      return true;
-    }
-  return false;
+/* 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  */
 }
 
 #endif /* _TREE_FLOW_INLINE_H  */