Mercurial > hg > CbC > CbC_gcc
annotate gcc/gimple-iterator.c @ 103:edcadcec937d
modify __rectype
author | Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 23 Mar 2012 17:11:33 +0900 |
parents | f6334be47118 |
children | 04ced10e8804 |
rev | line source |
---|---|
0 | 1 /* Iterator routines for GIMPLE statements. |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2 Copyright (C) 2007, 2008, 2010 Free Software Foundation, Inc. |
0 | 3 Contributed by Aldy Hernandez <aldy@quesejoda.com> |
4 | |
5 This file is part of GCC. | |
6 | |
7 GCC is free software; you can redistribute it and/or modify it under | |
8 the terms of the GNU General Public License as published by the Free | |
9 Software Foundation; either version 3, or (at your option) any later | |
10 version. | |
11 | |
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 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 "tm.h" | |
25 #include "tree.h" | |
26 #include "gimple.h" | |
27 #include "tree-flow.h" | |
28 #include "value-prof.h" | |
29 | |
30 | |
31 /* Mark the statement STMT as modified, and update it. */ | |
32 | |
33 static inline void | |
34 update_modified_stmt (gimple stmt) | |
35 { | |
36 if (!ssa_operands_active ()) | |
37 return; | |
38 update_stmt_if_modified (stmt); | |
39 } | |
40 | |
41 | |
42 /* Mark the statements in SEQ as modified, and update them. */ | |
43 | |
44 static void | |
45 update_modified_stmts (gimple_seq seq) | |
46 { | |
47 gimple_stmt_iterator gsi; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
48 |
0 | 49 if (!ssa_operands_active ()) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
50 return; |
0 | 51 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) |
52 update_stmt_if_modified (gsi_stmt (gsi)); | |
53 } | |
54 | |
55 | |
56 /* Set BB to be the basic block for all the statements in the list | |
57 starting at FIRST and LAST. */ | |
58 | |
59 static void | |
60 update_bb_for_stmts (gimple_seq_node first, basic_block bb) | |
61 { | |
62 gimple_seq_node n; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
63 |
0 | 64 for (n = first; n; n = n->next) |
65 gimple_set_bb (n->stmt, bb); | |
66 } | |
67 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
68 /* Set the frequencies for the cgraph_edges for each of the calls |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
69 starting at FIRST for their new position within BB. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
70 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
71 static void |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
72 update_call_edge_frequencies (gimple_seq_node first, basic_block bb) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
73 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
74 struct cgraph_node *cfun_node = NULL; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
75 int bb_freq = 0; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
76 gimple_seq_node n; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
77 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
78 for (n = first; n ; n = n->next) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
79 if (is_gimple_call (n->stmt)) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
80 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
81 struct cgraph_edge *e; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
82 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
83 /* These function calls are expensive enough that we want |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
84 to avoid calling them if we never see any calls. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
85 if (cfun_node == NULL) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
86 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
87 cfun_node = cgraph_node (current_function_decl); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
88 bb_freq = (compute_call_stmt_bb_frequency |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
89 (current_function_decl, bb)); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
90 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
91 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
92 e = cgraph_edge (cfun_node, n->stmt); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
93 if (e != NULL) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
94 e->frequency = bb_freq; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
95 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
96 } |
0 | 97 |
98 /* Insert the sequence delimited by nodes FIRST and LAST before | |
99 iterator I. M specifies how to update iterator I after insertion | |
100 (see enum gsi_iterator_update). | |
101 | |
102 This routine assumes that there is a forward and backward path | |
103 between FIRST and LAST (i.e., they are linked in a doubly-linked | |
104 list). Additionally, if FIRST == LAST, this routine will properly | |
105 insert a single node. */ | |
106 | |
107 static void | |
108 gsi_insert_seq_nodes_before (gimple_stmt_iterator *i, | |
109 gimple_seq_node first, | |
110 gimple_seq_node last, | |
111 enum gsi_iterator_update mode) | |
112 { | |
113 basic_block bb; | |
114 gimple_seq_node cur = i->ptr; | |
115 | |
116 if ((bb = gsi_bb (*i)) != NULL) | |
117 update_bb_for_stmts (first, bb); | |
118 | |
119 /* Link SEQ before CUR in the sequence. */ | |
120 if (cur) | |
121 { | |
122 first->prev = cur->prev; | |
123 if (first->prev) | |
124 first->prev->next = first; | |
125 else | |
126 gimple_seq_set_first (i->seq, first); | |
127 last->next = cur; | |
128 cur->prev = last; | |
129 } | |
130 else | |
131 { | |
132 gimple_seq_node itlast = gimple_seq_last (i->seq); | |
133 | |
134 /* If CUR is NULL, we link at the end of the sequence (this case happens | |
135 when gsi_after_labels is called for a basic block that contains only | |
136 labels, so it returns an iterator after the end of the block, and | |
137 we need to insert before it; it might be cleaner to add a flag to the | |
138 iterator saying whether we are at the start or end of the list). */ | |
139 first->prev = itlast; | |
140 if (itlast) | |
141 itlast->next = first; | |
142 else | |
143 gimple_seq_set_first (i->seq, first); | |
144 gimple_seq_set_last (i->seq, last); | |
145 } | |
146 | |
147 /* Update the iterator, if requested. */ | |
148 switch (mode) | |
149 { | |
150 case GSI_NEW_STMT: | |
151 case GSI_CONTINUE_LINKING: | |
152 i->ptr = first; | |
153 break; | |
154 case GSI_SAME_STMT: | |
155 break; | |
156 default: | |
157 gcc_unreachable (); | |
158 } | |
159 } | |
160 | |
161 | |
162 /* Inserts the sequence of statements SEQ before the statement pointed | |
163 by iterator I. MODE indicates what to do with the iterator after | |
164 insertion (see enum gsi_iterator_update). | |
165 | |
166 This function does not scan for new operands. It is provided for | |
167 the use of the gimplifier, which manipulates statements for which | |
168 def/use information has not yet been constructed. Most callers | |
169 should use gsi_insert_seq_before. */ | |
170 | |
171 void | |
172 gsi_insert_seq_before_without_update (gimple_stmt_iterator *i, gimple_seq seq, | |
173 enum gsi_iterator_update mode) | |
174 { | |
175 gimple_seq_node first, last; | |
176 | |
177 if (seq == NULL) | |
178 return; | |
179 | |
180 /* Don't allow inserting a sequence into itself. */ | |
181 gcc_assert (seq != i->seq); | |
182 | |
183 first = gimple_seq_first (seq); | |
184 last = gimple_seq_last (seq); | |
185 | |
186 gimple_seq_set_first (seq, NULL); | |
187 gimple_seq_set_last (seq, NULL); | |
188 gimple_seq_free (seq); | |
189 | |
190 /* Empty sequences need no work. */ | |
191 if (!first || !last) | |
192 { | |
193 gcc_assert (first == last); | |
194 return; | |
195 } | |
196 | |
197 gsi_insert_seq_nodes_before (i, first, last, mode); | |
198 } | |
199 | |
200 | |
201 /* Inserts the sequence of statements SEQ before the statement pointed | |
202 by iterator I. MODE indicates what to do with the iterator after | |
203 insertion (see enum gsi_iterator_update). Scan the statements in SEQ | |
204 for new operands. */ | |
205 | |
206 void | |
207 gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq, | |
208 enum gsi_iterator_update mode) | |
209 { | |
210 update_modified_stmts (seq); | |
211 gsi_insert_seq_before_without_update (i, seq, mode); | |
212 } | |
213 | |
214 | |
215 /* Insert the sequence delimited by nodes FIRST and LAST after | |
216 iterator I. M specifies how to update iterator I after insertion | |
217 (see enum gsi_iterator_update). | |
218 | |
219 This routine assumes that there is a forward and backward path | |
220 between FIRST and LAST (i.e., they are linked in a doubly-linked | |
221 list). Additionally, if FIRST == LAST, this routine will properly | |
222 insert a single node. */ | |
223 | |
224 static void | |
225 gsi_insert_seq_nodes_after (gimple_stmt_iterator *i, | |
226 gimple_seq_node first, | |
227 gimple_seq_node last, | |
228 enum gsi_iterator_update m) | |
229 { | |
230 basic_block bb; | |
231 gimple_seq_node cur = i->ptr; | |
232 | |
233 /* If the iterator is inside a basic block, we need to update the | |
234 basic block information for all the nodes between FIRST and LAST. */ | |
235 if ((bb = gsi_bb (*i)) != NULL) | |
236 update_bb_for_stmts (first, bb); | |
237 | |
238 /* Link SEQ after CUR. */ | |
239 if (cur) | |
240 { | |
241 last->next = cur->next; | |
242 if (last->next) | |
243 last->next->prev = last; | |
244 else | |
245 gimple_seq_set_last (i->seq, last); | |
246 first->prev = cur; | |
247 cur->next = first; | |
248 } | |
249 else | |
250 { | |
251 gcc_assert (!gimple_seq_last (i->seq)); | |
252 gimple_seq_set_first (i->seq, first); | |
253 gimple_seq_set_last (i->seq, last); | |
254 } | |
255 | |
256 /* Update the iterator, if requested. */ | |
257 switch (m) | |
258 { | |
259 case GSI_NEW_STMT: | |
260 i->ptr = first; | |
261 break; | |
262 case GSI_CONTINUE_LINKING: | |
263 i->ptr = last; | |
264 break; | |
265 case GSI_SAME_STMT: | |
266 gcc_assert (cur); | |
267 break; | |
268 default: | |
269 gcc_unreachable (); | |
270 } | |
271 } | |
272 | |
273 | |
274 /* Links sequence SEQ after the statement pointed-to by iterator I. | |
275 MODE is as in gsi_insert_after. | |
276 | |
277 This function does not scan for new operands. It is provided for | |
278 the use of the gimplifier, which manipulates statements for which | |
279 def/use information has not yet been constructed. Most callers | |
280 should use gsi_insert_seq_after. */ | |
281 | |
282 void | |
283 gsi_insert_seq_after_without_update (gimple_stmt_iterator *i, gimple_seq seq, | |
284 enum gsi_iterator_update mode) | |
285 { | |
286 gimple_seq_node first, last; | |
287 | |
288 if (seq == NULL) | |
289 return; | |
290 | |
291 /* Don't allow inserting a sequence into itself. */ | |
292 gcc_assert (seq != i->seq); | |
293 | |
294 first = gimple_seq_first (seq); | |
295 last = gimple_seq_last (seq); | |
296 | |
297 gimple_seq_set_first (seq, NULL); | |
298 gimple_seq_set_last (seq, NULL); | |
299 gimple_seq_free (seq); | |
300 | |
301 /* Empty sequences need no work. */ | |
302 if (!first || !last) | |
303 { | |
304 gcc_assert (first == last); | |
305 return; | |
306 } | |
307 | |
308 gsi_insert_seq_nodes_after (i, first, last, mode); | |
309 } | |
310 | |
311 | |
312 /* Links sequence SEQ after the statement pointed-to by iterator I. | |
313 MODE is as in gsi_insert_after. Scan the statements in SEQ | |
314 for new operands. */ | |
315 | |
316 void | |
317 gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq, | |
318 enum gsi_iterator_update mode) | |
319 { | |
320 update_modified_stmts (seq); | |
321 gsi_insert_seq_after_without_update (i, seq, mode); | |
322 } | |
323 | |
324 | |
325 /* Move all statements in the sequence after I to a new sequence. | |
326 Return this new sequence. */ | |
327 | |
328 gimple_seq | |
329 gsi_split_seq_after (gimple_stmt_iterator i) | |
330 { | |
331 gimple_seq_node cur, next; | |
332 gimple_seq old_seq, new_seq; | |
333 | |
334 cur = i.ptr; | |
335 | |
336 /* How can we possibly split after the end, or before the beginning? */ | |
337 gcc_assert (cur && cur->next); | |
338 next = cur->next; | |
339 | |
340 old_seq = i.seq; | |
341 new_seq = gimple_seq_alloc (); | |
342 | |
343 gimple_seq_set_first (new_seq, next); | |
344 gimple_seq_set_last (new_seq, gimple_seq_last (old_seq)); | |
345 gimple_seq_set_last (old_seq, cur); | |
346 cur->next = NULL; | |
347 next->prev = NULL; | |
348 | |
349 return new_seq; | |
350 } | |
351 | |
352 | |
353 /* Move all statements in the sequence before I to a new sequence. | |
354 Return this new sequence. I is set to the head of the new list. */ | |
355 | |
356 gimple_seq | |
357 gsi_split_seq_before (gimple_stmt_iterator *i) | |
358 { | |
359 gimple_seq_node cur, prev; | |
360 gimple_seq old_seq, new_seq; | |
361 | |
362 cur = i->ptr; | |
363 | |
364 /* How can we possibly split after the end? */ | |
365 gcc_assert (cur); | |
366 prev = cur->prev; | |
367 | |
368 old_seq = i->seq; | |
369 new_seq = gimple_seq_alloc (); | |
370 i->seq = new_seq; | |
371 | |
372 /* Set the limits on NEW_SEQ. */ | |
373 gimple_seq_set_first (new_seq, cur); | |
374 gimple_seq_set_last (new_seq, gimple_seq_last (old_seq)); | |
375 | |
376 /* Cut OLD_SEQ before I. */ | |
377 gimple_seq_set_last (old_seq, prev); | |
378 cur->prev = NULL; | |
379 if (prev) | |
380 prev->next = NULL; | |
381 else | |
382 gimple_seq_set_first (old_seq, NULL); | |
383 | |
384 return new_seq; | |
385 } | |
386 | |
387 | |
388 /* Replace the statement pointed-to by GSI to STMT. If UPDATE_EH_INFO | |
389 is true, the exception handling information of the original | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
390 statement is moved to the new statement. Assignments must only be |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
391 replaced with assignments to the same LHS. */ |
0 | 392 |
393 void | |
394 gsi_replace (gimple_stmt_iterator *gsi, gimple stmt, bool update_eh_info) | |
395 { | |
396 gimple orig_stmt = gsi_stmt (*gsi); | |
397 | |
398 if (stmt == orig_stmt) | |
399 return; | |
400 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
401 gcc_assert (!gimple_has_lhs (orig_stmt) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
402 || gimple_get_lhs (orig_stmt) == gimple_get_lhs (stmt)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
403 |
0 | 404 gimple_set_location (stmt, gimple_location (orig_stmt)); |
405 gimple_set_bb (stmt, gsi_bb (*gsi)); | |
406 | |
407 /* Preserve EH region information from the original statement, if | |
408 requested by the caller. */ | |
409 if (update_eh_info) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
410 maybe_clean_or_replace_eh_stmt (orig_stmt, stmt); |
0 | 411 |
412 gimple_duplicate_stmt_histograms (cfun, stmt, cfun, orig_stmt); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
413 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
414 /* Free all the data flow information for ORIG_STMT. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
415 gimple_set_bb (orig_stmt, NULL); |
0 | 416 gimple_remove_stmt_histograms (cfun, orig_stmt); |
417 delink_stmt_imm_use (orig_stmt); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
418 |
0 | 419 *gsi_stmt_ptr (gsi) = stmt; |
420 gimple_set_modified (stmt, true); | |
421 update_modified_stmt (stmt); | |
422 } | |
423 | |
424 | |
425 /* Insert statement STMT before the statement pointed-to by iterator I. | |
426 M specifies how to update iterator I after insertion (see enum | |
427 gsi_iterator_update). | |
428 | |
429 This function does not scan for new operands. It is provided for | |
430 the use of the gimplifier, which manipulates statements for which | |
431 def/use information has not yet been constructed. Most callers | |
432 should use gsi_insert_before. */ | |
433 | |
434 void | |
435 gsi_insert_before_without_update (gimple_stmt_iterator *i, gimple stmt, | |
436 enum gsi_iterator_update m) | |
437 { | |
438 gimple_seq_node n; | |
439 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
440 n = ggc_alloc_gimple_seq_node_d (); |
0 | 441 n->prev = n->next = NULL; |
442 n->stmt = stmt; | |
443 gsi_insert_seq_nodes_before (i, n, n, m); | |
444 } | |
445 | |
446 /* Insert statement STMT before the statement pointed-to by iterator I. | |
447 Update STMT's basic block and scan it for new operands. M | |
448 specifies how to update iterator I after insertion (see enum | |
449 gsi_iterator_update). */ | |
450 | |
451 void | |
452 gsi_insert_before (gimple_stmt_iterator *i, gimple stmt, | |
453 enum gsi_iterator_update m) | |
454 { | |
455 update_modified_stmt (stmt); | |
456 gsi_insert_before_without_update (i, stmt, m); | |
457 } | |
458 | |
459 | |
460 /* Insert statement STMT after the statement pointed-to by iterator I. | |
461 M specifies how to update iterator I after insertion (see enum | |
462 gsi_iterator_update). | |
463 | |
464 This function does not scan for new operands. It is provided for | |
465 the use of the gimplifier, which manipulates statements for which | |
466 def/use information has not yet been constructed. Most callers | |
467 should use gsi_insert_after. */ | |
468 | |
469 void | |
470 gsi_insert_after_without_update (gimple_stmt_iterator *i, gimple stmt, | |
471 enum gsi_iterator_update m) | |
472 { | |
473 gimple_seq_node n; | |
474 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
475 n = ggc_alloc_gimple_seq_node_d (); |
0 | 476 n->prev = n->next = NULL; |
477 n->stmt = stmt; | |
478 gsi_insert_seq_nodes_after (i, n, n, m); | |
479 } | |
480 | |
481 | |
482 /* Insert statement STMT after the statement pointed-to by iterator I. | |
483 Update STMT's basic block and scan it for new operands. M | |
484 specifies how to update iterator I after insertion (see enum | |
485 gsi_iterator_update). */ | |
486 | |
487 void | |
488 gsi_insert_after (gimple_stmt_iterator *i, gimple stmt, | |
489 enum gsi_iterator_update m) | |
490 { | |
491 update_modified_stmt (stmt); | |
492 gsi_insert_after_without_update (i, stmt, m); | |
493 } | |
494 | |
495 | |
496 /* Remove the current stmt from the sequence. The iterator is updated | |
497 to point to the next statement. | |
498 | |
499 REMOVE_PERMANENTLY is true when the statement is going to be removed | |
500 from the IL and not reinserted elsewhere. In that case we remove the | |
501 statement pointed to by iterator I from the EH tables, and free its | |
502 operand caches. Otherwise we do not modify this information. */ | |
503 | |
504 void | |
505 gsi_remove (gimple_stmt_iterator *i, bool remove_permanently) | |
506 { | |
507 gimple_seq_node cur, next, prev; | |
508 gimple stmt = gsi_stmt (*i); | |
509 | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
510 if (gimple_code (stmt) != GIMPLE_PHI) |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
511 insert_debug_temps_for_defs (i); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
512 |
0 | 513 /* Free all the data flow information for STMT. */ |
514 gimple_set_bb (stmt, NULL); | |
515 delink_stmt_imm_use (stmt); | |
516 gimple_set_modified (stmt, true); | |
517 | |
518 if (remove_permanently) | |
519 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
520 remove_stmt_from_eh_lp (stmt); |
0 | 521 gimple_remove_stmt_histograms (cfun, stmt); |
522 } | |
523 | |
524 /* Update the iterator and re-wire the links in I->SEQ. */ | |
525 cur = i->ptr; | |
526 next = cur->next; | |
527 prev = cur->prev; | |
528 | |
529 if (prev) | |
530 prev->next = next; | |
531 else | |
532 gimple_seq_set_first (i->seq, next); | |
533 | |
534 if (next) | |
535 next->prev = prev; | |
536 else | |
537 gimple_seq_set_last (i->seq, prev); | |
538 | |
539 i->ptr = next; | |
540 } | |
541 | |
542 | |
543 /* Finds iterator for STMT. */ | |
544 | |
545 gimple_stmt_iterator | |
546 gsi_for_stmt (gimple stmt) | |
547 { | |
548 gimple_stmt_iterator i; | |
549 basic_block bb = gimple_bb (stmt); | |
550 | |
551 if (gimple_code (stmt) == GIMPLE_PHI) | |
552 i = gsi_start_phis (bb); | |
553 else | |
554 i = gsi_start_bb (bb); | |
555 | |
556 for (; !gsi_end_p (i); gsi_next (&i)) | |
557 if (gsi_stmt (i) == stmt) | |
558 return i; | |
559 | |
560 gcc_unreachable (); | |
561 } | |
562 | |
563 | |
564 /* Move the statement at FROM so it comes right after the statement at TO. */ | |
565 | |
566 void | |
567 gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to) | |
568 { | |
569 gimple stmt = gsi_stmt (*from); | |
570 gsi_remove (from, false); | |
571 | |
572 /* We must have GSI_NEW_STMT here, as gsi_move_after is sometimes used to | |
573 move statements to an empty block. */ | |
574 gsi_insert_after (to, stmt, GSI_NEW_STMT); | |
575 } | |
576 | |
577 | |
578 /* Move the statement at FROM so it comes right before the statement | |
579 at TO. */ | |
580 | |
581 void | |
582 gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to) | |
583 { | |
584 gimple stmt = gsi_stmt (*from); | |
585 gsi_remove (from, false); | |
586 | |
587 /* For consistency with gsi_move_after, it might be better to have | |
588 GSI_NEW_STMT here; however, that breaks several places that expect | |
589 that TO does not change. */ | |
590 gsi_insert_before (to, stmt, GSI_SAME_STMT); | |
591 } | |
592 | |
593 | |
594 /* Move the statement at FROM to the end of basic block BB. */ | |
595 | |
596 void | |
597 gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb) | |
598 { | |
599 gimple_stmt_iterator last = gsi_last_bb (bb); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
600 gcc_checking_assert (gsi_bb (last) == bb); |
0 | 601 |
602 /* Have to check gsi_end_p because it could be an empty block. */ | |
603 if (!gsi_end_p (last) && is_ctrl_stmt (gsi_stmt (last))) | |
604 gsi_move_before (from, &last); | |
605 else | |
606 gsi_move_after (from, &last); | |
607 } | |
608 | |
609 | |
610 /* Add STMT to the pending list of edge E. No actual insertion is | |
611 made until a call to gsi_commit_edge_inserts () is made. */ | |
612 | |
613 void | |
614 gsi_insert_on_edge (edge e, gimple stmt) | |
615 { | |
616 gimple_seq_add_stmt (&PENDING_STMT (e), stmt); | |
617 } | |
618 | |
619 /* Add the sequence of statements SEQ to the pending list of edge E. | |
620 No actual insertion is made until a call to gsi_commit_edge_inserts | |
621 is made. */ | |
622 | |
623 void | |
624 gsi_insert_seq_on_edge (edge e, gimple_seq seq) | |
625 { | |
626 gimple_seq_add_seq (&PENDING_STMT (e), seq); | |
627 } | |
628 | |
629 | |
630 /* Insert the statement pointed-to by GSI into edge E. Every attempt | |
631 is made to place the statement in an existing basic block, but | |
632 sometimes that isn't possible. When it isn't possible, the edge is | |
633 split and the statement is added to the new block. | |
634 | |
635 In all cases, the returned *GSI points to the correct location. The | |
636 return value is true if insertion should be done after the location, | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
637 or false if it should be done before the location. If a new basic block |
0 | 638 has to be created, it is stored in *NEW_BB. */ |
639 | |
640 static bool | |
641 gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi, | |
642 basic_block *new_bb) | |
643 { | |
644 basic_block dest, src; | |
645 gimple tmp; | |
646 | |
647 dest = e->dest; | |
648 | |
649 /* If the destination has one predecessor which has no PHI nodes, | |
650 insert there. Except for the exit block. | |
651 | |
652 The requirement for no PHI nodes could be relaxed. Basically we | |
653 would have to examine the PHIs to prove that none of them used | |
654 the value set by the statement we want to insert on E. That | |
655 hardly seems worth the effort. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
656 restart: |
0 | 657 if (single_pred_p (dest) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
658 && gimple_seq_empty_p (phi_nodes (dest)) |
0 | 659 && dest != EXIT_BLOCK_PTR) |
660 { | |
661 *gsi = gsi_start_bb (dest); | |
662 if (gsi_end_p (*gsi)) | |
663 return true; | |
664 | |
665 /* Make sure we insert after any leading labels. */ | |
666 tmp = gsi_stmt (*gsi); | |
667 while (gimple_code (tmp) == GIMPLE_LABEL) | |
668 { | |
669 gsi_next (gsi); | |
670 if (gsi_end_p (*gsi)) | |
671 break; | |
672 tmp = gsi_stmt (*gsi); | |
673 } | |
674 | |
675 if (gsi_end_p (*gsi)) | |
676 { | |
677 *gsi = gsi_last_bb (dest); | |
678 return true; | |
679 } | |
680 else | |
681 return false; | |
682 } | |
683 | |
684 /* If the source has one successor, the edge is not abnormal and | |
685 the last statement does not end a basic block, insert there. | |
686 Except for the entry block. */ | |
687 src = e->src; | |
688 if ((e->flags & EDGE_ABNORMAL) == 0 | |
689 && single_succ_p (src) | |
690 && src != ENTRY_BLOCK_PTR) | |
691 { | |
692 *gsi = gsi_last_bb (src); | |
693 if (gsi_end_p (*gsi)) | |
694 return true; | |
695 | |
696 tmp = gsi_stmt (*gsi); | |
697 if (!stmt_ends_bb_p (tmp)) | |
698 return true; | |
699 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
700 switch (gimple_code (tmp)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
701 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
702 case GIMPLE_RETURN: |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
703 case GIMPLE_RESX: |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
704 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
705 default: |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
706 break; |
0 | 707 } |
708 } | |
709 | |
710 /* Otherwise, create a new basic block, and split this edge. */ | |
711 dest = split_edge (e); | |
712 if (new_bb) | |
713 *new_bb = dest; | |
714 e = single_pred_edge (dest); | |
715 goto restart; | |
716 } | |
717 | |
718 | |
719 /* Similar to gsi_insert_on_edge+gsi_commit_edge_inserts. If a new | |
720 block has to be created, it is returned. */ | |
721 | |
722 basic_block | |
723 gsi_insert_on_edge_immediate (edge e, gimple stmt) | |
724 { | |
725 gimple_stmt_iterator gsi; | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
726 struct gimple_seq_node_d node; |
0 | 727 basic_block new_bb = NULL; |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
728 bool ins_after; |
0 | 729 |
730 gcc_assert (!PENDING_STMT (e)); | |
731 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
732 ins_after = gimple_find_edge_insert_loc (e, &gsi, &new_bb); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
733 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
734 node.stmt = stmt; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
735 node.prev = node.next = NULL; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
736 update_call_edge_frequencies (&node, gsi.bb); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
737 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
738 if (ins_after) |
0 | 739 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT); |
740 else | |
741 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); | |
742 | |
743 return new_bb; | |
744 } | |
745 | |
746 /* Insert STMTS on edge E. If a new block has to be created, it | |
747 is returned. */ | |
748 | |
749 basic_block | |
750 gsi_insert_seq_on_edge_immediate (edge e, gimple_seq stmts) | |
751 { | |
752 gimple_stmt_iterator gsi; | |
753 basic_block new_bb = NULL; | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
754 bool ins_after; |
0 | 755 |
756 gcc_assert (!PENDING_STMT (e)); | |
757 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
758 ins_after = gimple_find_edge_insert_loc (e, &gsi, &new_bb); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
759 update_call_edge_frequencies (gimple_seq_first (stmts), gsi.bb); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
760 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
761 if (ins_after) |
0 | 762 gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT); |
763 else | |
764 gsi_insert_seq_before (&gsi, stmts, GSI_NEW_STMT); | |
765 | |
766 return new_bb; | |
767 } | |
768 | |
769 /* This routine will commit all pending edge insertions, creating any new | |
770 basic blocks which are necessary. */ | |
771 | |
772 void | |
773 gsi_commit_edge_inserts (void) | |
774 { | |
775 basic_block bb; | |
776 edge e; | |
777 edge_iterator ei; | |
778 | |
779 gsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR), NULL); | |
780 | |
781 FOR_EACH_BB (bb) | |
782 FOR_EACH_EDGE (e, ei, bb->succs) | |
783 gsi_commit_one_edge_insert (e, NULL); | |
784 } | |
785 | |
786 | |
787 /* Commit insertions pending at edge E. If a new block is created, set NEW_BB | |
788 to this block, otherwise set it to NULL. */ | |
789 | |
790 void | |
791 gsi_commit_one_edge_insert (edge e, basic_block *new_bb) | |
792 { | |
793 if (new_bb) | |
794 *new_bb = NULL; | |
795 | |
796 if (PENDING_STMT (e)) | |
797 { | |
798 gimple_stmt_iterator gsi; | |
799 gimple_seq seq = PENDING_STMT (e); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
800 bool ins_after; |
0 | 801 |
802 PENDING_STMT (e) = NULL; | |
803 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
804 ins_after = gimple_find_edge_insert_loc (e, &gsi, new_bb); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
805 update_call_edge_frequencies (gimple_seq_first (seq), gsi.bb); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
806 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
807 if (ins_after) |
0 | 808 gsi_insert_seq_after (&gsi, seq, GSI_NEW_STMT); |
809 else | |
810 gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT); | |
811 } | |
812 } | |
813 | |
814 /* Returns iterator at the start of the list of phi nodes of BB. */ | |
815 | |
816 gimple_stmt_iterator | |
817 gsi_start_phis (basic_block bb) | |
818 { | |
819 return gsi_start (phi_nodes (bb)); | |
820 } |