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