1 files changed, 377 insertions, 70 deletions

diff --git a/gcc/tree-flow-inline.h b/gcc/tree-flow-inline.h
index 4d6f5cb..d43812ef 100644
--- a/gcc/tree-flow-inline.h
+++ b/gcc/tree-flow-inline.h
@@ -141,9 +141,13 @@ noreturn_call_p (tree t)
 
 /* Mark statement T as modified.  */
 static inline void
-modify_stmt (tree t)
+mark_stmt_modified (tree t)
 {
-  stmt_ann_t ann = stmt_ann (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))
@@ -151,14 +155,42 @@ modify_stmt (tree t)
   ann->modified = 1;
 }
 
-/* Mark statement T as unmodified.  */
+/* Mark statement T as modified, and update it.  */
 static inline void
-unmodify_stmt (tree t)
+update_stmt (tree t)
 {
-  stmt_ann_t ann = stmt_ann (t);
-  if (ann == NULL)
-    ann = create_stmt_ann (t);
-  ann->modified = 0;
+  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);
+}
+
+static inline void 
+get_stmt_operands (tree stmt ATTRIBUTE_UNUSED)
+{
+#ifdef ENABLE_CHECKING
+  stmt_ann_t ann;
+                                                                                
+  /* The optimizers cannot handle statements that are nothing but a
+     _DECL.  This indicates a bug in the gimplifier.  */
+  gcc_assert (!SSA_VAR_P (stmt));
+                                                                                
+  /* Ignore error statements.  */
+  if (TREE_CODE (stmt) == ERROR_MARK)
+    return;
+                                                                                
+  ann = get_stmt_ann (stmt);
+  gcc_assert (!ann->modified);
+
+  return;
+#endif
 }
 
 /* Return true if T is marked as modified, false otherwise.  */
@@ -168,11 +200,286 @@ stmt_modified_p (tree t)
   stmt_ann_t ann = stmt_ann (t);
 
   /* Note that if the statement doesn't yet have an annotation, we consider it
-     modified.  This will force the next call to get_stmt_operands to scan the
-     statement.  */
+     modified.  This will force the next call to update_stmt_operands to scan 
+     the statement.  */
   return ann ? ann->modified : true;
 }
 
+/* Delink an immediate_uses node from its chain.  */
+static inline void
+delink_imm_use (ssa_imm_use_t *linknode)
+{
+  /* Return if this node is not in a list.  */
+  if (linknode->prev == NULL)
+    return;
+
+  linknode->prev->next = linknode->next;
+  linknode->next->prev = linknode->prev;
+  linknode->prev = NULL;
+  linknode->next = NULL;
+}
+
+/* Link ssa_imm_use node LINKNODE into the chain for LIST.  */
+static inline void
+link_imm_use_to_list (ssa_imm_use_t *linknode, ssa_imm_use_t *list)
+{
+  /* Link the new node at the head of the list.  If we are in the process of 
+     traversing the list, we wont visit any new nodes added to it.  */
+  linknode->prev = list;
+  linknode->next = list->next;
+  list->next->prev = linknode;
+  list->next = linknode;
+}
+
+/* Link ssa_imm_use node LINKNODE into the chain for DEF.  */
+static inline void
+link_imm_use (ssa_imm_use_t *linknode, tree def)
+{
+  ssa_imm_use_t *root;
+
+  if (!def || TREE_CODE (def) != SSA_NAME)
+    linknode->prev = NULL;
+  else
+    {
+      root = &(SSA_NAME_IMM_USE_NODE (def));
+#ifdef ENABLE_CHECKING
+      if (linknode->use)
+        gcc_assert (*(linknode->use) == def);
+#endif
+      link_imm_use_to_list (linknode, root);
+    }
+}
+
+/* Set the value of a use pointed by USE to VAL.  */
+static inline void
+set_ssa_use_from_ptr (use_operand_p use, tree val)
+{
+  delink_imm_use (use);
+  *(use->use) = val;
+  link_imm_use (use, val);
+}
+
+/* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occuring 
+   in STMT.  */
+static inline void
+link_imm_use_stmt (ssa_imm_use_t *linknode, tree def, tree stmt)
+{
+  if (stmt)
+    link_imm_use (linknode, def);
+  else
+    link_imm_use (linknode, NULL);
+  linknode->stmt = stmt;
+}
+
+/* Relink a new node in place of an old node in the list.  */
+static inline void
+relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old)
+{
+#ifdef ENABLE_CHECKING
+  /* The node one had better be in the same list.  */
+  if (*(old->use) != *(node->use))
+    abort ();
+#endif
+  node->prev = old->prev;
+  node->next = old->next;
+  if (old->prev)
+    {
+      old->prev->next = node;
+      old->next->prev = node;
+      /* Remove the old node from the list.  */
+      old->prev = NULL;
+    }
+
+}
+
+/* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occuring 
+   in STMT.  */
+static inline void
+relink_imm_use_stmt (ssa_imm_use_t *linknode, ssa_imm_use_t *old, tree 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));
+}
+
+/* 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 then next use in the list.  */
+static inline use_operand_p
+next_safe_imm_use (imm_use_iterator *imm)
+{
+  ssa_imm_use_t *ptr;
+  use_operand_p old;
+
+  old = imm->imm_use;
+  /* If the next node following the iter_node is still the one refered to by
+     imm_use, then the list hasnt changed, go to the next node.  */
+  if (imm->iter_node.next == imm->imm_use)
+    {
+      ptr = &(imm->iter_node);
+      /* Remove iternode fromn the list.  */
+      delink_imm_use (ptr);
+      imm->imm_use = imm->imm_use->next;
+      if (! end_safe_imm_use_p (imm))
+	{
+	  /* This isnt 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 sinply 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 immeidate use list.  */
+static inline bool
+end_readonly_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_readonly_imm_use (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;
+#ifdef ENABLE_CHECKING
+  imm->iter_node.next = imm->imm_use->next;
+#endif
+  if (end_readonly_imm_use_p (imm))
+    return NULL_USE_OPERAND_P;
+  return imm->imm_use;
+}
+
+/* Bump IMM to then next use in the list.  */
+static inline use_operand_p
+next_readonly_imm_use (imm_use_iterator *imm)
+{
+  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
+     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->iter_node.next = old->next->next;
+#endif
+
+  imm->imm_use = old->next;
+  if (end_readonly_imm_use_p (imm))
+    return old;
+  return imm->imm_use;
+}
+
+/* Return true if VAR has no uses.  */
+static inline bool
+has_zero_uses (tree var)
+{
+  ssa_imm_use_t *ptr;
+  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)
+{
+  ssa_imm_use_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);
+}
+
+/* If VAR has only a single immediate use, return true, and set USE_P and STMT
+   to the use pointer and stmt of occurence.  */
+static inline bool
+single_imm_use (tree var, use_operand_p *use_p, tree *stmt)
+{
+  ssa_imm_use_t *ptr;
+
+  ptr = &(SSA_NAME_IMM_USE_NODE (var));
+  if (ptr != ptr->next && ptr == ptr->next->next)
+    {
+      *use_p = ptr->next;
+      *stmt = ptr->next->stmt;
+      return true;
+    }
+  *use_p = NULL_USE_OPERAND_P;
+  *stmt = NULL_TREE;
+  return false;
+}
+
+/* Return the number of immediate uses of VAR.  */
+static inline unsigned int
+num_imm_uses (tree var)
+{
+  ssa_imm_use_t *ptr, *start;
+  unsigned int num;
+
+  start = &(SSA_NAME_IMM_USE_NODE (var));
+  num = 0;
+  for (ptr = start->next; ptr != start; ptr = ptr->next)
+     num++;
+
+  return num;
+}
+
 /* Return the definitions present in ANN, a statement annotation.
    Return NULL if this annotation contains no definitions.  */
 static inline def_optype
@@ -218,7 +525,7 @@ get_v_must_def_ops (stmt_ann_t ann)
 static inline tree
 get_use_from_ptr (use_operand_p use)
 { 
-  return *(use.use);
+  return *(use->use);
 } 
 
 /* Return the tree pointer to by DEF.  */
@@ -233,7 +540,7 @@ static inline use_operand_p
 get_use_op_ptr (use_optype uses, unsigned int index)
 {
   gcc_assert (index < uses->num_uses);
-  return uses->uses[index];
+  return &(uses->uses[index]);
 }
 
 /* Return a def_operand_p pointer for element INDEX of DEFS.  */
@@ -244,7 +551,6 @@ get_def_op_ptr (def_optype defs, unsigned int index)
   return defs->defs[index];
 }
 
-
 /* Return the def_operand_p that is the V_MAY_DEF_RESULT for the V_MAY_DEF
    at INDEX in the V_MAY_DEFS array.  */
 static inline def_operand_p
@@ -261,20 +567,16 @@ get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index)
 static inline use_operand_p
 get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index)
 {
-  use_operand_p op;
   gcc_assert (index < v_may_defs->num_v_may_defs);
-  op.use = &(v_may_defs->v_may_defs[index].use);
-  return op;
+  return &(v_may_defs->v_may_defs[index].imm_use);
 }
 
 /* Return a use_operand_p that is at INDEX in the VUSES array.  */
 static inline use_operand_p
 get_vuse_op_ptr(vuse_optype vuses, unsigned int index)
 {
-  use_operand_p op;
   gcc_assert (index < vuses->num_vuses);
-  op.use = &(vuses->vuses[index]);
-  return op;
+  return &(vuses->vuses[index].imm_use);
 }
 
 /* Return a def_operand_p that is the V_MUST_DEF_RESULT for the
@@ -293,10 +595,8 @@ get_v_must_def_result_ptr (v_must_def_optype v_must_defs, unsigned int index)
 static inline use_operand_p
 get_v_must_def_kill_ptr (v_must_def_optype v_must_defs, unsigned int index)
 {
-  use_operand_p op;
   gcc_assert (index < v_must_defs->num_v_must_defs);
-  op.use = &(v_must_defs->v_must_defs[index].use);
-  return op;
+  return &(v_must_defs->v_must_defs[index].imm_use);
 }
 
 /* Return a def_operand_p pointer for the result of PHI.  */
@@ -312,64 +612,40 @@ get_phi_result_ptr (tree phi)
 static inline use_operand_p
 get_phi_arg_def_ptr (tree phi, int i)
 {
-  use_operand_p op;
-  op.use = &(PHI_ARG_DEF_TREE (phi, i));
-  return op;
-}
- 
-/* Return the bitmap of addresses taken by STMT, or NULL if it takes
-   no addresses.  */
-static inline bitmap
-addresses_taken (tree stmt)
-{
-  stmt_ann_t ann = stmt_ann (stmt);
-  return ann ? ann->addresses_taken : NULL;
+  return &(PHI_ARG_IMM_USE_NODE (phi,i));
 }
 
-/* Return the immediate uses of STMT, or NULL if this information is
-   not computed.  */
-static dataflow_t
-get_immediate_uses (tree stmt)
+/* Delink all immediate_use information for STMT.  */
+static inline void
+delink_stmt_imm_use (tree stmt)
 {
-  stmt_ann_t ann;
+   unsigned int x;
+   use_optype uses = STMT_USE_OPS (stmt);
+   vuse_optype vuses = STMT_VUSE_OPS (stmt);
+   v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (stmt);
+   v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
 
-  if (TREE_CODE (stmt) == PHI_NODE)
-    return PHI_DF (stmt);
+   for (x = 0; x < NUM_USES (uses); x++)
+     delink_imm_use (&(uses->uses[x]));
 
-  ann = stmt_ann (stmt);
-  return ann ? ann->df : NULL;
-}
+   for (x = 0; x < NUM_VUSES (vuses); x++)
+     delink_imm_use (&(vuses->vuses[x].imm_use));
 
-/* Return the number of immediate uses present in the dataflow
-   information at DF.  */
-static inline int
-num_immediate_uses (dataflow_t df)
-{
-  varray_type imm;
+   for (x = 0; x < NUM_V_MAY_DEFS (v_may_defs); x++)
+     delink_imm_use (&(v_may_defs->v_may_defs[x].imm_use));
 
-  if (!df)
-    return 0;
-
-  imm = df->immediate_uses;
-  if (!imm)
-    return df->uses[1] ? 2 : 1;
-
-  return VARRAY_ACTIVE_SIZE (imm) + 2;
+   for (x = 0; x < NUM_V_MUST_DEFS (v_must_defs); x++)
+     delink_imm_use (&(v_must_defs->v_must_defs[x].imm_use));
 }
 
-/* Return the tree that is at NUM in the immediate use DF array.  */
-static inline tree
-immediate_use (dataflow_t df, int num)
-{
-  if (!df)
-    return NULL_TREE;
 
-#ifdef ENABLE_CHECKING
-  gcc_assert (num < num_immediate_uses (df));
-#endif
-  if (num < 2)
-    return df->uses[num];
-  return VARRAY_TREE (df->immediate_uses, num - 2);
+/* Return the bitmap of addresses taken by STMT, or NULL if it takes
+   no addresses.  */
+static inline bitmap
+addresses_taken (tree stmt)
+{
+  stmt_ann_t ann = stmt_ann (stmt);
+  return ann ? ann->addresses_taken : NULL;
 }
 
 /* Return the basic_block annotation for BB.  */
@@ -399,6 +675,37 @@ set_phi_nodes (basic_block bb, tree l)
     set_bb_for_stmt (phi, bb);
 }
 
+/* Return the phi argument which contains the specified use.  */
+
+static inline int
+phi_arg_index_from_use (use_operand_p use)
+{
+  struct phi_arg_d *element, *root;
+  int index;
+  tree phi;
+
+  /* Since the use is the first thing in a PHI arguemnt 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);
+
+  element = (struct phi_arg_d *)use;
+  root = &(PHI_ARG_ELT (phi, 0));
+  index = element - root;
+
+#ifdef ENABLE_CHECKING
+  /* Make sure the calculation doesn't have any leftover bytes.  If it does, 
+     then imm_use is liekly 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));
+#endif
+ 
+ return index;
+}
+
 /* Mark VAR as used, so that it'll be preserved during rtl expansion.  */
 
 static inline void