Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-into-ssa.c @ 60:bd49c42ec43e
remove unnecessary files
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Mon, 15 Feb 2010 17:39:45 +0900 |
parents | 77e2b8dfacca |
children | b7f97abdc517 |
rev | line source |
---|---|
0 | 1 /* Rewrite a program in Normal form into SSA. |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 |
0 | 3 Free Software Foundation, Inc. |
4 Contributed by Diego Novillo <dnovillo@redhat.com> | |
5 | |
6 This file is part of GCC. | |
7 | |
8 GCC is free software; you can redistribute it and/or modify | |
9 it under the terms of the GNU General Public License as published by | |
10 the Free Software Foundation; either version 3, or (at your option) | |
11 any later version. | |
12 | |
13 GCC is distributed in the hope that it will be useful, | |
14 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 GNU General Public License for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
19 along with GCC; see the file COPYING3. If not see | |
20 <http://www.gnu.org/licenses/>. */ | |
21 | |
22 #include "config.h" | |
23 #include "system.h" | |
24 #include "coretypes.h" | |
25 #include "tm.h" | |
26 #include "tree.h" | |
27 #include "flags.h" | |
28 #include "rtl.h" | |
29 #include "tm_p.h" | |
30 #include "langhooks.h" | |
31 #include "hard-reg-set.h" | |
32 #include "basic-block.h" | |
33 #include "output.h" | |
34 #include "expr.h" | |
35 #include "function.h" | |
36 #include "diagnostic.h" | |
37 #include "bitmap.h" | |
38 #include "tree-flow.h" | |
39 #include "gimple.h" | |
40 #include "tree-inline.h" | |
41 #include "varray.h" | |
42 #include "timevar.h" | |
43 #include "hashtab.h" | |
44 #include "tree-dump.h" | |
45 #include "tree-pass.h" | |
46 #include "cfgloop.h" | |
47 #include "domwalk.h" | |
48 #include "ggc.h" | |
49 #include "params.h" | |
50 #include "vecprim.h" | |
51 | |
52 | |
53 /* This file builds the SSA form for a function as described in: | |
54 R. Cytron, J. Ferrante, B. Rosen, M. Wegman, and K. Zadeck. Efficiently | |
55 Computing Static Single Assignment Form and the Control Dependence | |
56 Graph. ACM Transactions on Programming Languages and Systems, | |
57 13(4):451-490, October 1991. */ | |
58 | |
59 /* Structure to map a variable VAR to the set of blocks that contain | |
60 definitions for VAR. */ | |
61 struct def_blocks_d | |
62 { | |
63 /* The variable. */ | |
64 tree var; | |
65 | |
66 /* Blocks that contain definitions of VAR. Bit I will be set if the | |
67 Ith block contains a definition of VAR. */ | |
68 bitmap def_blocks; | |
69 | |
70 /* Blocks that contain a PHI node for VAR. */ | |
71 bitmap phi_blocks; | |
72 | |
73 /* Blocks where VAR is live-on-entry. Similar semantics as | |
74 DEF_BLOCKS. */ | |
75 bitmap livein_blocks; | |
76 }; | |
77 | |
78 | |
79 /* Each entry in DEF_BLOCKS contains an element of type STRUCT | |
80 DEF_BLOCKS_D, mapping a variable VAR to a bitmap describing all the | |
81 basic blocks where VAR is defined (assigned a new value). It also | |
82 contains a bitmap of all the blocks where VAR is live-on-entry | |
83 (i.e., there is a use of VAR in block B without a preceding | |
84 definition in B). The live-on-entry information is used when | |
85 computing PHI pruning heuristics. */ | |
86 static htab_t def_blocks; | |
87 | |
88 /* Stack of trees used to restore the global currdefs to its original | |
89 state after completing rewriting of a block and its dominator | |
90 children. Its elements have the following properties: | |
91 | |
92 - An SSA_NAME (N) indicates that the current definition of the | |
93 underlying variable should be set to the given SSA_NAME. If the | |
94 symbol associated with the SSA_NAME is not a GIMPLE register, the | |
95 next slot in the stack must be a _DECL node (SYM). In this case, | |
96 the name N in the previous slot is the current reaching | |
97 definition for SYM. | |
98 | |
99 - A _DECL node indicates that the underlying variable has no | |
100 current definition. | |
101 | |
102 - A NULL node at the top entry is used to mark the last slot | |
103 associated with the current block. */ | |
104 static VEC(tree,heap) *block_defs_stack; | |
105 | |
106 | |
107 /* Set of existing SSA names being replaced by update_ssa. */ | |
108 static sbitmap old_ssa_names; | |
109 | |
110 /* Set of new SSA names being added by update_ssa. Note that both | |
111 NEW_SSA_NAMES and OLD_SSA_NAMES are dense bitmaps because most of | |
112 the operations done on them are presence tests. */ | |
113 static sbitmap new_ssa_names; | |
114 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
115 sbitmap interesting_blocks; |
0 | 116 |
117 /* Set of SSA names that have been marked to be released after they | |
118 were registered in the replacement table. They will be finally | |
119 released after we finish updating the SSA web. */ | |
120 static bitmap names_to_release; | |
121 | |
122 static VEC(gimple_vec, heap) *phis_to_rewrite; | |
123 | |
124 /* The bitmap of non-NULL elements of PHIS_TO_REWRITE. */ | |
125 static bitmap blocks_with_phis_to_rewrite; | |
126 | |
127 /* Growth factor for NEW_SSA_NAMES and OLD_SSA_NAMES. These sets need | |
128 to grow as the callers to register_new_name_mapping will typically | |
129 create new names on the fly. FIXME. Currently set to 1/3 to avoid | |
130 frequent reallocations but still need to find a reasonable growth | |
131 strategy. */ | |
132 #define NAME_SETS_GROWTH_FACTOR (MAX (3, num_ssa_names / 3)) | |
133 | |
134 /* Tuple used to represent replacement mappings. */ | |
135 struct repl_map_d | |
136 { | |
137 tree name; | |
138 bitmap set; | |
139 }; | |
140 | |
141 | |
142 /* NEW -> OLD_SET replacement table. If we are replacing several | |
143 existing SSA names O_1, O_2, ..., O_j with a new name N_i, | |
144 then REPL_TBL[N_i] = { O_1, O_2, ..., O_j }. */ | |
145 static htab_t repl_tbl; | |
146 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
147 /* The function the SSA updating data structures have been initialized for. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
148 NULL if they need to be initialized by register_new_name_mapping. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
149 static struct function *update_ssa_initialized_fn = NULL; |
0 | 150 |
151 /* Statistics kept by update_ssa to use in the virtual mapping | |
152 heuristic. If the number of virtual mappings is beyond certain | |
153 threshold, the updater will switch from using the mappings into | |
154 renaming the virtual symbols from scratch. In some cases, the | |
155 large number of name mappings for virtual names causes significant | |
156 slowdowns in the PHI insertion code. */ | |
157 struct update_ssa_stats_d | |
158 { | |
159 unsigned num_virtual_mappings; | |
160 unsigned num_total_mappings; | |
161 bitmap virtual_symbols; | |
162 unsigned num_virtual_symbols; | |
163 }; | |
164 static struct update_ssa_stats_d update_ssa_stats; | |
165 | |
166 /* Global data to attach to the main dominator walk structure. */ | |
167 struct mark_def_sites_global_data | |
168 { | |
169 /* This bitmap contains the variables which are set before they | |
170 are used in a basic block. */ | |
171 bitmap kills; | |
172 }; | |
173 | |
174 | |
175 /* Information stored for SSA names. */ | |
176 struct ssa_name_info | |
177 { | |
178 /* The current reaching definition replacing this SSA name. */ | |
179 tree current_def; | |
180 | |
181 /* This field indicates whether or not the variable may need PHI nodes. | |
182 See the enum's definition for more detailed information about the | |
183 states. */ | |
184 ENUM_BITFIELD (need_phi_state) need_phi_state : 2; | |
185 | |
186 /* Age of this record (so that info_for_ssa_name table can be cleared | |
187 quickly); if AGE < CURRENT_INFO_FOR_SSA_NAME_AGE, then the fields | |
188 are assumed to be null. */ | |
189 unsigned age; | |
190 }; | |
191 | |
192 /* The information associated with names. */ | |
193 typedef struct ssa_name_info *ssa_name_info_p; | |
194 DEF_VEC_P (ssa_name_info_p); | |
195 DEF_VEC_ALLOC_P (ssa_name_info_p, heap); | |
196 | |
197 static VEC(ssa_name_info_p, heap) *info_for_ssa_name; | |
198 static unsigned current_info_for_ssa_name_age; | |
199 | |
200 /* The set of blocks affected by update_ssa. */ | |
201 static bitmap blocks_to_update; | |
202 | |
203 /* The main entry point to the SSA renamer (rewrite_blocks) may be | |
204 called several times to do different, but related, tasks. | |
205 Initially, we need it to rename the whole program into SSA form. | |
206 At other times, we may need it to only rename into SSA newly | |
207 exposed symbols. Finally, we can also call it to incrementally fix | |
208 an already built SSA web. */ | |
209 enum rewrite_mode { | |
210 /* Convert the whole function into SSA form. */ | |
211 REWRITE_ALL, | |
212 | |
213 /* Incrementally update the SSA web by replacing existing SSA | |
214 names with new ones. See update_ssa for details. */ | |
215 REWRITE_UPDATE | |
216 }; | |
217 | |
218 | |
219 | |
220 | |
221 /* Prototypes for debugging functions. */ | |
222 extern void dump_tree_ssa (FILE *); | |
223 extern void debug_tree_ssa (void); | |
224 extern void debug_def_blocks (void); | |
225 extern void dump_tree_ssa_stats (FILE *); | |
226 extern void debug_tree_ssa_stats (void); | |
227 extern void dump_update_ssa (FILE *); | |
228 extern void debug_update_ssa (void); | |
229 extern void dump_names_replaced_by (FILE *, tree); | |
230 extern void debug_names_replaced_by (tree); | |
231 extern void dump_def_blocks (FILE *); | |
232 extern void debug_def_blocks (void); | |
233 extern void dump_defs_stack (FILE *, int); | |
234 extern void debug_defs_stack (int); | |
235 extern void dump_currdefs (FILE *); | |
236 extern void debug_currdefs (void); | |
237 | |
238 /* Return true if STMT needs to be rewritten. When renaming a subset | |
239 of the variables, not all statements will be processed. This is | |
240 decided in mark_def_sites. */ | |
241 | |
242 static inline bool | |
243 rewrite_uses_p (gimple stmt) | |
244 { | |
245 return gimple_visited_p (stmt); | |
246 } | |
247 | |
248 | |
249 /* Set the rewrite marker on STMT to the value given by REWRITE_P. */ | |
250 | |
251 static inline void | |
252 set_rewrite_uses (gimple stmt, bool rewrite_p) | |
253 { | |
254 gimple_set_visited (stmt, rewrite_p); | |
255 } | |
256 | |
257 | |
258 /* Return true if the DEFs created by statement STMT should be | |
259 registered when marking new definition sites. This is slightly | |
260 different than rewrite_uses_p: it's used by update_ssa to | |
261 distinguish statements that need to have both uses and defs | |
262 processed from those that only need to have their defs processed. | |
263 Statements that define new SSA names only need to have their defs | |
264 registered, but they don't need to have their uses renamed. */ | |
265 | |
266 static inline bool | |
267 register_defs_p (gimple stmt) | |
268 { | |
269 return gimple_plf (stmt, GF_PLF_1) != 0; | |
270 } | |
271 | |
272 | |
273 /* If REGISTER_DEFS_P is true, mark STMT to have its DEFs registered. */ | |
274 | |
275 static inline void | |
276 set_register_defs (gimple stmt, bool register_defs_p) | |
277 { | |
278 gimple_set_plf (stmt, GF_PLF_1, register_defs_p); | |
279 } | |
280 | |
281 | |
282 /* Get the information associated with NAME. */ | |
283 | |
284 static inline ssa_name_info_p | |
285 get_ssa_name_ann (tree name) | |
286 { | |
287 unsigned ver = SSA_NAME_VERSION (name); | |
288 unsigned len = VEC_length (ssa_name_info_p, info_for_ssa_name); | |
289 struct ssa_name_info *info; | |
290 | |
291 if (ver >= len) | |
292 { | |
293 unsigned new_len = num_ssa_names; | |
294 | |
295 VEC_reserve (ssa_name_info_p, heap, info_for_ssa_name, new_len); | |
296 while (len++ < new_len) | |
297 { | |
298 struct ssa_name_info *info = XCNEW (struct ssa_name_info); | |
299 info->age = current_info_for_ssa_name_age; | |
300 VEC_quick_push (ssa_name_info_p, info_for_ssa_name, info); | |
301 } | |
302 } | |
303 | |
304 info = VEC_index (ssa_name_info_p, info_for_ssa_name, ver); | |
305 if (info->age < current_info_for_ssa_name_age) | |
306 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
307 info->need_phi_state = NEED_PHI_STATE_UNKNOWN; |
0 | 308 info->current_def = NULL_TREE; |
309 info->age = current_info_for_ssa_name_age; | |
310 } | |
311 | |
312 return info; | |
313 } | |
314 | |
315 | |
316 /* Clears info for SSA names. */ | |
317 | |
318 static void | |
319 clear_ssa_name_info (void) | |
320 { | |
321 current_info_for_ssa_name_age++; | |
322 } | |
323 | |
324 | |
325 /* Get phi_state field for VAR. */ | |
326 | |
327 static inline enum need_phi_state | |
328 get_phi_state (tree var) | |
329 { | |
330 if (TREE_CODE (var) == SSA_NAME) | |
331 return get_ssa_name_ann (var)->need_phi_state; | |
332 else | |
333 return var_ann (var)->need_phi_state; | |
334 } | |
335 | |
336 | |
337 /* Sets phi_state field for VAR to STATE. */ | |
338 | |
339 static inline void | |
340 set_phi_state (tree var, enum need_phi_state state) | |
341 { | |
342 if (TREE_CODE (var) == SSA_NAME) | |
343 get_ssa_name_ann (var)->need_phi_state = state; | |
344 else | |
345 var_ann (var)->need_phi_state = state; | |
346 } | |
347 | |
348 | |
349 /* Return the current definition for VAR. */ | |
350 | |
351 tree | |
352 get_current_def (tree var) | |
353 { | |
354 if (TREE_CODE (var) == SSA_NAME) | |
355 return get_ssa_name_ann (var)->current_def; | |
356 else | |
357 return var_ann (var)->current_def; | |
358 } | |
359 | |
360 | |
361 /* Sets current definition of VAR to DEF. */ | |
362 | |
363 void | |
364 set_current_def (tree var, tree def) | |
365 { | |
366 if (TREE_CODE (var) == SSA_NAME) | |
367 get_ssa_name_ann (var)->current_def = def; | |
368 else | |
369 var_ann (var)->current_def = def; | |
370 } | |
371 | |
372 | |
373 /* Compute global livein information given the set of blocks where | |
374 an object is locally live at the start of the block (LIVEIN) | |
375 and the set of blocks where the object is defined (DEF_BLOCKS). | |
376 | |
377 Note: This routine augments the existing local livein information | |
378 to include global livein (i.e., it modifies the underlying bitmap | |
379 for LIVEIN). */ | |
380 | |
381 void | |
382 compute_global_livein (bitmap livein ATTRIBUTE_UNUSED, bitmap def_blocks ATTRIBUTE_UNUSED) | |
383 { | |
384 basic_block bb, *worklist, *tos; | |
385 unsigned i; | |
386 bitmap_iterator bi; | |
387 | |
388 tos = worklist | |
389 = (basic_block *) xmalloc (sizeof (basic_block) * (last_basic_block + 1)); | |
390 | |
391 EXECUTE_IF_SET_IN_BITMAP (livein, 0, i, bi) | |
392 *tos++ = BASIC_BLOCK (i); | |
393 | |
394 /* Iterate until the worklist is empty. */ | |
395 while (tos != worklist) | |
396 { | |
397 edge e; | |
398 edge_iterator ei; | |
399 | |
400 /* Pull a block off the worklist. */ | |
401 bb = *--tos; | |
402 | |
403 /* For each predecessor block. */ | |
404 FOR_EACH_EDGE (e, ei, bb->preds) | |
405 { | |
406 basic_block pred = e->src; | |
407 int pred_index = pred->index; | |
408 | |
409 /* None of this is necessary for the entry block. */ | |
410 if (pred != ENTRY_BLOCK_PTR | |
411 && ! bitmap_bit_p (livein, pred_index) | |
412 && ! bitmap_bit_p (def_blocks, pred_index)) | |
413 { | |
414 *tos++ = pred; | |
415 bitmap_set_bit (livein, pred_index); | |
416 } | |
417 } | |
418 } | |
419 | |
420 free (worklist); | |
421 } | |
422 | |
423 | |
424 /* Cleans up the REWRITE_THIS_STMT and REGISTER_DEFS_IN_THIS_STMT flags for | |
425 all statements in basic block BB. */ | |
426 | |
427 static void | |
428 initialize_flags_in_bb (basic_block bb) | |
429 { | |
430 gimple stmt; | |
431 gimple_stmt_iterator gsi; | |
432 | |
433 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
434 { | |
435 gimple phi = gsi_stmt (gsi); | |
436 set_rewrite_uses (phi, false); | |
437 set_register_defs (phi, false); | |
438 } | |
439 | |
440 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
441 { | |
442 stmt = gsi_stmt (gsi); | |
443 | |
444 /* We are going to use the operand cache API, such as | |
445 SET_USE, SET_DEF, and FOR_EACH_IMM_USE_FAST. The operand | |
446 cache for each statement should be up-to-date. */ | |
447 gcc_assert (!gimple_modified_p (stmt)); | |
448 set_rewrite_uses (stmt, false); | |
449 set_register_defs (stmt, false); | |
450 } | |
451 } | |
452 | |
453 /* Mark block BB as interesting for update_ssa. */ | |
454 | |
455 static void | |
456 mark_block_for_update (basic_block bb) | |
457 { | |
458 gcc_assert (blocks_to_update != NULL); | |
459 if (bitmap_bit_p (blocks_to_update, bb->index)) | |
460 return; | |
461 bitmap_set_bit (blocks_to_update, bb->index); | |
462 initialize_flags_in_bb (bb); | |
463 } | |
464 | |
465 /* Return the set of blocks where variable VAR is defined and the blocks | |
466 where VAR is live on entry (livein). If no entry is found in | |
467 DEF_BLOCKS, a new one is created and returned. */ | |
468 | |
469 static inline struct def_blocks_d * | |
470 get_def_blocks_for (tree var) | |
471 { | |
472 struct def_blocks_d db, *db_p; | |
473 void **slot; | |
474 | |
475 db.var = var; | |
476 slot = htab_find_slot (def_blocks, (void *) &db, INSERT); | |
477 if (*slot == NULL) | |
478 { | |
479 db_p = XNEW (struct def_blocks_d); | |
480 db_p->var = var; | |
481 db_p->def_blocks = BITMAP_ALLOC (NULL); | |
482 db_p->phi_blocks = BITMAP_ALLOC (NULL); | |
483 db_p->livein_blocks = BITMAP_ALLOC (NULL); | |
484 *slot = (void *) db_p; | |
485 } | |
486 else | |
487 db_p = (struct def_blocks_d *) *slot; | |
488 | |
489 return db_p; | |
490 } | |
491 | |
492 | |
493 /* Mark block BB as the definition site for variable VAR. PHI_P is true if | |
494 VAR is defined by a PHI node. */ | |
495 | |
496 static void | |
497 set_def_block (tree var, basic_block bb, bool phi_p) | |
498 { | |
499 struct def_blocks_d *db_p; | |
500 enum need_phi_state state; | |
501 | |
502 state = get_phi_state (var); | |
503 db_p = get_def_blocks_for (var); | |
504 | |
505 /* Set the bit corresponding to the block where VAR is defined. */ | |
506 bitmap_set_bit (db_p->def_blocks, bb->index); | |
507 if (phi_p) | |
508 bitmap_set_bit (db_p->phi_blocks, bb->index); | |
509 | |
510 /* Keep track of whether or not we may need to insert PHI nodes. | |
511 | |
512 If we are in the UNKNOWN state, then this is the first definition | |
513 of VAR. Additionally, we have not seen any uses of VAR yet, so | |
514 we do not need a PHI node for this variable at this time (i.e., | |
515 transition to NEED_PHI_STATE_NO). | |
516 | |
517 If we are in any other state, then we either have multiple definitions | |
518 of this variable occurring in different blocks or we saw a use of the | |
519 variable which was not dominated by the block containing the | |
520 definition(s). In this case we may need a PHI node, so enter | |
521 state NEED_PHI_STATE_MAYBE. */ | |
522 if (state == NEED_PHI_STATE_UNKNOWN) | |
523 set_phi_state (var, NEED_PHI_STATE_NO); | |
524 else | |
525 set_phi_state (var, NEED_PHI_STATE_MAYBE); | |
526 } | |
527 | |
528 | |
529 /* Mark block BB as having VAR live at the entry to BB. */ | |
530 | |
531 static void | |
532 set_livein_block (tree var, basic_block bb) | |
533 { | |
534 struct def_blocks_d *db_p; | |
535 enum need_phi_state state = get_phi_state (var); | |
536 | |
537 db_p = get_def_blocks_for (var); | |
538 | |
539 /* Set the bit corresponding to the block where VAR is live in. */ | |
540 bitmap_set_bit (db_p->livein_blocks, bb->index); | |
541 | |
542 /* Keep track of whether or not we may need to insert PHI nodes. | |
543 | |
544 If we reach here in NEED_PHI_STATE_NO, see if this use is dominated | |
545 by the single block containing the definition(s) of this variable. If | |
546 it is, then we remain in NEED_PHI_STATE_NO, otherwise we transition to | |
547 NEED_PHI_STATE_MAYBE. */ | |
548 if (state == NEED_PHI_STATE_NO) | |
549 { | |
550 int def_block_index = bitmap_first_set_bit (db_p->def_blocks); | |
551 | |
552 if (def_block_index == -1 | |
553 || ! dominated_by_p (CDI_DOMINATORS, bb, | |
554 BASIC_BLOCK (def_block_index))) | |
555 set_phi_state (var, NEED_PHI_STATE_MAYBE); | |
556 } | |
557 else | |
558 set_phi_state (var, NEED_PHI_STATE_MAYBE); | |
559 } | |
560 | |
561 | |
562 /* Return true if symbol SYM is marked for renaming. */ | |
563 | |
564 static inline bool | |
565 symbol_marked_for_renaming (tree sym) | |
566 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
567 return bitmap_bit_p (SYMS_TO_RENAME (cfun), DECL_UID (sym)); |
0 | 568 } |
569 | |
570 | |
571 /* Return true if NAME is in OLD_SSA_NAMES. */ | |
572 | |
573 static inline bool | |
574 is_old_name (tree name) | |
575 { | |
576 unsigned ver = SSA_NAME_VERSION (name); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
577 if (!new_ssa_names) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
578 return false; |
0 | 579 return ver < new_ssa_names->n_bits && TEST_BIT (old_ssa_names, ver); |
580 } | |
581 | |
582 | |
583 /* Return true if NAME is in NEW_SSA_NAMES. */ | |
584 | |
585 static inline bool | |
586 is_new_name (tree name) | |
587 { | |
588 unsigned ver = SSA_NAME_VERSION (name); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
589 if (!new_ssa_names) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
590 return false; |
0 | 591 return ver < new_ssa_names->n_bits && TEST_BIT (new_ssa_names, ver); |
592 } | |
593 | |
594 | |
595 /* Hashing and equality functions for REPL_TBL. */ | |
596 | |
597 static hashval_t | |
598 repl_map_hash (const void *p) | |
599 { | |
600 return htab_hash_pointer ((const void *)((const struct repl_map_d *)p)->name); | |
601 } | |
602 | |
603 static int | |
604 repl_map_eq (const void *p1, const void *p2) | |
605 { | |
606 return ((const struct repl_map_d *)p1)->name | |
607 == ((const struct repl_map_d *)p2)->name; | |
608 } | |
609 | |
610 static void | |
611 repl_map_free (void *p) | |
612 { | |
613 BITMAP_FREE (((struct repl_map_d *)p)->set); | |
614 free (p); | |
615 } | |
616 | |
617 | |
618 /* Return the names replaced by NEW_TREE (i.e., REPL_TBL[NEW_TREE].SET). */ | |
619 | |
620 static inline bitmap | |
621 names_replaced_by (tree new_tree) | |
622 { | |
623 struct repl_map_d m; | |
624 void **slot; | |
625 | |
626 m.name = new_tree; | |
627 slot = htab_find_slot (repl_tbl, (void *) &m, NO_INSERT); | |
628 | |
629 /* If N was not registered in the replacement table, return NULL. */ | |
630 if (slot == NULL || *slot == NULL) | |
631 return NULL; | |
632 | |
633 return ((struct repl_map_d *) *slot)->set; | |
634 } | |
635 | |
636 | |
637 /* Add OLD to REPL_TBL[NEW_TREE].SET. */ | |
638 | |
639 static inline void | |
640 add_to_repl_tbl (tree new_tree, tree old) | |
641 { | |
642 struct repl_map_d m, *mp; | |
643 void **slot; | |
644 | |
645 m.name = new_tree; | |
646 slot = htab_find_slot (repl_tbl, (void *) &m, INSERT); | |
647 if (*slot == NULL) | |
648 { | |
649 mp = XNEW (struct repl_map_d); | |
650 mp->name = new_tree; | |
651 mp->set = BITMAP_ALLOC (NULL); | |
652 *slot = (void *) mp; | |
653 } | |
654 else | |
655 mp = (struct repl_map_d *) *slot; | |
656 | |
657 bitmap_set_bit (mp->set, SSA_NAME_VERSION (old)); | |
658 } | |
659 | |
660 | |
661 /* Add a new mapping NEW_TREE -> OLD REPL_TBL. Every entry N_i in REPL_TBL | |
662 represents the set of names O_1 ... O_j replaced by N_i. This is | |
663 used by update_ssa and its helpers to introduce new SSA names in an | |
664 already formed SSA web. */ | |
665 | |
666 static void | |
667 add_new_name_mapping (tree new_tree, tree old) | |
668 { | |
669 timevar_push (TV_TREE_SSA_INCREMENTAL); | |
670 | |
671 /* OLD and NEW_TREE must be different SSA names for the same symbol. */ | |
672 gcc_assert (new_tree != old && SSA_NAME_VAR (new_tree) == SSA_NAME_VAR (old)); | |
673 | |
674 /* If this mapping is for virtual names, we will need to update | |
675 virtual operands. If this is a mapping for .MEM, then we gather | |
676 the symbols associated with each name. */ | |
677 if (!is_gimple_reg (new_tree)) | |
678 { | |
679 tree sym; | |
680 | |
681 update_ssa_stats.num_virtual_mappings++; | |
682 update_ssa_stats.num_virtual_symbols++; | |
683 | |
684 /* Keep counts of virtual mappings and symbols to use in the | |
685 virtual mapping heuristic. If we have large numbers of | |
686 virtual mappings for a relatively low number of symbols, it | |
687 will make more sense to rename the symbols from scratch. | |
688 Otherwise, the insertion of PHI nodes for each of the old | |
689 names in these mappings will be very slow. */ | |
690 sym = SSA_NAME_VAR (new_tree); | |
691 bitmap_set_bit (update_ssa_stats.virtual_symbols, DECL_UID (sym)); | |
692 } | |
693 | |
694 /* We may need to grow NEW_SSA_NAMES and OLD_SSA_NAMES because our | |
695 caller may have created new names since the set was created. */ | |
696 if (new_ssa_names->n_bits <= num_ssa_names - 1) | |
697 { | |
698 unsigned int new_sz = num_ssa_names + NAME_SETS_GROWTH_FACTOR; | |
699 new_ssa_names = sbitmap_resize (new_ssa_names, new_sz, 0); | |
700 old_ssa_names = sbitmap_resize (old_ssa_names, new_sz, 0); | |
701 } | |
702 | |
703 /* Update the REPL_TBL table. */ | |
704 add_to_repl_tbl (new_tree, old); | |
705 | |
706 /* If OLD had already been registered as a new name, then all the | |
707 names that OLD replaces should also be replaced by NEW_TREE. */ | |
708 if (is_new_name (old)) | |
709 bitmap_ior_into (names_replaced_by (new_tree), names_replaced_by (old)); | |
710 | |
711 /* Register NEW_TREE and OLD in NEW_SSA_NAMES and OLD_SSA_NAMES, | |
712 respectively. */ | |
713 SET_BIT (new_ssa_names, SSA_NAME_VERSION (new_tree)); | |
714 SET_BIT (old_ssa_names, SSA_NAME_VERSION (old)); | |
715 | |
716 /* Update mapping counter to use in the virtual mapping heuristic. */ | |
717 update_ssa_stats.num_total_mappings++; | |
718 | |
719 timevar_pop (TV_TREE_SSA_INCREMENTAL); | |
720 } | |
721 | |
722 | |
723 /* Call back for walk_dominator_tree used to collect definition sites | |
724 for every variable in the function. For every statement S in block | |
725 BB: | |
726 | |
727 1- Variables defined by S in the DEFS of S are marked in the bitmap | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
728 KILLS. |
0 | 729 |
730 2- If S uses a variable VAR and there is no preceding kill of VAR, | |
731 then it is marked in the LIVEIN_BLOCKS bitmap associated with VAR. | |
732 | |
733 This information is used to determine which variables are live | |
734 across block boundaries to reduce the number of PHI nodes | |
735 we create. */ | |
736 | |
737 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
738 mark_def_sites (basic_block bb, gimple stmt, bitmap kills) |
0 | 739 { |
740 tree def; | |
741 use_operand_p use_p; | |
742 ssa_op_iter iter; | |
743 | |
744 /* Since this is the first time that we rewrite the program into SSA | |
745 form, force an operand scan on every statement. */ | |
746 update_stmt (stmt); | |
747 | |
748 gcc_assert (blocks_to_update == NULL); | |
749 set_register_defs (stmt, false); | |
750 set_rewrite_uses (stmt, false); | |
751 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
752 if (is_gimple_debug (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
753 return; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
754 |
0 | 755 /* If a variable is used before being set, then the variable is live |
756 across a block boundary, so mark it live-on-entry to BB. */ | |
757 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE) | |
758 { | |
759 tree sym = USE_FROM_PTR (use_p); | |
760 gcc_assert (DECL_P (sym)); | |
761 if (!bitmap_bit_p (kills, DECL_UID (sym))) | |
762 set_livein_block (sym, bb); | |
763 set_rewrite_uses (stmt, true); | |
764 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
765 |
0 | 766 /* Now process the defs. Mark BB as the definition block and add |
767 each def to the set of killed symbols. */ | |
768 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF) | |
769 { | |
770 gcc_assert (DECL_P (def)); | |
771 set_def_block (def, bb, false); | |
772 bitmap_set_bit (kills, DECL_UID (def)); | |
773 set_register_defs (stmt, true); | |
774 } | |
775 | |
776 /* If we found the statement interesting then also mark the block BB | |
777 as interesting. */ | |
778 if (rewrite_uses_p (stmt) || register_defs_p (stmt)) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
779 SET_BIT (interesting_blocks, bb->index); |
0 | 780 } |
781 | |
782 /* Structure used by prune_unused_phi_nodes to record bounds of the intervals | |
783 in the dfs numbering of the dominance tree. */ | |
784 | |
785 struct dom_dfsnum | |
786 { | |
787 /* Basic block whose index this entry corresponds to. */ | |
788 unsigned bb_index; | |
789 | |
790 /* The dfs number of this node. */ | |
791 unsigned dfs_num; | |
792 }; | |
793 | |
794 /* Compares two entries of type struct dom_dfsnum by dfs_num field. Callback | |
795 for qsort. */ | |
796 | |
797 static int | |
798 cmp_dfsnum (const void *a, const void *b) | |
799 { | |
800 const struct dom_dfsnum *const da = (const struct dom_dfsnum *) a; | |
801 const struct dom_dfsnum *const db = (const struct dom_dfsnum *) b; | |
802 | |
803 return (int) da->dfs_num - (int) db->dfs_num; | |
804 } | |
805 | |
806 /* Among the intervals starting at the N points specified in DEFS, find | |
807 the one that contains S, and return its bb_index. */ | |
808 | |
809 static unsigned | |
810 find_dfsnum_interval (struct dom_dfsnum *defs, unsigned n, unsigned s) | |
811 { | |
812 unsigned f = 0, t = n, m; | |
813 | |
814 while (t > f + 1) | |
815 { | |
816 m = (f + t) / 2; | |
817 if (defs[m].dfs_num <= s) | |
818 f = m; | |
819 else | |
820 t = m; | |
821 } | |
822 | |
823 return defs[f].bb_index; | |
824 } | |
825 | |
826 /* Clean bits from PHIS for phi nodes whose value cannot be used in USES. | |
827 KILLS is a bitmap of blocks where the value is defined before any use. */ | |
828 | |
829 static void | |
830 prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses) | |
831 { | |
832 VEC(int, heap) *worklist; | |
833 bitmap_iterator bi; | |
834 unsigned i, b, p, u, top; | |
835 bitmap live_phis; | |
836 basic_block def_bb, use_bb; | |
837 edge e; | |
838 edge_iterator ei; | |
839 bitmap to_remove; | |
840 struct dom_dfsnum *defs; | |
841 unsigned n_defs, adef; | |
842 | |
843 if (bitmap_empty_p (uses)) | |
844 { | |
845 bitmap_clear (phis); | |
846 return; | |
847 } | |
848 | |
849 /* The phi must dominate a use, or an argument of a live phi. Also, we | |
850 do not create any phi nodes in def blocks, unless they are also livein. */ | |
851 to_remove = BITMAP_ALLOC (NULL); | |
852 bitmap_and_compl (to_remove, kills, uses); | |
853 bitmap_and_compl_into (phis, to_remove); | |
854 if (bitmap_empty_p (phis)) | |
855 { | |
856 BITMAP_FREE (to_remove); | |
857 return; | |
858 } | |
859 | |
860 /* We want to remove the unnecessary phi nodes, but we do not want to compute | |
861 liveness information, as that may be linear in the size of CFG, and if | |
862 there are lot of different variables to rewrite, this may lead to quadratic | |
863 behavior. | |
864 | |
865 Instead, we basically emulate standard dce. We put all uses to worklist, | |
866 then for each of them find the nearest def that dominates them. If this | |
867 def is a phi node, we mark it live, and if it was not live before, we | |
868 add the predecessors of its basic block to the worklist. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
869 |
0 | 870 To quickly locate the nearest def that dominates use, we use dfs numbering |
871 of the dominance tree (that is already available in order to speed up | |
872 queries). For each def, we have the interval given by the dfs number on | |
873 entry to and on exit from the corresponding subtree in the dominance tree. | |
874 The nearest dominator for a given use is the smallest of these intervals | |
875 that contains entry and exit dfs numbers for the basic block with the use. | |
876 If we store the bounds for all the uses to an array and sort it, we can | |
877 locate the nearest dominating def in logarithmic time by binary search.*/ | |
878 bitmap_ior (to_remove, kills, phis); | |
879 n_defs = bitmap_count_bits (to_remove); | |
880 defs = XNEWVEC (struct dom_dfsnum, 2 * n_defs + 1); | |
881 defs[0].bb_index = 1; | |
882 defs[0].dfs_num = 0; | |
883 adef = 1; | |
884 EXECUTE_IF_SET_IN_BITMAP (to_remove, 0, i, bi) | |
885 { | |
886 def_bb = BASIC_BLOCK (i); | |
887 defs[adef].bb_index = i; | |
888 defs[adef].dfs_num = bb_dom_dfs_in (CDI_DOMINATORS, def_bb); | |
889 defs[adef + 1].bb_index = i; | |
890 defs[adef + 1].dfs_num = bb_dom_dfs_out (CDI_DOMINATORS, def_bb); | |
891 adef += 2; | |
892 } | |
893 BITMAP_FREE (to_remove); | |
894 gcc_assert (adef == 2 * n_defs + 1); | |
895 qsort (defs, adef, sizeof (struct dom_dfsnum), cmp_dfsnum); | |
896 gcc_assert (defs[0].bb_index == 1); | |
897 | |
898 /* Now each DEFS entry contains the number of the basic block to that the | |
899 dfs number corresponds. Change them to the number of basic block that | |
900 corresponds to the interval following the dfs number. Also, for the | |
901 dfs_out numbers, increase the dfs number by one (so that it corresponds | |
902 to the start of the following interval, not to the end of the current | |
903 one). We use WORKLIST as a stack. */ | |
904 worklist = VEC_alloc (int, heap, n_defs + 1); | |
905 VEC_quick_push (int, worklist, 1); | |
906 top = 1; | |
907 n_defs = 1; | |
908 for (i = 1; i < adef; i++) | |
909 { | |
910 b = defs[i].bb_index; | |
911 if (b == top) | |
912 { | |
913 /* This is a closing element. Interval corresponding to the top | |
914 of the stack after removing it follows. */ | |
915 VEC_pop (int, worklist); | |
916 top = VEC_index (int, worklist, VEC_length (int, worklist) - 1); | |
917 defs[n_defs].bb_index = top; | |
918 defs[n_defs].dfs_num = defs[i].dfs_num + 1; | |
919 } | |
920 else | |
921 { | |
922 /* Opening element. Nothing to do, just push it to the stack and move | |
923 it to the correct position. */ | |
924 defs[n_defs].bb_index = defs[i].bb_index; | |
925 defs[n_defs].dfs_num = defs[i].dfs_num; | |
926 VEC_quick_push (int, worklist, b); | |
927 top = b; | |
928 } | |
929 | |
930 /* If this interval starts at the same point as the previous one, cancel | |
931 the previous one. */ | |
932 if (defs[n_defs].dfs_num == defs[n_defs - 1].dfs_num) | |
933 defs[n_defs - 1].bb_index = defs[n_defs].bb_index; | |
934 else | |
935 n_defs++; | |
936 } | |
937 VEC_pop (int, worklist); | |
938 gcc_assert (VEC_empty (int, worklist)); | |
939 | |
940 /* Now process the uses. */ | |
941 live_phis = BITMAP_ALLOC (NULL); | |
942 EXECUTE_IF_SET_IN_BITMAP (uses, 0, i, bi) | |
943 { | |
944 VEC_safe_push (int, heap, worklist, i); | |
945 } | |
946 | |
947 while (!VEC_empty (int, worklist)) | |
948 { | |
949 b = VEC_pop (int, worklist); | |
950 if (b == ENTRY_BLOCK) | |
951 continue; | |
952 | |
953 /* If there is a phi node in USE_BB, it is made live. Otherwise, | |
954 find the def that dominates the immediate dominator of USE_BB | |
955 (the kill in USE_BB does not dominate the use). */ | |
956 if (bitmap_bit_p (phis, b)) | |
957 p = b; | |
958 else | |
959 { | |
960 use_bb = get_immediate_dominator (CDI_DOMINATORS, BASIC_BLOCK (b)); | |
961 p = find_dfsnum_interval (defs, n_defs, | |
962 bb_dom_dfs_in (CDI_DOMINATORS, use_bb)); | |
963 if (!bitmap_bit_p (phis, p)) | |
964 continue; | |
965 } | |
966 | |
967 /* If the phi node is already live, there is nothing to do. */ | |
968 if (bitmap_bit_p (live_phis, p)) | |
969 continue; | |
970 | |
971 /* Mark the phi as live, and add the new uses to the worklist. */ | |
972 bitmap_set_bit (live_phis, p); | |
973 def_bb = BASIC_BLOCK (p); | |
974 FOR_EACH_EDGE (e, ei, def_bb->preds) | |
975 { | |
976 u = e->src->index; | |
977 if (bitmap_bit_p (uses, u)) | |
978 continue; | |
979 | |
980 /* In case there is a kill directly in the use block, do not record | |
981 the use (this is also necessary for correctness, as we assume that | |
982 uses dominated by a def directly in their block have been filtered | |
983 out before). */ | |
984 if (bitmap_bit_p (kills, u)) | |
985 continue; | |
986 | |
987 bitmap_set_bit (uses, u); | |
988 VEC_safe_push (int, heap, worklist, u); | |
989 } | |
990 } | |
991 | |
992 VEC_free (int, heap, worklist); | |
993 bitmap_copy (phis, live_phis); | |
994 BITMAP_FREE (live_phis); | |
995 free (defs); | |
996 } | |
997 | |
998 /* Return the set of blocks where variable VAR is defined and the blocks | |
999 where VAR is live on entry (livein). Return NULL, if no entry is | |
1000 found in DEF_BLOCKS. */ | |
1001 | |
1002 static inline struct def_blocks_d * | |
1003 find_def_blocks_for (tree var) | |
1004 { | |
1005 struct def_blocks_d dm; | |
1006 dm.var = var; | |
1007 return (struct def_blocks_d *) htab_find (def_blocks, &dm); | |
1008 } | |
1009 | |
1010 | |
1011 /* Retrieve or create a default definition for symbol SYM. */ | |
1012 | |
1013 static inline tree | |
1014 get_default_def_for (tree sym) | |
1015 { | |
1016 tree ddef = gimple_default_def (cfun, sym); | |
1017 | |
1018 if (ddef == NULL_TREE) | |
1019 { | |
1020 ddef = make_ssa_name (sym, gimple_build_nop ()); | |
1021 set_default_def (sym, ddef); | |
1022 } | |
1023 | |
1024 return ddef; | |
1025 } | |
1026 | |
1027 | |
1028 /* Marks phi node PHI in basic block BB for rewrite. */ | |
1029 | |
1030 static void | |
1031 mark_phi_for_rewrite (basic_block bb, gimple phi) | |
1032 { | |
1033 gimple_vec phis; | |
1034 unsigned i, idx = bb->index; | |
1035 | |
1036 if (rewrite_uses_p (phi)) | |
1037 return; | |
1038 | |
1039 set_rewrite_uses (phi, true); | |
1040 | |
1041 if (!blocks_with_phis_to_rewrite) | |
1042 return; | |
1043 | |
1044 bitmap_set_bit (blocks_with_phis_to_rewrite, idx); | |
1045 VEC_reserve (gimple_vec, heap, phis_to_rewrite, last_basic_block + 1); | |
1046 for (i = VEC_length (gimple_vec, phis_to_rewrite); i <= idx; i++) | |
1047 VEC_quick_push (gimple_vec, phis_to_rewrite, NULL); | |
1048 | |
1049 phis = VEC_index (gimple_vec, phis_to_rewrite, idx); | |
1050 if (!phis) | |
1051 phis = VEC_alloc (gimple, heap, 10); | |
1052 | |
1053 VEC_safe_push (gimple, heap, phis, phi); | |
1054 VEC_replace (gimple_vec, phis_to_rewrite, idx, phis); | |
1055 } | |
1056 | |
1057 /* Insert PHI nodes for variable VAR using the iterated dominance | |
1058 frontier given in PHI_INSERTION_POINTS. If UPDATE_P is true, this | |
1059 function assumes that the caller is incrementally updating the | |
1060 existing SSA form, in which case VAR may be an SSA name instead of | |
1061 a symbol. | |
1062 | |
1063 PHI_INSERTION_POINTS is updated to reflect nodes that already had a | |
1064 PHI node for VAR. On exit, only the nodes that received a PHI node | |
1065 for VAR will be present in PHI_INSERTION_POINTS. */ | |
1066 | |
1067 static void | |
1068 insert_phi_nodes_for (tree var, bitmap phi_insertion_points, bool update_p) | |
1069 { | |
1070 unsigned bb_index; | |
1071 edge e; | |
1072 gimple phi; | |
1073 basic_block bb; | |
1074 bitmap_iterator bi; | |
1075 struct def_blocks_d *def_map; | |
1076 | |
1077 def_map = find_def_blocks_for (var); | |
1078 gcc_assert (def_map); | |
1079 | |
1080 /* Remove the blocks where we already have PHI nodes for VAR. */ | |
1081 bitmap_and_compl_into (phi_insertion_points, def_map->phi_blocks); | |
1082 | |
1083 /* Remove obviously useless phi nodes. */ | |
1084 prune_unused_phi_nodes (phi_insertion_points, def_map->def_blocks, | |
1085 def_map->livein_blocks); | |
1086 | |
1087 /* And insert the PHI nodes. */ | |
1088 EXECUTE_IF_SET_IN_BITMAP (phi_insertion_points, 0, bb_index, bi) | |
1089 { | |
1090 bb = BASIC_BLOCK (bb_index); | |
1091 if (update_p) | |
1092 mark_block_for_update (bb); | |
1093 | |
1094 phi = NULL; | |
1095 | |
1096 if (TREE_CODE (var) == SSA_NAME) | |
1097 { | |
1098 /* If we are rewriting SSA names, create the LHS of the PHI | |
1099 node by duplicating VAR. This is useful in the case of | |
1100 pointers, to also duplicate pointer attributes (alias | |
1101 information, in particular). */ | |
1102 edge_iterator ei; | |
1103 tree new_lhs; | |
1104 | |
1105 gcc_assert (update_p); | |
1106 phi = create_phi_node (var, bb); | |
1107 | |
1108 new_lhs = duplicate_ssa_name (var, phi); | |
1109 gimple_phi_set_result (phi, new_lhs); | |
1110 add_new_name_mapping (new_lhs, var); | |
1111 | |
1112 /* Add VAR to every argument slot of PHI. We need VAR in | |
1113 every argument so that rewrite_update_phi_arguments knows | |
1114 which name is this PHI node replacing. If VAR is a | |
1115 symbol marked for renaming, this is not necessary, the | |
1116 renamer will use the symbol on the LHS to get its | |
1117 reaching definition. */ | |
1118 FOR_EACH_EDGE (e, ei, bb->preds) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1119 add_phi_arg (phi, var, e, UNKNOWN_LOCATION); |
0 | 1120 } |
1121 else | |
1122 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1123 tree tracked_var; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1124 |
0 | 1125 gcc_assert (DECL_P (var)); |
1126 phi = create_phi_node (var, bb); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1127 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1128 tracked_var = target_for_debug_bind (var); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1129 if (tracked_var) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1130 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1131 gimple note = gimple_build_debug_bind (tracked_var, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1132 PHI_RESULT (phi), |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1133 phi); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1134 gimple_stmt_iterator si = gsi_after_labels (bb); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1135 gsi_insert_before (&si, note, GSI_SAME_STMT); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1136 } |
0 | 1137 } |
1138 | |
1139 /* Mark this PHI node as interesting for update_ssa. */ | |
1140 set_register_defs (phi, true); | |
1141 mark_phi_for_rewrite (bb, phi); | |
1142 } | |
1143 } | |
1144 | |
1145 | |
1146 /* Insert PHI nodes at the dominance frontier of blocks with variable | |
1147 definitions. DFS contains the dominance frontier information for | |
1148 the flowgraph. */ | |
1149 | |
1150 static void | |
1151 insert_phi_nodes (bitmap *dfs) | |
1152 { | |
1153 referenced_var_iterator rvi; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1154 bitmap_iterator bi; |
0 | 1155 tree var; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1156 bitmap vars; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1157 unsigned uid; |
0 | 1158 |
1159 timevar_push (TV_TREE_INSERT_PHI_NODES); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1160 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1161 /* Do two stages to avoid code generation differences for UID |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1162 differences but no UID ordering differences. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1163 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1164 vars = BITMAP_ALLOC (NULL); |
0 | 1165 FOR_EACH_REFERENCED_VAR (var, rvi) |
1166 { | |
1167 struct def_blocks_d *def_map; | |
1168 | |
1169 def_map = find_def_blocks_for (var); | |
1170 if (def_map == NULL) | |
1171 continue; | |
1172 | |
1173 if (get_phi_state (var) != NEED_PHI_STATE_NO) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1174 bitmap_set_bit (vars, DECL_UID (var)); |
0 | 1175 } |
1176 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1177 EXECUTE_IF_SET_IN_BITMAP (vars, 0, uid, bi) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1178 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1179 tree var = referenced_var (uid); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1180 struct def_blocks_d *def_map; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1181 bitmap idf; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1182 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1183 def_map = find_def_blocks_for (var); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1184 idf = compute_idf (def_map->def_blocks, dfs); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1185 insert_phi_nodes_for (var, idf, false); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1186 BITMAP_FREE (idf); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1187 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1188 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1189 BITMAP_FREE (vars); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1190 |
0 | 1191 timevar_pop (TV_TREE_INSERT_PHI_NODES); |
1192 } | |
1193 | |
1194 | |
1195 /* Push SYM's current reaching definition into BLOCK_DEFS_STACK and | |
1196 register DEF (an SSA_NAME) to be a new definition for SYM. */ | |
1197 | |
1198 static void | |
1199 register_new_def (tree def, tree sym) | |
1200 { | |
1201 tree currdef; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1202 |
0 | 1203 /* If this variable is set in a single basic block and all uses are |
1204 dominated by the set(s) in that single basic block, then there is | |
1205 no reason to record anything for this variable in the block local | |
1206 definition stacks. Doing so just wastes time and memory. | |
1207 | |
1208 This is the same test to prune the set of variables which may | |
1209 need PHI nodes. So we just use that information since it's already | |
1210 computed and available for us to use. */ | |
1211 if (get_phi_state (sym) == NEED_PHI_STATE_NO) | |
1212 { | |
1213 set_current_def (sym, def); | |
1214 return; | |
1215 } | |
1216 | |
1217 currdef = get_current_def (sym); | |
1218 | |
1219 /* If SYM is not a GIMPLE register, then CURRDEF may be a name whose | |
1220 SSA_NAME_VAR is not necessarily SYM. In this case, also push SYM | |
1221 in the stack so that we know which symbol is being defined by | |
1222 this SSA name when we unwind the stack. */ | |
1223 if (currdef && !is_gimple_reg (sym)) | |
1224 VEC_safe_push (tree, heap, block_defs_stack, sym); | |
1225 | |
1226 /* Push the current reaching definition into BLOCK_DEFS_STACK. This | |
1227 stack is later used by the dominator tree callbacks to restore | |
1228 the reaching definitions for all the variables defined in the | |
1229 block after a recursive visit to all its immediately dominated | |
1230 blocks. If there is no current reaching definition, then just | |
1231 record the underlying _DECL node. */ | |
1232 VEC_safe_push (tree, heap, block_defs_stack, currdef ? currdef : sym); | |
1233 | |
1234 /* Set the current reaching definition for SYM to be DEF. */ | |
1235 set_current_def (sym, def); | |
1236 } | |
1237 | |
1238 | |
1239 /* Perform a depth-first traversal of the dominator tree looking for | |
1240 variables to rename. BB is the block where to start searching. | |
1241 Renaming is a five step process: | |
1242 | |
1243 1- Every definition made by PHI nodes at the start of the blocks is | |
1244 registered as the current definition for the corresponding variable. | |
1245 | |
1246 2- Every statement in BB is rewritten. USE and VUSE operands are | |
1247 rewritten with their corresponding reaching definition. DEF and | |
1248 VDEF targets are registered as new definitions. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1249 |
0 | 1250 3- All the PHI nodes in successor blocks of BB are visited. The |
1251 argument corresponding to BB is replaced with its current reaching | |
1252 definition. | |
1253 | |
1254 4- Recursively rewrite every dominator child block of BB. | |
1255 | |
1256 5- Restore (in reverse order) the current reaching definition for every | |
1257 new definition introduced in this block. This is done so that when | |
1258 we return from the recursive call, all the current reaching | |
1259 definitions are restored to the names that were valid in the | |
1260 dominator parent of BB. */ | |
1261 | |
1262 /* Return the current definition for variable VAR. If none is found, | |
1263 create a new SSA name to act as the zeroth definition for VAR. */ | |
1264 | |
1265 static tree | |
1266 get_reaching_def (tree var) | |
1267 { | |
1268 tree currdef; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1269 |
0 | 1270 /* Lookup the current reaching definition for VAR. */ |
1271 currdef = get_current_def (var); | |
1272 | |
1273 /* If there is no reaching definition for VAR, create and register a | |
1274 default definition for it (if needed). */ | |
1275 if (currdef == NULL_TREE) | |
1276 { | |
1277 tree sym = DECL_P (var) ? var : SSA_NAME_VAR (var); | |
1278 currdef = get_default_def_for (sym); | |
1279 set_current_def (var, currdef); | |
1280 } | |
1281 | |
1282 /* Return the current reaching definition for VAR, or the default | |
1283 definition, if we had to create one. */ | |
1284 return currdef; | |
1285 } | |
1286 | |
1287 | |
1288 /* SSA Rewriting Step 2. Rewrite every variable used in each statement in | |
1289 the block with its immediate reaching definitions. Update the current | |
1290 definition of a variable when a new real or virtual definition is found. */ | |
1291 | |
1292 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1293 rewrite_stmt (gimple_stmt_iterator si) |
0 | 1294 { |
1295 use_operand_p use_p; | |
1296 def_operand_p def_p; | |
1297 ssa_op_iter iter; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1298 gimple stmt = gsi_stmt (si); |
0 | 1299 |
1300 /* If mark_def_sites decided that we don't need to rewrite this | |
1301 statement, ignore it. */ | |
1302 gcc_assert (blocks_to_update == NULL); | |
1303 if (!rewrite_uses_p (stmt) && !register_defs_p (stmt)) | |
1304 return; | |
1305 | |
1306 if (dump_file && (dump_flags & TDF_DETAILS)) | |
1307 { | |
1308 fprintf (dump_file, "Renaming statement "); | |
1309 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
1310 fprintf (dump_file, "\n"); | |
1311 } | |
1312 | |
1313 /* Step 1. Rewrite USES in the statement. */ | |
1314 if (rewrite_uses_p (stmt)) | |
1315 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE) | |
1316 { | |
1317 tree var = USE_FROM_PTR (use_p); | |
1318 gcc_assert (DECL_P (var)); | |
1319 SET_USE (use_p, get_reaching_def (var)); | |
1320 } | |
1321 | |
1322 /* Step 2. Register the statement's DEF operands. */ | |
1323 if (register_defs_p (stmt)) | |
1324 FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_DEF) | |
1325 { | |
1326 tree var = DEF_FROM_PTR (def_p); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1327 tree name = make_ssa_name (var, stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1328 tree tracked_var; |
0 | 1329 gcc_assert (DECL_P (var)); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1330 SET_DEF (def_p, name); |
0 | 1331 register_new_def (DEF_FROM_PTR (def_p), var); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1332 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1333 tracked_var = target_for_debug_bind (var); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1334 if (tracked_var) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1335 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1336 gimple note = gimple_build_debug_bind (tracked_var, name, stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1337 gsi_insert_after (&si, note, GSI_SAME_STMT); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1338 } |
0 | 1339 } |
1340 } | |
1341 | |
1342 | |
1343 /* SSA Rewriting Step 3. Visit all the successor blocks of BB looking for | |
1344 PHI nodes. For every PHI node found, add a new argument containing the | |
1345 current reaching definition for the variable and the edge through which | |
1346 that definition is reaching the PHI node. */ | |
1347 | |
1348 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1349 rewrite_add_phi_arguments (basic_block bb) |
0 | 1350 { |
1351 edge e; | |
1352 edge_iterator ei; | |
1353 | |
1354 FOR_EACH_EDGE (e, ei, bb->succs) | |
1355 { | |
1356 gimple phi; | |
1357 gimple_stmt_iterator gsi; | |
1358 | |
1359 for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); | |
1360 gsi_next (&gsi)) | |
1361 { | |
1362 tree currdef; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1363 gimple stmt; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1364 |
0 | 1365 phi = gsi_stmt (gsi); |
1366 currdef = get_reaching_def (SSA_NAME_VAR (gimple_phi_result (phi))); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1367 stmt = SSA_NAME_DEF_STMT (currdef); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1368 add_phi_arg (phi, currdef, e, gimple_location (stmt)); |
0 | 1369 } |
1370 } | |
1371 } | |
1372 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1373 /* SSA Rewriting Step 1. Initialization, create a block local stack |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1374 of reaching definitions for new SSA names produced in this block |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1375 (BLOCK_DEFS). Register new definitions for every PHI node in the |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1376 block. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1377 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1378 static void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1379 rewrite_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1380 basic_block bb) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1381 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1382 gimple phi; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1383 gimple_stmt_iterator gsi; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1384 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1385 if (dump_file && (dump_flags & TDF_DETAILS)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1386 fprintf (dump_file, "\n\nRenaming block #%d\n\n", bb->index); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1387 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1388 /* Mark the unwind point for this block. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1389 VEC_safe_push (tree, heap, block_defs_stack, NULL_TREE); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1390 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1391 /* Step 1. Register new definitions for every PHI node in the block. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1392 Conceptually, all the PHI nodes are executed in parallel and each PHI |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1393 node introduces a new version for the associated variable. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1394 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1395 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1396 tree result; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1397 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1398 phi = gsi_stmt (gsi); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1399 result = gimple_phi_result (phi); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1400 gcc_assert (is_gimple_reg (result)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1401 register_new_def (result, SSA_NAME_VAR (result)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1402 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1403 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1404 /* Step 2. Rewrite every variable used in each statement in the block |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1405 with its immediate reaching definitions. Update the current definition |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1406 of a variable when a new real or virtual definition is found. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1407 if (TEST_BIT (interesting_blocks, bb->index)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1408 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1409 rewrite_stmt (gsi); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1410 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1411 /* Step 3. Visit all the successor blocks of BB looking for PHI nodes. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1412 For every PHI node found, add a new argument containing the current |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1413 reaching definition for the variable and the edge through which that |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1414 definition is reaching the PHI node. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1415 rewrite_add_phi_arguments (bb); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1416 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1417 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1418 |
0 | 1419 |
1420 /* Called after visiting all the statements in basic block BB and all | |
1421 of its dominator children. Restore CURRDEFS to its original value. */ | |
1422 | |
1423 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1424 rewrite_leave_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1425 basic_block bb ATTRIBUTE_UNUSED) |
0 | 1426 { |
1427 /* Restore CURRDEFS to its original state. */ | |
1428 while (VEC_length (tree, block_defs_stack) > 0) | |
1429 { | |
1430 tree tmp = VEC_pop (tree, block_defs_stack); | |
1431 tree saved_def, var; | |
1432 | |
1433 if (tmp == NULL_TREE) | |
1434 break; | |
1435 | |
1436 if (TREE_CODE (tmp) == SSA_NAME) | |
1437 { | |
1438 /* If we recorded an SSA_NAME, then make the SSA_NAME the | |
1439 current definition of its underlying variable. Note that | |
1440 if the SSA_NAME is not for a GIMPLE register, the symbol | |
1441 being defined is stored in the next slot in the stack. | |
1442 This mechanism is needed because an SSA name for a | |
1443 non-register symbol may be the definition for more than | |
1444 one symbol (e.g., SFTs, aliased variables, etc). */ | |
1445 saved_def = tmp; | |
1446 var = SSA_NAME_VAR (saved_def); | |
1447 if (!is_gimple_reg (var)) | |
1448 var = VEC_pop (tree, block_defs_stack); | |
1449 } | |
1450 else | |
1451 { | |
1452 /* If we recorded anything else, it must have been a _DECL | |
1453 node and its current reaching definition must have been | |
1454 NULL. */ | |
1455 saved_def = NULL; | |
1456 var = tmp; | |
1457 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1458 |
0 | 1459 set_current_def (var, saved_def); |
1460 } | |
1461 } | |
1462 | |
1463 | |
1464 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */ | |
1465 | |
1466 void | |
1467 dump_decl_set (FILE *file, bitmap set) | |
1468 { | |
1469 if (set) | |
1470 { | |
1471 bitmap_iterator bi; | |
1472 unsigned i; | |
1473 | |
1474 fprintf (file, "{ "); | |
1475 | |
1476 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi) | |
1477 { | |
1478 print_generic_expr (file, referenced_var (i), 0); | |
1479 fprintf (file, " "); | |
1480 } | |
1481 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1482 fprintf (file, "}"); |
0 | 1483 } |
1484 else | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1485 fprintf (file, "NIL"); |
0 | 1486 } |
1487 | |
1488 | |
1489 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */ | |
1490 | |
1491 void | |
1492 debug_decl_set (bitmap set) | |
1493 { | |
1494 dump_decl_set (stderr, set); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1495 fprintf (stderr, "\n"); |
0 | 1496 } |
1497 | |
1498 | |
1499 /* Dump the renaming stack (block_defs_stack) to FILE. Traverse the | |
1500 stack up to a maximum of N levels. If N is -1, the whole stack is | |
1501 dumped. New levels are created when the dominator tree traversal | |
1502 used for renaming enters a new sub-tree. */ | |
1503 | |
1504 void | |
1505 dump_defs_stack (FILE *file, int n) | |
1506 { | |
1507 int i, j; | |
1508 | |
1509 fprintf (file, "\n\nRenaming stack"); | |
1510 if (n > 0) | |
1511 fprintf (file, " (up to %d levels)", n); | |
1512 fprintf (file, "\n\n"); | |
1513 | |
1514 i = 1; | |
1515 fprintf (file, "Level %d (current level)\n", i); | |
1516 for (j = (int) VEC_length (tree, block_defs_stack) - 1; j >= 0; j--) | |
1517 { | |
1518 tree name, var; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1519 |
0 | 1520 name = VEC_index (tree, block_defs_stack, j); |
1521 if (name == NULL_TREE) | |
1522 { | |
1523 i++; | |
1524 if (n > 0 && i > n) | |
1525 break; | |
1526 fprintf (file, "\nLevel %d\n", i); | |
1527 continue; | |
1528 } | |
1529 | |
1530 if (DECL_P (name)) | |
1531 { | |
1532 var = name; | |
1533 name = NULL_TREE; | |
1534 } | |
1535 else | |
1536 { | |
1537 var = SSA_NAME_VAR (name); | |
1538 if (!is_gimple_reg (var)) | |
1539 { | |
1540 j--; | |
1541 var = VEC_index (tree, block_defs_stack, j); | |
1542 } | |
1543 } | |
1544 | |
1545 fprintf (file, " Previous CURRDEF ("); | |
1546 print_generic_expr (file, var, 0); | |
1547 fprintf (file, ") = "); | |
1548 if (name) | |
1549 print_generic_expr (file, name, 0); | |
1550 else | |
1551 fprintf (file, "<NIL>"); | |
1552 fprintf (file, "\n"); | |
1553 } | |
1554 } | |
1555 | |
1556 | |
1557 /* Dump the renaming stack (block_defs_stack) to stderr. Traverse the | |
1558 stack up to a maximum of N levels. If N is -1, the whole stack is | |
1559 dumped. New levels are created when the dominator tree traversal | |
1560 used for renaming enters a new sub-tree. */ | |
1561 | |
1562 void | |
1563 debug_defs_stack (int n) | |
1564 { | |
1565 dump_defs_stack (stderr, n); | |
1566 } | |
1567 | |
1568 | |
1569 /* Dump the current reaching definition of every symbol to FILE. */ | |
1570 | |
1571 void | |
1572 dump_currdefs (FILE *file) | |
1573 { | |
1574 referenced_var_iterator i; | |
1575 tree var; | |
1576 | |
1577 fprintf (file, "\n\nCurrent reaching definitions\n\n"); | |
1578 FOR_EACH_REFERENCED_VAR (var, i) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1579 if (SYMS_TO_RENAME (cfun) == NULL |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1580 || bitmap_bit_p (SYMS_TO_RENAME (cfun), DECL_UID (var))) |
0 | 1581 { |
1582 fprintf (file, "CURRDEF ("); | |
1583 print_generic_expr (file, var, 0); | |
1584 fprintf (file, ") = "); | |
1585 if (get_current_def (var)) | |
1586 print_generic_expr (file, get_current_def (var), 0); | |
1587 else | |
1588 fprintf (file, "<NIL>"); | |
1589 fprintf (file, "\n"); | |
1590 } | |
1591 } | |
1592 | |
1593 | |
1594 /* Dump the current reaching definition of every symbol to stderr. */ | |
1595 | |
1596 void | |
1597 debug_currdefs (void) | |
1598 { | |
1599 dump_currdefs (stderr); | |
1600 } | |
1601 | |
1602 | |
1603 /* Dump SSA information to FILE. */ | |
1604 | |
1605 void | |
1606 dump_tree_ssa (FILE *file) | |
1607 { | |
1608 const char *funcname | |
1609 = lang_hooks.decl_printable_name (current_function_decl, 2); | |
1610 | |
1611 fprintf (file, "SSA renaming information for %s\n\n", funcname); | |
1612 | |
1613 dump_def_blocks (file); | |
1614 dump_defs_stack (file, -1); | |
1615 dump_currdefs (file); | |
1616 dump_tree_ssa_stats (file); | |
1617 } | |
1618 | |
1619 | |
1620 /* Dump SSA information to stderr. */ | |
1621 | |
1622 void | |
1623 debug_tree_ssa (void) | |
1624 { | |
1625 dump_tree_ssa (stderr); | |
1626 } | |
1627 | |
1628 | |
1629 /* Dump statistics for the hash table HTAB. */ | |
1630 | |
1631 static void | |
1632 htab_statistics (FILE *file, htab_t htab) | |
1633 { | |
1634 fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n", | |
1635 (long) htab_size (htab), | |
1636 (long) htab_elements (htab), | |
1637 htab_collisions (htab)); | |
1638 } | |
1639 | |
1640 | |
1641 /* Dump SSA statistics on FILE. */ | |
1642 | |
1643 void | |
1644 dump_tree_ssa_stats (FILE *file) | |
1645 { | |
1646 if (def_blocks || repl_tbl) | |
1647 fprintf (file, "\nHash table statistics:\n"); | |
1648 | |
1649 if (def_blocks) | |
1650 { | |
1651 fprintf (file, " def_blocks: "); | |
1652 htab_statistics (file, def_blocks); | |
1653 } | |
1654 | |
1655 if (repl_tbl) | |
1656 { | |
1657 fprintf (file, " repl_tbl: "); | |
1658 htab_statistics (file, repl_tbl); | |
1659 } | |
1660 | |
1661 if (def_blocks || repl_tbl) | |
1662 fprintf (file, "\n"); | |
1663 } | |
1664 | |
1665 | |
1666 /* Dump SSA statistics on stderr. */ | |
1667 | |
1668 void | |
1669 debug_tree_ssa_stats (void) | |
1670 { | |
1671 dump_tree_ssa_stats (stderr); | |
1672 } | |
1673 | |
1674 | |
1675 /* Hashing and equality functions for DEF_BLOCKS. */ | |
1676 | |
1677 static hashval_t | |
1678 def_blocks_hash (const void *p) | |
1679 { | |
1680 return htab_hash_pointer | |
1681 ((const void *)((const struct def_blocks_d *)p)->var); | |
1682 } | |
1683 | |
1684 static int | |
1685 def_blocks_eq (const void *p1, const void *p2) | |
1686 { | |
1687 return ((const struct def_blocks_d *)p1)->var | |
1688 == ((const struct def_blocks_d *)p2)->var; | |
1689 } | |
1690 | |
1691 | |
1692 /* Free memory allocated by one entry in DEF_BLOCKS. */ | |
1693 | |
1694 static void | |
1695 def_blocks_free (void *p) | |
1696 { | |
1697 struct def_blocks_d *entry = (struct def_blocks_d *) p; | |
1698 BITMAP_FREE (entry->def_blocks); | |
1699 BITMAP_FREE (entry->phi_blocks); | |
1700 BITMAP_FREE (entry->livein_blocks); | |
1701 free (entry); | |
1702 } | |
1703 | |
1704 | |
1705 /* Callback for htab_traverse to dump the DEF_BLOCKS hash table. */ | |
1706 | |
1707 static int | |
1708 debug_def_blocks_r (void **slot, void *data) | |
1709 { | |
1710 FILE *file = (FILE *) data; | |
1711 struct def_blocks_d *db_p = (struct def_blocks_d *) *slot; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1712 |
0 | 1713 fprintf (file, "VAR: "); |
1714 print_generic_expr (file, db_p->var, dump_flags); | |
1715 bitmap_print (file, db_p->def_blocks, ", DEF_BLOCKS: { ", "}"); | |
1716 bitmap_print (file, db_p->livein_blocks, ", LIVEIN_BLOCKS: { ", "}"); | |
1717 bitmap_print (file, db_p->phi_blocks, ", PHI_BLOCKS: { ", "}\n"); | |
1718 | |
1719 return 1; | |
1720 } | |
1721 | |
1722 | |
1723 /* Dump the DEF_BLOCKS hash table on FILE. */ | |
1724 | |
1725 void | |
1726 dump_def_blocks (FILE *file) | |
1727 { | |
1728 fprintf (file, "\n\nDefinition and live-in blocks:\n\n"); | |
1729 if (def_blocks) | |
1730 htab_traverse (def_blocks, debug_def_blocks_r, file); | |
1731 } | |
1732 | |
1733 | |
1734 /* Dump the DEF_BLOCKS hash table on stderr. */ | |
1735 | |
1736 void | |
1737 debug_def_blocks (void) | |
1738 { | |
1739 dump_def_blocks (stderr); | |
1740 } | |
1741 | |
1742 | |
1743 /* Register NEW_NAME to be the new reaching definition for OLD_NAME. */ | |
1744 | |
1745 static inline void | |
1746 register_new_update_single (tree new_name, tree old_name) | |
1747 { | |
1748 tree currdef = get_current_def (old_name); | |
1749 | |
1750 /* Push the current reaching definition into BLOCK_DEFS_STACK. | |
1751 This stack is later used by the dominator tree callbacks to | |
1752 restore the reaching definitions for all the variables | |
1753 defined in the block after a recursive visit to all its | |
1754 immediately dominated blocks. */ | |
1755 VEC_reserve (tree, heap, block_defs_stack, 2); | |
1756 VEC_quick_push (tree, block_defs_stack, currdef); | |
1757 VEC_quick_push (tree, block_defs_stack, old_name); | |
1758 | |
1759 /* Set the current reaching definition for OLD_NAME to be | |
1760 NEW_NAME. */ | |
1761 set_current_def (old_name, new_name); | |
1762 } | |
1763 | |
1764 | |
1765 /* Register NEW_NAME to be the new reaching definition for all the | |
1766 names in OLD_NAMES. Used by the incremental SSA update routines to | |
1767 replace old SSA names with new ones. */ | |
1768 | |
1769 static inline void | |
1770 register_new_update_set (tree new_name, bitmap old_names) | |
1771 { | |
1772 bitmap_iterator bi; | |
1773 unsigned i; | |
1774 | |
1775 EXECUTE_IF_SET_IN_BITMAP (old_names, 0, i, bi) | |
1776 register_new_update_single (new_name, ssa_name (i)); | |
1777 } | |
1778 | |
1779 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1780 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1781 /* If the operand pointed to by USE_P is a name in OLD_SSA_NAMES or |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1782 it is a symbol marked for renaming, replace it with USE_P's current |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1783 reaching definition. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1784 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1785 static inline void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1786 maybe_replace_use (use_operand_p use_p) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1787 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1788 tree rdef = NULL_TREE; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1789 tree use = USE_FROM_PTR (use_p); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1790 tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1791 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1792 if (symbol_marked_for_renaming (sym)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1793 rdef = get_reaching_def (sym); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1794 else if (is_old_name (use)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1795 rdef = get_reaching_def (use); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1796 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1797 if (rdef && rdef != use) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1798 SET_USE (use_p, rdef); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1799 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1800 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1801 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1802 /* Same as maybe_replace_use, but without introducing default stmts, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1803 returning false to indicate a need to do so. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1804 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1805 static inline bool |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1806 maybe_replace_use_in_debug_stmt (use_operand_p use_p) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1807 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1808 tree rdef = NULL_TREE; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1809 tree use = USE_FROM_PTR (use_p); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1810 tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1811 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1812 if (symbol_marked_for_renaming (sym)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1813 rdef = get_current_def (sym); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1814 else if (is_old_name (use)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1815 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1816 rdef = get_current_def (use); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1817 /* We can't assume that, if there's no current definition, the |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1818 default one should be used. It could be the case that we've |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1819 rearranged blocks so that the earlier definition no longer |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1820 dominates the use. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1821 if (!rdef && SSA_NAME_IS_DEFAULT_DEF (use)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1822 rdef = use; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1823 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1824 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1825 rdef = use; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1826 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1827 if (rdef && rdef != use) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1828 SET_USE (use_p, rdef); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1829 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1830 return rdef != NULL_TREE; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1831 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1832 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1833 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1834 /* If the operand pointed to by DEF_P is an SSA name in NEW_SSA_NAMES |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1835 or OLD_SSA_NAMES, or if it is a symbol marked for renaming, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1836 register it as the current definition for the names replaced by |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1837 DEF_P. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1838 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1839 static inline void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1840 maybe_register_def (def_operand_p def_p, gimple stmt, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1841 gimple_stmt_iterator gsi) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1842 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1843 tree def = DEF_FROM_PTR (def_p); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1844 tree sym = DECL_P (def) ? def : SSA_NAME_VAR (def); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1845 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1846 /* If DEF is a naked symbol that needs renaming, create a new |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1847 name for it. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1848 if (symbol_marked_for_renaming (sym)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1849 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1850 if (DECL_P (def)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1851 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1852 tree tracked_var; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1853 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1854 def = make_ssa_name (def, stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1855 SET_DEF (def_p, def); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1856 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1857 tracked_var = target_for_debug_bind (sym); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1858 if (tracked_var) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1859 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1860 gimple note = gimple_build_debug_bind (tracked_var, def, stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1861 gsi_insert_after (&gsi, note, GSI_SAME_STMT); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1862 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1863 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1864 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1865 register_new_update_single (def, sym); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1866 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1867 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1868 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1869 /* If DEF is a new name, register it as a new definition |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1870 for all the names replaced by DEF. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1871 if (is_new_name (def)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1872 register_new_update_set (def, names_replaced_by (def)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1873 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1874 /* If DEF is an old name, register DEF as a new |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1875 definition for itself. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1876 if (is_old_name (def)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1877 register_new_update_single (def, def); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1878 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1879 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1880 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1881 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1882 /* Update every variable used in the statement pointed-to by SI. The |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1883 statement is assumed to be in SSA form already. Names in |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1884 OLD_SSA_NAMES used by SI will be updated to their current reaching |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1885 definition. Names in OLD_SSA_NAMES or NEW_SSA_NAMES defined by SI |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1886 will be registered as a new definition for their corresponding name |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1887 in OLD_SSA_NAMES. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1888 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1889 static void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1890 rewrite_update_stmt (gimple stmt, gimple_stmt_iterator gsi) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1891 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1892 use_operand_p use_p; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1893 def_operand_p def_p; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1894 ssa_op_iter iter; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1895 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1896 /* Only update marked statements. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1897 if (!rewrite_uses_p (stmt) && !register_defs_p (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1898 return; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1899 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1900 if (dump_file && (dump_flags & TDF_DETAILS)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1901 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1902 fprintf (dump_file, "Updating SSA information for statement "); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1903 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1904 fprintf (dump_file, "\n"); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1905 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1906 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1907 /* Rewrite USES included in OLD_SSA_NAMES and USES whose underlying |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1908 symbol is marked for renaming. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1909 if (rewrite_uses_p (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1910 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1911 if (is_gimple_debug (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1912 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1913 bool failed = false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1914 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1915 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1916 if (!maybe_replace_use_in_debug_stmt (use_p)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1917 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1918 failed = true; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1919 break; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1920 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1921 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1922 if (failed) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1923 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1924 /* DOM sometimes threads jumps in such a way that a |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1925 debug stmt ends up referencing a SSA variable that no |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1926 longer dominates the debug stmt, but such that all |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1927 incoming definitions refer to the same definition in |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1928 an earlier dominator. We could try to recover that |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1929 definition somehow, but this will have to do for now. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1930 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1931 Introducing a default definition, which is what |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1932 maybe_replace_use() would do in such cases, may |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1933 modify code generation, for the otherwise-unused |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1934 default definition would never go away, modifying SSA |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1935 version numbers all over. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1936 gimple_debug_bind_reset_value (stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1937 update_stmt (stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1938 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1939 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1940 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1941 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1942 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1943 maybe_replace_use (use_p); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1944 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1945 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1946 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1947 /* Register definitions of names in NEW_SSA_NAMES and OLD_SSA_NAMES. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1948 Also register definitions for names whose underlying symbol is |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1949 marked for renaming. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1950 if (register_defs_p (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1951 FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_ALL_DEFS) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1952 maybe_register_def (def_p, stmt, gsi); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1953 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1954 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1955 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1956 /* Visit all the successor blocks of BB looking for PHI nodes. For |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1957 every PHI node found, check if any of its arguments is in |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1958 OLD_SSA_NAMES. If so, and if the argument has a current reaching |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1959 definition, replace it. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1960 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1961 static void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1962 rewrite_update_phi_arguments (basic_block bb) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1963 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1964 edge e; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1965 edge_iterator ei; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1966 unsigned i; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1967 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1968 FOR_EACH_EDGE (e, ei, bb->succs) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1969 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1970 gimple phi; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1971 gimple_vec phis; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1972 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1973 if (!bitmap_bit_p (blocks_with_phis_to_rewrite, e->dest->index)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1974 continue; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1975 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1976 phis = VEC_index (gimple_vec, phis_to_rewrite, e->dest->index); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1977 for (i = 0; VEC_iterate (gimple, phis, i, phi); i++) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1978 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1979 tree arg, lhs_sym, reaching_def = NULL; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1980 use_operand_p arg_p; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1981 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1982 gcc_assert (rewrite_uses_p (phi)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1983 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1984 arg_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1985 arg = USE_FROM_PTR (arg_p); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1986 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1987 if (arg && !DECL_P (arg) && TREE_CODE (arg) != SSA_NAME) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1988 continue; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1989 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1990 lhs_sym = SSA_NAME_VAR (gimple_phi_result (phi)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1991 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1992 if (arg == NULL_TREE) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1993 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1994 /* When updating a PHI node for a recently introduced |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1995 symbol we may find NULL arguments. That's why we |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1996 take the symbol from the LHS of the PHI node. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1997 reaching_def = get_reaching_def (lhs_sym); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1998 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1999 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2000 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2001 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2002 tree sym = DECL_P (arg) ? arg : SSA_NAME_VAR (arg); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2003 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2004 if (symbol_marked_for_renaming (sym)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2005 reaching_def = get_reaching_def (sym); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2006 else if (is_old_name (arg)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2007 reaching_def = get_reaching_def (arg); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2008 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2009 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2010 /* Update the argument if there is a reaching def. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2011 if (reaching_def) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2012 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2013 gimple stmt; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2014 source_location locus; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2015 int arg_i = PHI_ARG_INDEX_FROM_USE (arg_p); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2016 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2017 SET_USE (arg_p, reaching_def); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2018 stmt = SSA_NAME_DEF_STMT (reaching_def); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2019 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2020 /* Single element PHI nodes behave like copies, so get the |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2021 location from the phi argument. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2022 if (gimple_code (stmt) == GIMPLE_PHI && |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2023 gimple_phi_num_args (stmt) == 1) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2024 locus = gimple_phi_arg_location (stmt, 0); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2025 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2026 locus = gimple_location (stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2027 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2028 gimple_phi_arg_set_location (phi, arg_i, locus); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2029 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2030 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2031 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2032 if (e->flags & EDGE_ABNORMAL) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2033 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (arg_p)) = 1; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2034 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2035 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2036 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2037 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2038 |
0 | 2039 /* Initialization of block data structures for the incremental SSA |
2040 update pass. Create a block local stack of reaching definitions | |
2041 for new SSA names produced in this block (BLOCK_DEFS). Register | |
2042 new definitions for every PHI node in the block. */ | |
2043 | |
2044 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2045 rewrite_update_enter_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2046 basic_block bb) |
0 | 2047 { |
2048 edge e; | |
2049 edge_iterator ei; | |
2050 bool is_abnormal_phi; | |
2051 gimple_stmt_iterator gsi; | |
2052 | |
2053 if (dump_file && (dump_flags & TDF_DETAILS)) | |
2054 fprintf (dump_file, "\n\nRegistering new PHI nodes in block #%d\n\n", | |
2055 bb->index); | |
2056 | |
2057 /* Mark the unwind point for this block. */ | |
2058 VEC_safe_push (tree, heap, block_defs_stack, NULL_TREE); | |
2059 | |
2060 if (!bitmap_bit_p (blocks_to_update, bb->index)) | |
2061 return; | |
2062 | |
2063 /* Mark the LHS if any of the arguments flows through an abnormal | |
2064 edge. */ | |
2065 is_abnormal_phi = false; | |
2066 FOR_EACH_EDGE (e, ei, bb->preds) | |
2067 if (e->flags & EDGE_ABNORMAL) | |
2068 { | |
2069 is_abnormal_phi = true; | |
2070 break; | |
2071 } | |
2072 | |
2073 /* If any of the PHI nodes is a replacement for a name in | |
2074 OLD_SSA_NAMES or it's one of the names in NEW_SSA_NAMES, then | |
2075 register it as a new definition for its corresponding name. Also | |
2076 register definitions for names whose underlying symbols are | |
2077 marked for renaming. */ | |
2078 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
2079 { | |
2080 tree lhs, lhs_sym; | |
2081 gimple phi = gsi_stmt (gsi); | |
2082 | |
2083 if (!register_defs_p (phi)) | |
2084 continue; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2085 |
0 | 2086 lhs = gimple_phi_result (phi); |
2087 lhs_sym = SSA_NAME_VAR (lhs); | |
2088 | |
2089 if (symbol_marked_for_renaming (lhs_sym)) | |
2090 register_new_update_single (lhs, lhs_sym); | |
2091 else | |
2092 { | |
2093 | |
2094 /* If LHS is a new name, register a new definition for all | |
2095 the names replaced by LHS. */ | |
2096 if (is_new_name (lhs)) | |
2097 register_new_update_set (lhs, names_replaced_by (lhs)); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2098 |
0 | 2099 /* If LHS is an OLD name, register it as a new definition |
2100 for itself. */ | |
2101 if (is_old_name (lhs)) | |
2102 register_new_update_single (lhs, lhs); | |
2103 } | |
2104 | |
2105 if (is_abnormal_phi) | |
2106 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs) = 1; | |
2107 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2108 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2109 /* Step 2. Rewrite every variable used in each statement in the block. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2110 if (TEST_BIT (interesting_blocks, bb->index)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2111 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2112 gcc_assert (bitmap_bit_p (blocks_to_update, bb->index)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2113 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2114 rewrite_update_stmt (gsi_stmt (gsi), gsi); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2115 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2116 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2117 /* Step 3. Update PHI nodes. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2118 rewrite_update_phi_arguments (bb); |
0 | 2119 } |
2120 | |
2121 /* Called after visiting block BB. Unwind BLOCK_DEFS_STACK to restore | |
2122 the current reaching definition of every name re-written in BB to | |
2123 the original reaching definition before visiting BB. This | |
2124 unwinding must be done in the opposite order to what is done in | |
2125 register_new_update_set. */ | |
2126 | |
2127 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2128 rewrite_update_leave_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2129 basic_block bb ATTRIBUTE_UNUSED) |
0 | 2130 { |
2131 while (VEC_length (tree, block_defs_stack) > 0) | |
2132 { | |
2133 tree var = VEC_pop (tree, block_defs_stack); | |
2134 tree saved_def; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2135 |
0 | 2136 /* NULL indicates the unwind stop point for this block (see |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2137 rewrite_update_enter_block). */ |
0 | 2138 if (var == NULL) |
2139 return; | |
2140 | |
2141 saved_def = VEC_pop (tree, block_defs_stack); | |
2142 set_current_def (var, saved_def); | |
2143 } | |
2144 } | |
2145 | |
2146 | |
2147 /* Rewrite the actual blocks, statements, and PHI arguments, to be in SSA | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2148 form. |
0 | 2149 |
2150 ENTRY indicates the block where to start. Every block dominated by | |
2151 ENTRY will be rewritten. | |
2152 | |
2153 WHAT indicates what actions will be taken by the renamer (see enum | |
2154 rewrite_mode). | |
2155 | |
2156 BLOCKS are the set of interesting blocks for the dominator walker | |
2157 to process. If this set is NULL, then all the nodes dominated | |
2158 by ENTRY are walked. Otherwise, blocks dominated by ENTRY that | |
2159 are not present in BLOCKS are ignored. */ | |
2160 | |
2161 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2162 rewrite_blocks (basic_block entry, enum rewrite_mode what) |
0 | 2163 { |
2164 struct dom_walk_data walk_data; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2165 |
0 | 2166 /* Rewrite all the basic blocks in the program. */ |
2167 timevar_push (TV_TREE_SSA_REWRITE_BLOCKS); | |
2168 | |
2169 /* Setup callbacks for the generic dominator tree walker. */ | |
2170 memset (&walk_data, 0, sizeof (walk_data)); | |
2171 | |
2172 walk_data.dom_direction = CDI_DOMINATORS; | |
2173 | |
2174 if (what == REWRITE_ALL) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2175 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2176 walk_data.before_dom_children = rewrite_enter_block; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2177 walk_data.after_dom_children = rewrite_leave_block; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2178 } |
0 | 2179 else if (what == REWRITE_UPDATE) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2180 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2181 walk_data.before_dom_children = rewrite_update_enter_block; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2182 walk_data.after_dom_children = rewrite_update_leave_block; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2183 } |
0 | 2184 else |
2185 gcc_unreachable (); | |
2186 | |
2187 block_defs_stack = VEC_alloc (tree, heap, 10); | |
2188 | |
2189 /* Initialize the dominator walker. */ | |
2190 init_walk_dominator_tree (&walk_data); | |
2191 | |
2192 /* Recursively walk the dominator tree rewriting each statement in | |
2193 each basic block. */ | |
2194 walk_dominator_tree (&walk_data, entry); | |
2195 | |
2196 /* Finalize the dominator walker. */ | |
2197 fini_walk_dominator_tree (&walk_data); | |
2198 | |
2199 /* Debugging dumps. */ | |
2200 if (dump_file && (dump_flags & TDF_STATS)) | |
2201 { | |
2202 dump_dfa_stats (dump_file); | |
2203 if (def_blocks) | |
2204 dump_tree_ssa_stats (dump_file); | |
2205 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2206 |
0 | 2207 VEC_free (tree, heap, block_defs_stack); |
2208 | |
2209 timevar_pop (TV_TREE_SSA_REWRITE_BLOCKS); | |
2210 } | |
2211 | |
2212 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2213 /* Block processing routine for mark_def_sites. Clear the KILLS bitmap |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2214 at the start of each block, and call mark_def_sites for each statement. */ |
0 | 2215 |
2216 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2217 mark_def_sites_block (struct dom_walk_data *walk_data, basic_block bb) |
0 | 2218 { |
2219 struct mark_def_sites_global_data *gd; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2220 bitmap kills; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2221 gimple_stmt_iterator gsi; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2222 |
0 | 2223 gd = (struct mark_def_sites_global_data *) walk_data->global_data; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2224 kills = gd->kills; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2225 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2226 bitmap_clear (kills); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2227 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2228 mark_def_sites (bb, gsi_stmt (gsi), kills); |
0 | 2229 } |
2230 | |
2231 | |
2232 /* Mark the definition site blocks for each variable, so that we know | |
2233 where the variable is actually live. | |
2234 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2235 The INTERESTING_BLOCKS global will be filled in with all the blocks |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2236 that should be processed by the renamer. It is assumed that the |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2237 caller has already initialized and zeroed it. */ |
0 | 2238 |
2239 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2240 mark_def_site_blocks (void) |
0 | 2241 { |
2242 struct dom_walk_data walk_data; | |
2243 struct mark_def_sites_global_data mark_def_sites_global_data; | |
2244 | |
2245 /* Setup callbacks for the generic dominator tree walker to find and | |
2246 mark definition sites. */ | |
2247 walk_data.dom_direction = CDI_DOMINATORS; | |
2248 walk_data.initialize_block_local_data = NULL; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2249 walk_data.before_dom_children = mark_def_sites_block; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2250 walk_data.after_dom_children = NULL; |
0 | 2251 |
2252 /* Notice that this bitmap is indexed using variable UIDs, so it must be | |
2253 large enough to accommodate all the variables referenced in the | |
2254 function, not just the ones we are renaming. */ | |
2255 mark_def_sites_global_data.kills = BITMAP_ALLOC (NULL); | |
2256 walk_data.global_data = &mark_def_sites_global_data; | |
2257 | |
2258 /* We do not have any local data. */ | |
2259 walk_data.block_local_data_size = 0; | |
2260 | |
2261 /* Initialize the dominator walker. */ | |
2262 init_walk_dominator_tree (&walk_data); | |
2263 | |
2264 /* Recursively walk the dominator tree. */ | |
2265 walk_dominator_tree (&walk_data, ENTRY_BLOCK_PTR); | |
2266 | |
2267 /* Finalize the dominator walker. */ | |
2268 fini_walk_dominator_tree (&walk_data); | |
2269 | |
2270 /* We no longer need this bitmap, clear and free it. */ | |
2271 BITMAP_FREE (mark_def_sites_global_data.kills); | |
2272 } | |
2273 | |
2274 | |
2275 /* Initialize internal data needed during renaming. */ | |
2276 | |
2277 static void | |
2278 init_ssa_renamer (void) | |
2279 { | |
2280 tree var; | |
2281 referenced_var_iterator rvi; | |
2282 | |
2283 cfun->gimple_df->in_ssa_p = false; | |
2284 | |
2285 /* Allocate memory for the DEF_BLOCKS hash table. */ | |
2286 gcc_assert (def_blocks == NULL); | |
2287 def_blocks = htab_create (num_referenced_vars, def_blocks_hash, | |
2288 def_blocks_eq, def_blocks_free); | |
2289 | |
2290 FOR_EACH_REFERENCED_VAR(var, rvi) | |
2291 set_current_def (var, NULL_TREE); | |
2292 } | |
2293 | |
2294 | |
2295 /* Deallocate internal data structures used by the renamer. */ | |
2296 | |
2297 static void | |
2298 fini_ssa_renamer (void) | |
2299 { | |
2300 if (def_blocks) | |
2301 { | |
2302 htab_delete (def_blocks); | |
2303 def_blocks = NULL; | |
2304 } | |
2305 | |
2306 cfun->gimple_df->in_ssa_p = true; | |
2307 } | |
2308 | |
2309 /* Main entry point into the SSA builder. The renaming process | |
2310 proceeds in four main phases: | |
2311 | |
2312 1- Compute dominance frontier and immediate dominators, needed to | |
2313 insert PHI nodes and rename the function in dominator tree | |
2314 order. | |
2315 | |
2316 2- Find and mark all the blocks that define variables | |
2317 (mark_def_site_blocks). | |
2318 | |
2319 3- Insert PHI nodes at dominance frontiers (insert_phi_nodes). | |
2320 | |
2321 4- Rename all the blocks (rewrite_blocks) and statements in the program. | |
2322 | |
2323 Steps 3 and 4 are done using the dominator tree walker | |
2324 (walk_dominator_tree). */ | |
2325 | |
2326 static unsigned int | |
2327 rewrite_into_ssa (void) | |
2328 { | |
2329 bitmap *dfs; | |
2330 basic_block bb; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2331 |
0 | 2332 timevar_push (TV_TREE_SSA_OTHER); |
2333 | |
2334 /* Initialize operand data structures. */ | |
2335 init_ssa_operands (); | |
2336 | |
2337 /* Initialize internal data needed by the renamer. */ | |
2338 init_ssa_renamer (); | |
2339 | |
2340 /* Initialize the set of interesting blocks. The callback | |
2341 mark_def_sites will add to this set those blocks that the renamer | |
2342 should process. */ | |
2343 interesting_blocks = sbitmap_alloc (last_basic_block); | |
2344 sbitmap_zero (interesting_blocks); | |
2345 | |
2346 /* Initialize dominance frontier. */ | |
2347 dfs = XNEWVEC (bitmap, last_basic_block); | |
2348 FOR_EACH_BB (bb) | |
2349 dfs[bb->index] = BITMAP_ALLOC (NULL); | |
2350 | |
2351 /* 1- Compute dominance frontiers. */ | |
2352 calculate_dominance_info (CDI_DOMINATORS); | |
2353 compute_dominance_frontiers (dfs); | |
2354 | |
2355 /* 2- Find and mark definition sites. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2356 mark_def_site_blocks (); |
0 | 2357 |
2358 /* 3- Insert PHI nodes at dominance frontiers of definition blocks. */ | |
2359 insert_phi_nodes (dfs); | |
2360 | |
2361 /* 4- Rename all the blocks. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2362 rewrite_blocks (ENTRY_BLOCK_PTR, REWRITE_ALL); |
0 | 2363 |
2364 /* Free allocated memory. */ | |
2365 FOR_EACH_BB (bb) | |
2366 BITMAP_FREE (dfs[bb->index]); | |
2367 free (dfs); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2368 |
0 | 2369 sbitmap_free (interesting_blocks); |
2370 | |
2371 fini_ssa_renamer (); | |
2372 | |
2373 timevar_pop (TV_TREE_SSA_OTHER); | |
2374 return 0; | |
2375 } | |
2376 | |
2377 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2378 struct gimple_opt_pass pass_build_ssa = |
0 | 2379 { |
2380 { | |
2381 GIMPLE_PASS, | |
2382 "ssa", /* name */ | |
2383 NULL, /* gate */ | |
2384 rewrite_into_ssa, /* execute */ | |
2385 NULL, /* sub */ | |
2386 NULL, /* next */ | |
2387 0, /* static_pass_number */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2388 TV_NONE, /* tv_id */ |
0 | 2389 PROP_cfg | PROP_referenced_vars, /* properties_required */ |
2390 PROP_ssa, /* properties_provided */ | |
2391 0, /* properties_destroyed */ | |
2392 0, /* todo_flags_start */ | |
2393 TODO_dump_func | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2394 | TODO_update_ssa_only_virtuals |
0 | 2395 | TODO_verify_ssa |
2396 | TODO_remove_unused_locals /* todo_flags_finish */ | |
2397 } | |
2398 }; | |
2399 | |
2400 | |
2401 /* Mark the definition of VAR at STMT and BB as interesting for the | |
2402 renamer. BLOCKS is the set of blocks that need updating. */ | |
2403 | |
2404 static void | |
2405 mark_def_interesting (tree var, gimple stmt, basic_block bb, bool insert_phi_p) | |
2406 { | |
2407 gcc_assert (bitmap_bit_p (blocks_to_update, bb->index)); | |
2408 set_register_defs (stmt, true); | |
2409 | |
2410 if (insert_phi_p) | |
2411 { | |
2412 bool is_phi_p = gimple_code (stmt) == GIMPLE_PHI; | |
2413 | |
2414 set_def_block (var, bb, is_phi_p); | |
2415 | |
2416 /* If VAR is an SSA name in NEW_SSA_NAMES, this is a definition | |
2417 site for both itself and all the old names replaced by it. */ | |
2418 if (TREE_CODE (var) == SSA_NAME && is_new_name (var)) | |
2419 { | |
2420 bitmap_iterator bi; | |
2421 unsigned i; | |
2422 bitmap set = names_replaced_by (var); | |
2423 if (set) | |
2424 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi) | |
2425 set_def_block (ssa_name (i), bb, is_phi_p); | |
2426 } | |
2427 } | |
2428 } | |
2429 | |
2430 | |
2431 /* Mark the use of VAR at STMT and BB as interesting for the | |
2432 renamer. INSERT_PHI_P is true if we are going to insert new PHI | |
2433 nodes. */ | |
2434 | |
2435 static inline void | |
2436 mark_use_interesting (tree var, gimple stmt, basic_block bb, bool insert_phi_p) | |
2437 { | |
2438 basic_block def_bb = gimple_bb (stmt); | |
2439 | |
2440 mark_block_for_update (def_bb); | |
2441 mark_block_for_update (bb); | |
2442 | |
2443 if (gimple_code (stmt) == GIMPLE_PHI) | |
2444 mark_phi_for_rewrite (def_bb, stmt); | |
2445 else | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2446 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2447 set_rewrite_uses (stmt, true); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2448 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2449 if (is_gimple_debug (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2450 return; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2451 } |
0 | 2452 |
2453 /* If VAR has not been defined in BB, then it is live-on-entry | |
2454 to BB. Note that we cannot just use the block holding VAR's | |
2455 definition because if VAR is one of the names in OLD_SSA_NAMES, | |
2456 it will have several definitions (itself and all the names that | |
2457 replace it). */ | |
2458 if (insert_phi_p) | |
2459 { | |
2460 struct def_blocks_d *db_p = get_def_blocks_for (var); | |
2461 if (!bitmap_bit_p (db_p->def_blocks, bb->index)) | |
2462 set_livein_block (var, bb); | |
2463 } | |
2464 } | |
2465 | |
2466 | |
2467 /* Do a dominator walk starting at BB processing statements that | |
2468 reference symbols in SYMS_TO_RENAME. This is very similar to | |
2469 mark_def_sites, but the scan handles statements whose operands may | |
2470 already be SSA names. | |
2471 | |
2472 If INSERT_PHI_P is true, mark those uses as live in the | |
2473 corresponding block. This is later used by the PHI placement | |
2474 algorithm to make PHI pruning decisions. | |
2475 | |
2476 FIXME. Most of this would be unnecessary if we could associate a | |
2477 symbol to all the SSA names that reference it. But that | |
2478 sounds like it would be expensive to maintain. Still, it | |
2479 would be interesting to see if it makes better sense to do | |
2480 that. */ | |
2481 | |
2482 static void | |
2483 prepare_block_for_update (basic_block bb, bool insert_phi_p) | |
2484 { | |
2485 basic_block son; | |
2486 gimple_stmt_iterator si; | |
2487 edge e; | |
2488 edge_iterator ei; | |
2489 | |
2490 mark_block_for_update (bb); | |
2491 | |
2492 /* Process PHI nodes marking interesting those that define or use | |
2493 the symbols that we are interested in. */ | |
2494 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) | |
2495 { | |
2496 gimple phi = gsi_stmt (si); | |
2497 tree lhs_sym, lhs = gimple_phi_result (phi); | |
2498 | |
2499 lhs_sym = DECL_P (lhs) ? lhs : SSA_NAME_VAR (lhs); | |
2500 | |
2501 if (!symbol_marked_for_renaming (lhs_sym)) | |
2502 continue; | |
2503 | |
2504 mark_def_interesting (lhs_sym, phi, bb, insert_phi_p); | |
2505 | |
2506 /* Mark the uses in phi nodes as interesting. It would be more correct | |
2507 to process the arguments of the phi nodes of the successor edges of | |
2508 BB at the end of prepare_block_for_update, however, that turns out | |
2509 to be significantly more expensive. Doing it here is conservatively | |
2510 correct -- it may only cause us to believe a value to be live in a | |
2511 block that also contains its definition, and thus insert a few more | |
2512 phi nodes for it. */ | |
2513 FOR_EACH_EDGE (e, ei, bb->preds) | |
2514 mark_use_interesting (lhs_sym, phi, e->src, insert_phi_p); | |
2515 } | |
2516 | |
2517 /* Process the statements. */ | |
2518 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) | |
2519 { | |
2520 gimple stmt; | |
2521 ssa_op_iter i; | |
2522 use_operand_p use_p; | |
2523 def_operand_p def_p; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2524 |
0 | 2525 stmt = gsi_stmt (si); |
2526 | |
2527 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, i, SSA_OP_ALL_USES) | |
2528 { | |
2529 tree use = USE_FROM_PTR (use_p); | |
2530 tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use); | |
2531 if (symbol_marked_for_renaming (sym)) | |
2532 mark_use_interesting (sym, stmt, bb, insert_phi_p); | |
2533 } | |
2534 | |
2535 FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, i, SSA_OP_ALL_DEFS) | |
2536 { | |
2537 tree def = DEF_FROM_PTR (def_p); | |
2538 tree sym = DECL_P (def) ? def : SSA_NAME_VAR (def); | |
2539 if (symbol_marked_for_renaming (sym)) | |
2540 mark_def_interesting (sym, stmt, bb, insert_phi_p); | |
2541 } | |
2542 } | |
2543 | |
2544 /* Now visit all the blocks dominated by BB. */ | |
2545 for (son = first_dom_son (CDI_DOMINATORS, bb); | |
2546 son; | |
2547 son = next_dom_son (CDI_DOMINATORS, son)) | |
2548 prepare_block_for_update (son, insert_phi_p); | |
2549 } | |
2550 | |
2551 | |
2552 /* Helper for prepare_names_to_update. Mark all the use sites for | |
2553 NAME as interesting. BLOCKS and INSERT_PHI_P are as in | |
2554 prepare_names_to_update. */ | |
2555 | |
2556 static void | |
2557 prepare_use_sites_for (tree name, bool insert_phi_p) | |
2558 { | |
2559 use_operand_p use_p; | |
2560 imm_use_iterator iter; | |
2561 | |
2562 FOR_EACH_IMM_USE_FAST (use_p, iter, name) | |
2563 { | |
2564 gimple stmt = USE_STMT (use_p); | |
2565 basic_block bb = gimple_bb (stmt); | |
2566 | |
2567 if (gimple_code (stmt) == GIMPLE_PHI) | |
2568 { | |
2569 int ix = PHI_ARG_INDEX_FROM_USE (use_p); | |
2570 edge e = gimple_phi_arg_edge (stmt, ix); | |
2571 mark_use_interesting (name, stmt, e->src, insert_phi_p); | |
2572 } | |
2573 else | |
2574 { | |
2575 /* For regular statements, mark this as an interesting use | |
2576 for NAME. */ | |
2577 mark_use_interesting (name, stmt, bb, insert_phi_p); | |
2578 } | |
2579 } | |
2580 } | |
2581 | |
2582 | |
2583 /* Helper for prepare_names_to_update. Mark the definition site for | |
2584 NAME as interesting. BLOCKS and INSERT_PHI_P are as in | |
2585 prepare_names_to_update. */ | |
2586 | |
2587 static void | |
2588 prepare_def_site_for (tree name, bool insert_phi_p) | |
2589 { | |
2590 gimple stmt; | |
2591 basic_block bb; | |
2592 | |
2593 gcc_assert (names_to_release == NULL | |
2594 || !bitmap_bit_p (names_to_release, SSA_NAME_VERSION (name))); | |
2595 | |
2596 stmt = SSA_NAME_DEF_STMT (name); | |
2597 bb = gimple_bb (stmt); | |
2598 if (bb) | |
2599 { | |
2600 gcc_assert (bb->index < last_basic_block); | |
2601 mark_block_for_update (bb); | |
2602 mark_def_interesting (name, stmt, bb, insert_phi_p); | |
2603 } | |
2604 } | |
2605 | |
2606 | |
2607 /* Mark definition and use sites of names in NEW_SSA_NAMES and | |
2608 OLD_SSA_NAMES. INSERT_PHI_P is true if the caller wants to insert | |
2609 PHI nodes for newly created names. */ | |
2610 | |
2611 static void | |
2612 prepare_names_to_update (bool insert_phi_p) | |
2613 { | |
2614 unsigned i = 0; | |
2615 bitmap_iterator bi; | |
2616 sbitmap_iterator sbi; | |
2617 | |
2618 /* If a name N from NEW_SSA_NAMES is also marked to be released, | |
2619 remove it from NEW_SSA_NAMES so that we don't try to visit its | |
2620 defining basic block (which most likely doesn't exist). Notice | |
2621 that we cannot do the same with names in OLD_SSA_NAMES because we | |
2622 want to replace existing instances. */ | |
2623 if (names_to_release) | |
2624 EXECUTE_IF_SET_IN_BITMAP (names_to_release, 0, i, bi) | |
2625 RESET_BIT (new_ssa_names, i); | |
2626 | |
2627 /* First process names in NEW_SSA_NAMES. Otherwise, uses of old | |
2628 names may be considered to be live-in on blocks that contain | |
2629 definitions for their replacements. */ | |
2630 EXECUTE_IF_SET_IN_SBITMAP (new_ssa_names, 0, i, sbi) | |
2631 prepare_def_site_for (ssa_name (i), insert_phi_p); | |
2632 | |
2633 /* If an old name is in NAMES_TO_RELEASE, we cannot remove it from | |
2634 OLD_SSA_NAMES, but we have to ignore its definition site. */ | |
2635 EXECUTE_IF_SET_IN_SBITMAP (old_ssa_names, 0, i, sbi) | |
2636 { | |
2637 if (names_to_release == NULL || !bitmap_bit_p (names_to_release, i)) | |
2638 prepare_def_site_for (ssa_name (i), insert_phi_p); | |
2639 prepare_use_sites_for (ssa_name (i), insert_phi_p); | |
2640 } | |
2641 } | |
2642 | |
2643 | |
2644 /* Dump all the names replaced by NAME to FILE. */ | |
2645 | |
2646 void | |
2647 dump_names_replaced_by (FILE *file, tree name) | |
2648 { | |
2649 unsigned i; | |
2650 bitmap old_set; | |
2651 bitmap_iterator bi; | |
2652 | |
2653 print_generic_expr (file, name, 0); | |
2654 fprintf (file, " -> { "); | |
2655 | |
2656 old_set = names_replaced_by (name); | |
2657 EXECUTE_IF_SET_IN_BITMAP (old_set, 0, i, bi) | |
2658 { | |
2659 print_generic_expr (file, ssa_name (i), 0); | |
2660 fprintf (file, " "); | |
2661 } | |
2662 | |
2663 fprintf (file, "}\n"); | |
2664 } | |
2665 | |
2666 | |
2667 /* Dump all the names replaced by NAME to stderr. */ | |
2668 | |
2669 void | |
2670 debug_names_replaced_by (tree name) | |
2671 { | |
2672 dump_names_replaced_by (stderr, name); | |
2673 } | |
2674 | |
2675 | |
2676 /* Dump SSA update information to FILE. */ | |
2677 | |
2678 void | |
2679 dump_update_ssa (FILE *file) | |
2680 { | |
2681 unsigned i = 0; | |
2682 bitmap_iterator bi; | |
2683 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2684 if (!need_ssa_update_p (cfun)) |
0 | 2685 return; |
2686 | |
2687 if (new_ssa_names && sbitmap_first_set_bit (new_ssa_names) >= 0) | |
2688 { | |
2689 sbitmap_iterator sbi; | |
2690 | |
2691 fprintf (file, "\nSSA replacement table\n"); | |
2692 fprintf (file, "N_i -> { O_1 ... O_j } means that N_i replaces " | |
2693 "O_1, ..., O_j\n\n"); | |
2694 | |
2695 EXECUTE_IF_SET_IN_SBITMAP (new_ssa_names, 0, i, sbi) | |
2696 dump_names_replaced_by (file, ssa_name (i)); | |
2697 | |
2698 fprintf (file, "\n"); | |
2699 fprintf (file, "Number of virtual NEW -> OLD mappings: %7u\n", | |
2700 update_ssa_stats.num_virtual_mappings); | |
2701 fprintf (file, "Number of real NEW -> OLD mappings: %7u\n", | |
2702 update_ssa_stats.num_total_mappings | |
2703 - update_ssa_stats.num_virtual_mappings); | |
2704 fprintf (file, "Number of total NEW -> OLD mappings: %7u\n", | |
2705 update_ssa_stats.num_total_mappings); | |
2706 | |
2707 fprintf (file, "\nNumber of virtual symbols: %u\n", | |
2708 update_ssa_stats.num_virtual_symbols); | |
2709 } | |
2710 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2711 if (!bitmap_empty_p (SYMS_TO_RENAME (cfun))) |
0 | 2712 { |
2713 fprintf (file, "\n\nSymbols to be put in SSA form\n\n"); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2714 dump_decl_set (file, SYMS_TO_RENAME (cfun)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2715 fprintf (file, "\n"); |
0 | 2716 } |
2717 | |
2718 if (names_to_release && !bitmap_empty_p (names_to_release)) | |
2719 { | |
2720 fprintf (file, "\n\nSSA names to release after updating the SSA web\n\n"); | |
2721 EXECUTE_IF_SET_IN_BITMAP (names_to_release, 0, i, bi) | |
2722 { | |
2723 print_generic_expr (file, ssa_name (i), 0); | |
2724 fprintf (file, " "); | |
2725 } | |
2726 } | |
2727 | |
2728 fprintf (file, "\n\n"); | |
2729 } | |
2730 | |
2731 | |
2732 /* Dump SSA update information to stderr. */ | |
2733 | |
2734 void | |
2735 debug_update_ssa (void) | |
2736 { | |
2737 dump_update_ssa (stderr); | |
2738 } | |
2739 | |
2740 | |
2741 /* Initialize data structures used for incremental SSA updates. */ | |
2742 | |
2743 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2744 init_update_ssa (struct function *fn) |
0 | 2745 { |
2746 /* Reserve more space than the current number of names. The calls to | |
2747 add_new_name_mapping are typically done after creating new SSA | |
2748 names, so we'll need to reallocate these arrays. */ | |
2749 old_ssa_names = sbitmap_alloc (num_ssa_names + NAME_SETS_GROWTH_FACTOR); | |
2750 sbitmap_zero (old_ssa_names); | |
2751 | |
2752 new_ssa_names = sbitmap_alloc (num_ssa_names + NAME_SETS_GROWTH_FACTOR); | |
2753 sbitmap_zero (new_ssa_names); | |
2754 | |
2755 repl_tbl = htab_create (20, repl_map_hash, repl_map_eq, repl_map_free); | |
2756 names_to_release = NULL; | |
2757 memset (&update_ssa_stats, 0, sizeof (update_ssa_stats)); | |
2758 update_ssa_stats.virtual_symbols = BITMAP_ALLOC (NULL); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2759 update_ssa_initialized_fn = fn; |
0 | 2760 } |
2761 | |
2762 | |
2763 /* Deallocate data structures used for incremental SSA updates. */ | |
2764 | |
2765 void | |
2766 delete_update_ssa (void) | |
2767 { | |
2768 unsigned i; | |
2769 bitmap_iterator bi; | |
2770 | |
2771 sbitmap_free (old_ssa_names); | |
2772 old_ssa_names = NULL; | |
2773 | |
2774 sbitmap_free (new_ssa_names); | |
2775 new_ssa_names = NULL; | |
2776 | |
2777 htab_delete (repl_tbl); | |
2778 repl_tbl = NULL; | |
2779 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2780 bitmap_clear (SYMS_TO_RENAME (update_ssa_initialized_fn)); |
0 | 2781 BITMAP_FREE (update_ssa_stats.virtual_symbols); |
2782 | |
2783 if (names_to_release) | |
2784 { | |
2785 EXECUTE_IF_SET_IN_BITMAP (names_to_release, 0, i, bi) | |
2786 release_ssa_name (ssa_name (i)); | |
2787 BITMAP_FREE (names_to_release); | |
2788 } | |
2789 | |
2790 clear_ssa_name_info (); | |
2791 | |
2792 fini_ssa_renamer (); | |
2793 | |
2794 if (blocks_with_phis_to_rewrite) | |
2795 EXECUTE_IF_SET_IN_BITMAP (blocks_with_phis_to_rewrite, 0, i, bi) | |
2796 { | |
2797 gimple_vec phis = VEC_index (gimple_vec, phis_to_rewrite, i); | |
2798 | |
2799 VEC_free (gimple, heap, phis); | |
2800 VEC_replace (gimple_vec, phis_to_rewrite, i, NULL); | |
2801 } | |
2802 | |
2803 BITMAP_FREE (blocks_with_phis_to_rewrite); | |
2804 BITMAP_FREE (blocks_to_update); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2805 update_ssa_initialized_fn = NULL; |
0 | 2806 } |
2807 | |
2808 | |
2809 /* Create a new name for OLD_NAME in statement STMT and replace the | |
2810 operand pointed to by DEF_P with the newly created name. Return | |
2811 the new name and register the replacement mapping <NEW, OLD> in | |
2812 update_ssa's tables. */ | |
2813 | |
2814 tree | |
2815 create_new_def_for (tree old_name, gimple stmt, def_operand_p def) | |
2816 { | |
2817 tree new_name = duplicate_ssa_name (old_name, stmt); | |
2818 | |
2819 SET_DEF (def, new_name); | |
2820 | |
2821 if (gimple_code (stmt) == GIMPLE_PHI) | |
2822 { | |
2823 edge e; | |
2824 edge_iterator ei; | |
2825 basic_block bb = gimple_bb (stmt); | |
2826 | |
2827 /* If needed, mark NEW_NAME as occurring in an abnormal PHI node. */ | |
2828 FOR_EACH_EDGE (e, ei, bb->preds) | |
2829 if (e->flags & EDGE_ABNORMAL) | |
2830 { | |
2831 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_name) = 1; | |
2832 break; | |
2833 } | |
2834 } | |
2835 | |
2836 register_new_name_mapping (new_name, old_name); | |
2837 | |
2838 /* For the benefit of passes that will be updating the SSA form on | |
2839 their own, set the current reaching definition of OLD_NAME to be | |
2840 NEW_NAME. */ | |
2841 set_current_def (old_name, new_name); | |
2842 | |
2843 return new_name; | |
2844 } | |
2845 | |
2846 | |
2847 /* Register name NEW to be a replacement for name OLD. This function | |
2848 must be called for every replacement that should be performed by | |
2849 update_ssa. */ | |
2850 | |
2851 void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2852 register_new_name_mapping (tree new_tree, tree old) |
0 | 2853 { |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2854 if (!update_ssa_initialized_fn) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2855 init_update_ssa (cfun); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2856 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2857 gcc_assert (update_ssa_initialized_fn == cfun); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2858 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2859 add_new_name_mapping (new_tree, old); |
0 | 2860 } |
2861 | |
2862 | |
2863 /* Register symbol SYM to be renamed by update_ssa. */ | |
2864 | |
2865 void | |
2866 mark_sym_for_renaming (tree sym) | |
2867 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2868 bitmap_set_bit (SYMS_TO_RENAME (cfun), DECL_UID (sym)); |
0 | 2869 } |
2870 | |
2871 | |
2872 /* Register all the symbols in SET to be renamed by update_ssa. */ | |
2873 | |
2874 void | |
2875 mark_set_for_renaming (bitmap set) | |
2876 { | |
2877 bitmap_iterator bi; | |
2878 unsigned i; | |
2879 | |
2880 if (set == NULL || bitmap_empty_p (set)) | |
2881 return; | |
2882 | |
2883 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi) | |
2884 mark_sym_for_renaming (referenced_var (i)); | |
2885 } | |
2886 | |
2887 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2888 /* Return true if there is any work to be done by update_ssa |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2889 for function FN. */ |
0 | 2890 |
2891 bool | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2892 need_ssa_update_p (struct function *fn) |
0 | 2893 { |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2894 gcc_assert (fn != NULL); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2895 return (update_ssa_initialized_fn == fn |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2896 || (fn->gimple_df |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2897 && !bitmap_empty_p (SYMS_TO_RENAME (fn)))); |
0 | 2898 } |
2899 | |
2900 /* Return true if SSA name mappings have been registered for SSA updating. */ | |
2901 | |
2902 bool | |
2903 name_mappings_registered_p (void) | |
2904 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2905 if (!update_ssa_initialized_fn) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2906 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2907 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2908 gcc_assert (update_ssa_initialized_fn == cfun); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2909 |
0 | 2910 return repl_tbl && htab_elements (repl_tbl) > 0; |
2911 } | |
2912 | |
2913 /* Return true if name N has been registered in the replacement table. */ | |
2914 | |
2915 bool | |
2916 name_registered_for_update_p (tree n ATTRIBUTE_UNUSED) | |
2917 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2918 if (!update_ssa_initialized_fn) |
0 | 2919 return false; |
2920 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2921 gcc_assert (update_ssa_initialized_fn == cfun); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2922 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2923 return is_new_name (n) || is_old_name (n); |
0 | 2924 } |
2925 | |
2926 | |
2927 /* Return the set of all the SSA names marked to be replaced. */ | |
2928 | |
2929 bitmap | |
2930 ssa_names_to_replace (void) | |
2931 { | |
2932 unsigned i = 0; | |
2933 bitmap ret; | |
2934 sbitmap_iterator sbi; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2935 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2936 gcc_assert (update_ssa_initialized_fn == NULL |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2937 || update_ssa_initialized_fn == cfun); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2938 |
0 | 2939 ret = BITMAP_ALLOC (NULL); |
2940 EXECUTE_IF_SET_IN_SBITMAP (old_ssa_names, 0, i, sbi) | |
2941 bitmap_set_bit (ret, i); | |
2942 | |
2943 return ret; | |
2944 } | |
2945 | |
2946 | |
2947 /* Mark NAME to be released after update_ssa has finished. */ | |
2948 | |
2949 void | |
2950 release_ssa_name_after_update_ssa (tree name) | |
2951 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2952 gcc_assert (cfun && update_ssa_initialized_fn == cfun); |
0 | 2953 |
2954 if (names_to_release == NULL) | |
2955 names_to_release = BITMAP_ALLOC (NULL); | |
2956 | |
2957 bitmap_set_bit (names_to_release, SSA_NAME_VERSION (name)); | |
2958 } | |
2959 | |
2960 | |
2961 /* Insert new PHI nodes to replace VAR. DFS contains dominance | |
2962 frontier information. BLOCKS is the set of blocks to be updated. | |
2963 | |
2964 This is slightly different than the regular PHI insertion | |
2965 algorithm. The value of UPDATE_FLAGS controls how PHI nodes for | |
2966 real names (i.e., GIMPLE registers) are inserted: | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2967 |
0 | 2968 - If UPDATE_FLAGS == TODO_update_ssa, we are only interested in PHI |
2969 nodes inside the region affected by the block that defines VAR | |
2970 and the blocks that define all its replacements. All these | |
2971 definition blocks are stored in DEF_BLOCKS[VAR]->DEF_BLOCKS. | |
2972 | |
2973 First, we compute the entry point to the region (ENTRY). This is | |
2974 given by the nearest common dominator to all the definition | |
2975 blocks. When computing the iterated dominance frontier (IDF), any | |
2976 block not strictly dominated by ENTRY is ignored. | |
2977 | |
2978 We then call the standard PHI insertion algorithm with the pruned | |
2979 IDF. | |
2980 | |
2981 - If UPDATE_FLAGS == TODO_update_ssa_full_phi, the IDF for real | |
2982 names is not pruned. PHI nodes are inserted at every IDF block. */ | |
2983 | |
2984 static void | |
2985 insert_updated_phi_nodes_for (tree var, bitmap *dfs, bitmap blocks, | |
2986 unsigned update_flags) | |
2987 { | |
2988 basic_block entry; | |
2989 struct def_blocks_d *db; | |
2990 bitmap idf, pruned_idf; | |
2991 bitmap_iterator bi; | |
2992 unsigned i; | |
2993 | |
2994 #if defined ENABLE_CHECKING | |
2995 if (TREE_CODE (var) == SSA_NAME) | |
2996 gcc_assert (is_old_name (var)); | |
2997 else | |
2998 gcc_assert (symbol_marked_for_renaming (var)); | |
2999 #endif | |
3000 | |
3001 /* Get all the definition sites for VAR. */ | |
3002 db = find_def_blocks_for (var); | |
3003 | |
3004 /* No need to do anything if there were no definitions to VAR. */ | |
3005 if (db == NULL || bitmap_empty_p (db->def_blocks)) | |
3006 return; | |
3007 | |
3008 /* Compute the initial iterated dominance frontier. */ | |
3009 idf = compute_idf (db->def_blocks, dfs); | |
3010 pruned_idf = BITMAP_ALLOC (NULL); | |
3011 | |
3012 if (TREE_CODE (var) == SSA_NAME) | |
3013 { | |
3014 if (update_flags == TODO_update_ssa) | |
3015 { | |
3016 /* If doing regular SSA updates for GIMPLE registers, we are | |
3017 only interested in IDF blocks dominated by the nearest | |
3018 common dominator of all the definition blocks. */ | |
3019 entry = nearest_common_dominator_for_set (CDI_DOMINATORS, | |
3020 db->def_blocks); | |
3021 if (entry != ENTRY_BLOCK_PTR) | |
3022 EXECUTE_IF_SET_IN_BITMAP (idf, 0, i, bi) | |
3023 if (BASIC_BLOCK (i) != entry | |
3024 && dominated_by_p (CDI_DOMINATORS, BASIC_BLOCK (i), entry)) | |
3025 bitmap_set_bit (pruned_idf, i); | |
3026 } | |
3027 else | |
3028 { | |
3029 /* Otherwise, do not prune the IDF for VAR. */ | |
3030 gcc_assert (update_flags == TODO_update_ssa_full_phi); | |
3031 bitmap_copy (pruned_idf, idf); | |
3032 } | |
3033 } | |
3034 else | |
3035 { | |
3036 /* Otherwise, VAR is a symbol that needs to be put into SSA form | |
3037 for the first time, so we need to compute the full IDF for | |
3038 it. */ | |
3039 bitmap_copy (pruned_idf, idf); | |
3040 } | |
3041 | |
3042 if (!bitmap_empty_p (pruned_idf)) | |
3043 { | |
3044 /* Make sure that PRUNED_IDF blocks and all their feeding blocks | |
3045 are included in the region to be updated. The feeding blocks | |
3046 are important to guarantee that the PHI arguments are renamed | |
3047 properly. */ | |
3048 | |
3049 /* FIXME, this is not needed if we are updating symbols. We are | |
3050 already starting at the ENTRY block anyway. */ | |
3051 bitmap_ior_into (blocks, pruned_idf); | |
3052 EXECUTE_IF_SET_IN_BITMAP (pruned_idf, 0, i, bi) | |
3053 { | |
3054 edge e; | |
3055 edge_iterator ei; | |
3056 basic_block bb = BASIC_BLOCK (i); | |
3057 | |
3058 FOR_EACH_EDGE (e, ei, bb->preds) | |
3059 if (e->src->index >= 0) | |
3060 bitmap_set_bit (blocks, e->src->index); | |
3061 } | |
3062 | |
3063 insert_phi_nodes_for (var, pruned_idf, true); | |
3064 } | |
3065 | |
3066 BITMAP_FREE (pruned_idf); | |
3067 BITMAP_FREE (idf); | |
3068 } | |
3069 | |
3070 | |
3071 /* Heuristic to determine whether SSA name mappings for virtual names | |
3072 should be discarded and their symbols rewritten from scratch. When | |
3073 there is a large number of mappings for virtual names, the | |
3074 insertion of PHI nodes for the old names in the mappings takes | |
3075 considerable more time than if we inserted PHI nodes for the | |
3076 symbols instead. | |
3077 | |
3078 Currently the heuristic takes these stats into account: | |
3079 | |
3080 - Number of mappings for virtual SSA names. | |
3081 - Number of distinct virtual symbols involved in those mappings. | |
3082 | |
3083 If the number of virtual mappings is much larger than the number of | |
3084 virtual symbols, then it will be faster to compute PHI insertion | |
3085 spots for the symbols. Even if this involves traversing the whole | |
3086 CFG, which is what happens when symbols are renamed from scratch. */ | |
3087 | |
3088 static bool | |
3089 switch_virtuals_to_full_rewrite_p (void) | |
3090 { | |
3091 if (update_ssa_stats.num_virtual_mappings < (unsigned) MIN_VIRTUAL_MAPPINGS) | |
3092 return false; | |
3093 | |
3094 if (update_ssa_stats.num_virtual_mappings | |
3095 > (unsigned) VIRTUAL_MAPPINGS_TO_SYMS_RATIO | |
3096 * update_ssa_stats.num_virtual_symbols) | |
3097 return true; | |
3098 | |
3099 return false; | |
3100 } | |
3101 | |
3102 | |
3103 /* Remove every virtual mapping and mark all the affected virtual | |
3104 symbols for renaming. */ | |
3105 | |
3106 static void | |
3107 switch_virtuals_to_full_rewrite (void) | |
3108 { | |
3109 unsigned i = 0; | |
3110 sbitmap_iterator sbi; | |
3111 | |
3112 if (dump_file) | |
3113 { | |
3114 fprintf (dump_file, "\nEnabled virtual name mapping heuristic.\n"); | |
3115 fprintf (dump_file, "\tNumber of virtual mappings: %7u\n", | |
3116 update_ssa_stats.num_virtual_mappings); | |
3117 fprintf (dump_file, "\tNumber of unique virtual symbols: %7u\n", | |
3118 update_ssa_stats.num_virtual_symbols); | |
3119 fprintf (dump_file, "Updating FUD-chains from top of CFG will be " | |
3120 "faster than processing\nthe name mappings.\n\n"); | |
3121 } | |
3122 | |
3123 /* Remove all virtual names from NEW_SSA_NAMES and OLD_SSA_NAMES. | |
3124 Note that it is not really necessary to remove the mappings from | |
3125 REPL_TBL, that would only waste time. */ | |
3126 EXECUTE_IF_SET_IN_SBITMAP (new_ssa_names, 0, i, sbi) | |
3127 if (!is_gimple_reg (ssa_name (i))) | |
3128 RESET_BIT (new_ssa_names, i); | |
3129 | |
3130 EXECUTE_IF_SET_IN_SBITMAP (old_ssa_names, 0, i, sbi) | |
3131 if (!is_gimple_reg (ssa_name (i))) | |
3132 RESET_BIT (old_ssa_names, i); | |
3133 | |
3134 mark_set_for_renaming (update_ssa_stats.virtual_symbols); | |
3135 } | |
3136 | |
3137 | |
3138 /* Given a set of newly created SSA names (NEW_SSA_NAMES) and a set of | |
3139 existing SSA names (OLD_SSA_NAMES), update the SSA form so that: | |
3140 | |
3141 1- The names in OLD_SSA_NAMES dominated by the definitions of | |
3142 NEW_SSA_NAMES are all re-written to be reached by the | |
3143 appropriate definition from NEW_SSA_NAMES. | |
3144 | |
3145 2- If needed, new PHI nodes are added to the iterated dominance | |
3146 frontier of the blocks where each of NEW_SSA_NAMES are defined. | |
3147 | |
3148 The mapping between OLD_SSA_NAMES and NEW_SSA_NAMES is setup by | |
3149 calling register_new_name_mapping for every pair of names that the | |
3150 caller wants to replace. | |
3151 | |
3152 The caller identifies the new names that have been inserted and the | |
3153 names that need to be replaced by calling register_new_name_mapping | |
3154 for every pair <NEW, OLD>. Note that the function assumes that the | |
3155 new names have already been inserted in the IL. | |
3156 | |
3157 For instance, given the following code: | |
3158 | |
3159 1 L0: | |
3160 2 x_1 = PHI (0, x_5) | |
3161 3 if (x_1 < 10) | |
3162 4 if (x_1 > 7) | |
3163 5 y_2 = 0 | |
3164 6 else | |
3165 7 y_3 = x_1 + x_7 | |
3166 8 endif | |
3167 9 x_5 = x_1 + 1 | |
3168 10 goto L0; | |
3169 11 endif | |
3170 | |
3171 Suppose that we insert new names x_10 and x_11 (lines 4 and 8). | |
3172 | |
3173 1 L0: | |
3174 2 x_1 = PHI (0, x_5) | |
3175 3 if (x_1 < 10) | |
3176 4 x_10 = ... | |
3177 5 if (x_1 > 7) | |
3178 6 y_2 = 0 | |
3179 7 else | |
3180 8 x_11 = ... | |
3181 9 y_3 = x_1 + x_7 | |
3182 10 endif | |
3183 11 x_5 = x_1 + 1 | |
3184 12 goto L0; | |
3185 13 endif | |
3186 | |
3187 We want to replace all the uses of x_1 with the new definitions of | |
3188 x_10 and x_11. Note that the only uses that should be replaced are | |
3189 those at lines 5, 9 and 11. Also, the use of x_7 at line 9 should | |
3190 *not* be replaced (this is why we cannot just mark symbol 'x' for | |
3191 renaming). | |
3192 | |
3193 Additionally, we may need to insert a PHI node at line 11 because | |
3194 that is a merge point for x_10 and x_11. So the use of x_1 at line | |
3195 11 will be replaced with the new PHI node. The insertion of PHI | |
3196 nodes is optional. They are not strictly necessary to preserve the | |
3197 SSA form, and depending on what the caller inserted, they may not | |
3198 even be useful for the optimizers. UPDATE_FLAGS controls various | |
3199 aspects of how update_ssa operates, see the documentation for | |
3200 TODO_update_ssa*. */ | |
3201 | |
3202 void | |
3203 update_ssa (unsigned update_flags) | |
3204 { | |
3205 basic_block bb, start_bb; | |
3206 bitmap_iterator bi; | |
3207 unsigned i = 0; | |
3208 bool insert_phi_p; | |
3209 sbitmap_iterator sbi; | |
3210 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3211 if (!need_ssa_update_p (cfun)) |
0 | 3212 return; |
3213 | |
3214 timevar_push (TV_TREE_SSA_INCREMENTAL); | |
3215 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3216 if (!update_ssa_initialized_fn) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3217 init_update_ssa (cfun); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3218 gcc_assert (update_ssa_initialized_fn == cfun); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3219 |
0 | 3220 blocks_with_phis_to_rewrite = BITMAP_ALLOC (NULL); |
3221 if (!phis_to_rewrite) | |
3222 phis_to_rewrite = VEC_alloc (gimple_vec, heap, last_basic_block); | |
3223 blocks_to_update = BITMAP_ALLOC (NULL); | |
3224 | |
3225 /* Ensure that the dominance information is up-to-date. */ | |
3226 calculate_dominance_info (CDI_DOMINATORS); | |
3227 | |
3228 /* Only one update flag should be set. */ | |
3229 gcc_assert (update_flags == TODO_update_ssa | |
3230 || update_flags == TODO_update_ssa_no_phi | |
3231 || update_flags == TODO_update_ssa_full_phi | |
3232 || update_flags == TODO_update_ssa_only_virtuals); | |
3233 | |
3234 /* If we only need to update virtuals, remove all the mappings for | |
3235 real names before proceeding. The caller is responsible for | |
3236 having dealt with the name mappings before calling update_ssa. */ | |
3237 if (update_flags == TODO_update_ssa_only_virtuals) | |
3238 { | |
3239 sbitmap_zero (old_ssa_names); | |
3240 sbitmap_zero (new_ssa_names); | |
3241 htab_empty (repl_tbl); | |
3242 } | |
3243 | |
3244 insert_phi_p = (update_flags != TODO_update_ssa_no_phi); | |
3245 | |
3246 if (insert_phi_p) | |
3247 { | |
3248 /* If the caller requested PHI nodes to be added, initialize | |
3249 live-in information data structures (DEF_BLOCKS). */ | |
3250 | |
3251 /* For each SSA name N, the DEF_BLOCKS table describes where the | |
3252 name is defined, which blocks have PHI nodes for N, and which | |
3253 blocks have uses of N (i.e., N is live-on-entry in those | |
3254 blocks). */ | |
3255 def_blocks = htab_create (num_ssa_names, def_blocks_hash, | |
3256 def_blocks_eq, def_blocks_free); | |
3257 } | |
3258 else | |
3259 { | |
3260 def_blocks = NULL; | |
3261 } | |
3262 | |
3263 /* Heuristic to avoid massive slow downs when the replacement | |
3264 mappings include lots of virtual names. */ | |
3265 if (insert_phi_p && switch_virtuals_to_full_rewrite_p ()) | |
3266 switch_virtuals_to_full_rewrite (); | |
3267 | |
3268 /* If there are names defined in the replacement table, prepare | |
3269 definition and use sites for all the names in NEW_SSA_NAMES and | |
3270 OLD_SSA_NAMES. */ | |
3271 if (sbitmap_first_set_bit (new_ssa_names) >= 0) | |
3272 { | |
3273 prepare_names_to_update (insert_phi_p); | |
3274 | |
3275 /* If all the names in NEW_SSA_NAMES had been marked for | |
3276 removal, and there are no symbols to rename, then there's | |
3277 nothing else to do. */ | |
3278 if (sbitmap_first_set_bit (new_ssa_names) < 0 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3279 && bitmap_empty_p (SYMS_TO_RENAME (cfun))) |
0 | 3280 goto done; |
3281 } | |
3282 | |
3283 /* Next, determine the block at which to start the renaming process. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3284 if (!bitmap_empty_p (SYMS_TO_RENAME (cfun))) |
0 | 3285 { |
3286 /* If we have to rename some symbols from scratch, we need to | |
3287 start the process at the root of the CFG. FIXME, it should | |
3288 be possible to determine the nearest block that had a | |
3289 definition for each of the symbols that are marked for | |
3290 updating. For now this seems more work than it's worth. */ | |
3291 start_bb = ENTRY_BLOCK_PTR; | |
3292 | |
3293 /* Traverse the CFG looking for existing definitions and uses of | |
3294 symbols in SYMS_TO_RENAME. Mark interesting blocks and | |
3295 statements and set local live-in information for the PHI | |
3296 placement heuristics. */ | |
3297 prepare_block_for_update (start_bb, insert_phi_p); | |
3298 } | |
3299 else | |
3300 { | |
3301 /* Otherwise, the entry block to the region is the nearest | |
3302 common dominator for the blocks in BLOCKS. */ | |
3303 start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS, | |
3304 blocks_to_update); | |
3305 } | |
3306 | |
3307 /* If requested, insert PHI nodes at the iterated dominance frontier | |
3308 of every block, creating new definitions for names in OLD_SSA_NAMES | |
3309 and for symbols in SYMS_TO_RENAME. */ | |
3310 if (insert_phi_p) | |
3311 { | |
3312 bitmap *dfs; | |
3313 | |
3314 /* If the caller requested PHI nodes to be added, compute | |
3315 dominance frontiers. */ | |
3316 dfs = XNEWVEC (bitmap, last_basic_block); | |
3317 FOR_EACH_BB (bb) | |
3318 dfs[bb->index] = BITMAP_ALLOC (NULL); | |
3319 compute_dominance_frontiers (dfs); | |
3320 | |
3321 if (sbitmap_first_set_bit (old_ssa_names) >= 0) | |
3322 { | |
3323 sbitmap_iterator sbi; | |
3324 | |
3325 /* insert_update_phi_nodes_for will call add_new_name_mapping | |
3326 when inserting new PHI nodes, so the set OLD_SSA_NAMES | |
3327 will grow while we are traversing it (but it will not | |
3328 gain any new members). Copy OLD_SSA_NAMES to a temporary | |
3329 for traversal. */ | |
3330 sbitmap tmp = sbitmap_alloc (old_ssa_names->n_bits); | |
3331 sbitmap_copy (tmp, old_ssa_names); | |
3332 EXECUTE_IF_SET_IN_SBITMAP (tmp, 0, i, sbi) | |
3333 insert_updated_phi_nodes_for (ssa_name (i), dfs, blocks_to_update, | |
3334 update_flags); | |
3335 sbitmap_free (tmp); | |
3336 } | |
3337 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3338 EXECUTE_IF_SET_IN_BITMAP (SYMS_TO_RENAME (cfun), 0, i, bi) |
0 | 3339 insert_updated_phi_nodes_for (referenced_var (i), dfs, blocks_to_update, |
3340 update_flags); | |
3341 | |
3342 FOR_EACH_BB (bb) | |
3343 BITMAP_FREE (dfs[bb->index]); | |
3344 free (dfs); | |
3345 | |
3346 /* Insertion of PHI nodes may have added blocks to the region. | |
3347 We need to re-compute START_BB to include the newly added | |
3348 blocks. */ | |
3349 if (start_bb != ENTRY_BLOCK_PTR) | |
3350 start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS, | |
3351 blocks_to_update); | |
3352 } | |
3353 | |
3354 /* Reset the current definition for name and symbol before renaming | |
3355 the sub-graph. */ | |
3356 EXECUTE_IF_SET_IN_SBITMAP (old_ssa_names, 0, i, sbi) | |
3357 set_current_def (ssa_name (i), NULL_TREE); | |
3358 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3359 EXECUTE_IF_SET_IN_BITMAP (SYMS_TO_RENAME (cfun), 0, i, bi) |
0 | 3360 set_current_def (referenced_var (i), NULL_TREE); |
3361 | |
3362 /* Now start the renaming process at START_BB. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3363 interesting_blocks = sbitmap_alloc (last_basic_block); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3364 sbitmap_zero (interesting_blocks); |
0 | 3365 EXECUTE_IF_SET_IN_BITMAP (blocks_to_update, 0, i, bi) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3366 SET_BIT (interesting_blocks, i); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3367 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3368 rewrite_blocks (start_bb, REWRITE_UPDATE); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3369 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3370 sbitmap_free (interesting_blocks); |
0 | 3371 |
3372 /* Debugging dumps. */ | |
3373 if (dump_file) | |
3374 { | |
3375 int c; | |
3376 unsigned i; | |
3377 | |
3378 dump_update_ssa (dump_file); | |
3379 | |
3380 fprintf (dump_file, "Incremental SSA update started at block: %d\n\n", | |
3381 start_bb->index); | |
3382 | |
3383 c = 0; | |
3384 EXECUTE_IF_SET_IN_BITMAP (blocks_to_update, 0, i, bi) | |
3385 c++; | |
3386 fprintf (dump_file, "Number of blocks in CFG: %d\n", last_basic_block); | |
3387 fprintf (dump_file, "Number of blocks to update: %d (%3.0f%%)\n\n", | |
3388 c, PERCENT (c, last_basic_block)); | |
3389 | |
3390 if (dump_flags & TDF_DETAILS) | |
3391 { | |
3392 fprintf (dump_file, "Affected blocks: "); | |
3393 EXECUTE_IF_SET_IN_BITMAP (blocks_to_update, 0, i, bi) | |
3394 fprintf (dump_file, "%u ", i); | |
3395 fprintf (dump_file, "\n"); | |
3396 } | |
3397 | |
3398 fprintf (dump_file, "\n\n"); | |
3399 } | |
3400 | |
3401 /* Free allocated memory. */ | |
3402 done: | |
3403 delete_update_ssa (); | |
3404 | |
3405 timevar_pop (TV_TREE_SSA_INCREMENTAL); | |
3406 } |