You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree.h"
-#include "tree-simple.h"
+#include "tree-gimple.h"
#include "tree-iterator.h"
#include "ggc.h"
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;
}
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)
{
/* Empty statement lists need no work. */
if (!head || !tail)
{
- if (head != tail)
- abort ();
+ gcc_assert (head == tail);
return;
}
}
tail = head;
}
+ TREE_SIDE_EFFECTS (i->container) = 1;
+
cur = i->ptr;
/* Link it into the list. */
}
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;
}
i->ptr = tail;
break;
case TSI_SAME_STMT:
- if (!cur)
- abort ();
break;
}
}
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)
{
/* Empty statement lists need no work. */
if (!head || !tail)
{
- if (head != tail)
- abort ();
+ gcc_assert (head == tail);
return;
}
}
tail = head;
}
+ TREE_SIDE_EFFECTS (i->container) = 1;
+
cur = i->ptr;
/* Link it into the list. */
}
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;
}
i->ptr = tail;
break;
case TSI_SAME_STMT:
- if (!cur)
- abort ();
+ gcc_assert (cur);
break;
}
}
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;
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;
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;
return new_sl;
}
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)