* ChangeLog.vta: New.

[pf3gnuchains/gcc-fork.git] / gcc / tree-iterator.c

diff --git a/gcc/tree-iterator.c b/gcc/tree-iterator.c
index ebc477b..a49744c 100644 (file)
--- a/gcc/tree-iterator.c
+++ b/gcc/tree-iterator.c
@@ -1,12 +1,12 @@
 /* Iterator routines for manipulating GENERIC and GIMPLE tree statements.
-   Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2007 Free Software Foundation, Inc.
    Contributed by Andrew MacLeod  <amacleod@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,
@@ -15,9 +15,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
-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/>.  */
 
 #include "config.h"
 #include "system.h"
@@ -40,24 +39,24 @@ alloc_stmt_list (void)
   if (list)
     {
       stmt_list_cache = TREE_CHAIN (list);
-      TREE_CHAIN (list) = NULL;
-      TREE_SIDE_EFFECTS (list) = 0;
+      gcc_assert (stmt_list_cache != list);
+      memset (list, 0, sizeof(struct tree_common));
+      TREE_SET_CODE (list, STATEMENT_LIST);
     }
   else
-    {
-      list = make_node (STATEMENT_LIST);
-      TREE_TYPE (list) = void_type_node;
-    }
+    list = make_node (STATEMENT_LIST);
+  TREE_TYPE (list) = void_type_node;
   return list;
 }
 
 void
 free_stmt_list (tree t)
 {
-#ifdef ENABLE_CHECKING
-  if (STATEMENT_LIST_HEAD (t) || STATEMENT_LIST_TAIL (t))
-    abort ();
-#endif
+  gcc_assert (!STATEMENT_LIST_HEAD (t));
+  gcc_assert (!STATEMENT_LIST_TAIL (t));
+  /* If this triggers, it's a sign that the same list is being freed
+     twice.  */
+  gcc_assert (t != stmt_list_cache || stmt_list_cache == NULL);
   TREE_CHAIN (t) = stmt_list_cache;
   stmt_list_cache = t;
 }
@@ -70,10 +69,7 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
   struct tree_statement_list_node *head, *tail, *cur;
 
   /* Die on looping.  */
-  if (t == i->container)
-    abort ();
-
-  TREE_SIDE_EFFECTS (i->container) = 1;
+  gcc_assert (t != i->container);
 
   if (TREE_CODE (t) == STATEMENT_LIST)
     {
@@ -87,8 +83,7 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       /* Empty statement lists need no work.  */
       if (!head || !tail)
        {
-         if (head != tail)
-           abort ();
+         gcc_assert (head == tail);
          return;
        }
     }
@@ -101,6 +96,8 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       tail = head;
     }
 
+  TREE_SIDE_EFFECTS (i->container) = 1;
+
   cur = i->ptr;
 
   /* Link it into the list.  */
@@ -116,9 +113,11 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
     }
   else
     {
-      if (STATEMENT_LIST_TAIL (i->container))
-       abort ();
-      STATEMENT_LIST_HEAD (i->container) = head;
+      head->prev = STATEMENT_LIST_TAIL (i->container);
+      if (head->prev)
+       head->prev->next = head;
+      else
+       STATEMENT_LIST_HEAD (i->container) = head;
       STATEMENT_LIST_TAIL (i->container) = tail;
     }
 
@@ -134,8 +133,6 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       i->ptr = tail;
       break;
     case TSI_SAME_STMT:
-      if (!cur)
-       abort ();
       break;
     }
 }
@@ -148,10 +145,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
   struct tree_statement_list_node *head, *tail, *cur;
 
   /* Die on looping.  */
-  if (t == i->container)
-    abort ();
-
-  TREE_SIDE_EFFECTS (i->container) = 1;
+  gcc_assert (t != i->container);
 
   if (TREE_CODE (t) == STATEMENT_LIST)
     {
@@ -165,8 +159,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       /* Empty statement lists need no work.  */
       if (!head || !tail)
        {
-         if (head != tail)
-           abort ();
+         gcc_assert (head == tail);
          return;
        }
     }
@@ -179,6 +172,8 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       tail = head;
     }
 
+  TREE_SIDE_EFFECTS (i->container) = 1;
+
   cur = i->ptr;
 
   /* Link it into the list.  */
@@ -194,8 +189,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
     }
   else
     {
-      if (STATEMENT_LIST_TAIL (i->container))
-       abort ();
+      gcc_assert (!STATEMENT_LIST_TAIL (i->container));
       STATEMENT_LIST_HEAD (i->container) = head;
       STATEMENT_LIST_TAIL (i->container) = tail;
     }
@@ -212,8 +206,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       i->ptr = tail;
       break;
     case TSI_SAME_STMT:
-      if (!cur)
-        abort ();
+      gcc_assert (cur);
       break;
     }
 }
@@ -256,8 +249,7 @@ tsi_split_statement_list_after (const tree_stmt_iterator *i)
 
   cur = i->ptr;
   /* How can we possibly split after the end, or before the beginning?  */
-  if (cur == NULL)
-    abort ();
+  gcc_assert (cur);
   next = cur->next;
 
   old_sl = i->container;
@@ -284,8 +276,7 @@ tsi_split_statement_list_before (tree_stmt_iterator *i)
 
   cur = i->ptr;
   /* How can we possibly split after the end, or before the beginning?  */
-  if (cur == NULL)
-    abort ();
+  gcc_assert (cur);
   prev = cur->prev;
 
   old_sl = i->container;
@@ -297,7 +288,10 @@ tsi_split_statement_list_before (tree_stmt_iterator *i)
   STATEMENT_LIST_TAIL (new_sl) = STATEMENT_LIST_TAIL (old_sl);
   STATEMENT_LIST_TAIL (old_sl) = prev;
   cur->prev = NULL;
-  prev->next = NULL;
+  if (prev)
+    prev->next = NULL;
+  else
+    STATEMENT_LIST_HEAD (old_sl) = NULL;
 
   return new_sl;
 }
@@ -319,12 +313,26 @@ expr_first (tree expr)
 
   while (TREE_CODE (expr) == COMPOUND_EXPR)
     expr = TREE_OPERAND (expr, 0);
+
   return expr;
 }
 
 /* Return the last expression in a sequence of COMPOUND_EXPRs,
    or in a STATEMENT_LIST.  */
 
+#define EXPR_LAST_BODY do { \
+  if (expr == NULL_TREE) \
+    return expr;\
+  if (TREE_CODE (expr) == STATEMENT_LIST) \
+    { \
+      struct tree_statement_list_node *n = STATEMENT_LIST_TAIL (expr); \
+      return n ? n->stmt : NULL_TREE; \
+    } \
+  while (TREE_CODE (expr) == COMPOUND_EXPR) \
+    expr = TREE_OPERAND (expr, 1); \
+  return expr; \
+} while (0)
+
 tree
 expr_last (tree expr)
 {
@@ -339,11 +347,13 @@ expr_last (tree expr)
 
   while (TREE_CODE (expr) == COMPOUND_EXPR)
     expr = TREE_OPERAND (expr, 1);
+
   return expr;
 }
 
-/* If EXPR is a single statement, naked or in a STATEMENT_LIST, then
-   return it.  Otherwise return NULL.  */
+/* If EXPR is a single statement return it.  If EXPR is a
+   STATEMENT_LIST containing exactly one statement S, return S.
+   Otherwise, return NULL.  */
 
 tree 
 expr_only (tree expr)