1 /* Iterator routines for manipulating GENERIC and GIMPLE tree statements.
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "tree-iterator.h"
29 /* This is a cache of STATEMENT_LIST nodes. We create and destroy them
30 fairly often during gimplification. */
32 static GTY ((deletable (""))) vec
<tree
, va_gc
> *stmt_list_cache
;
35 alloc_stmt_list (void)
38 if (!vec_safe_is_empty (stmt_list_cache
))
40 list
= stmt_list_cache
->pop ();
41 memset (list
, 0, sizeof (struct tree_base
));
42 TREE_SET_CODE (list
, STATEMENT_LIST
);
45 list
= make_node (STATEMENT_LIST
);
46 TREE_TYPE (list
) = void_type_node
;
51 free_stmt_list (tree t
)
53 gcc_assert (!STATEMENT_LIST_HEAD (t
));
54 gcc_assert (!STATEMENT_LIST_TAIL (t
));
55 vec_safe_push (stmt_list_cache
, t
);
58 /* A subroutine of append_to_statement_list{,_force}. T is not NULL. */
61 append_to_statement_list_1 (tree t
, tree
*list_p
)
68 if (t
&& TREE_CODE (t
) == STATEMENT_LIST
)
73 *list_p
= list
= alloc_stmt_list ();
75 else if (TREE_CODE (list
) != STATEMENT_LIST
)
78 *list_p
= list
= alloc_stmt_list ();
80 tsi_link_after (&i
, first
, TSI_CONTINUE_LINKING
);
84 tsi_link_after (&i
, t
, TSI_CONTINUE_LINKING
);
87 /* Add T to the end of the list container pointed to by LIST_P.
88 If T is an expression with no effects, it is ignored. */
91 append_to_statement_list (tree t
, tree
*list_p
)
93 if (t
&& TREE_SIDE_EFFECTS (t
))
94 append_to_statement_list_1 (t
, list_p
);
97 /* Similar, but the statement is always added, regardless of side effects. */
100 append_to_statement_list_force (tree t
, tree
*list_p
)
103 append_to_statement_list_1 (t
, list_p
);
106 /* Links a statement, or a chain of statements, before the current stmt. */
109 tsi_link_before (tree_stmt_iterator
*i
, tree t
, enum tsi_iterator_update mode
)
111 struct tree_statement_list_node
*head
, *tail
, *cur
;
113 /* Die on looping. */
114 gcc_assert (t
!= i
->container
);
116 if (TREE_CODE (t
) == STATEMENT_LIST
)
118 head
= STATEMENT_LIST_HEAD (t
);
119 tail
= STATEMENT_LIST_TAIL (t
);
120 STATEMENT_LIST_HEAD (t
) = NULL
;
121 STATEMENT_LIST_TAIL (t
) = NULL
;
125 /* Empty statement lists need no work. */
128 gcc_assert (head
== tail
);
134 head
= ggc_alloc
<tree_statement_list_node
> ();
141 TREE_SIDE_EFFECTS (i
->container
) = 1;
145 /* Link it into the list. */
148 head
->prev
= cur
->prev
;
150 head
->prev
->next
= head
;
152 STATEMENT_LIST_HEAD (i
->container
) = head
;
158 head
->prev
= STATEMENT_LIST_TAIL (i
->container
);
160 head
->prev
->next
= head
;
162 STATEMENT_LIST_HEAD (i
->container
) = head
;
163 STATEMENT_LIST_TAIL (i
->container
) = tail
;
166 /* Update the iterator, if requested. */
170 case TSI_CONTINUE_LINKING
:
171 case TSI_CHAIN_START
:
182 /* Links a statement, or a chain of statements, after the current stmt. */
185 tsi_link_after (tree_stmt_iterator
*i
, tree t
, enum tsi_iterator_update mode
)
187 struct tree_statement_list_node
*head
, *tail
, *cur
;
189 /* Die on looping. */
190 gcc_assert (t
!= i
->container
);
192 if (TREE_CODE (t
) == STATEMENT_LIST
)
194 head
= STATEMENT_LIST_HEAD (t
);
195 tail
= STATEMENT_LIST_TAIL (t
);
196 STATEMENT_LIST_HEAD (t
) = NULL
;
197 STATEMENT_LIST_TAIL (t
) = NULL
;
201 /* Empty statement lists need no work. */
204 gcc_assert (head
== tail
);
210 head
= ggc_alloc
<tree_statement_list_node
> ();
217 TREE_SIDE_EFFECTS (i
->container
) = 1;
221 /* Link it into the list. */
224 tail
->next
= cur
->next
;
226 tail
->next
->prev
= tail
;
228 STATEMENT_LIST_TAIL (i
->container
) = tail
;
234 gcc_assert (!STATEMENT_LIST_TAIL (i
->container
));
235 STATEMENT_LIST_HEAD (i
->container
) = head
;
236 STATEMENT_LIST_TAIL (i
->container
) = tail
;
239 /* Update the iterator, if requested. */
243 case TSI_CHAIN_START
:
246 case TSI_CONTINUE_LINKING
:
256 /* Remove a stmt from the tree list. The iterator is updated to point to
260 tsi_delink (tree_stmt_iterator
*i
)
262 struct tree_statement_list_node
*cur
, *next
, *prev
;
271 STATEMENT_LIST_HEAD (i
->container
) = next
;
275 STATEMENT_LIST_TAIL (i
->container
) = prev
;
278 TREE_SIDE_EFFECTS (i
->container
) = 0;
283 /* Return the first expression in a sequence of COMPOUND_EXPRs,
284 or in a STATEMENT_LIST. */
287 expr_first (tree expr
)
289 if (expr
== NULL_TREE
)
292 if (TREE_CODE (expr
) == STATEMENT_LIST
)
294 struct tree_statement_list_node
*n
= STATEMENT_LIST_HEAD (expr
);
295 return n
? n
->stmt
: NULL_TREE
;
298 while (TREE_CODE (expr
) == COMPOUND_EXPR
)
299 expr
= TREE_OPERAND (expr
, 0);
304 /* Return the last expression in a sequence of COMPOUND_EXPRs,
305 or in a STATEMENT_LIST. */
308 expr_last (tree expr
)
310 if (expr
== NULL_TREE
)
313 if (TREE_CODE (expr
) == STATEMENT_LIST
)
315 struct tree_statement_list_node
*n
= STATEMENT_LIST_TAIL (expr
);
316 return n
? n
->stmt
: NULL_TREE
;
319 while (TREE_CODE (expr
) == COMPOUND_EXPR
)
320 expr
= TREE_OPERAND (expr
, 1);
325 #include "gt-tree-iterator.h"