Bring gcc-4.4.0 to up-to-date.
[asac-android-toolchain:gcc-linaro.git] / gcc-4.4.0 / gcc / tree-into-ssa.c
1 /* Rewrite a program in Normal form into SSA.
2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008
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
115
116 /* Symbols whose SSA form needs to be updated or created for the first
117    time.  */
118 static bitmap syms_to_rename;
119
120 /* Subset of SYMS_TO_RENAME.  Contains all the GIMPLE register symbols
121    that have been marked for renaming.  */
122 static bitmap regs_to_rename;
123
124 /* Subset of SYMS_TO_RENAME.  Contains all the memory symbols
125    that have been marked for renaming.  */
126 static bitmap mem_syms_to_rename;
127
128 /* Set of SSA names that have been marked to be released after they
129    were registered in the replacement table.  They will be finally
130    released after we finish updating the SSA web.  */
131 static bitmap names_to_release;
132
133 static VEC(gimple_vec, heap) *phis_to_rewrite;
134
135 /* The bitmap of non-NULL elements of PHIS_TO_REWRITE.  */
136 static bitmap blocks_with_phis_to_rewrite;
137
138 /* Growth factor for NEW_SSA_NAMES and OLD_SSA_NAMES.  These sets need
139    to grow as the callers to register_new_name_mapping will typically
140    create new names on the fly.  FIXME.  Currently set to 1/3 to avoid
141    frequent reallocations but still need to find a reasonable growth
142    strategy.  */
143 #define NAME_SETS_GROWTH_FACTOR (MAX (3, num_ssa_names / 3))
144
145 /* Tuple used to represent replacement mappings.  */
146 struct repl_map_d
147 {
148   tree name;
149   bitmap set;
150 };
151
152
153 /* NEW -> OLD_SET replacement table.  If we are replacing several
154    existing SSA names O_1, O_2, ..., O_j with a new name N_i,
155    then REPL_TBL[N_i] = { O_1, O_2, ..., O_j }.  */
156 static htab_t repl_tbl;
157
158 /* true if register_new_name_mapping needs to initialize the data
159    structures needed by update_ssa.  */
160 static bool need_to_initialize_update_ssa_p = true;
161
162 /* true if update_ssa needs to update virtual operands.  */
163 static bool need_to_update_vops_p = false;
164
165 /* Statistics kept by update_ssa to use in the virtual mapping
166    heuristic.  If the number of virtual mappings is beyond certain
167    threshold, the updater will switch from using the mappings into
168    renaming the virtual symbols from scratch.  In some cases, the
169    large number of name mappings for virtual names causes significant
170    slowdowns in the PHI insertion code.  */
171 struct update_ssa_stats_d
172 {
173   unsigned num_virtual_mappings;
174   unsigned num_total_mappings;
175   bitmap virtual_symbols;
176   unsigned num_virtual_symbols;
177 };
178 static struct update_ssa_stats_d update_ssa_stats;
179
180 /* Global data to attach to the main dominator walk structure.  */
181 struct mark_def_sites_global_data
182 {
183   /* This bitmap contains the variables which are set before they
184      are used in a basic block.  */
185   bitmap kills;
186
187   /* Bitmap of names to rename.  */
188   sbitmap names_to_rename;
189
190   /* Set of blocks that mark_def_sites deems interesting for the
191      renamer to process.  */
192   sbitmap interesting_blocks;
193 };
194
195
196 /* Information stored for SSA names.  */
197 struct ssa_name_info
198 {
199   /* The current reaching definition replacing this SSA name.  */
200   tree current_def;
201
202   /* This field indicates whether or not the variable may need PHI nodes.
203      See the enum's definition for more detailed information about the
204      states.  */
205   ENUM_BITFIELD (need_phi_state) need_phi_state : 2;
206
207   /* Age of this record (so that info_for_ssa_name table can be cleared
208      quickly); if AGE < CURRENT_INFO_FOR_SSA_NAME_AGE, then the fields
209      are assumed to be null.  */
210   unsigned age;
211 };
212
213 /* The information associated with names.  */
214 typedef struct ssa_name_info *ssa_name_info_p;
215 DEF_VEC_P (ssa_name_info_p);
216 DEF_VEC_ALLOC_P (ssa_name_info_p, heap);
217
218 static VEC(ssa_name_info_p, heap) *info_for_ssa_name;
219 static unsigned current_info_for_ssa_name_age;
220
221 /* The set of blocks affected by update_ssa.  */
222 static bitmap blocks_to_update;
223
224 /* The main entry point to the SSA renamer (rewrite_blocks) may be
225    called several times to do different, but related, tasks.
226    Initially, we need it to rename the whole program into SSA form.
227    At other times, we may need it to only rename into SSA newly
228    exposed symbols.  Finally, we can also call it to incrementally fix
229    an already built SSA web.  */
230 enum rewrite_mode {
231     /* Convert the whole function into SSA form.  */
232     REWRITE_ALL,
233
234     /* Incrementally update the SSA web by replacing existing SSA
235        names with new ones.  See update_ssa for details.  */
236     REWRITE_UPDATE
237 };
238
239
240
241
242 /* Prototypes for debugging functions.  */
243 extern void dump_tree_ssa (FILE *);
244 extern void debug_tree_ssa (void);
245 extern void debug_def_blocks (void);
246 extern void dump_tree_ssa_stats (FILE *);
247 extern void debug_tree_ssa_stats (void);
248 extern void dump_update_ssa (FILE *);
249 extern void debug_update_ssa (void);
250 extern void dump_names_replaced_by (FILE *, tree);
251 extern void debug_names_replaced_by (tree);
252 extern void dump_def_blocks (FILE *);
253 extern void debug_def_blocks (void);
254 extern void dump_defs_stack (FILE *, int);
255 extern void debug_defs_stack (int);
256 extern void dump_currdefs (FILE *);
257 extern void debug_currdefs (void);
258
259 /* Return true if STMT needs to be rewritten.  When renaming a subset
260    of the variables, not all statements will be processed.  This is
261    decided in mark_def_sites.  */
262
263 static inline bool
264 rewrite_uses_p (gimple stmt)
265 {
266   return gimple_visited_p (stmt);
267 }
268
269
270 /* Set the rewrite marker on STMT to the value given by REWRITE_P.  */
271
272 static inline void
273 set_rewrite_uses (gimple stmt, bool rewrite_p)
274 {
275   gimple_set_visited (stmt, rewrite_p);
276 }
277
278
279 /* Return true if the DEFs created by statement STMT should be
280    registered when marking new definition sites.  This is slightly
281    different than rewrite_uses_p: it's used by update_ssa to
282    distinguish statements that need to have both uses and defs
283    processed from those that only need to have their defs processed.
284    Statements that define new SSA names only need to have their defs
285    registered, but they don't need to have their uses renamed.  */
286
287 static inline bool
288 register_defs_p (gimple stmt)
289 {
290   return gimple_plf (stmt, GF_PLF_1) != 0;
291 }
292
293
294 /* If REGISTER_DEFS_P is true, mark STMT to have its DEFs registered.  */
295
296 static inline void
297 set_register_defs (gimple stmt, bool register_defs_p)
298 {
299   gimple_set_plf (stmt, GF_PLF_1, register_defs_p);
300 }
301
302
303 /* Get the information associated with NAME.  */
304
305 static inline ssa_name_info_p
306 get_ssa_name_ann (tree name)
307 {
308   unsigned ver = SSA_NAME_VERSION (name);
309   unsigned len = VEC_length (ssa_name_info_p, info_for_ssa_name);
310   struct ssa_name_info *info;
311
312   if (ver >= len)
313     {
314       unsigned new_len = num_ssa_names;
315
316       VEC_reserve (ssa_name_info_p, heap, info_for_ssa_name, new_len);
317       while (len++ < new_len)
318         {
319           struct ssa_name_info *info = XCNEW (struct ssa_name_info);
320           info->age = current_info_for_ssa_name_age;
321           VEC_quick_push (ssa_name_info_p, info_for_ssa_name, info);
322         }
323     }
324
325   info = VEC_index (ssa_name_info_p, info_for_ssa_name, ver);
326   if (info->age < current_info_for_ssa_name_age)
327     {
328       info->need_phi_state = 0;
329       info->current_def = NULL_TREE;
330       info->age = current_info_for_ssa_name_age;
331     }
332
333   return info;
334 }
335
336
337 /* Clears info for SSA names.  */
338
339 static void
340 clear_ssa_name_info (void)
341 {
342   current_info_for_ssa_name_age++;
343 }
344
345
346 /* Get phi_state field for VAR.  */
347
348 static inline enum need_phi_state
349 get_phi_state (tree var)
350 {
351   if (TREE_CODE (var) == SSA_NAME)
352     return get_ssa_name_ann (var)->need_phi_state;
353   else
354     return var_ann (var)->need_phi_state;
355 }
356
357
358 /* Sets phi_state field for VAR to STATE.  */
359
360 static inline void
361 set_phi_state (tree var, enum need_phi_state state)
362 {
363   if (TREE_CODE (var) == SSA_NAME)
364     get_ssa_name_ann (var)->need_phi_state = state;
365   else
366     var_ann (var)->need_phi_state = state;
367 }
368
369
370 /* Return the current definition for VAR.  */
371
372 tree
373 get_current_def (tree var)
374 {
375   if (TREE_CODE (var) == SSA_NAME)
376     return get_ssa_name_ann (var)->current_def;
377   else
378     return var_ann (var)->current_def;
379 }
380
381
382 /* Sets current definition of VAR to DEF.  */
383
384 void
385 set_current_def (tree var, tree def)
386 {
387   if (TREE_CODE (var) == SSA_NAME)
388     get_ssa_name_ann (var)->current_def = def;
389   else
390     var_ann (var)->current_def = def;
391 }
392
393
394 /* Compute global livein information given the set of blocks where
395    an object is locally live at the start of the block (LIVEIN)
396    and the set of blocks where the object is defined (DEF_BLOCKS).
397
398    Note: This routine augments the existing local livein information
399    to include global livein (i.e., it modifies the underlying bitmap
400    for LIVEIN).  */
401
402 void
403 compute_global_livein (bitmap livein ATTRIBUTE_UNUSED, bitmap def_blocks ATTRIBUTE_UNUSED)
404 {
405   basic_block bb, *worklist, *tos;
406   unsigned i;
407   bitmap_iterator bi;
408
409   tos = worklist
410     = (basic_block *) xmalloc (sizeof (basic_block) * (last_basic_block + 1));
411
412   EXECUTE_IF_SET_IN_BITMAP (livein, 0, i, bi)
413     *tos++ = BASIC_BLOCK (i);
414
415   /* Iterate until the worklist is empty.  */
416   while (tos != worklist)
417     {
418       edge e;
419       edge_iterator ei;
420
421       /* Pull a block off the worklist.  */
422       bb = *--tos;
423
424       /* For each predecessor block.  */
425       FOR_EACH_EDGE (e, ei, bb->preds)
426         {
427           basic_block pred = e->src;
428           int pred_index = pred->index;
429
430           /* None of this is necessary for the entry block.  */
431           if (pred != ENTRY_BLOCK_PTR
432               && ! bitmap_bit_p (livein, pred_index)
433               && ! bitmap_bit_p (def_blocks, pred_index))
434             {
435               *tos++ = pred;
436               bitmap_set_bit (livein, pred_index);
437             }
438         }
439     }
440
441   free (worklist);
442 }
443
444
445 /* Cleans up the REWRITE_THIS_STMT and REGISTER_DEFS_IN_THIS_STMT flags for
446    all statements in basic block BB.  */
447
448 static void
449 initialize_flags_in_bb (basic_block bb)
450 {
451   gimple stmt;
452   gimple_stmt_iterator gsi;
453
454   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
455     {
456       gimple phi = gsi_stmt (gsi);
457       set_rewrite_uses (phi, false);
458       set_register_defs (phi, false);
459     }
460
461   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
462     {
463       stmt = gsi_stmt (gsi);
464
465       /* We are going to use the operand cache API, such as
466          SET_USE, SET_DEF, and FOR_EACH_IMM_USE_FAST.  The operand
467          cache for each statement should be up-to-date.  */
468       gcc_assert (!gimple_modified_p (stmt));
469       set_rewrite_uses (stmt, false);
470       set_register_defs (stmt, false);
471     }
472 }
473
474 /* Mark block BB as interesting for update_ssa.  */
475
476 static void
477 mark_block_for_update (basic_block bb)
478 {
479   gcc_assert (blocks_to_update != NULL);
480   if (bitmap_bit_p (blocks_to_update, bb->index))
481     return;
482   bitmap_set_bit (blocks_to_update, bb->index);
483   initialize_flags_in_bb (bb);
484 }
485
486 /* Return the set of blocks where variable VAR is defined and the blocks
487    where VAR is live on entry (livein).  If no entry is found in
488    DEF_BLOCKS, a new one is created and returned.  */
489
490 static inline struct def_blocks_d *
491 get_def_blocks_for (tree var)
492 {
493   struct def_blocks_d db, *db_p;
494   void **slot;
495
496   db.var = var;
497   slot = htab_find_slot (def_blocks, (void *) &db, INSERT);
498   if (*slot == NULL)
499     {
500       db_p = XNEW (struct def_blocks_d);
501       db_p->var = var;
502       db_p->def_blocks = BITMAP_ALLOC (NULL);
503       db_p->phi_blocks = BITMAP_ALLOC (NULL);
504       db_p->livein_blocks = BITMAP_ALLOC (NULL);
505       *slot = (void *) db_p;
506     }
507   else
508     db_p = (struct def_blocks_d *) *slot;
509
510   return db_p;
511 }
512
513
514 /* Mark block BB as the definition site for variable VAR.  PHI_P is true if
515    VAR is defined by a PHI node.  */
516
517 static void
518 set_def_block (tree var, basic_block bb, bool phi_p)
519 {
520   struct def_blocks_d *db_p;
521   enum need_phi_state state;
522
523   state = get_phi_state (var);
524   db_p = get_def_blocks_for (var);
525
526   /* Set the bit corresponding to the block where VAR is defined.  */
527   bitmap_set_bit (db_p->def_blocks, bb->index);
528   if (phi_p)
529     bitmap_set_bit (db_p->phi_blocks, bb->index);
530
531   /* Keep track of whether or not we may need to insert PHI nodes.
532
533      If we are in the UNKNOWN state, then this is the first definition
534      of VAR.  Additionally, we have not seen any uses of VAR yet, so
535      we do not need a PHI node for this variable at this time (i.e.,
536      transition to NEED_PHI_STATE_NO).
537
538      If we are in any other state, then we either have multiple definitions
539      of this variable occurring in different blocks or we saw a use of the
540      variable which was not dominated by the block containing the
541      definition(s).  In this case we may need a PHI node, so enter
542      state NEED_PHI_STATE_MAYBE.  */
543   if (state == NEED_PHI_STATE_UNKNOWN)
544     set_phi_state (var, NEED_PHI_STATE_NO);
545   else
546     set_phi_state (var, NEED_PHI_STATE_MAYBE);
547 }
548
549
550 /* Mark block BB as having VAR live at the entry to BB.  */
551
552 static void
553 set_livein_block (tree var, basic_block bb)
554 {
555   struct def_blocks_d *db_p;
556   enum need_phi_state state = get_phi_state (var);
557
558   db_p = get_def_blocks_for (var);
559
560   /* Set the bit corresponding to the block where VAR is live in.  */
561   bitmap_set_bit (db_p->livein_blocks, bb->index);
562
563   /* Keep track of whether or not we may need to insert PHI nodes.
564
565      If we reach here in NEED_PHI_STATE_NO, see if this use is dominated
566      by the single block containing the definition(s) of this variable.  If
567      it is, then we remain in NEED_PHI_STATE_NO, otherwise we transition to
568      NEED_PHI_STATE_MAYBE.  */
569   if (state == NEED_PHI_STATE_NO)
570     {
571       int def_block_index = bitmap_first_set_bit (db_p->def_blocks);
572
573       if (def_block_index == -1
574           || ! dominated_by_p (CDI_DOMINATORS, bb,
575                                BASIC_BLOCK (def_block_index)))
576         set_phi_state (var, NEED_PHI_STATE_MAYBE);
577     }
578   else
579     set_phi_state (var, NEED_PHI_STATE_MAYBE);
580 }
581
582
583 /* Return true if symbol SYM is marked for renaming.  */
584
585 static inline bool
586 symbol_marked_for_renaming (tree sym)
587 {
588   return bitmap_bit_p (syms_to_rename, DECL_UID (sym));
589 }
590
591
592 /* Return true if NAME is in OLD_SSA_NAMES.  */
593
594 static inline bool
595 is_old_name (tree name)
596 {
597   unsigned ver = SSA_NAME_VERSION (name);
598   return ver < new_ssa_names->n_bits && TEST_BIT (old_ssa_names, ver);
599 }
600
601
602 /* Return true if NAME is in NEW_SSA_NAMES.  */
603
604 static inline bool
605 is_new_name (tree name)
606 {
607   unsigned ver = SSA_NAME_VERSION (name);
608   return ver < new_ssa_names->n_bits && TEST_BIT (new_ssa_names, ver);
609 }
610
611
612 /* Hashing and equality functions for REPL_TBL.  */
613
614 static hashval_t
615 repl_map_hash (const void *p)
616 {
617   return htab_hash_pointer ((const void *)((const struct repl_map_d *)p)->name);
618 }
619
620 static int
621 repl_map_eq (const void *p1, const void *p2)
622 {
623   return ((const struct repl_map_d *)p1)->name
624          == ((const struct repl_map_d *)p2)->name;
625 }
626
627 static void
628 repl_map_free (void *p)
629 {
630   BITMAP_FREE (((struct repl_map_d *)p)->set);
631   free (p);
632 }
633
634
635 /* Return the names replaced by NEW_TREE (i.e., REPL_TBL[NEW_TREE].SET).  */
636
637 static inline bitmap
638 names_replaced_by (tree new_tree)
639 {
640   struct repl_map_d m;
641   void **slot;
642
643   m.name = new_tree;
644   slot = htab_find_slot (repl_tbl, (void *) &m, NO_INSERT);
645
646   /* If N was not registered in the replacement table, return NULL.  */
647   if (slot == NULL || *slot == NULL)
648     return NULL;
649
650   return ((struct repl_map_d *) *slot)->set;
651 }
652
653
654 /* Add OLD to REPL_TBL[NEW_TREE].SET.  */
655
656 static inline void
657 add_to_repl_tbl (tree new_tree, tree old)
658 {
659   struct repl_map_d m, *mp;
660   void **slot;
661
662   m.name = new_tree;
663   slot = htab_find_slot (repl_tbl, (void *) &m, INSERT);
664   if (*slot == NULL)
665     {
666       mp = XNEW (struct repl_map_d);
667       mp->name = new_tree;
668       mp->set = BITMAP_ALLOC (NULL);
669       *slot = (void *) mp;
670     }
671   else
672     mp = (struct repl_map_d *) *slot;
673
674   bitmap_set_bit (mp->set, SSA_NAME_VERSION (old));
675 }
676
677
678 /* Add a new mapping NEW_TREE -> OLD REPL_TBL.  Every entry N_i in REPL_TBL
679    represents the set of names O_1 ... O_j replaced by N_i.  This is
680    used by update_ssa and its helpers to introduce new SSA names in an
681    already formed SSA web.  */
682
683 static void
684 add_new_name_mapping (tree new_tree, tree old)
685 {
686   timevar_push (TV_TREE_SSA_INCREMENTAL);
687
688   /* OLD and NEW_TREE must be different SSA names for the same symbol.  */
689   gcc_assert (new_tree != old && SSA_NAME_VAR (new_tree) == SSA_NAME_VAR (old));
690
691   /* If this mapping is for virtual names, we will need to update
692      virtual operands.  If this is a mapping for .MEM, then we gather
693      the symbols associated with each name.  */
694   if (!is_gimple_reg (new_tree))
695     {
696       tree sym;
697
698       need_to_update_vops_p = true;
699
700       update_ssa_stats.num_virtual_mappings++;
701       update_ssa_stats.num_virtual_symbols++;
702
703       /* Keep counts of virtual mappings and symbols to use in the
704          virtual mapping heuristic.  If we have large numbers of
705          virtual mappings for a relatively low number of symbols, it
706          will make more sense to rename the symbols from scratch.
707          Otherwise, the insertion of PHI nodes for each of the old
708          names in these mappings will be very slow.  */
709       sym = SSA_NAME_VAR (new_tree);
710       bitmap_set_bit (update_ssa_stats.virtual_symbols, DECL_UID (sym));
711     }
712
713   /* We may need to grow NEW_SSA_NAMES and OLD_SSA_NAMES because our
714      caller may have created new names since the set was created.  */
715   if (new_ssa_names->n_bits <= num_ssa_names - 1)
716     {
717       unsigned int new_sz = num_ssa_names + NAME_SETS_GROWTH_FACTOR;
718       new_ssa_names = sbitmap_resize (new_ssa_names, new_sz, 0);
719       old_ssa_names = sbitmap_resize (old_ssa_names, new_sz, 0);
720     }
721
722   /* Update the REPL_TBL table.  */
723   add_to_repl_tbl (new_tree, old);
724
725   /* If OLD had already been registered as a new name, then all the
726      names that OLD replaces should also be replaced by NEW_TREE.  */
727   if (is_new_name (old))
728     bitmap_ior_into (names_replaced_by (new_tree), names_replaced_by (old));
729
730   /* Register NEW_TREE and OLD in NEW_SSA_NAMES and OLD_SSA_NAMES,
731      respectively.  */
732   SET_BIT (new_ssa_names, SSA_NAME_VERSION (new_tree));
733   SET_BIT (old_ssa_names, SSA_NAME_VERSION (old));
734
735   /* Update mapping counter to use in the virtual mapping heuristic.  */
736   update_ssa_stats.num_total_mappings++;
737
738   timevar_pop (TV_TREE_SSA_INCREMENTAL);
739 }
740
741
742 /* Call back for walk_dominator_tree used to collect definition sites
743    for every variable in the function.  For every statement S in block
744    BB:
745
746    1- Variables defined by S in the DEFS of S are marked in the bitmap
747       WALK_DATA->GLOBAL_DATA->KILLS.
748
749    2- If S uses a variable VAR and there is no preceding kill of VAR,
750       then it is marked in the LIVEIN_BLOCKS bitmap associated with VAR.
751
752    This information is used to determine which variables are live
753    across block boundaries to reduce the number of PHI nodes
754    we create.  */
755
756 static void
757 mark_def_sites (struct dom_walk_data *walk_data, basic_block bb,
758                 gimple_stmt_iterator gsi)
759 {
760   struct mark_def_sites_global_data *gd;
761   bitmap kills;
762   tree def;
763   gimple stmt;
764   use_operand_p use_p;
765   ssa_op_iter iter;
766
767   /* Since this is the first time that we rewrite the program into SSA
768      form, force an operand scan on every statement.  */
769   stmt = gsi_stmt (gsi);
770   update_stmt (stmt);
771
772   gd = (struct mark_def_sites_global_data *) walk_data->global_data;
773   kills = gd->kills;
774
775   gcc_assert (blocks_to_update == NULL);
776   set_register_defs (stmt, false);
777   set_rewrite_uses (stmt, false);
778
779   /* If a variable is used before being set, then the variable is live
780      across a block boundary, so mark it live-on-entry to BB.  */
781   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
782     {
783       tree sym = USE_FROM_PTR (use_p);
784       gcc_assert (DECL_P (sym));
785       if (!bitmap_bit_p (kills, DECL_UID (sym)))
786         set_livein_block (sym, bb);
787       set_rewrite_uses (stmt, true);
788     }
789   
790   /* Now process the defs.  Mark BB as the definition block and add
791      each def to the set of killed symbols.  */
792   FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
793     {
794       gcc_assert (DECL_P (def));
795       set_def_block (def, bb, false);
796       bitmap_set_bit (kills, DECL_UID (def));
797       set_register_defs (stmt, true);
798     }
799
800   /* If we found the statement interesting then also mark the block BB
801      as interesting.  */
802   if (rewrite_uses_p (stmt) || register_defs_p (stmt))
803     SET_BIT (gd->interesting_blocks, bb->index);
804 }
805
806 /* Structure used by prune_unused_phi_nodes to record bounds of the intervals
807    in the dfs numbering of the dominance tree.  */
808
809 struct dom_dfsnum
810 {
811   /* Basic block whose index this entry corresponds to.  */
812   unsigned bb_index;
813
814   /* The dfs number of this node.  */
815   unsigned dfs_num;
816 };
817
818 /* Compares two entries of type struct dom_dfsnum by dfs_num field.  Callback
819    for qsort.  */
820
821 static int
822 cmp_dfsnum (const void *a, const void *b)
823 {
824   const struct dom_dfsnum *const da = (const struct dom_dfsnum *) a;
825   const struct dom_dfsnum *const db = (const struct dom_dfsnum *) b;
826
827   return (int) da->dfs_num - (int) db->dfs_num;
828 }
829
830 /* Among the intervals starting at the N points specified in DEFS, find
831    the one that contains S, and return its bb_index.  */
832
833 static unsigned
834 find_dfsnum_interval (struct dom_dfsnum *defs, unsigned n, unsigned s)
835 {
836   unsigned f = 0, t = n, m;
837
838   while (t > f + 1)
839     {
840       m = (f + t) / 2;
841       if (defs[m].dfs_num <= s)
842         f = m;
843       else
844         t = m;
845     }
846
847   return defs[f].bb_index;
848 }
849
850 /* Clean bits from PHIS for phi nodes whose value cannot be used in USES.
851    KILLS is a bitmap of blocks where the value is defined before any use.  */
852
853 static void
854 prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
855 {
856   VEC(int, heap) *worklist;
857   bitmap_iterator bi;
858   unsigned i, b, p, u, top;
859   bitmap live_phis;
860   basic_block def_bb, use_bb;
861   edge e;
862   edge_iterator ei;
863   bitmap to_remove;
864   struct dom_dfsnum *defs;
865   unsigned n_defs, adef;
866
867   if (bitmap_empty_p (uses))
868     {
869       bitmap_clear (phis);
870       return;
871     }
872
873   /* The phi must dominate a use, or an argument of a live phi.  Also, we
874      do not create any phi nodes in def blocks, unless they are also livein.  */
875   to_remove = BITMAP_ALLOC (NULL);
876   bitmap_and_compl (to_remove, kills, uses);
877   bitmap_and_compl_into (phis, to_remove);
878   if (bitmap_empty_p (phis))
879     {
880       BITMAP_FREE (to_remove);
881       return;
882     }
883
884   /* We want to remove the unnecessary phi nodes, but we do not want to compute
885      liveness information, as that may be linear in the size of CFG, and if
886      there are lot of different variables to rewrite, this may lead to quadratic
887      behavior.
888
889      Instead, we basically emulate standard dce.  We put all uses to worklist,
890      then for each of them find the nearest def that dominates them.  If this
891      def is a phi node, we mark it live, and if it was not live before, we
892      add the predecessors of its basic block to the worklist.
893    
894      To quickly locate the nearest def that dominates use, we use dfs numbering
895      of the dominance tree (that is already available in order to speed up
896      queries).  For each def, we have the interval given by the dfs number on
897      entry to and on exit from the corresponding subtree in the dominance tree.
898      The nearest dominator for a given use is the smallest of these intervals
899      that contains entry and exit dfs numbers for the basic block with the use.
900      If we store the bounds for all the uses to an array and sort it, we can
901      locate the nearest dominating def in logarithmic time by binary search.*/
902   bitmap_ior (to_remove, kills, phis);
903   n_defs = bitmap_count_bits (to_remove);
904   defs = XNEWVEC (struct dom_dfsnum, 2 * n_defs + 1);
905   defs[0].bb_index = 1;
906   defs[0].dfs_num = 0;
907   adef = 1;
908   EXECUTE_IF_SET_IN_BITMAP (to_remove, 0, i, bi)
909     {
910       def_bb = BASIC_BLOCK (i);
911       defs[adef].bb_index = i;
912       defs[adef].dfs_num = bb_dom_dfs_in (CDI_DOMINATORS, def_bb);
913       defs[adef + 1].bb_index = i;
914       defs[adef + 1].dfs_num = bb_dom_dfs_out (CDI_DOMINATORS, def_bb);
915       adef += 2;
916     }
917   BITMAP_FREE (to_remove);
918   gcc_assert (adef == 2 * n_defs + 1);
919   qsort (defs, adef, sizeof (struct dom_dfsnum), cmp_dfsnum);
920   gcc_assert (defs[0].bb_index == 1);
921
922   /* Now each DEFS entry contains the number of the basic block to that the
923      dfs number corresponds.  Change them to the number of basic block that
924      corresponds to the interval following the dfs number.  Also, for the
925      dfs_out numbers, increase the dfs number by one (so that it corresponds
926      to the start of the following interval, not to the end of the current
927      one).  We use WORKLIST as a stack.  */
928   worklist = VEC_alloc (int, heap, n_defs + 1);
929   VEC_quick_push (int, worklist, 1);
930   top = 1;
931   n_defs = 1;
932   for (i = 1; i < adef; i++)
933     {
934       b = defs[i].bb_index;
935       if (b == top)
936         {
937           /* This is a closing element.  Interval corresponding to the top
938              of the stack after removing it follows.  */
939           VEC_pop (int, worklist);
940           top = VEC_index (int, worklist, VEC_length (int, worklist) - 1);
941           defs[n_defs].bb_index = top;
942           defs[n_defs].dfs_num = defs[i].dfs_num + 1;
943         }
944       else
945         {
946           /* Opening element.  Nothing to do, just push it to the stack and move
947              it to the correct position.  */
948           defs[n_defs].bb_index = defs[i].bb_index;
949           defs[n_defs].dfs_num = defs[i].dfs_num;
950           VEC_quick_push (int, worklist, b);
951           top = b;
952         }
953
954       /* If this interval starts at the same point as the previous one, cancel
955          the previous one.  */
956       if (defs[n_defs].dfs_num == defs[n_defs - 1].dfs_num)
957         defs[n_defs - 1].bb_index = defs[n_defs].bb_index;
958       else
959         n_defs++;
960     }
961   VEC_pop (int, worklist);
962   gcc_assert (VEC_empty (int, worklist));
963
964   /* Now process the uses.  */
965   live_phis = BITMAP_ALLOC (NULL);
966   EXECUTE_IF_SET_IN_BITMAP (uses, 0, i, bi)
967     {
968       VEC_safe_push (int, heap, worklist, i);
969     }
970
971   while (!VEC_empty (int, worklist))
972     {
973       b = VEC_pop (int, worklist);
974       if (b == ENTRY_BLOCK)
975         continue;
976
977       /* If there is a phi node in USE_BB, it is made live.  Otherwise,
978          find the def that dominates the immediate dominator of USE_BB
979          (the kill in USE_BB does not dominate the use).  */
980       if (bitmap_bit_p (phis, b))
981         p = b;
982       else
983         {
984           use_bb = get_immediate_dominator (CDI_DOMINATORS, BASIC_BLOCK (b));
985           p = find_dfsnum_interval (defs, n_defs,
986                                     bb_dom_dfs_in (CDI_DOMINATORS, use_bb));
987           if (!bitmap_bit_p (phis, p))
988             continue;
989         }
990
991       /* If the phi node is already live, there is nothing to do.  */
992       if (bitmap_bit_p (live_phis, p))
993         continue;
994
995       /* Mark the phi as live, and add the new uses to the worklist.  */
996       bitmap_set_bit (live_phis, p);
997       def_bb = BASIC_BLOCK (p);
998       FOR_EACH_EDGE (e, ei, def_bb->preds)
999         {
1000           u = e->src->index;
1001           if (bitmap_bit_p (uses, u))
1002             continue;
1003
1004           /* In case there is a kill directly in the use block, do not record
1005              the use (this is also necessary for correctness, as we assume that
1006              uses dominated by a def directly in their block have been filtered
1007              out before).  */
1008           if (bitmap_bit_p (kills, u))
1009             continue;
1010
1011           bitmap_set_bit (uses, u);
1012           VEC_safe_push (int, heap, worklist, u);
1013         }
1014     }
1015
1016   VEC_free (int, heap, worklist);
1017   bitmap_copy (phis, live_phis);
1018   BITMAP_FREE (live_phis);
1019   free (defs);
1020 }
1021
1022 /* Return the set of blocks where variable VAR is defined and the blocks
1023    where VAR is live on entry (livein).  Return NULL, if no entry is
1024    found in DEF_BLOCKS.  */
1025
1026 static inline struct def_blocks_d *
1027 find_def_blocks_for (tree var)
1028 {
1029   struct def_blocks_d dm;
1030   dm.var = var;
1031   return (struct def_blocks_d *) htab_find (def_blocks, &dm);
1032 }
1033
1034
1035 /* Retrieve or create a default definition for symbol SYM.  */
1036
1037 static inline tree
1038 get_default_def_for (tree sym)
1039 {
1040   tree ddef = gimple_default_def (cfun, sym);
1041
1042   if (ddef == NULL_TREE)
1043     {
1044       ddef = make_ssa_name (sym, gimple_build_nop ());
1045       set_default_def (sym, ddef);
1046     }
1047
1048   return ddef;
1049 }
1050
1051
1052 /* Marks phi node PHI in basic block BB for rewrite.  */
1053
1054 static void
1055 mark_phi_for_rewrite (basic_block bb, gimple phi)
1056 {
1057   gimple_vec phis;
1058   unsigned i, idx = bb->index;
1059
1060   if (rewrite_uses_p (phi))
1061     return;
1062
1063   set_rewrite_uses (phi, true);
1064
1065   if (!blocks_with_phis_to_rewrite)
1066     return;
1067
1068   bitmap_set_bit (blocks_with_phis_to_rewrite, idx);
1069   VEC_reserve (gimple_vec, heap, phis_to_rewrite, last_basic_block + 1);
1070   for (i = VEC_length (gimple_vec, phis_to_rewrite); i <= idx; i++)
1071     VEC_quick_push (gimple_vec, phis_to_rewrite, NULL);
1072
1073   phis = VEC_index (gimple_vec, phis_to_rewrite, idx);
1074   if (!phis)
1075     phis = VEC_alloc (gimple, heap, 10);
1076
1077   VEC_safe_push (gimple, heap, phis, phi);
1078   VEC_replace (gimple_vec, phis_to_rewrite, idx, phis);
1079 }
1080
1081
1082 /* Insert PHI nodes for variable VAR using the iterated dominance
1083    frontier given in PHI_INSERTION_POINTS.  If UPDATE_P is true, this
1084    function assumes that the caller is incrementally updating the
1085    existing SSA form, in which case VAR may be an SSA name instead of
1086    a symbol.
1087
1088    PHI_INSERTION_POINTS is updated to reflect nodes that already had a
1089    PHI node for VAR.  On exit, only the nodes that received a PHI node
1090    for VAR will be present in PHI_INSERTION_POINTS.  */
1091
1092 static void
1093 insert_phi_nodes_for (tree var, bitmap phi_insertion_points, bool update_p)
1094 {
1095   unsigned bb_index;
1096   edge e;
1097   gimple phi;
1098   basic_block bb;
1099   bitmap_iterator bi;
1100   struct def_blocks_d *def_map;
1101
1102   def_map = find_def_blocks_for (var);
1103   gcc_assert (def_map);
1104
1105   /* Remove the blocks where we already have PHI nodes for VAR.  */
1106   bitmap_and_compl_into (phi_insertion_points, def_map->phi_blocks);
1107
1108   /* Remove obviously useless phi nodes.  */
1109   prune_unused_phi_nodes (phi_insertion_points, def_map->def_blocks,
1110                           def_map->livein_blocks);
1111
1112   /* And insert the PHI nodes.  */
1113   EXECUTE_IF_SET_IN_BITMAP (phi_insertion_points, 0, bb_index, bi)
1114     {
1115       bb = BASIC_BLOCK (bb_index);
1116       if (update_p)
1117         mark_block_for_update (bb);
1118
1119       phi = NULL;
1120
1121       if (TREE_CODE (var) == SSA_NAME)
1122         {
1123           /* If we are rewriting SSA names, create the LHS of the PHI
1124              node by duplicating VAR.  This is useful in the case of
1125              pointers, to also duplicate pointer attributes (alias
1126              information, in particular).  */
1127           edge_iterator ei;
1128           tree new_lhs;
1129
1130           gcc_assert (update_p);
1131           phi = create_phi_node (var, bb);
1132
1133           new_lhs = duplicate_ssa_name (var, phi);
1134           gimple_phi_set_result (phi, new_lhs);
1135           add_new_name_mapping (new_lhs, var);
1136
1137           /* Add VAR to every argument slot of PHI.  We need VAR in
1138              every argument so that rewrite_update_phi_arguments knows
1139              which name is this PHI node replacing.  If VAR is a
1140              symbol marked for renaming, this is not necessary, the
1141              renamer will use the symbol on the LHS to get its
1142              reaching definition.  */
1143           FOR_EACH_EDGE (e, ei, bb->preds)
1144             add_phi_arg (phi, var, e, UNKNOWN_LOCATION);
1145         }
1146       else
1147         {
1148           gcc_assert (DECL_P (var));
1149           phi = create_phi_node (var, bb);
1150         }
1151
1152       /* Mark this PHI node as interesting for update_ssa.  */
1153       set_register_defs (phi, true);
1154       mark_phi_for_rewrite (bb, phi);
1155     }
1156 }
1157
1158
1159 /* Insert PHI nodes at the dominance frontier of blocks with variable
1160    definitions.  DFS contains the dominance frontier information for
1161    the flowgraph.  */
1162
1163 static void
1164 insert_phi_nodes (bitmap *dfs)
1165 {
1166   referenced_var_iterator rvi;
1167   tree var;
1168
1169   timevar_push (TV_TREE_INSERT_PHI_NODES);
1170   
1171   FOR_EACH_REFERENCED_VAR (var, rvi)
1172     {
1173       struct def_blocks_d *def_map;
1174       bitmap idf;
1175
1176       def_map = find_def_blocks_for (var);
1177       if (def_map == NULL)
1178         continue;
1179
1180       if (get_phi_state (var) != NEED_PHI_STATE_NO)
1181         {
1182           idf = compute_idf (def_map->def_blocks, dfs);
1183           insert_phi_nodes_for (var, idf, false);
1184           BITMAP_FREE (idf);
1185         }
1186     }
1187
1188   timevar_pop (TV_TREE_INSERT_PHI_NODES);
1189 }
1190
1191
1192 /* Push SYM's current reaching definition into BLOCK_DEFS_STACK and
1193    register DEF (an SSA_NAME) to be a new definition for SYM.  */
1194
1195 static void
1196 register_new_def (tree def, tree sym)
1197 {
1198   tree currdef;
1199    
1200   /* If this variable is set in a single basic block and all uses are
1201      dominated by the set(s) in that single basic block, then there is
1202      no reason to record anything for this variable in the block local
1203      definition stacks.  Doing so just wastes time and memory.
1204
1205      This is the same test to prune the set of variables which may
1206      need PHI nodes.  So we just use that information since it's already
1207      computed and available for us to use.  */
1208   if (get_phi_state (sym) == NEED_PHI_STATE_NO)
1209     {
1210       set_current_def (sym, def);
1211       return;
1212     }
1213
1214   currdef = get_current_def (sym);
1215
1216   /* If SYM is not a GIMPLE register, then CURRDEF may be a name whose
1217      SSA_NAME_VAR is not necessarily SYM.  In this case, also push SYM
1218      in the stack so that we know which symbol is being defined by
1219      this SSA name when we unwind the stack.  */
1220   if (currdef && !is_gimple_reg (sym))
1221     VEC_safe_push (tree, heap, block_defs_stack, sym);
1222
1223   /* Push the current reaching definition into BLOCK_DEFS_STACK.  This
1224      stack is later used by the dominator tree callbacks to restore
1225      the reaching definitions for all the variables defined in the
1226      block after a recursive visit to all its immediately dominated
1227      blocks.  If there is no current reaching definition, then just
1228      record the underlying _DECL node.  */
1229   VEC_safe_push (tree, heap, block_defs_stack, currdef ? currdef : sym);
1230
1231   /* Set the current reaching definition for SYM to be DEF.  */
1232   set_current_def (sym, def);
1233 }
1234
1235
1236 /* Perform a depth-first traversal of the dominator tree looking for
1237    variables to rename.  BB is the block where to start searching.
1238    Renaming is a five step process:
1239
1240    1- Every definition made by PHI nodes at the start of the blocks is
1241       registered as the current definition for the corresponding variable.
1242
1243    2- Every statement in BB is rewritten.  USE and VUSE operands are
1244       rewritten with their corresponding reaching definition.  DEF and
1245       VDEF targets are registered as new definitions.
1246       
1247    3- All the PHI nodes in successor blocks of BB are visited.  The
1248       argument corresponding to BB is replaced with its current reaching
1249       definition.
1250
1251    4- Recursively rewrite every dominator child block of BB.
1252
1253    5- Restore (in reverse order) the current reaching definition for every
1254       new definition introduced in this block.  This is done so that when
1255       we return from the recursive call, all the current reaching
1256       definitions are restored to the names that were valid in the
1257       dominator parent of BB.  */
1258
1259 /* SSA Rewriting Step 1.  Initialization, create a block local stack
1260    of reaching definitions for new SSA names produced in this block
1261    (BLOCK_DEFS).  Register new definitions for every PHI node in the
1262    block.  */
1263
1264 static void
1265 rewrite_initialize_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1266                           basic_block bb)
1267 {
1268   gimple phi;
1269   gimple_stmt_iterator gsi;
1270
1271   if (dump_file && (dump_flags & TDF_DETAILS))
1272     fprintf (dump_file, "\n\nRenaming block #%d\n\n", bb->index);
1273
1274   /* Mark the unwind point for this block.  */
1275   VEC_safe_push (tree, heap, block_defs_stack, NULL_TREE);
1276
1277   /* Step 1.  Register new definitions for every PHI node in the block.
1278      Conceptually, all the PHI nodes are executed in parallel and each PHI
1279      node introduces a new version for the associated variable.  */
1280   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1281     {
1282       tree result;
1283
1284       phi = gsi_stmt (gsi);
1285       result = gimple_phi_result (phi);
1286       gcc_assert (is_gimple_reg (result));
1287       register_new_def (result, SSA_NAME_VAR (result));
1288     }
1289 }
1290
1291
1292 /* Return the current definition for variable VAR.  If none is found,
1293    create a new SSA name to act as the zeroth definition for VAR.  */
1294
1295 static tree
1296 get_reaching_def (tree var)
1297 {
1298   tree currdef;
1299   
1300   /* Lookup the current reaching definition for VAR.  */
1301   currdef = get_current_def (var);
1302
1303   /* If there is no reaching definition for VAR, create and register a
1304      default definition for it (if needed).  */
1305   if (currdef == NULL_TREE)
1306     {
1307       tree sym = DECL_P (var) ? var : SSA_NAME_VAR (var);
1308       currdef = get_default_def_for (sym);
1309       set_current_def (var, currdef);
1310     }
1311
1312   /* Return the current reaching definition for VAR, or the default
1313      definition, if we had to create one.  */
1314   return currdef;
1315 }
1316
1317
1318 /* SSA Rewriting Step 2.  Rewrite every variable used in each statement in
1319    the block with its immediate reaching definitions.  Update the current
1320    definition of a variable when a new real or virtual definition is found.  */
1321
1322 static void
1323 rewrite_stmt (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1324               basic_block bb ATTRIBUTE_UNUSED, gimple_stmt_iterator si)
1325 {
1326   gimple stmt;
1327   use_operand_p use_p;
1328   def_operand_p def_p;
1329   ssa_op_iter iter;
1330
1331   stmt = gsi_stmt (si);
1332
1333   /* If mark_def_sites decided that we don't need to rewrite this
1334      statement, ignore it.  */
1335   gcc_assert (blocks_to_update == NULL);
1336   if (!rewrite_uses_p (stmt) && !register_defs_p (stmt))
1337     return;
1338
1339   if (dump_file && (dump_flags & TDF_DETAILS))
1340     {
1341       fprintf (dump_file, "Renaming statement ");
1342       print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
1343       fprintf (dump_file, "\n");
1344     }
1345
1346   /* Step 1.  Rewrite USES in the statement.  */
1347   if (rewrite_uses_p (stmt))
1348     FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
1349       {
1350         tree var = USE_FROM_PTR (use_p);
1351         gcc_assert (DECL_P (var));
1352         SET_USE (use_p, get_reaching_def (var));
1353       }
1354
1355   /* Step 2.  Register the statement's DEF operands.  */
1356   if (register_defs_p (stmt))
1357     FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_DEF)
1358       {
1359         tree var = DEF_FROM_PTR (def_p);
1360         gcc_assert (DECL_P (var));
1361         SET_DEF (def_p, make_ssa_name (var, stmt));
1362         register_new_def (DEF_FROM_PTR (def_p), var);
1363       }
1364 }
1365
1366
1367 /* SSA Rewriting Step 3.  Visit all the successor blocks of BB looking for
1368    PHI nodes.  For every PHI node found, add a new argument containing the
1369    current reaching definition for the variable and the edge through which
1370    that definition is reaching the PHI node.  */
1371
1372 static void
1373 rewrite_add_phi_arguments (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1374                            basic_block bb)
1375 {
1376   edge e;
1377   edge_iterator ei;
1378
1379   FOR_EACH_EDGE (e, ei, bb->succs)
1380     {
1381       gimple phi;
1382       gimple_stmt_iterator gsi;
1383
1384       for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi);
1385            gsi_next (&gsi))
1386         {
1387           tree currdef;
1388           gimple stmt;
1389
1390           phi = gsi_stmt (gsi);
1391           currdef = get_reaching_def (SSA_NAME_VAR (gimple_phi_result (phi)));
1392           stmt = SSA_NAME_DEF_STMT (currdef);
1393           add_phi_arg (phi, currdef, e, gimple_location (stmt));
1394         }
1395     }
1396 }
1397
1398
1399 /* Called after visiting all the statements in basic block BB and all
1400    of its dominator children.  Restore CURRDEFS to its original value.  */
1401
1402 static void
1403 rewrite_finalize_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1404                         basic_block bb ATTRIBUTE_UNUSED)
1405 {
1406   /* Restore CURRDEFS to its original state.  */
1407   while (VEC_length (tree, block_defs_stack) > 0)
1408     {
1409       tree tmp = VEC_pop (tree, block_defs_stack);
1410       tree saved_def, var;
1411
1412       if (tmp == NULL_TREE)
1413         break;
1414
1415       if (TREE_CODE (tmp) == SSA_NAME)
1416         {
1417           /* If we recorded an SSA_NAME, then make the SSA_NAME the
1418              current definition of its underlying variable.  Note that
1419              if the SSA_NAME is not for a GIMPLE register, the symbol
1420              being defined is stored in the next slot in the stack.
1421              This mechanism is needed because an SSA name for a
1422              non-register symbol may be the definition for more than
1423              one symbol (e.g., SFTs, aliased variables, etc).  */
1424           saved_def = tmp;
1425           var = SSA_NAME_VAR (saved_def);
1426           if (!is_gimple_reg (var))
1427             var = VEC_pop (tree, block_defs_stack);
1428         }
1429       else
1430         {
1431           /* If we recorded anything else, it must have been a _DECL
1432              node and its current reaching definition must have been
1433              NULL.  */
1434           saved_def = NULL;
1435           var = tmp;
1436         }
1437                                                                                 
1438       set_current_def (var, saved_def);
1439     }
1440 }
1441
1442
1443 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.  */
1444
1445 void
1446 dump_decl_set (FILE *file, bitmap set)
1447 {
1448   if (set)
1449     {
1450       bitmap_iterator bi;
1451       unsigned i;
1452
1453       fprintf (file, "{ ");
1454
1455       EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
1456         {
1457           print_generic_expr (file, referenced_var (i), 0);
1458           fprintf (file, " ");
1459         }
1460
1461       fprintf (file, "}\n");
1462     }
1463   else
1464     fprintf (file, "NIL\n");
1465 }
1466
1467
1468 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.  */
1469
1470 void
1471 debug_decl_set (bitmap set)
1472 {
1473   dump_decl_set (stderr, set);
1474 }
1475
1476
1477 /* Dump the renaming stack (block_defs_stack) to FILE.  Traverse the
1478    stack up to a maximum of N levels.  If N is -1, the whole stack is
1479    dumped.  New levels are created when the dominator tree traversal
1480    used for renaming enters a new sub-tree.  */
1481
1482 void
1483 dump_defs_stack (FILE *file, int n)
1484 {
1485   int i, j;
1486
1487   fprintf (file, "\n\nRenaming stack");
1488   if (n > 0)
1489     fprintf (file, " (up to %d levels)", n);
1490   fprintf (file, "\n\n");
1491
1492   i = 1;
1493   fprintf (file, "Level %d (current level)\n", i);
1494   for (j = (int) VEC_length (tree, block_defs_stack) - 1; j >= 0; j--)
1495     {
1496       tree name, var;
1497       
1498       name = VEC_index (tree, block_defs_stack, j);
1499       if (name == NULL_TREE)
1500         {
1501           i++;
1502           if (n > 0 && i > n)
1503             break;
1504           fprintf (file, "\nLevel %d\n", i);
1505           continue;
1506         }
1507
1508       if (DECL_P (name))
1509         {
1510           var = name;
1511           name = NULL_TREE;
1512         }
1513       else
1514         {
1515           var = SSA_NAME_VAR (name);
1516           if (!is_gimple_reg (var))
1517             {
1518               j--;
1519               var = VEC_index (tree, block_defs_stack, j);
1520             }
1521         }
1522
1523       fprintf (file, "    Previous CURRDEF (");
1524       print_generic_expr (file, var, 0);
1525       fprintf (file, ") = ");
1526       if (name)
1527         print_generic_expr (file, name, 0);
1528       else
1529         fprintf (file, "<NIL>");
1530       fprintf (file, "\n");
1531     }
1532 }
1533
1534
1535 /* Dump the renaming stack (block_defs_stack) to stderr.  Traverse the
1536    stack up to a maximum of N levels.  If N is -1, the whole stack is
1537    dumped.  New levels are created when the dominator tree traversal
1538    used for renaming enters a new sub-tree.  */
1539
1540 void
1541 debug_defs_stack (int n)
1542 {
1543   dump_defs_stack (stderr, n);
1544 }
1545
1546
1547 /* Dump the current reaching definition of every symbol to FILE.  */
1548
1549 void
1550 dump_currdefs (FILE *file)
1551 {
1552   referenced_var_iterator i;
1553   tree var;
1554
1555   fprintf (file, "\n\nCurrent reaching definitions\n\n");
1556   FOR_EACH_REFERENCED_VAR (var, i)
1557     if (syms_to_rename == NULL || bitmap_bit_p (syms_to_rename, DECL_UID (var)))
1558       {
1559         fprintf (file, "CURRDEF (");
1560         print_generic_expr (file, var, 0);
1561         fprintf (file, ") = ");
1562         if (get_current_def (var))
1563           print_generic_expr (file, get_current_def (var), 0);
1564         else
1565           fprintf (file, "<NIL>");
1566         fprintf (file, "\n");
1567       }
1568 }
1569
1570
1571 /* Dump the current reaching definition of every symbol to stderr.  */
1572
1573 void
1574 debug_currdefs (void)
1575 {
1576   dump_currdefs (stderr);
1577 }
1578
1579
1580 /* Dump SSA information to FILE.  */
1581
1582 void
1583 dump_tree_ssa (FILE *file)
1584 {
1585   const char *funcname
1586     = lang_hooks.decl_printable_name (current_function_decl, 2);
1587
1588   fprintf (file, "SSA renaming information for %s\n\n", funcname);
1589
1590   dump_def_blocks (file);
1591   dump_defs_stack (file, -1);
1592   dump_currdefs (file);
1593   dump_tree_ssa_stats (file);
1594 }
1595
1596
1597 /* Dump SSA information to stderr.  */
1598
1599 void
1600 debug_tree_ssa (void)
1601 {
1602   dump_tree_ssa (stderr);
1603 }
1604
1605
1606 /* Dump statistics for the hash table HTAB.  */
1607
1608 static void
1609 htab_statistics (FILE *file, htab_t htab)
1610 {
1611   fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n",
1612            (long) htab_size (htab),
1613            (long) htab_elements (htab),
1614            htab_collisions (htab));
1615 }
1616
1617
1618 /* Dump SSA statistics on FILE.  */
1619
1620 void
1621 dump_tree_ssa_stats (FILE *file)
1622 {
1623   if (def_blocks || repl_tbl)
1624     fprintf (file, "\nHash table statistics:\n");
1625
1626   if (def_blocks)
1627     {
1628       fprintf (file, "    def_blocks:   ");
1629       htab_statistics (file, def_blocks);
1630     }
1631
1632   if (repl_tbl)
1633     {
1634       fprintf (file, "    repl_tbl:     ");
1635       htab_statistics (file, repl_tbl);
1636     }
1637
1638   if (def_blocks || repl_tbl)
1639     fprintf (file, "\n");
1640 }
1641
1642
1643 /* Dump SSA statistics on stderr.  */
1644
1645 void
1646 debug_tree_ssa_stats (void)
1647 {
1648   dump_tree_ssa_stats (stderr);
1649 }
1650
1651
1652 /* Hashing and equality functions for DEF_BLOCKS.  */
1653
1654 static hashval_t
1655 def_blocks_hash (const void *p)
1656 {
1657   return htab_hash_pointer
1658         ((const void *)((const struct def_blocks_d *)p)->var);
1659 }
1660
1661 static int
1662 def_blocks_eq (const void *p1, const void *p2)
1663 {
1664   return ((const struct def_blocks_d *)p1)->var
1665          == ((const struct def_blocks_d *)p2)->var;
1666 }
1667
1668
1669 /* Free memory allocated by one entry in DEF_BLOCKS.  */
1670
1671 static void
1672 def_blocks_free (void *p)
1673 {
1674   struct def_blocks_d *entry = (struct def_blocks_d *) p;
1675   BITMAP_FREE (entry->def_blocks);
1676   BITMAP_FREE (entry->phi_blocks);
1677   BITMAP_FREE (entry->livein_blocks);
1678   free (entry);
1679 }
1680
1681
1682 /* Callback for htab_traverse to dump the DEF_BLOCKS hash table.  */
1683
1684 static int
1685 debug_def_blocks_r (void **slot, void *data)
1686 {
1687   FILE *file = (FILE *) data;
1688   struct def_blocks_d *db_p = (struct def_blocks_d *) *slot;
1689   
1690   fprintf (file, "VAR: ");
1691   print_generic_expr (file, db_p->var, dump_flags);
1692   bitmap_print (file, db_p->def_blocks, ", DEF_BLOCKS: { ", "}");
1693   bitmap_print (file, db_p->livein_blocks, ", LIVEIN_BLOCKS: { ", "}");
1694   bitmap_print (file, db_p->phi_blocks, ", PHI_BLOCKS: { ", "}\n");
1695
1696   return 1;
1697 }
1698
1699
1700 /* Dump the DEF_BLOCKS hash table on FILE.  */
1701
1702 void
1703 dump_def_blocks (FILE *file)
1704 {
1705   fprintf (file, "\n\nDefinition and live-in blocks:\n\n");
1706   if (def_blocks)
1707     htab_traverse (def_blocks, debug_def_blocks_r, file);
1708 }
1709
1710
1711 /* Dump the DEF_BLOCKS hash table on stderr.  */
1712
1713 void
1714 debug_def_blocks (void)
1715 {
1716   dump_def_blocks (stderr);
1717 }
1718
1719
1720 /* Register NEW_NAME to be the new reaching definition for OLD_NAME.  */
1721
1722 static inline void
1723 register_new_update_single (tree new_name, tree old_name)
1724 {
1725   tree currdef = get_current_def (old_name);
1726
1727   /* Push the current reaching definition into BLOCK_DEFS_STACK.
1728      This stack is later used by the dominator tree callbacks to
1729      restore the reaching definitions for all the variables
1730      defined in the block after a recursive visit to all its
1731      immediately dominated blocks.  */
1732   VEC_reserve (tree, heap, block_defs_stack, 2);
1733   VEC_quick_push (tree, block_defs_stack, currdef);
1734   VEC_quick_push (tree, block_defs_stack, old_name);
1735
1736   /* Set the current reaching definition for OLD_NAME to be
1737      NEW_NAME.  */
1738   set_current_def (old_name, new_name);
1739 }
1740
1741
1742 /* Register NEW_NAME to be the new reaching definition for all the
1743    names in OLD_NAMES.  Used by the incremental SSA update routines to
1744    replace old SSA names with new ones.  */
1745
1746 static inline void
1747 register_new_update_set (tree new_name, bitmap old_names)
1748 {
1749   bitmap_iterator bi;
1750   unsigned i;
1751
1752   EXECUTE_IF_SET_IN_BITMAP (old_names, 0, i, bi)
1753     register_new_update_single (new_name, ssa_name (i));
1754 }
1755
1756
1757 /* Initialization of block data structures for the incremental SSA
1758    update pass.  Create a block local stack of reaching definitions
1759    for new SSA names produced in this block (BLOCK_DEFS).  Register
1760    new definitions for every PHI node in the block.  */
1761
1762 static void
1763 rewrite_update_init_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1764                            basic_block bb)
1765 {
1766   edge e;
1767   edge_iterator ei;
1768   bool is_abnormal_phi;
1769   gimple_stmt_iterator gsi;
1770
1771   if (dump_file && (dump_flags & TDF_DETAILS))
1772     fprintf (dump_file, "\n\nRegistering new PHI nodes in block #%d\n\n",
1773              bb->index);
1774
1775   /* Mark the unwind point for this block.  */
1776   VEC_safe_push (tree, heap, block_defs_stack, NULL_TREE);
1777
1778   if (!bitmap_bit_p (blocks_to_update, bb->index))
1779     return;
1780
1781   /* Mark the LHS if any of the arguments flows through an abnormal
1782      edge.  */
1783   is_abnormal_phi = false;
1784   FOR_EACH_EDGE (e, ei, bb->preds)
1785     if (e->flags & EDGE_ABNORMAL)
1786       {
1787         is_abnormal_phi = true;
1788         break;
1789       }
1790
1791   /* If any of the PHI nodes is a replacement for a name in
1792      OLD_SSA_NAMES or it's one of the names in NEW_SSA_NAMES, then
1793      register it as a new definition for its corresponding name.  Also
1794      register definitions for names whose underlying symbols are
1795      marked for renaming.  */
1796   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1797     {
1798       tree lhs, lhs_sym;
1799       gimple phi = gsi_stmt (gsi);
1800
1801       if (!register_defs_p (phi))
1802         continue;
1803       
1804       lhs = gimple_phi_result (phi);
1805       lhs_sym = SSA_NAME_VAR (lhs);
1806
1807       if (symbol_marked_for_renaming (lhs_sym))
1808         register_new_update_single (lhs, lhs_sym);
1809       else
1810         {
1811
1812           /* If LHS is a new name, register a new definition for all
1813              the names replaced by LHS.  */
1814           if (is_new_name (lhs))
1815             register_new_update_set (lhs, names_replaced_by (lhs));
1816           
1817           /* If LHS is an OLD name, register it as a new definition
1818              for itself.  */
1819           if (is_old_name (lhs))
1820             register_new_update_single (lhs, lhs);
1821         }
1822
1823       if (is_abnormal_phi)
1824         SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs) = 1;
1825     }
1826 }
1827
1828
1829 /* Called after visiting block BB.  Unwind BLOCK_DEFS_STACK to restore
1830    the current reaching definition of every name re-written in BB to
1831    the original reaching definition before visiting BB.  This
1832    unwinding must be done in the opposite order to what is done in
1833    register_new_update_set.  */
1834
1835 static void
1836 rewrite_update_fini_block (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1837                            basic_block bb ATTRIBUTE_UNUSED)
1838 {
1839   while (VEC_length (tree, block_defs_stack) > 0)
1840     {
1841       tree var = VEC_pop (tree, block_defs_stack);
1842       tree saved_def;
1843       
1844       /* NULL indicates the unwind stop point for this block (see
1845          rewrite_update_init_block).  */
1846       if (var == NULL)
1847         return;
1848
1849       saved_def = VEC_pop (tree, block_defs_stack);
1850       set_current_def (var, saved_def);
1851     }
1852 }
1853
1854
1855 /* If the operand pointed to by USE_P is a name in OLD_SSA_NAMES or
1856    it is a symbol marked for renaming, replace it with USE_P's current
1857    reaching definition.  */
1858
1859 static inline void
1860 maybe_replace_use (use_operand_p use_p)
1861 {
1862   tree rdef = NULL_TREE;
1863   tree use = USE_FROM_PTR (use_p);
1864   tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use);
1865
1866   if (symbol_marked_for_renaming (sym))
1867     rdef = get_reaching_def (sym);
1868   else if (is_old_name (use))
1869     rdef = get_reaching_def (use);
1870
1871   if (rdef && rdef != use)
1872     SET_USE (use_p, rdef);
1873 }
1874
1875
1876 /* If the operand pointed to by DEF_P is an SSA name in NEW_SSA_NAMES
1877    or OLD_SSA_NAMES, or if it is a symbol marked for renaming,
1878    register it as the current definition for the names replaced by
1879    DEF_P.  */
1880
1881 static inline void
1882 maybe_register_def (def_operand_p def_p, gimple stmt)
1883 {
1884   tree def = DEF_FROM_PTR (def_p);
1885   tree sym = DECL_P (def) ? def : SSA_NAME_VAR (def);
1886
1887   /* If DEF is a naked symbol that needs renaming, create a new
1888      name for it.  */
1889   if (symbol_marked_for_renaming (sym))
1890     {
1891       if (DECL_P (def))
1892         {
1893           def = make_ssa_name (def, stmt);
1894           SET_DEF (def_p, def);
1895         }
1896
1897       register_new_update_single (def, sym);
1898     }
1899   else
1900     {
1901       /* If DEF is a new name, register it as a new definition
1902          for all the names replaced by DEF.  */
1903       if (is_new_name (def))
1904         register_new_update_set (def, names_replaced_by (def));
1905
1906       /* If DEF is an old name, register DEF as a new
1907          definition for itself.  */
1908       if (is_old_name (def))
1909         register_new_update_single (def, def);
1910     }
1911 }
1912
1913
1914 /* Update every variable used in the statement pointed-to by SI.  The
1915    statement is assumed to be in SSA form already.  Names in
1916    OLD_SSA_NAMES used by SI will be updated to their current reaching
1917    definition.  Names in OLD_SSA_NAMES or NEW_SSA_NAMES defined by SI
1918    will be registered as a new definition for their corresponding name
1919    in OLD_SSA_NAMES.  */
1920
1921 static void
1922 rewrite_update_stmt (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1923                      basic_block bb ATTRIBUTE_UNUSED,
1924                      gimple_stmt_iterator si)
1925 {
1926   gimple stmt;
1927   use_operand_p use_p;
1928   def_operand_p def_p;
1929   ssa_op_iter iter;
1930
1931   stmt = gsi_stmt (si);
1932
1933   gcc_assert (bitmap_bit_p (blocks_to_update, bb->index));
1934
1935   /* Only update marked statements.  */
1936   if (!rewrite_uses_p (stmt) && !register_defs_p (stmt))
1937     return;
1938
1939   if (dump_file && (dump_flags & TDF_DETAILS))
1940     {
1941       fprintf (dump_file, "Updating SSA information for statement ");
1942       print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
1943       fprintf (dump_file, "\n");
1944     }
1945
1946   /* Rewrite USES included in OLD_SSA_NAMES and USES whose underlying
1947      symbol is marked for renaming.  */
1948   if (rewrite_uses_p (stmt))
1949     {
1950       FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
1951         maybe_replace_use (use_p);
1952
1953       if (need_to_update_vops_p)
1954         FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_VIRTUAL_USES)
1955           maybe_replace_use (use_p);
1956     }
1957
1958   /* Register definitions of names in NEW_SSA_NAMES and OLD_SSA_NAMES.
1959      Also register definitions for names whose underlying symbol is
1960      marked for renaming.  */
1961   if (register_defs_p (stmt))
1962     {
1963       FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_DEF)
1964         maybe_register_def (def_p, stmt);
1965
1966       if (need_to_update_vops_p)
1967         FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, iter, SSA_OP_VIRTUAL_DEFS)
1968           maybe_register_def (def_p, stmt);
1969     }
1970 }
1971
1972
1973 /* Visit all the successor blocks of BB looking for PHI nodes.  For
1974    every PHI node found, check if any of its arguments is in
1975    OLD_SSA_NAMES.  If so, and if the argument has a current reaching
1976    definition, replace it.  */
1977
1978 static void
1979 rewrite_update_phi_arguments (struct dom_walk_data *walk_data ATTRIBUTE_UNUSED,
1980                               basic_block bb)
1981 {
1982   edge e;
1983   edge_iterator ei;
1984   unsigned i;
1985
1986   FOR_EACH_EDGE (e, ei, bb->succs)
1987     {
1988       gimple phi;
1989       gimple_vec phis;
1990
1991       if (!bitmap_bit_p (blocks_with_phis_to_rewrite, e->dest->index))
1992         continue;
1993      
1994       phis = VEC_index (gimple_vec, phis_to_rewrite, e->dest->index);
1995       for (i = 0; VEC_iterate (gimple, phis, i, phi); i++)
1996         {
1997           tree arg, lhs_sym, reaching_def = NULL;
1998           use_operand_p arg_p;
1999
2000           gcc_assert (rewrite_uses_p (phi));
2001
2002           arg_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
2003           arg = USE_FROM_PTR (arg_p);
2004
2005           if (arg && !DECL_P (arg) && TREE_CODE (arg) != SSA_NAME)
2006             continue;
2007
2008           lhs_sym = SSA_NAME_VAR (gimple_phi_result (phi));
2009
2010           if (arg == NULL_TREE)
2011             {
2012               /* When updating a PHI node for a recently introduced
2013                  symbol we may find NULL arguments.  That's why we
2014                  take the symbol from the LHS of the PHI node.  */
2015               reaching_def = get_reaching_def (lhs_sym);
2016             }
2017           else
2018             {
2019               tree sym = DECL_P (arg) ? arg : SSA_NAME_VAR (arg);
2020
2021               if (symbol_marked_for_renaming (sym))
2022                 reaching_def = get_reaching_def (sym);
2023               else if (is_old_name (arg))
2024                 reaching_def = get_reaching_def (arg);
2025             }
2026
2027           /* Update the argument if there is a reaching def.  */
2028           if (reaching_def)
2029             {
2030               gimple stmt;
2031               source_location locus;
2032               int arg_i = PHI_ARG_INDEX_FROM_USE (arg_p);
2033
2034               SET_USE (arg_p, reaching_def);
2035               stmt = SSA_NAME_DEF_STMT (reaching_def);
2036
2037               /* Single element PHI nodes  behave like copies, so get the 
2038                  location from the phi argument.  */
2039               if (gimple_code (stmt) == GIMPLE_PHI && 
2040                   gimple_phi_num_args (stmt) == 1)
2041                 locus = gimple_phi_arg_location (stmt, 0);
2042               else
2043                 locus = gimple_location (stmt);
2044
2045               gimple_phi_arg_set_location (phi, arg_i, locus);
2046             }
2047
2048
2049           if (e->flags & EDGE_ABNORMAL)
2050             SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (arg_p)) = 1;
2051         }
2052     }
2053 }
2054
2055
2056 /* Rewrite the actual blocks, statements, and PHI arguments, to be in SSA
2057    form.  
2058
2059    ENTRY indicates the block where to start.  Every block dominated by
2060       ENTRY will be rewritten.
2061
2062    WHAT indicates what actions will be taken by the renamer (see enum
2063       rewrite_mode).
2064
2065    BLOCKS are the set of interesting blocks for the dominator walker
2066       to process.  If this set is NULL, then all the nodes dominated
2067       by ENTRY are walked.  Otherwise, blocks dominated by ENTRY that
2068       are not present in BLOCKS are ignored.  */
2069
2070 static void
2071 rewrite_blocks (basic_block entry, enum rewrite_mode what, sbitmap blocks)
2072 {
2073   struct dom_walk_data walk_data;
2074   
2075   /* Rewrite all the basic blocks in the program.  */
2076   timevar_push (TV_TREE_SSA_REWRITE_BLOCKS);
2077
2078   /* Setup callbacks for the generic dominator tree walker.  */
2079   memset (&walk_data, 0, sizeof (walk_data));
2080
2081   walk_data.dom_direction = CDI_DOMINATORS;
2082   walk_data.interesting_blocks = blocks;
2083
2084   if (what == REWRITE_ALL)
2085     walk_data.before_dom_children_before_stmts = rewrite_initialize_block;
2086   else
2087     walk_data.before_dom_children_before_stmts = rewrite_update_init_block;
2088
2089   if (what == REWRITE_ALL)
2090     walk_data.before_dom_children_walk_stmts = rewrite_stmt;
2091   else if (what == REWRITE_UPDATE)
2092     walk_data.before_dom_children_walk_stmts = rewrite_update_stmt;
2093   else
2094     gcc_unreachable ();
2095
2096   if (what == REWRITE_ALL)
2097     walk_data.before_dom_children_after_stmts = rewrite_add_phi_arguments;
2098   else if (what == REWRITE_UPDATE)
2099     walk_data.before_dom_children_after_stmts = rewrite_update_phi_arguments;
2100   else
2101     gcc_unreachable ();
2102   
2103   if (what == REWRITE_ALL)
2104     walk_data.after_dom_children_after_stmts =  rewrite_finalize_block;
2105   else if (what == REWRITE_UPDATE)
2106     walk_data.after_dom_children_after_stmts = rewrite_update_fini_block;
2107   else
2108     gcc_unreachable ();
2109
2110   block_defs_stack = VEC_alloc (tree, heap, 10);
2111
2112   /* Initialize the dominator walker.  */
2113   init_walk_dominator_tree (&walk_data);
2114
2115   /* Recursively walk the dominator tree rewriting each statement in
2116      each basic block.  */
2117   walk_dominator_tree (&walk_data, entry);
2118
2119   /* Finalize the dominator walker.  */
2120   fini_walk_dominator_tree (&walk_data);
2121
2122   /* Debugging dumps.  */
2123   if (dump_file && (dump_flags & TDF_STATS))
2124     {
2125       dump_dfa_stats (dump_file);
2126       if (def_blocks)
2127         dump_tree_ssa_stats (dump_file);
2128     }
2129   
2130   VEC_free (tree, heap, block_defs_stack);
2131
2132   timevar_pop (TV_TREE_SSA_REWRITE_BLOCKS);
2133 }
2134
2135
2136 /* Block initialization routine for mark_def_sites.  Clear the 
2137    KILLS bitmap at the start of each block.  */
2138
2139 static void
2140 mark_def_sites_initialize_block (struct dom_walk_data *walk_data,
2141                                  basic_block bb ATTRIBUTE_UNUSED)
2142 {
2143   struct mark_def_sites_global_data *gd;
2144   gd = (struct mark_def_sites_global_data *) walk_data->global_data;
2145   bitmap_clear (gd->kills);
2146 }
2147
2148
2149 /* Mark the definition site blocks for each variable, so that we know
2150    where the variable is actually live.
2151
2152    INTERESTING_BLOCKS will be filled in with all the blocks that
2153       should be processed by the renamer.  It is assumed to be
2154       initialized and zeroed by the caller.  */
2155
2156 static void
2157 mark_def_site_blocks (sbitmap interesting_blocks)
2158 {
2159   struct dom_walk_data walk_data;
2160   struct mark_def_sites_global_data mark_def_sites_global_data;
2161
2162   /* Setup callbacks for the generic dominator tree walker to find and
2163      mark definition sites.  */
2164   walk_data.walk_stmts_backward = false;
2165   walk_data.dom_direction = CDI_DOMINATORS;
2166   walk_data.initialize_block_local_data = NULL;
2167   walk_data.before_dom_children_before_stmts = mark_def_sites_initialize_block;
2168   walk_data.before_dom_children_walk_stmts = mark_def_sites;
2169   walk_data.before_dom_children_after_stmts = NULL; 
2170   walk_data.after_dom_children_before_stmts =  NULL;
2171   walk_data.after_dom_children_walk_stmts =  NULL;
2172   walk_data.after_dom_children_after_stmts =  NULL;
2173   walk_data.interesting_blocks = NULL;
2174
2175   /* Notice that this bitmap is indexed using variable UIDs, so it must be
2176      large enough to accommodate all the variables referenced in the
2177      function, not just the ones we are renaming.  */
2178   mark_def_sites_global_data.kills = BITMAP_ALLOC (NULL);
2179
2180   /* Create the set of interesting blocks that will be filled by
2181      mark_def_sites.  */
2182   mark_def_sites_global_data.interesting_blocks = interesting_blocks;
2183   walk_data.global_data = &mark_def_sites_global_data;
2184
2185   /* We do not have any local data.  */
2186   walk_data.block_local_data_size = 0;
2187
2188   /* Initialize the dominator walker.  */
2189   init_walk_dominator_tree (&walk_data);
2190
2191   /* Recursively walk the dominator tree.  */
2192   walk_dominator_tree (&walk_data, ENTRY_BLOCK_PTR);
2193
2194   /* Finalize the dominator walker.  */
2195   fini_walk_dominator_tree (&walk_data);
2196
2197   /* We no longer need this bitmap, clear and free it.  */
2198   BITMAP_FREE (mark_def_sites_global_data.kills);
2199 }
2200
2201
2202 /* Initialize internal data needed during renaming.  */
2203
2204 static void
2205 init_ssa_renamer (void)
2206 {
2207   tree var;
2208   referenced_var_iterator rvi;
2209
2210   cfun->gimple_df->in_ssa_p = false;
2211
2212   /* Allocate memory for the DEF_BLOCKS hash table.  */
2213   gcc_assert (def_blocks == NULL);
2214   def_blocks = htab_create (num_referenced_vars, def_blocks_hash,
2215                             def_blocks_eq, def_blocks_free);
2216
2217   FOR_EACH_REFERENCED_VAR(var, rvi)
2218     set_current_def (var, NULL_TREE);
2219 }
2220
2221
2222 /* Deallocate internal data structures used by the renamer.  */
2223
2224 static void
2225 fini_ssa_renamer (void)
2226 {
2227   if (def_blocks)
2228     {
2229       htab_delete (def_blocks);
2230       def_blocks = NULL;
2231     }
2232
2233   cfun->gimple_df->in_ssa_p = true;
2234 }
2235
2236 /* Main entry point into the SSA builder.  The renaming process
2237    proceeds in four main phases:
2238
2239    1- Compute dominance frontier and immediate dominators, needed to
2240       insert PHI nodes and rename the function in dominator tree
2241       order.
2242
2243    2- Find and mark all the blocks that define variables
2244       (mark_def_site_blocks).
2245
2246    3- Insert PHI nodes at dominance frontiers (insert_phi_nodes).
2247
2248    4- Rename all the blocks (rewrite_blocks) and statements in the program.
2249
2250    Steps 3 and 4 are done using the dominator tree walker
2251    (walk_dominator_tree).  */
2252
2253 static unsigned int
2254 rewrite_into_ssa (void)
2255 {
2256   bitmap *dfs;
2257   basic_block bb;
2258   sbitmap interesting_blocks;
2259   
2260   timevar_push (TV_TREE_SSA_OTHER);
2261
2262   /* Initialize operand data structures.  */
2263   init_ssa_operands ();
2264
2265   /* Initialize internal data needed by the renamer.  */
2266   init_ssa_renamer ();
2267
2268   /* Initialize the set of interesting blocks.  The callback
2269      mark_def_sites will add to this set those blocks that the renamer
2270      should process.  */
2271   interesting_blocks = sbitmap_alloc (last_basic_block);
2272   sbitmap_zero (interesting_blocks);
2273
2274   /* Initialize dominance frontier.  */
2275   dfs = XNEWVEC (bitmap, last_basic_block);
2276   FOR_EACH_BB (bb)
2277     dfs[bb->index] = BITMAP_ALLOC (NULL);
2278
2279   /* 1- Compute dominance frontiers.  */
2280   calculate_dominance_info (CDI_DOMINATORS);
2281   compute_dominance_frontiers (dfs);
2282
2283   /* 2- Find and mark definition sites.  */
2284   mark_def_site_blocks (interesting_blocks);
2285
2286   /* 3- Insert PHI nodes at dominance frontiers of definition blocks.  */
2287   insert_phi_nodes (dfs);
2288
2289   /* 4- Rename all the blocks.  */
2290   rewrite_blocks (ENTRY_BLOCK_PTR, REWRITE_ALL, interesting_blocks);
2291
2292   /* Free allocated memory.  */
2293   FOR_EACH_BB (bb)
2294     BITMAP_FREE (dfs[bb->index]);
2295   free (dfs);
2296   sbitmap_free (interesting_blocks);
2297
2298   fini_ssa_renamer ();
2299
2300   timevar_pop (TV_TREE_SSA_OTHER);
2301   return 0;
2302 }
2303
2304
2305 struct gimple_opt_pass pass_build_ssa = 
2306 {
2307  {
2308   GIMPLE_PASS,
2309   "ssa",                                /* name */
2310   NULL,                                 /* gate */
2311   rewrite_into_ssa,                     /* execute */
2312   NULL,                                 /* sub */
2313   NULL,                                 /* next */
2314   0,                                    /* static_pass_number */
2315   0,                                    /* tv_id */
2316   PROP_cfg | PROP_referenced_vars,      /* properties_required */
2317   PROP_ssa,                             /* properties_provided */
2318   0,                                    /* properties_destroyed */
2319   0,                                    /* todo_flags_start */
2320   TODO_dump_func
2321     | TODO_verify_ssa
2322     | TODO_remove_unused_locals         /* todo_flags_finish */
2323  }
2324 };
2325
2326
2327 /* Mark the definition of VAR at STMT and BB as interesting for the
2328    renamer.  BLOCKS is the set of blocks that need updating.  */
2329
2330 static void
2331 mark_def_interesting (tree var, gimple stmt, basic_block bb, bool insert_phi_p)
2332 {
2333   gcc_assert (bitmap_bit_p (blocks_to_update, bb->index));
2334   set_register_defs (stmt, true);
2335
2336   if (insert_phi_p)
2337     {
2338       bool is_phi_p = gimple_code (stmt) == GIMPLE_PHI;
2339
2340       set_def_block (var, bb, is_phi_p);
2341
2342       /* If VAR is an SSA name in NEW_SSA_NAMES, this is a definition
2343          site for both itself and all the old names replaced by it.  */
2344       if (TREE_CODE (var) == SSA_NAME && is_new_name (var))
2345         {
2346           bitmap_iterator bi;
2347           unsigned i;
2348           bitmap set = names_replaced_by (var);
2349           if (set)
2350             EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2351               set_def_block (ssa_name (i), bb, is_phi_p);
2352         }
2353     }
2354 }
2355
2356
2357 /* Mark the use of VAR at STMT and BB as interesting for the
2358    renamer.  INSERT_PHI_P is true if we are going to insert new PHI
2359    nodes.  */
2360
2361 static inline void
2362 mark_use_interesting (tree var, gimple stmt, basic_block bb, bool insert_phi_p)
2363 {
2364   basic_block def_bb = gimple_bb (stmt);
2365
2366   mark_block_for_update (def_bb);
2367   mark_block_for_update (bb);
2368
2369   if (gimple_code (stmt) == GIMPLE_PHI)
2370     mark_phi_for_rewrite (def_bb, stmt);
2371   else
2372     set_rewrite_uses (stmt, true);
2373
2374   /* If VAR has not been defined in BB, then it is live-on-entry
2375      to BB.  Note that we cannot just use the block holding VAR's
2376      definition because if VAR is one of the names in OLD_SSA_NAMES,
2377      it will have several definitions (itself and all the names that
2378      replace it).  */
2379   if (insert_phi_p)
2380     {
2381       struct def_blocks_d *db_p = get_def_blocks_for (var);
2382       if (!bitmap_bit_p (db_p->def_blocks, bb->index))
2383         set_livein_block (var, bb);
2384     }
2385 }
2386
2387
2388 /* Do a dominator walk starting at BB processing statements that
2389    reference symbols in SYMS_TO_RENAME.  This is very similar to
2390    mark_def_sites, but the scan handles statements whose operands may
2391    already be SSA names.
2392
2393    If INSERT_PHI_P is true, mark those uses as live in the
2394    corresponding block.  This is later used by the PHI placement
2395    algorithm to make PHI pruning decisions.
2396
2397    FIXME.  Most of this would be unnecessary if we could associate a
2398            symbol to all the SSA names that reference it.  But that
2399            sounds like it would be expensive to maintain.  Still, it
2400            would be interesting to see if it makes better sense to do
2401            that.  */
2402
2403 static void
2404 prepare_block_for_update (basic_block bb, bool insert_phi_p)
2405 {
2406   basic_block son;
2407   gimple_stmt_iterator si;
2408   edge e;
2409   edge_iterator ei;
2410
2411   mark_block_for_update (bb);
2412
2413   /* Process PHI nodes marking interesting those that define or use
2414      the symbols that we are interested in.  */
2415   for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
2416     {
2417       gimple phi = gsi_stmt (si);
2418       tree lhs_sym, lhs = gimple_phi_result (phi);
2419
2420       lhs_sym = DECL_P (lhs) ? lhs : SSA_NAME_VAR (lhs);
2421
2422       if (!symbol_marked_for_renaming (lhs_sym))
2423         continue;
2424
2425       mark_def_interesting (lhs_sym, phi, bb, insert_phi_p);
2426
2427       /* Mark the uses in phi nodes as interesting.  It would be more correct
2428          to process the arguments of the phi nodes of the successor edges of
2429          BB at the end of prepare_block_for_update, however, that turns out
2430          to be significantly more expensive.  Doing it here is conservatively
2431          correct -- it may only cause us to believe a value to be live in a
2432          block that also contains its definition, and thus insert a few more
2433          phi nodes for it.  */
2434       FOR_EACH_EDGE (e, ei, bb->preds)
2435         mark_use_interesting (lhs_sym, phi, e->src, insert_phi_p);
2436     }
2437
2438   /* Process the statements.  */
2439   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
2440     {
2441       gimple stmt;
2442       ssa_op_iter i;
2443       use_operand_p use_p;
2444       def_operand_p def_p;
2445       
2446       stmt = gsi_stmt (si);
2447
2448       FOR_EACH_SSA_USE_OPERAND (use_p, stmt, i, SSA_OP_ALL_USES)
2449         {
2450           tree use = USE_FROM_PTR (use_p);
2451           tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use);
2452           if (symbol_marked_for_renaming (sym))
2453             mark_use_interesting (sym, stmt, bb, insert_phi_p);
2454         }
2455
2456       FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, i, SSA_OP_ALL_DEFS)
2457         {
2458           tree def = DEF_FROM_PTR (def_p);
2459           tree sym = DECL_P (def) ? def : SSA_NAME_VAR (def);
2460           if (symbol_marked_for_renaming (sym))
2461             mark_def_interesting (sym, stmt, bb, insert_phi_p);
2462         }
2463     }
2464
2465   /* Now visit all the blocks dominated by BB.  */
2466   for (son = first_dom_son (CDI_DOMINATORS, bb);
2467        son;
2468        son = next_dom_son (CDI_DOMINATORS, son))
2469     prepare_block_for_update (son, insert_phi_p);
2470 }
2471
2472
2473 /* Helper for prepare_names_to_update.  Mark all the use sites for
2474    NAME as interesting.  BLOCKS and INSERT_PHI_P are as in
2475    prepare_names_to_update.  */
2476
2477 static void
2478 prepare_use_sites_for (tree name, bool insert_phi_p)
2479 {
2480   use_operand_p use_p;
2481   imm_use_iterator iter;
2482
2483   FOR_EACH_IMM_USE_FAST (use_p, iter, name)
2484     {
2485       gimple stmt = USE_STMT (use_p);
2486       basic_block bb = gimple_bb (stmt);
2487
2488       if (gimple_code (stmt) == GIMPLE_PHI)
2489         {
2490           int ix = PHI_ARG_INDEX_FROM_USE (use_p);
2491           edge e = gimple_phi_arg_edge (stmt, ix);
2492           mark_use_interesting (name, stmt, e->src, insert_phi_p);
2493         }
2494       else
2495         {
2496           /* For regular statements, mark this as an interesting use
2497              for NAME.  */
2498           mark_use_interesting (name, stmt, bb, insert_phi_p);
2499         }
2500     }
2501 }
2502
2503
2504 /* Helper for prepare_names_to_update.  Mark the definition site for
2505    NAME as interesting.  BLOCKS and INSERT_PHI_P are as in
2506    prepare_names_to_update.  */
2507
2508 static void
2509 prepare_def_site_for (tree name, bool insert_phi_p)
2510 {
2511   gimple stmt;
2512   basic_block bb;
2513
2514   gcc_assert (names_to_release == NULL
2515               || !bitmap_bit_p (names_to_release, SSA_NAME_VERSION (name)));
2516
2517   stmt = SSA_NAME_DEF_STMT (name);
2518   bb = gimple_bb (stmt);
2519   if (bb)
2520     {
2521       gcc_assert (bb->index < last_basic_block);
2522       mark_block_for_update (bb);
2523       mark_def_interesting (name, stmt, bb, insert_phi_p);
2524     }
2525 }
2526
2527
2528 /* Mark definition and use sites of names in NEW_SSA_NAMES and
2529    OLD_SSA_NAMES.  INSERT_PHI_P is true if the caller wants to insert
2530    PHI nodes for newly created names.  */
2531
2532 static void
2533 prepare_names_to_update (bool insert_phi_p)
2534 {
2535   unsigned i = 0;
2536   bitmap_iterator bi;
2537   sbitmap_iterator sbi;
2538
2539   /* If a name N from NEW_SSA_NAMES is also marked to be released,
2540      remove it from NEW_SSA_NAMES so that we don't try to visit its
2541      defining basic block (which most likely doesn't exist).  Notice
2542      that we cannot do the same with names in OLD_SSA_NAMES because we
2543      want to replace existing instances.  */
2544   if (names_to_release)
2545     EXECUTE_IF_SET_IN_BITMAP (names_to_release, 0, i, bi)
2546       RESET_BIT (new_ssa_names, i);
2547
2548   /* First process names in NEW_SSA_NAMES.  Otherwise, uses of old
2549      names may be considered to be live-in on blocks that contain
2550      definitions for their replacements.  */
2551   EXECUTE_IF_SET_IN_SBITMAP (new_ssa_names, 0, i, sbi)
2552     prepare_def_site_for (ssa_name (i), insert_phi_p);
2553
2554   /* If an old name is in NAMES_TO_RELEASE, we cannot remove it from
2555      OLD_SSA_NAMES, but we have to ignore its definition site.  */
2556   EXECUTE_IF_SET_IN_SBITMAP (old_ssa_names, 0, i, sbi)
2557     {
2558       if (names_to_release == NULL || !bitmap_bit_p (names_to_release, i))
2559         prepare_def_site_for (ssa_name (i), insert_phi_p);
2560       prepare_use_sites_for (ssa_name (i), insert_phi_p);
2561     }
2562 }
2563
2564
2565 /* Dump all the names replaced by NAME to FILE.  */
2566
2567 void
2568 dump_names_replaced_by (FILE *file, tree name)
2569 {
2570   unsigned i;
2571   bitmap old_set;
2572   bitmap_iterator bi;
2573
2574   print_generic_expr (file, name, 0);
2575   fprintf (file, " -> { ");
2576
2577   old_set = names_replaced_by (name);
2578   EXECUTE_IF_SET_IN_BITMAP (old_set, 0, i, bi)
2579     {
2580       print_generic_expr (file, ssa_name (i), 0);
2581       fprintf (file, " ");
2582     }
2583
2584   fprintf (file, "}\n");
2585 }
2586
2587
2588 /* Dump all the names replaced by NAME to stderr.  */
2589
2590 void
2591 debug_names_replaced_by (tree name)
2592 {
2593   dump_names_replaced_by (stderr, name);
2594 }
2595
2596
2597 /* Dump SSA update information to FILE.  */
2598
2599 void
2600 dump_update_ssa (FILE *file)
2601 {
2602   unsigned i = 0;
2603   bitmap_iterator bi;
2604
2605   if (!need_ssa_update_p ())
2606     return;
2607
2608   if (new_ssa_names && sbitmap_first_set_bit (new_ssa_names) >= 0)
2609     {
2610       sbitmap_iterator sbi;
2611
2612       fprintf (file, "\nSSA replacement table\n");
2613       fprintf (file, "N_i -> { O_1 ... O_j } means that N_i replaces "
2614                      "O_1, ..., O_j\n\n");
2615
2616       EXECUTE_IF_SET_IN_SBITMAP (new_ssa_names, 0, i, sbi)
2617         dump_names_replaced_by (file, ssa_name (i));
2618
2619       fprintf (file, "\n");
2620       fprintf (file, "Number of virtual NEW -> OLD mappings: %7u\n",
2621                update_ssa_stats.num_virtual_mappings);
2622       fprintf (file, "Number of real NEW -> OLD mappings:    %7u\n",
2623                update_ssa_stats.num_total_mappings
2624                - update_ssa_stats.num_virtual_mappings);
2625       fprintf (file, "Number of total NEW -> OLD mappings:   %7u\n",
2626                update_ssa_stats.num_total_mappings);
2627
2628       fprintf (file, "\nNumber of virtual symbols: %u\n",
2629                update_ssa_stats.num_virtual_symbols);
2630     }
2631
2632   if (syms_to_rename && !bitmap_empty_p (syms_to_rename))
2633     {
2634       fprintf (file, "\n\nSymbols to be put in SSA form\n\n");
2635       dump_decl_set (file, syms_to_rename);
2636     }
2637
2638   if (names_to_release && !bitmap_empty_p (names_to_release))
2639     {
2640       fprintf (file, "\n\nSSA names to release after updating the SSA web\n\n");
2641       EXECUTE_IF_SET_IN_BITMAP (names_to_release, 0, i, bi)
2642         {
2643           print_generic_expr (file, ssa_name (i), 0);
2644           fprintf (file, " ");
2645         }
2646     }
2647
2648   fprintf (file, "\n\n");
2649 }
2650
2651
2652 /* Dump SSA update information to stderr.  */
2653
2654 void
2655 debug_update_ssa (void)
2656 {
2657   dump_update_ssa (stderr);
2658 }
2659
2660
2661 /* Initialize data structures used for incremental SSA updates.  */
2662
2663 static void
2664 init_update_ssa (void)
2665 {
2666   /* Reserve more space than the current number of names.  The calls to
2667      add_new_name_mapping are typically done after creating new SSA
2668      names, so we'll need to reallocate these arrays.  */
2669   old_ssa_names = sbitmap_alloc (num_ssa_names + NAME_SETS_GROWTH_FACTOR);
2670   sbitmap_zero (old_ssa_names);
2671
2672   new_ssa_names = sbitmap_alloc (num_ssa_names + NAME_SETS_GROWTH_FACTOR);
2673   sbitmap_zero (new_ssa_names);
2674
2675   repl_tbl = htab_create (20, repl_map_hash, repl_map_eq, repl_map_free);
2676   need_to_initialize_update_ssa_p = false;
2677   need_to_update_vops_p = false;
2678   syms_to_rename = BITMAP_ALLOC (NULL);
2679   regs_to_rename = BITMAP_ALLOC (NULL);
2680   mem_syms_to_rename = BITMAP_ALLOC (NULL);
2681   names_to_release = NULL;
2682   memset (&update_ssa_stats, 0, sizeof (update_ssa_stats));
2683   update_ssa_stats.virtual_symbols = BITMAP_ALLOC (NULL);
2684 }
2685
2686
2687 /* Deallocate data structures used for incremental SSA updates.  */
2688
2689 void
2690 delete_update_ssa (void)
2691 {
2692   unsigned i;
2693   bitmap_iterator bi;
2694
2695   sbitmap_free (old_ssa_names);
2696   old_ssa_names = NULL;
2697
2698   sbitmap_free (new_ssa_names);
2699   new_ssa_names = NULL;
2700
2701   htab_delete (repl_tbl);
2702   repl_tbl = NULL;
2703
2704   need_to_initialize_update_ssa_p = true;
2705   need_to_update_vops_p = false;
2706   BITMAP_FREE (syms_to_rename);
2707   BITMAP_FREE (regs_to_rename);
2708   BITMAP_FREE (mem_syms_to_rename);
2709   BITMAP_FREE (update_ssa_stats.virtual_symbols);
2710
2711   if (names_to_release)
2712     {
2713       EXECUTE_IF_SET_IN_BITMAP (names_to_release, 0, i, bi)
2714         release_ssa_name&