1 /* Iterator routines for manipulating GENERIC and GIMPLE tree statements.
2 Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
4
5 This file is part of GCC.
6
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 2, or (at your option)
10 any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tree.h"
26 #include "tree-gimple.h"
27 #include "tree-iterator.h"
28 #include "ggc.h"
29
30
31 /* This is a cache of STATEMENT_LIST nodes. We create and destroy them
32 fairly often during gimplification. */
33
34 static GTY ((deletable (""))) tree stmt_list_cache;
35
36 tree
alloc_stmt_list(void)37 alloc_stmt_list (void)
38 {
39 tree list = stmt_list_cache;
40 if (list)
41 {
42 stmt_list_cache = TREE_CHAIN (list);
43 memset (list, 0, sizeof(struct tree_common));
44 TREE_SET_CODE (list, STATEMENT_LIST);
45 }
46 else
47 list = make_node (STATEMENT_LIST);
48 TREE_TYPE (list) = void_type_node;
49 return list;
50 }
51
52 void
free_stmt_list(tree t)53 free_stmt_list (tree t)
54 {
55 gcc_assert (!STATEMENT_LIST_HEAD (t));
56 gcc_assert (!STATEMENT_LIST_TAIL (t));
57 TREE_CHAIN (t) = stmt_list_cache;
58 stmt_list_cache = t;
59 }
60
61 /* Links a statement, or a chain of statements, before the current stmt. */
62
63 void
tsi_link_before(tree_stmt_iterator * i,tree t,enum tsi_iterator_update mode)64 tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
65 {
66 struct tree_statement_list_node *head, *tail, *cur;
67
68 /* Die on looping. */
69 gcc_assert (t != i->container);
70
71 if (TREE_CODE (t) == STATEMENT_LIST)
72 {
73 head = STATEMENT_LIST_HEAD (t);
74 tail = STATEMENT_LIST_TAIL (t);
75 STATEMENT_LIST_HEAD (t) = NULL;
76 STATEMENT_LIST_TAIL (t) = NULL;
77
78 free_stmt_list (t);
79
80 /* Empty statement lists need no work. */
81 if (!head || !tail)
82 {
83 gcc_assert (head == tail);
84 return;
85 }
86 }
87 else
88 {
89 head = ggc_alloc (sizeof (*head));
90 head->prev = NULL;
91 head->next = NULL;
92 head->stmt = t;
93 tail = head;
94 }
95
96 TREE_SIDE_EFFECTS (i->container) = 1;
97
98 cur = i->ptr;
99
100 /* Link it into the list. */
101 if (cur)
102 {
103 head->prev = cur->prev;
104 if (head->prev)
105 head->prev->next = head;
106 else
107 STATEMENT_LIST_HEAD (i->container) = head;
108 tail->next = cur;
109 cur->prev = tail;
110 }
111 else
112 {
113 head->prev = STATEMENT_LIST_TAIL (i->container);
114 if (head->prev)
115 head->prev->next = head;
116 else
117 STATEMENT_LIST_HEAD (i->container) = head;
118 STATEMENT_LIST_TAIL (i->container) = tail;
119 }
120
121 /* Update the iterator, if requested. */
122 switch (mode)
123 {
124 case TSI_NEW_STMT:
125 case TSI_CONTINUE_LINKING:
126 case TSI_CHAIN_START:
127 i->ptr = head;
128 break;
129 case TSI_CHAIN_END:
130 i->ptr = tail;
131 break;
132 case TSI_SAME_STMT:
133 break;
134 }
135 }
136
137 /* Links a statement, or a chain of statements, after the current stmt. */
138
139 void
tsi_link_after(tree_stmt_iterator * i,tree t,enum tsi_iterator_update mode)140 tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
141 {
142 struct tree_statement_list_node *head, *tail, *cur;
143
144 /* Die on looping. */
145 gcc_assert (t != i->container);
146
147 if (TREE_CODE (t) == STATEMENT_LIST)
148 {
149 head = STATEMENT_LIST_HEAD (t);
150 tail = STATEMENT_LIST_TAIL (t);
151 STATEMENT_LIST_HEAD (t) = NULL;
152 STATEMENT_LIST_TAIL (t) = NULL;
153
154 free_stmt_list (t);
155
156 /* Empty statement lists need no work. */
157 if (!head || !tail)
158 {
159 gcc_assert (head == tail);
160 return;
161 }
162 }
163 else
164 {
165 head = ggc_alloc (sizeof (*head));
166 head->prev = NULL;
167 head->next = NULL;
168 head->stmt = t;
169 tail = head;
170 }
171
172 TREE_SIDE_EFFECTS (i->container) = 1;
173
174 cur = i->ptr;
175
176 /* Link it into the list. */
177 if (cur)
178 {
179 tail->next = cur->next;
180 if (tail->next)
181 tail->next->prev = tail;
182 else
183 STATEMENT_LIST_TAIL (i->container) = tail;
184 head->prev = cur;
185 cur->next = head;
186 }
187 else
188 {
189 gcc_assert (!STATEMENT_LIST_TAIL (i->container));
190 STATEMENT_LIST_HEAD (i->container) = head;
191 STATEMENT_LIST_TAIL (i->container) = tail;
192 }
193
194 /* Update the iterator, if requested. */
195 switch (mode)
196 {
197 case TSI_NEW_STMT:
198 case TSI_CHAIN_START:
199 i->ptr = head;
200 break;
201 case TSI_CONTINUE_LINKING:
202 case TSI_CHAIN_END:
203 i->ptr = tail;
204 break;
205 case TSI_SAME_STMT:
206 gcc_assert (cur);
207 break;
208 }
209 }
210
211 /* Remove a stmt from the tree list. The iterator is updated to point to
212 the next stmt. */
213
214 void
tsi_delink(tree_stmt_iterator * i)215 tsi_delink (tree_stmt_iterator *i)
216 {
217 struct tree_statement_list_node *cur, *next, *prev;
218
219 cur = i->ptr;
220 next = cur->next;
221 prev = cur->prev;
222
223 if (prev)
224 prev->next = next;
225 else
226 STATEMENT_LIST_HEAD (i->container) = next;
227 if (next)
228 next->prev = prev;
229 else
230 STATEMENT_LIST_TAIL (i->container) = prev;
231
232 if (!next && !prev)
233 TREE_SIDE_EFFECTS (i->container) = 0;
234
235 i->ptr = next;
236 }
237
238 /* Move all statements in the statement list after I to a new
239 statement list. I itself is unchanged. */
240
241 tree
tsi_split_statement_list_after(const tree_stmt_iterator * i)242 tsi_split_statement_list_after (const tree_stmt_iterator *i)
243 {
244 struct tree_statement_list_node *cur, *next;
245 tree old_sl, new_sl;
246
247 cur = i->ptr;
248 /* How can we possibly split after the end, or before the beginning? */
249 gcc_assert (cur);
250 next = cur->next;
251
252 old_sl = i->container;
253 new_sl = alloc_stmt_list ();
254 TREE_SIDE_EFFECTS (new_sl) = 1;
255
256 STATEMENT_LIST_HEAD (new_sl) = next;
257 STATEMENT_LIST_TAIL (new_sl) = STATEMENT_LIST_TAIL (old_sl);
258 STATEMENT_LIST_TAIL (old_sl) = cur;
259 cur->next = NULL;
260 next->prev = NULL;
261
262 return new_sl;
263 }
264
265 /* Move all statements in the statement list before I to a new
266 statement list. I is set to the head of the new list. */
267
268 tree
tsi_split_statement_list_before(tree_stmt_iterator * i)269 tsi_split_statement_list_before (tree_stmt_iterator *i)
270 {
271 struct tree_statement_list_node *cur, *prev;
272 tree old_sl, new_sl;
273
274 cur = i->ptr;
275 /* How can we possibly split after the end, or before the beginning? */
276 gcc_assert (cur);
277 prev = cur->prev;
278
279 old_sl = i->container;
280 new_sl = alloc_stmt_list ();
281 TREE_SIDE_EFFECTS (new_sl) = 1;
282 i->container = new_sl;
283
284 STATEMENT_LIST_HEAD (new_sl) = cur;
285 STATEMENT_LIST_TAIL (new_sl) = STATEMENT_LIST_TAIL (old_sl);
286 STATEMENT_LIST_TAIL (old_sl) = prev;
287 cur->prev = NULL;
288 prev->next = NULL;
289
290 return new_sl;
291 }
292
293 /* Return the first expression in a sequence of COMPOUND_EXPRs,
294 or in a STATEMENT_LIST. */
295
296 tree
expr_first(tree expr)297 expr_first (tree expr)
298 {
299 if (expr == NULL_TREE)
300 return expr;
301
302 if (TREE_CODE (expr) == STATEMENT_LIST)
303 {
304 struct tree_statement_list_node *n = STATEMENT_LIST_HEAD (expr);
305 return n ? n->stmt : NULL_TREE;
306 }
307
308 while (TREE_CODE (expr) == COMPOUND_EXPR)
309 expr = TREE_OPERAND (expr, 0);
310 return expr;
311 }
312
313 /* Return the last expression in a sequence of COMPOUND_EXPRs,
314 or in a STATEMENT_LIST. */
315
316 tree
expr_last(tree expr)317 expr_last (tree expr)
318 {
319 if (expr == NULL_TREE)
320 return expr;
321
322 if (TREE_CODE (expr) == STATEMENT_LIST)
323 {
324 struct tree_statement_list_node *n = STATEMENT_LIST_TAIL (expr);
325 return n ? n->stmt : NULL_TREE;
326 }
327
328 while (TREE_CODE (expr) == COMPOUND_EXPR)
329 expr = TREE_OPERAND (expr, 1);
330 return expr;
331 }
332
333 /* If EXPR is a single statement, naked or in a STATEMENT_LIST, then
334 return it. Otherwise return NULL. */
335
336 tree
expr_only(tree expr)337 expr_only (tree expr)
338 {
339 if (expr == NULL_TREE)
340 return NULL_TREE;
341
342 if (TREE_CODE (expr) == STATEMENT_LIST)
343 {
344 struct tree_statement_list_node *n = STATEMENT_LIST_TAIL (expr);
345 if (n && STATEMENT_LIST_HEAD (expr) == n)
346 return n->stmt;
347 else
348 return NULL_TREE;
349 }
350
351 if (TREE_CODE (expr) == COMPOUND_EXPR)
352 return NULL_TREE;
353
354 return expr;
355 }
356
357 #include "gt-tree-iterator.h"
358