diff options
Diffstat (limited to 'gcc/tree-ssa-live.c')
| -rw-r--r-- | gcc/tree-ssa-live.c | 375 |
1 files changed, 131 insertions, 244 deletions
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c index 8f504f005fe..294a5d49861 100644 --- a/gcc/tree-ssa-live.c +++ b/gcc/tree-ssa-live.c @@ -24,11 +24,11 @@ along with GCC; see the file COPYING3. If not see #include "coretypes.h" #include "tm.h" #include "tree.h" -#include "tree-pretty-print.h" #include "gimple-pretty-print.h" #include "bitmap.h" #include "tree-flow.h" -#include "tree-dump.h" +#include "timevar.h" +#include "dumpfile.h" #include "tree-ssa-live.h" #include "diagnostic-core.h" #include "debug.h" @@ -59,59 +59,57 @@ static void verify_live_on_entry (tree_live_info_p); static void var_map_base_init (var_map map) { - int x, num_part, num; + int x, num_part; tree var; - var_ann_t ann; + htab_t tree_to_index; + struct tree_int_map *m, *mapstorage; - num = 0; num_part = num_var_partitions (map); + tree_to_index = htab_create (num_part, tree_map_base_hash, + tree_int_map_eq, NULL); + /* We can have at most num_part entries in the hash tables, so it's + enough to allocate so many map elements once, saving some malloc + calls. */ + mapstorage = m = XNEWVEC (struct tree_int_map, num_part); /* If a base table already exists, clear it, otherwise create it. */ - if (map->partition_to_base_index != NULL) - { - free (map->partition_to_base_index); - VEC_truncate (tree, map->basevars, 0); - } - else - map->basevars = VEC_alloc (tree, heap, MAX (40, (num_part / 10))); - + free (map->partition_to_base_index); map->partition_to_base_index = (int *) xmalloc (sizeof (int) * num_part); /* Build the base variable list, and point partitions at their bases. */ for (x = 0; x < num_part; x++) { + struct tree_int_map **slot; + unsigned baseindex; var = partition_to_var (map, x); - if (TREE_CODE (var) == SSA_NAME) - var = SSA_NAME_VAR (var); - ann = var_ann (var); + if (SSA_NAME_VAR (var)) + m->base.from = SSA_NAME_VAR (var); + else + /* This restricts what anonymous SSA names we can coalesce + as it restricts the sets we compute conflicts for. + Using TREE_TYPE to generate sets is the easies as + type equivalency also holds for SSA names with the same + underlying decl. */ + m->base.from = TREE_TYPE (var); /* If base variable hasn't been seen, set it up. */ - if (!ann->base_var_processed) - { - ann->base_var_processed = 1; - VAR_ANN_BASE_INDEX (ann) = num++; - VEC_safe_push (tree, heap, map->basevars, var); + slot = (struct tree_int_map **) htab_find_slot (tree_to_index, + m, INSERT); + if (!*slot) + { + baseindex = m - mapstorage; + m->to = baseindex; + *slot = m; + m++; } - map->partition_to_base_index[x] = VAR_ANN_BASE_INDEX (ann); + else + baseindex = (*slot)->to; + map->partition_to_base_index[x] = baseindex; } - map->num_basevars = num; + map->num_basevars = m - mapstorage; - /* Now clear the processed bit. */ - for (x = 0; x < num; x++) - { - var = VEC_index (tree, map->basevars, x); - var_ann (var)->base_var_processed = 0; - } - -#ifdef ENABLE_CHECKING - for (x = 0; x < num_part; x++) - { - tree var2; - var = SSA_NAME_VAR (partition_to_var (map, x)); - var2 = VEC_index (tree, map->basevars, basevar_index (map, x)); - gcc_assert (var == var2); - } -#endif + free (mapstorage); + htab_delete (tree_to_index); } @@ -123,7 +121,6 @@ var_map_base_fini (var_map map) /* Free the basevar info if it is present. */ if (map->partition_to_base_index != NULL) { - VEC_free (tree, heap, map->basevars); free (map->partition_to_base_index); map->partition_to_base_index = NULL; map->num_basevars = 0; @@ -145,7 +142,6 @@ init_var_map (int size) map->partition_size = size; map->num_basevars = 0; map->partition_to_base_index = NULL; - map->basevars = NULL; return map; } @@ -244,7 +240,7 @@ partition_view_init (var_map map) for (x = 0; x < map->partition_size; x++) { tmp = partition_find (map->var_partition, x); - if (ssa_name (tmp) != NULL_TREE && is_gimple_reg (ssa_name (tmp)) + if (ssa_name (tmp) != NULL_TREE && !virtual_operand_p (ssa_name (tmp)) && (!has_zero_uses (ssa_name (tmp)) || !SSA_NAME_IS_DEFAULT_DEF (ssa_name (tmp)))) bitmap_set_bit (used, tmp); @@ -297,7 +293,7 @@ partition_view_fini (var_map map, bitmap selected) /* Create a partition view which includes all the used partitions in MAP. If WANT_BASES is true, create the base variable map as well. */ -extern void +void partition_view_normal (var_map map, bool want_bases) { bitmap used; @@ -316,7 +312,7 @@ partition_view_normal (var_map map, bool want_bases) the bitmap ONLY. If WANT_BASES is true, create the base variable map as well. */ -extern void +void partition_view_bitmap (var_map map, bitmap only, bool want_bases) { bitmap used; @@ -333,7 +329,6 @@ partition_view_bitmap (var_map map, bitmap only, bool want_bases) } partition_view_fini (map, new_partitions); - BITMAP_FREE (used); if (want_bases) var_map_base_init (map); else @@ -341,20 +336,43 @@ partition_view_bitmap (var_map map, bitmap only, bool want_bases) } -static inline void mark_all_vars_used (tree *, void *data); +static bitmap usedvars; + +/* Mark VAR as used, so that it'll be preserved during rtl expansion. + Returns true if VAR wasn't marked before. */ + +static inline bool +set_is_used (tree var) +{ + return bitmap_set_bit (usedvars, DECL_UID (var)); +} + +/* Return true if VAR is marked as used. */ + +static inline bool +is_used_p (tree var) +{ + return bitmap_bit_p (usedvars, DECL_UID (var)); +} + +static inline void mark_all_vars_used (tree *); /* Helper function for mark_all_vars_used, called via walk_tree. */ static tree -mark_all_vars_used_1 (tree *tp, int *walk_subtrees, void *data) +mark_all_vars_used_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) { - bitmap global_unused_vars = (bitmap)data; tree t = *tp; enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t)); tree b; if (TREE_CODE (t) == SSA_NAME) - t = SSA_NAME_VAR (t); + { + *walk_subtrees = 0; + t = SSA_NAME_VAR (t); + if (!t) + return NULL; + } if (IS_EXPR_CODE_CLASS (c) && (b = TREE_BLOCK (t)) != NULL) @@ -364,9 +382,9 @@ mark_all_vars_used_1 (tree *tp, int *walk_subtrees, void *data) fields do not contain vars. */ if (TREE_CODE (t) == TARGET_MEM_REF) { - mark_all_vars_used (&TMR_BASE (t), data); - mark_all_vars_used (&TMR_INDEX (t), data); - mark_all_vars_used (&TMR_INDEX2 (t), data); + mark_all_vars_used (&TMR_BASE (t)); + mark_all_vars_used (&TMR_INDEX (t)); + mark_all_vars_used (&TMR_INDEX2 (t)); *walk_subtrees = 0; return NULL; } @@ -375,16 +393,10 @@ mark_all_vars_used_1 (tree *tp, int *walk_subtrees, void *data) eliminated as unused. */ if (TREE_CODE (t) == VAR_DECL) { - /* Global vars do not have a var-annotation so their use is tracked - with the global_unused_vars bitmap. Also walk their initializer - when they are first recognized as used. */ - if (is_global_var (t)) - { - if (bitmap_clear_bit (global_unused_vars, DECL_UID (t))) - mark_all_vars_used (&DECL_INITIAL (t), data); - } - else - set_is_used (t); + /* When a global var becomes used for the first time also walk its + initializer (non global ones don't have any). */ + if (set_is_used (t) && is_global_var (t)) + mark_all_vars_used (&DECL_INITIAL (t)); } /* remove_unused_scope_block_p requires information about labels which are not DECL_IGNORED_P to tell if they might be used in the IL. */ @@ -429,7 +441,7 @@ mark_scope_block_unused (tree scope) done by the inliner. */ static bool -remove_unused_scope_block_p (tree scope, bitmap global_unused_vars) +remove_unused_scope_block_p (tree scope) { tree *t, *next; bool unused = !TREE_USED (scope); @@ -469,9 +481,7 @@ remove_unused_scope_block_p (tree scope, bitmap global_unused_vars) info about optimized-out variables in the scope blocks. Exception are the scope blocks not containing any instructions at all so user can't get into the scopes at first place. */ - else if ((is_global_var (*t) - && !bitmap_bit_p (global_unused_vars, DECL_UID (*t))) - || (var_ann (*t) != NULL && is_used_p (*t))) + else if (is_used_p (*t)) unused = false; else if (TREE_CODE (*t) == LABEL_DECL && TREE_USED (*t)) /* For labels that are still used in the IL, the decision to @@ -516,7 +526,7 @@ remove_unused_scope_block_p (tree scope, bitmap global_unused_vars) } for (t = &BLOCK_SUBBLOCKS (scope); *t ;) - if (remove_unused_scope_block_p (*t, global_unused_vars)) + if (remove_unused_scope_block_p (*t)) { if (BLOCK_SUBBLOCKS (*t)) { @@ -597,9 +607,9 @@ remove_unused_scope_block_p (tree scope, bitmap global_unused_vars) eliminated during the tree->rtl conversion process. */ static inline void -mark_all_vars_used (tree *expr_p, void *data) +mark_all_vars_used (tree *expr_p) { - walk_tree (expr_p, mark_all_vars_used_1, data, NULL); + walk_tree (expr_p, mark_all_vars_used_1, NULL, NULL); } @@ -635,14 +645,9 @@ dump_scope_block (FILE *file, int indent, tree scope, int flags) fprintf (file, " \n"); for (var = BLOCK_VARS (scope); var; var = DECL_CHAIN (var)) { - bool used = false; - - if (var_ann (var)) - used = is_used_p (var); - fprintf (file, "%*s", indent, ""); print_generic_decl (file, var, flags); - fprintf (file, "%s\n", used ? "" : " (unused)"); + fprintf (file, "\n"); } for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (scope); i++) { @@ -691,10 +696,8 @@ void remove_unused_locals (void) { basic_block bb; - tree var, t; - referenced_var_iterator rvi; - bitmap global_unused_vars = NULL; - unsigned srcidx, dstidx, num, ix; + tree var; + unsigned srcidx, dstidx, num; bool have_local_clobbers = false; /* Removing declarations from lexical blocks when not optimizing is @@ -707,16 +710,7 @@ remove_unused_locals (void) mark_scope_block_unused (DECL_INITIAL (current_function_decl)); - /* Assume all locals are unused. */ - FOR_EACH_REFERENCED_VAR (cfun, t, rvi) - clear_is_used (t); - - /* Assume all globals in local decls are unused. */ - global_unused_vars = BITMAP_ALLOC (NULL); - FOR_EACH_LOCAL_DECL (cfun, ix, var) - if (TREE_CODE (var) == VAR_DECL - && is_global_var (var)) - bitmap_set_bit (global_unused_vars, DECL_UID (var)); + usedvars = BITMAP_ALLOC (NULL); /* Walk the CFG marking all referenced symbols. */ FOR_EACH_BB (bb) @@ -745,8 +739,7 @@ remove_unused_locals (void) TREE_USED (b) = true; for (i = 0; i < gimple_num_ops (stmt); i++) - mark_all_vars_used (gimple_op_ptr (gsi_stmt (gsi), i), - global_unused_vars); + mark_all_vars_used (gimple_op_ptr (gsi_stmt (gsi), i)); } for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) @@ -756,16 +749,16 @@ remove_unused_locals (void) tree def; gimple phi = gsi_stmt (gsi); - if (!is_gimple_reg (gimple_phi_result (phi))) + if (virtual_operand_p (gimple_phi_result (phi))) continue; def = gimple_phi_result (phi); - mark_all_vars_used (&def, global_unused_vars); + mark_all_vars_used (&def); FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_ALL_USES) { tree arg = USE_FROM_PTR (arg_p); - mark_all_vars_used (&arg, global_unused_vars); + mark_all_vars_used (&arg); } } @@ -792,13 +785,7 @@ remove_unused_locals (void) if (gimple_clobber_p (stmt)) { tree lhs = gimple_assign_lhs (stmt); - lhs = get_base_address (lhs); - if (TREE_CODE (lhs) == SSA_NAME) - lhs = SSA_NAME_VAR (lhs); - if (TREE_CODE (lhs) == VAR_DECL - && ((is_global_var (lhs) - && bitmap_bit_p (global_unused_vars, DECL_UID (lhs))) - || (!is_global_var (lhs) && !is_used_p (lhs)))) + if (TREE_CODE (lhs) == VAR_DECL && !is_used_p (lhs)) { unlink_stmt_vdef (stmt); gsi_remove (&gsi, true); @@ -814,27 +801,25 @@ remove_unused_locals (void) cfun->has_local_explicit_reg_vars = false; - /* Remove unmarked local and global vars from local_decls - and referenced vars. */ + /* Remove unmarked local and global vars from local_decls. */ num = VEC_length (tree, cfun->local_decls); for (srcidx = 0, dstidx = 0; srcidx < num; srcidx++) { var = VEC_index (tree, cfun->local_decls, srcidx); if (TREE_CODE (var) == VAR_DECL) { - if (is_global_var (var)) - { - if (bitmap_bit_p (global_unused_vars, DECL_UID (var))) - continue; - } - else if (var_ann (var) == NULL - || !is_used_p (var)) + if (!is_used_p (var)) { - if (var_ann (var)) - remove_referenced_var (var); + tree def; if (cfun->nonlocal_goto_save_area && TREE_OPERAND (cfun->nonlocal_goto_save_area, 0) == var) cfun->nonlocal_goto_save_area = NULL; + /* Release any default def associated with var. */ + if ((def = ssa_default_def (cfun, var)) != NULL_TREE) + { + set_ssa_default_def (cfun, var, NULL_TREE); + release_ssa_name (def); + } continue; } } @@ -850,18 +835,9 @@ remove_unused_locals (void) if (dstidx != num) VEC_truncate (tree, cfun->local_decls, dstidx); - /* ??? We end up with decls in referenced-vars that are not in - local-decls. */ - FOR_EACH_REFERENCED_VAR (cfun, t, rvi) - if (TREE_CODE (t) == VAR_DECL - && !VAR_DECL_IS_VIRTUAL_OPERAND (t) - && !is_used_p (t)) - remove_referenced_var (t); + remove_unused_scope_block_p (DECL_INITIAL (current_function_decl)); - remove_unused_scope_block_p (DECL_INITIAL (current_function_decl), - global_unused_vars); - - BITMAP_FREE (global_unused_vars); + BITMAP_FREE (usedvars); if (dump_file && (dump_flags & TDF_DETAILS)) { @@ -872,6 +848,12 @@ remove_unused_locals (void) timevar_pop (TV_REMOVE_UNUSED); } +/* Obstack for globale liveness info bitmaps. We don't want to put these + on the default obstack because these bitmaps can grow quite large and + we'll hold on to all that memory until the end of the compiler run. + As a bonus, delete_tree_live_info can destroy all the bitmaps by just + releasing the whole obstack. */ +static bitmap_obstack liveness_bitmap_obstack; /* Allocate and return a new live range information object base on MAP. */ @@ -879,24 +861,24 @@ static tree_live_info_p new_tree_live_info (var_map map) { tree_live_info_p live; - unsigned x; + basic_block bb; - live = (tree_live_info_p) xmalloc (sizeof (struct tree_live_info_d)); + live = XNEW (struct tree_live_info_d); live->map = map; live->num_blocks = last_basic_block; - live->livein = (bitmap *)xmalloc (last_basic_block * sizeof (bitmap)); - for (x = 0; x < (unsigned)last_basic_block; x++) - live->livein[x] = BITMAP_ALLOC (NULL); + live->livein = XNEWVEC (bitmap_head, last_basic_block); + FOR_EACH_BB (bb) + bitmap_initialize (&live->livein[bb->index], &liveness_bitmap_obstack); - live->liveout = (bitmap *)xmalloc (last_basic_block * sizeof (bitmap)); - for (x = 0; x < (unsigned)last_basic_block; x++) - live->liveout[x] = BITMAP_ALLOC (NULL); + live->liveout = XNEWVEC (bitmap_head, last_basic_block); + FOR_EACH_BB (bb) + bitmap_initialize (&live->liveout[bb->index], &liveness_bitmap_obstack); live->work_stack = XNEWVEC (int, last_basic_block); live->stack_top = live->work_stack; - live->global = BITMAP_ALLOC (NULL); + live->global = BITMAP_ALLOC (&liveness_bitmap_obstack); return live; } @@ -906,19 +888,10 @@ new_tree_live_info (var_map map) void delete_tree_live_info (tree_live_info_p live) { - int x; - - BITMAP_FREE (live->global); + bitmap_obstack_release (&liveness_bitmap_obstack); free (live->work_stack); - - for (x = live->num_blocks - 1; x >= 0; x--) - BITMAP_FREE (live->liveout[x]); free (live->liveout); - - for (x = live->num_blocks - 1; x >= 0; x--) - BITMAP_FREE (live->livein[x]); free (live->livein); - free (live); } @@ -951,7 +924,7 @@ loe_visit_block (tree_live_info_p live, basic_block bb, sbitmap visited, predecessor block. This should be the live on entry vars to pred. Note that liveout is the DEFs in a block while live on entry is being calculated. */ - bitmap_and_compl (tmp, loe, live->liveout[pred_bb->index]); + bitmap_and_compl (tmp, loe, &live->liveout[pred_bb->index]); /* Add these bits to live-on-entry for the pred. if there are any changes, and pred_bb has been visited already, add it to the @@ -975,7 +948,7 @@ live_worklist (tree_live_info_p live) unsigned b; basic_block bb; sbitmap visited = sbitmap_alloc (last_basic_block + 1); - bitmap tmp = BITMAP_ALLOC (NULL); + bitmap tmp = BITMAP_ALLOC (&liveness_bitmap_obstack); sbitmap_zero (visited); @@ -1020,7 +993,7 @@ set_var_live_on_entry (tree ssa_name, tree_live_info_p live) def_bb = gimple_bb (stmt); /* Mark defs in liveout bitmap temporarily. */ if (def_bb) - bitmap_set_bit (live->liveout[def_bb->index], p); + bitmap_set_bit (&live->liveout[def_bb->index], p); } else def_bb = ENTRY_BLOCK_PTR; @@ -1059,7 +1032,7 @@ set_var_live_on_entry (tree ssa_name, tree_live_info_p live) if (add_block) { global = true; - bitmap_set_bit (live->livein[add_block->index], p); + bitmap_set_bit (&live->livein[add_block->index], p); } } @@ -1081,7 +1054,7 @@ calculate_live_on_exit (tree_live_info_p liveinfo) /* live on entry calculations used liveout vectors for defs, clear them. */ FOR_EACH_BB (bb) - bitmap_clear (liveinfo->liveout[bb->index]); + bitmap_clear (&liveinfo->liveout[bb->index]); /* Set all the live-on-exit bits for uses in PHIs. */ FOR_EACH_BB (bb) @@ -1106,14 +1079,14 @@ calculate_live_on_exit (tree_live_info_p liveinfo) continue; e = gimple_phi_arg_edge (phi, i); if (e->src != ENTRY_BLOCK_PTR) - bitmap_set_bit (liveinfo->liveout[e->src->index], p); + bitmap_set_bit (&liveinfo->liveout[e->src->index], p); } } /* Add each successors live on entry to this bock live on exit. */ FOR_EACH_EDGE (e, ei, bb->succs) if (e->dest != EXIT_BLOCK_PTR) - bitmap_ior_into (liveinfo->liveout[bb->index], + bitmap_ior_into (&liveinfo->liveout[bb->index], live_on_entry (liveinfo, e->dest)); } } @@ -1129,6 +1102,7 @@ calculate_live_ranges (var_map map) unsigned i; tree_live_info_p live; + bitmap_obstack_initialize (&liveness_bitmap_obstack); live = new_tree_live_info (map); for (i = 0; i < num_var_partitions (map); i++) { @@ -1166,7 +1140,8 @@ dump_var_map (FILE *f, var_map map) else p = x; - if (ssa_name (p) == NULL_TREE) + if (ssa_name (p) == NULL_TREE + || virtual_operand_p (ssa_name (p))) continue; t = 0; @@ -1208,7 +1183,7 @@ dump_live_info (FILE *f, tree_live_info_p live, int flag) FOR_EACH_BB (bb) { fprintf (f, "\nLive on entry to BB%d : ", bb->index); - EXECUTE_IF_SET_IN_BITMAP (live->livein[bb->index], 0, i, bi) + EXECUTE_IF_SET_IN_BITMAP (&live->livein[bb->index], 0, i, bi) { print_generic_expr (f, partition_to_var (map, i), TDF_SLIM); fprintf (f, " "); @@ -1222,7 +1197,7 @@ dump_live_info (FILE *f, tree_live_info_p live, int flag) FOR_EACH_BB (bb) { fprintf (f, "\nLive on exit from BB%d : ", bb->index); - EXECUTE_IF_SET_IN_BITMAP (live->liveout[bb->index], 0, i, bi) + EXECUTE_IF_SET_IN_BITMAP (&live->liveout[bb->index], 0, i, bi) { print_generic_expr (f, partition_to_var (map, i), TDF_SLIM); fprintf (f, " "); @@ -1232,95 +1207,6 @@ dump_live_info (FILE *f, tree_live_info_p live, int flag) } } -struct GTY(()) numbered_tree_d -{ - tree t; - int num; -}; -typedef struct numbered_tree_d numbered_tree; - -DEF_VEC_O (numbered_tree); -DEF_VEC_ALLOC_O (numbered_tree, heap); - -/* Compare two declarations references by their DECL_UID / sequence number. - Called via qsort. */ - -static int -compare_decls_by_uid (const void *pa, const void *pb) -{ - const numbered_tree *nt_a = ((const numbered_tree *)pa); - const numbered_tree *nt_b = ((const numbered_tree *)pb); - - if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t)) - return DECL_UID (nt_a->t) - DECL_UID (nt_b->t); - return nt_a->num - nt_b->num; -} - -/* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */ -static tree -dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data) -{ - struct walk_stmt_info *wi = (struct walk_stmt_info *) data; - VEC (numbered_tree, heap) **list = (VEC (numbered_tree, heap) **) &wi->info; - numbered_tree nt; - - if (!DECL_P (*tp)) - return NULL_TREE; - nt.t = *tp; - nt.num = VEC_length (numbered_tree, *list); - VEC_safe_push (numbered_tree, heap, *list, &nt); - *walk_subtrees = 0; - return NULL_TREE; -} - -/* Find all the declarations used by the current function, sort them by uid, - and emit the sorted list. Each declaration is tagged with a sequence - number indicating when it was found during statement / tree walking, - so that TDF_NOUID comparisons of anonymous declarations are still - meaningful. Where a declaration was encountered more than once, we - emit only the sequence number of the first encounter. - FILE is the dump file where to output the list and FLAGS is as in - print_generic_expr. */ -void -dump_enumerated_decls (FILE *file, int flags) -{ - basic_block bb; - struct walk_stmt_info wi; - VEC (numbered_tree, heap) *decl_list = VEC_alloc (numbered_tree, heap, 40); - - memset (&wi, '\0', sizeof (wi)); - wi.info = (void*) decl_list; - FOR_EACH_BB (bb) - { - gimple_stmt_iterator gsi; - - for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) - if (!is_gimple_debug (gsi_stmt (gsi))) - walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi); - } - decl_list = (VEC (numbered_tree, heap) *) wi.info; - VEC_qsort (numbered_tree, decl_list, compare_decls_by_uid); - if (VEC_length (numbered_tree, decl_list)) - { - unsigned ix; - numbered_tree *ntp; - tree last = NULL_TREE; - - fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n", - current_function_name ()); - FOR_EACH_VEC_ELT (numbered_tree, decl_list, ix, ntp) - { - if (ntp->t == last) - continue; - fprintf (file, "%d: ", ntp->num); - print_generic_decl (file, ntp->t, flags); - fprintf (file, "\n"); - last = ntp->t; - } - } - VEC_free (numbered_tree, heap, decl_list); -} - #ifdef ENABLE_CHECKING /* Verify that SSA_VAR is a non-virtual SSA_NAME. */ @@ -1328,7 +1214,7 @@ void register_ssa_partition_check (tree ssa_var) { gcc_assert (TREE_CODE (ssa_var) == SSA_NAME); - if (!is_gimple_reg (SSA_NAME_VAR (ssa_var))) + if (virtual_operand_p (ssa_var)) { fprintf (stderr, "Illegally registering a virtual SSA name :"); print_generic_expr (stderr, ssa_var, TDF_SLIM); @@ -1365,12 +1251,13 @@ verify_live_on_entry (tree_live_info_p live) for (i = 0; i < (unsigned)num_var_partitions (map); i++) { basic_block tmp; - tree d; + tree d = NULL_TREE; bitmap loe; var = partition_to_var (map, i); stmt = SSA_NAME_DEF_STMT (var); tmp = gimple_bb (stmt); - d = gimple_default_def (cfun, SSA_NAME_VAR (var)); + if (SSA_NAME_VAR (var)) + d = ssa_default_def (cfun, SSA_NAME_VAR (var)); loe = live_on_entry (live, e->dest); if (loe && bitmap_bit_p (loe, i)) |