1 /* Liveness for SSA trees.
2 Copyright (C) 2003-2024 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
31 #include "gimple-pretty-print.h"
32 #include "diagnostic-core.h"
33 #include "gimple-iterator.h"
36 #include "tree-ssa-live.h"
39 #include "ipa-utils.h"
41 #include "stringpool.h"
44 #include "gimple-walk.h"
48 static void verify_live_on_entry (tree_live_info_p
);
51 /* VARMAP maintains a mapping from SSA version number to real variables.
53 All SSA_NAMES are divided into partitions. Initially each ssa_name is the
54 only member of it's own partition. Coalescing will attempt to group any
55 ssa_names which occur in a copy or in a PHI node into the same partition.
57 At the end of out-of-ssa, each partition becomes a "real" variable and is
58 rewritten as a compiler variable.
60 The var_map data structure is used to manage these partitions. It allows
61 partitions to be combined, and determines which partition belongs to what
62 ssa_name or variable, and vice versa. */
65 /* Remove the base table in MAP. */
68 var_map_base_fini (var_map map
)
70 /* Free the basevar info if it is present. */
71 if (map
->partition_to_base_index
!= NULL
)
73 free (map
->partition_to_base_index
);
74 map
->partition_to_base_index
= NULL
;
75 map
->num_basevars
= 0;
78 /* Create a variable partition map of SIZE for region, initialize and return
79 it. Region is a loop if LOOP is non-NULL, otherwise is the current
80 function. If BITINT is non-NULL, only SSA_NAMEs from that bitmap
84 init_var_map (int size
, class loop
*loop
, bitmap bitint
)
88 map
= (var_map
) xmalloc (sizeof (struct _var_map
));
89 map
->var_partition
= partition_new (size
);
91 map
->partition_to_view
= NULL
;
92 map
->view_to_partition
= NULL
;
93 map
->num_partitions
= size
;
94 map
->partition_size
= size
;
95 map
->num_basevars
= 0;
96 map
->partition_to_base_index
= NULL
;
100 map
->bmp_bbs
= BITMAP_ALLOC (NULL
);
101 map
->outofssa_p
= false;
102 basic_block
*bbs
= get_loop_body_in_dom_order (loop
);
103 for (unsigned i
= 0; i
< loop
->num_nodes
; ++i
)
105 bitmap_set_bit (map
->bmp_bbs
, bbs
[i
]->index
);
106 map
->vec_bbs
.safe_push (bbs
[i
]);
113 map
->outofssa_p
= bitint
== NULL
;
114 map
->bitint
= bitint
;
116 map
->vec_bbs
.reserve_exact (n_basic_blocks_for_fn (cfun
)
118 FOR_EACH_BB_FN (bb
, cfun
)
119 map
->vec_bbs
.quick_push (bb
);
125 /* Free memory associated with MAP. */
128 delete_var_map (var_map map
)
130 var_map_base_fini (map
);
131 partition_delete (map
->var_partition
);
132 free (map
->partition_to_view
);
133 free (map
->view_to_partition
);
135 BITMAP_FREE (map
->bmp_bbs
);
136 map
->vec_bbs
.release ();
141 /* This function will combine the partitions in MAP for VAR1 and VAR2. It
142 Returns the partition which represents the new partition. If the two
143 partitions cannot be combined, NO_PARTITION is returned. */
146 var_union (var_map map
, tree var1
, tree var2
)
150 gcc_assert (TREE_CODE (var1
) == SSA_NAME
);
151 gcc_assert (TREE_CODE (var2
) == SSA_NAME
);
153 /* This is independent of partition_to_view. If partition_to_view is
154 on, then whichever one of these partitions is absorbed will never have a
155 dereference into the partition_to_view array any more. */
157 p1
= partition_find (map
->var_partition
, SSA_NAME_VERSION (var1
));
158 p2
= partition_find (map
->var_partition
, SSA_NAME_VERSION (var2
));
160 gcc_assert (p1
!= NO_PARTITION
);
161 gcc_assert (p2
!= NO_PARTITION
);
166 p3
= partition_union (map
->var_partition
, p1
, p2
);
168 if (map
->partition_to_view
)
169 p3
= map
->partition_to_view
[p3
];
175 /* Compress the partition numbers in MAP such that they fall in the range
176 0..(num_partitions-1) instead of wherever they turned out during
177 the partitioning exercise. This removes any references to unused
178 partitions, thereby allowing bitmaps and other vectors to be much
181 This is implemented such that compaction doesn't affect partitioning.
182 Ie., once partitions are created and possibly merged, running one
183 or more different kind of compaction will not affect the partitions
184 themselves. Their index might change, but all the same variables will
185 still be members of the same partition group. This allows work on reduced
186 sets, and no loss of information when a larger set is later desired.
188 In particular, coalescing can work on partitions which have 2 or more
189 definitions, and then 'recompact' later to include all the single
190 definitions for assignment to program variables. */
193 /* Set MAP back to the initial state of having no partition view. Return a
194 bitmap which has a bit set for each partition number which is in use in the
198 partition_view_init (var_map map
)
204 used
= BITMAP_ALLOC (NULL
);
206 /* Already in a view? Abandon the old one. */
207 if (map
->partition_to_view
)
209 free (map
->partition_to_view
);
210 map
->partition_to_view
= NULL
;
212 if (map
->view_to_partition
)
214 free (map
->view_to_partition
);
215 map
->view_to_partition
= NULL
;
218 /* Find out which partitions are actually referenced. */
219 for (x
= 0; x
< map
->partition_size
; x
++)
221 tmp
= partition_find (map
->var_partition
, x
);
222 if (ssa_name (tmp
) != NULL_TREE
&& !virtual_operand_p (ssa_name (tmp
))
223 && (!has_zero_uses (ssa_name (tmp
))
224 || !SSA_NAME_IS_DEFAULT_DEF (ssa_name (tmp
))
225 || (SSA_NAME_VAR (ssa_name (tmp
))
226 && !VAR_P (SSA_NAME_VAR (ssa_name (tmp
))))))
227 bitmap_set_bit (used
, tmp
);
230 map
->num_partitions
= map
->partition_size
;
235 /* This routine will finalize the view data for MAP based on the partitions
236 set in SELECTED. This is either the same bitmap returned from
237 partition_view_init, or a trimmed down version if some of those partitions
238 were not desired in this view. SELECTED is freed before returning. */
241 partition_view_fini (var_map map
, bitmap selected
)
244 unsigned count
, i
, x
, limit
;
246 gcc_assert (selected
);
248 count
= bitmap_count_bits (selected
);
249 limit
= map
->partition_size
;
251 /* If its a one-to-one ratio, we don't need any view compaction. */
254 map
->partition_to_view
= (int *)xmalloc (limit
* sizeof (int));
255 memset (map
->partition_to_view
, 0xff, (limit
* sizeof (int)));
256 map
->view_to_partition
= (int *)xmalloc (count
* sizeof (int));
259 /* Give each selected partition an index. */
260 EXECUTE_IF_SET_IN_BITMAP (selected
, 0, x
, bi
)
262 map
->partition_to_view
[x
] = i
;
263 map
->view_to_partition
[i
] = x
;
266 gcc_assert (i
== count
);
267 map
->num_partitions
= i
;
270 BITMAP_FREE (selected
);
274 /* Create a partition view which includes all the used partitions in MAP. */
277 partition_view_normal (var_map map
)
281 used
= partition_view_init (map
);
282 partition_view_fini (map
, used
);
284 var_map_base_fini (map
);
288 /* Create a partition view in MAP which includes just partitions which occur in
289 the bitmap ONLY. If WANT_BASES is true, create the base variable map
293 partition_view_bitmap (var_map map
, bitmap only
)
296 bitmap new_partitions
= BITMAP_ALLOC (NULL
);
300 used
= partition_view_init (map
);
301 EXECUTE_IF_SET_IN_BITMAP (only
, 0, x
, bi
)
303 p
= partition_find (map
->var_partition
, x
);
304 gcc_assert (bitmap_bit_p (used
, p
));
305 bitmap_set_bit (new_partitions
, p
);
307 partition_view_fini (map
, new_partitions
);
309 var_map_base_fini (map
);
313 static bitmap usedvars
;
315 /* Mark VAR as used, so that it'll be preserved during rtl expansion.
316 Returns true if VAR wasn't marked before. */
319 set_is_used (tree var
)
321 return bitmap_set_bit (usedvars
, DECL_UID (var
));
324 /* Return true if VAR is marked as used. */
329 return bitmap_bit_p (usedvars
, DECL_UID (var
));
332 static inline void mark_all_vars_used (tree
*);
334 /* Helper function for mark_all_vars_used, called via walk_tree. */
337 mark_all_vars_used_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
340 enum tree_code_class c
= TREE_CODE_CLASS (TREE_CODE (t
));
343 if (TREE_CODE (t
) == SSA_NAME
)
346 t
= SSA_NAME_VAR (t
);
351 if (IS_EXPR_CODE_CLASS (c
)
352 && (b
= TREE_BLOCK (t
)) != NULL
)
353 TREE_USED (b
) = true;
355 /* Ignore TMR_OFFSET and TMR_STEP for TARGET_MEM_REFS, as those
356 fields do not contain vars. */
357 if (TREE_CODE (t
) == TARGET_MEM_REF
)
359 mark_all_vars_used (&TMR_BASE (t
));
360 mark_all_vars_used (&TMR_INDEX (t
));
361 mark_all_vars_used (&TMR_INDEX2 (t
));
366 /* Only need to mark VAR_DECLS; parameters and return results are not
367 eliminated as unused. */
370 /* When a global var becomes used for the first time also walk its
371 initializer (non global ones don't have any). */
372 if (set_is_used (t
) && is_global_var (t
)
373 && DECL_CONTEXT (t
) == current_function_decl
)
374 mark_all_vars_used (&DECL_INITIAL (t
));
376 /* remove_unused_scope_block_p requires information about labels
377 which are not DECL_IGNORED_P to tell if they might be used in the IL. */
378 else if (TREE_CODE (t
) == LABEL_DECL
)
379 /* Although the TREE_USED values that the frontend uses would be
380 acceptable (albeit slightly over-conservative) for our purposes,
381 init_vars_expansion clears TREE_USED for LABEL_DECLs too, so we
382 must re-compute it here. */
385 if (IS_TYPE_OR_DECL_P (t
))
391 /* Mark the scope block SCOPE and its subblocks unused when they can be
392 possibly eliminated if dead. */
395 mark_scope_block_unused (tree scope
)
398 TREE_USED (scope
) = false;
399 if (!(*debug_hooks
->ignore_block
) (scope
))
400 TREE_USED (scope
) = true;
401 for (t
= BLOCK_SUBBLOCKS (scope
); t
; t
= BLOCK_CHAIN (t
))
402 mark_scope_block_unused (t
);
405 /* Look if the block is dead (by possibly eliminating its dead subblocks)
406 and return true if so.
407 Block is declared dead if:
408 1) No statements are associated with it.
409 2) Declares no live variables
410 3) All subblocks are dead
411 or there is precisely one subblocks and the block
412 has same abstract origin as outer block and declares
413 no variables, so it is pure wrapper.
414 When we are not outputting full debug info, we also eliminate dead variables
415 out of scope blocks to let them to be recycled by GGC and to save copying work
416 done by the inliner. */
419 remove_unused_scope_block_p (tree scope
, bool in_ctor_dtor_block
)
422 bool unused
= !TREE_USED (scope
);
425 /* For ipa-polymorphic-call.cc purposes, preserve blocks:
426 1) with BLOCK_ABSTRACT_ORIGIN of a ctor/dtor or their clones */
427 if (inlined_polymorphic_ctor_dtor_block_p (scope
, true))
429 in_ctor_dtor_block
= true;
432 /* 2) inside such blocks, the outermost block with block_ultimate_origin
433 being a FUNCTION_DECL. */
434 else if (in_ctor_dtor_block
)
436 tree fn
= block_ultimate_origin (scope
);
437 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
439 in_ctor_dtor_block
= false;
444 for (t
= &BLOCK_VARS (scope
); *t
; t
= next
)
446 next
= &DECL_CHAIN (*t
);
448 /* Debug info of nested function refers to the block of the
449 function. We might stil call it even if all statements
450 of function it was nested into was elliminated.
452 TODO: We can actually look into cgraph to see if function
453 will be output to file. */
454 if (TREE_CODE (*t
) == FUNCTION_DECL
)
457 /* If a decl has a value expr, we need to instantiate it
458 regardless of debug info generation, to avoid codegen
459 differences in memory overlap tests. update_equiv_regs() may
460 indirectly call validate_equiv_mem() to test whether a
461 SET_DEST overlaps with others, and if the value expr changes
462 by virtual register instantiation, we may get end up with
463 different results. */
464 else if (VAR_P (*t
) && DECL_HAS_VALUE_EXPR_P (*t
))
467 /* Remove everything we don't generate debug info for. */
468 else if (DECL_IGNORED_P (*t
))
470 *t
= DECL_CHAIN (*t
);
474 /* When we are outputting debug info, we usually want to output
475 info about optimized-out variables in the scope blocks.
476 Exception are the scope blocks not containing any instructions
477 at all so user can't get into the scopes at first place. */
478 else if (is_used_p (*t
))
480 else if (TREE_CODE (*t
) == LABEL_DECL
&& TREE_USED (*t
))
481 /* For labels that are still used in the IL, the decision to
482 preserve them must not depend DEBUG_INFO_LEVEL, otherwise we
483 risk having different ordering in debug vs. non-debug builds
484 during inlining or versioning.
485 A label appearing here (we have already checked DECL_IGNORED_P)
486 should not be used in the IL unless it has been explicitly used
487 before, so we use TREE_USED as an approximation. */
488 /* In principle, we should do the same here as for the debug case
489 below, however, when debugging, there might be additional nested
490 levels that keep an upper level with a label live, so we have to
491 force this block to be considered used, too. */
494 /* When we are not doing full debug info, we however can keep around
495 only the used variables for cfgexpand's memory packing saving quite
498 For sake of -g3, we keep around those vars but we don't count this as
499 use of block, so innermost block with no used vars and no instructions
500 can be considered dead. We only want to keep around blocks user can
501 breakpoint into and ask about value of optimized out variables.
503 Similarly we need to keep around types at least until all
504 variables of all nested blocks are gone. We track no
505 information on whether given type is used or not, so we have
506 to keep them even when not emitting debug information,
507 otherwise we may end up remapping variables and their (local)
508 types in different orders depending on whether debug
509 information is being generated. */
511 else if (TREE_CODE (*t
) == TYPE_DECL
512 || debug_info_level
== DINFO_LEVEL_NORMAL
513 || debug_info_level
== DINFO_LEVEL_VERBOSE
)
517 *t
= DECL_CHAIN (*t
);
522 for (t
= &BLOCK_SUBBLOCKS (scope
); *t
;)
523 if (remove_unused_scope_block_p (*t
, in_ctor_dtor_block
))
525 if (BLOCK_SUBBLOCKS (*t
))
527 tree next
= BLOCK_CHAIN (*t
);
528 tree supercontext
= BLOCK_SUPERCONTEXT (*t
);
530 *t
= BLOCK_SUBBLOCKS (*t
);
531 while (BLOCK_CHAIN (*t
))
533 BLOCK_SUPERCONTEXT (*t
) = supercontext
;
534 t
= &BLOCK_CHAIN (*t
);
536 BLOCK_CHAIN (*t
) = next
;
537 BLOCK_SUPERCONTEXT (*t
) = supercontext
;
538 t
= &BLOCK_CHAIN (*t
);
542 *t
= BLOCK_CHAIN (*t
);
546 t
= &BLOCK_CHAIN (*t
);
553 /* Outer scope is always used. */
554 else if (!BLOCK_SUPERCONTEXT (scope
)
555 || TREE_CODE (BLOCK_SUPERCONTEXT (scope
)) == FUNCTION_DECL
)
557 /* Innermost blocks with no live variables nor statements can be always
559 else if (!nsubblocks
)
561 /* When not generating debug info we can eliminate info on unused
563 else if (!flag_auto_profile
564 && debug_info_level
== DINFO_LEVEL_NONE
565 && !optinfo_wants_inlining_info_p ())
567 /* Even for -g0 don't prune outer scopes from inlined functions,
568 otherwise late diagnostics from such functions will not be
569 emitted or suppressed properly. */
570 if (inlined_function_outer_scope_p (scope
))
572 gcc_assert (TREE_CODE (BLOCK_ORIGIN (scope
)) == FUNCTION_DECL
);
576 else if (BLOCK_VARS (scope
) || BLOCK_NUM_NONLOCALIZED_VARS (scope
))
578 /* See if this block is important for representation of inlined
579 function. Inlined functions are always represented by block
580 with block_ultimate_origin being set to FUNCTION_DECL and
581 DECL_SOURCE_LOCATION set, unless they expand to nothing... */
582 else if (inlined_function_outer_scope_p (scope
))
585 /* Verfify that only blocks with source location set
586 are entry points to the inlined functions. */
587 gcc_assert (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope
))
588 == UNKNOWN_LOCATION
);
590 TREE_USED (scope
) = !unused
;
594 /* Mark all VAR_DECLS under *EXPR_P as used, so that they won't be
595 eliminated during the tree->rtl conversion process. */
598 mark_all_vars_used (tree
*expr_p
)
600 walk_tree (expr_p
, mark_all_vars_used_1
, NULL
, NULL
);
603 /* Helper function for clear_unused_block_pointer, called via walk_tree. */
606 clear_unused_block_pointer_1 (tree
*tp
, int *, void *)
608 if (EXPR_P (*tp
) && TREE_BLOCK (*tp
)
609 && !TREE_USED (TREE_BLOCK (*tp
)))
610 TREE_SET_BLOCK (*tp
, NULL
);
614 /* Set all block pointer in debug or clobber stmt to NULL if the block
615 is unused, so that they will not be streamed out. */
618 clear_unused_block_pointer (void)
621 gimple_stmt_iterator gsi
;
623 FOR_EACH_BB_FN (bb
, cfun
)
624 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
631 stmt
= gsi_stmt (gsi
);
632 if (!is_gimple_debug (stmt
) && !gimple_clobber_p (stmt
))
634 b
= gimple_block (stmt
);
635 if (b
&& !TREE_USED (b
))
637 /* Elide debug marker stmts that have an associated BLOCK from an
638 inline instance removed with also the outermost scope BLOCK of
639 said inline instance removed. If the outermost scope BLOCK of
640 said inline instance is preserved use that in place of the
641 removed BLOCK. That keeps the marker associated to the correct
642 inline instance (or no inline instance in case it was not from
643 an inline instance). */
644 if (gimple_debug_nonbind_marker_p (stmt
)
645 && BLOCK_ABSTRACT_ORIGIN (b
))
647 while (TREE_CODE (b
) == BLOCK
648 && !inlined_function_outer_scope_p (b
))
649 b
= BLOCK_SUPERCONTEXT (b
);
650 if (TREE_CODE (b
) == BLOCK
)
654 gimple_set_block (stmt
, b
);
657 gsi_remove (&gsi
, true);
663 gimple_set_block (stmt
, NULL
);
665 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
666 walk_tree (gimple_op_ptr (stmt
, i
), clear_unused_block_pointer_1
,
671 /* Dump scope blocks starting at SCOPE to FILE. INDENT is the
672 indentation level and FLAGS is as in print_generic_expr. */
675 dump_scope_block (FILE *file
, int indent
, tree scope
, dump_flags_t flags
)
680 fprintf (file
, "\n%*s{ Scope block #%i%s",indent
, "" , BLOCK_NUMBER (scope
),
681 TREE_USED (scope
) ? "" : " (unused)");
682 if (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope
)) != UNKNOWN_LOCATION
)
684 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (scope
));
685 fprintf (file
, " %s:%i", s
.file
, s
.line
);
687 if (BLOCK_ABSTRACT_ORIGIN (scope
))
689 tree origin
= block_ultimate_origin (scope
);
692 fprintf (file
, " Originating from :");
694 print_generic_decl (file
, origin
, flags
);
696 fprintf (file
, "#%i", BLOCK_NUMBER (origin
));
699 if (BLOCK_FRAGMENT_ORIGIN (scope
))
700 fprintf (file
, " Fragment of : #%i",
701 BLOCK_NUMBER (BLOCK_FRAGMENT_ORIGIN (scope
)));
702 else if (BLOCK_FRAGMENT_CHAIN (scope
))
704 fprintf (file
, " Fragment chain :");
705 for (t
= BLOCK_FRAGMENT_CHAIN (scope
); t
;
706 t
= BLOCK_FRAGMENT_CHAIN (t
))
707 fprintf (file
, " #%i", BLOCK_NUMBER (t
));
709 fprintf (file
, " \n");
710 for (var
= BLOCK_VARS (scope
); var
; var
= DECL_CHAIN (var
))
712 fprintf (file
, "%*s", indent
, "");
713 print_generic_decl (file
, var
, flags
);
714 fprintf (file
, "\n");
716 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (scope
); i
++)
718 fprintf (file
, "%*s",indent
, "");
719 print_generic_decl (file
, BLOCK_NONLOCALIZED_VAR (scope
, i
),
721 fprintf (file
, " (nonlocalized)\n");
723 for (t
= BLOCK_SUBBLOCKS (scope
); t
; t
= BLOCK_CHAIN (t
))
724 dump_scope_block (file
, indent
+ 2, t
, flags
);
725 fprintf (file
, "\n%*s}\n",indent
, "");
728 /* Dump the tree of lexical scopes starting at SCOPE to stderr. FLAGS
729 is as in print_generic_expr. */
732 debug_scope_block (tree scope
, dump_flags_t flags
)
734 dump_scope_block (stderr
, 0, scope
, flags
);
738 /* Dump the tree of lexical scopes of current_function_decl to FILE.
739 FLAGS is as in print_generic_expr. */
742 dump_scope_blocks (FILE *file
, dump_flags_t flags
)
744 dump_scope_block (file
, 0, DECL_INITIAL (current_function_decl
), flags
);
748 /* Dump the tree of lexical scopes of current_function_decl to stderr.
749 FLAGS is as in print_generic_expr. */
752 debug_scope_blocks (dump_flags_t flags
)
754 dump_scope_blocks (stderr
, flags
);
757 /* Remove local variables that are not referenced in the IL. */
760 remove_unused_locals (void)
764 unsigned srcidx
, dstidx
, num
;
765 bool have_local_clobbers
= false;
767 /* Removing declarations from lexical blocks when not optimizing is
768 not only a waste of time, it actually causes differences in stack
773 timevar_push (TV_REMOVE_UNUSED
);
775 mark_scope_block_unused (DECL_INITIAL (current_function_decl
));
777 usedvars
= BITMAP_ALLOC (NULL
);
778 auto_bitmap useddebug
;
780 /* Walk the CFG marking all referenced symbols. */
781 FOR_EACH_BB_FN (bb
, cfun
)
783 gimple_stmt_iterator gsi
;
788 /* Walk the statements. */
789 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
791 gimple
*stmt
= gsi_stmt (gsi
);
792 tree b
= gimple_block (stmt
);
794 /* If we wanted to mark the block referenced by the inline
795 entry point marker as used, this would be a good spot to
796 do it. If the block is not otherwise used, the stmt will
797 be cleaned up in clean_unused_block_pointer. */
798 if (is_gimple_debug (stmt
))
800 if (gimple_debug_bind_p (stmt
))
802 tree var
= gimple_debug_bind_get_var (stmt
);
805 if (!gimple_debug_bind_get_value (stmt
))
806 /* Run the 2nd phase. */
807 have_local_clobbers
= true;
809 bitmap_set_bit (useddebug
, DECL_UID (var
));
815 if (gimple_clobber_p (stmt
))
817 have_local_clobbers
= true;
821 if (gimple_call_internal_p (stmt
, IFN_DEFERRED_INIT
))
823 have_local_clobbers
= true;
828 TREE_USED (b
) = true;
830 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
831 mark_all_vars_used (gimple_op_ptr (gsi_stmt (gsi
), i
));
834 for (gphi_iterator gpi
= gsi_start_phis (bb
);
841 gphi
*phi
= gpi
.phi ();
843 if (virtual_operand_p (gimple_phi_result (phi
)))
846 def
= gimple_phi_result (phi
);
847 mark_all_vars_used (&def
);
849 FOR_EACH_PHI_ARG (arg_p
, phi
, i
, SSA_OP_ALL_USES
)
851 tree arg
= USE_FROM_PTR (arg_p
);
852 int index
= PHI_ARG_INDEX_FROM_USE (arg_p
);
854 LOCATION_BLOCK (gimple_phi_arg_location (phi
, index
));
856 TREE_USED (block
) = true;
857 mark_all_vars_used (&arg
);
861 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
862 if (LOCATION_BLOCK (e
->goto_locus
) != NULL
)
863 TREE_USED (LOCATION_BLOCK (e
->goto_locus
)) = true;
866 /* We do a two-pass approach about the out-of-scope clobbers. We want
867 to remove them if they are the only references to a local variable,
868 but we want to retain them when there's any other. So the first pass
869 ignores them, and the second pass (if there were any) tries to remove
870 them. We do the same for .DEFERRED_INIT. */
871 if (have_local_clobbers
)
872 FOR_EACH_BB_FN (bb
, cfun
)
874 gimple_stmt_iterator gsi
;
876 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
878 gimple
*stmt
= gsi_stmt (gsi
);
879 tree b
= gimple_block (stmt
);
881 if (gimple_clobber_p (stmt
))
883 tree lhs
= gimple_assign_lhs (stmt
);
884 tree base
= get_base_address (lhs
);
885 /* Remove clobbers referencing unused vars, or clobbers
886 with MEM_REF lhs referencing uninitialized pointers. */
887 if ((VAR_P (base
) && !is_used_p (base
))
888 || (TREE_CODE (lhs
) == MEM_REF
889 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
890 && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (lhs
, 0))
891 && (TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (lhs
, 0)))
894 unlink_stmt_vdef (stmt
);
895 gsi_remove (&gsi
, true);
900 TREE_USED (b
) = true;
902 else if (gimple_call_internal_p (stmt
, IFN_DEFERRED_INIT
))
904 tree lhs
= gimple_call_lhs (stmt
);
905 tree base
= get_base_address (lhs
);
906 if (DECL_P (base
) && !is_used_p (base
))
908 unlink_stmt_vdef (stmt
);
909 gsi_remove (&gsi
, true);
914 TREE_USED (b
) = true;
916 else if (gimple_debug_bind_p (stmt
))
918 tree var
= gimple_debug_bind_get_var (stmt
);
920 && !bitmap_bit_p (useddebug
, DECL_UID (var
))
923 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
924 fprintf (dump_file
, "Dead debug bind reset to %u\n",
926 gsi_remove (&gsi
, true);
934 if (cfun
->has_simduid_loops
)
936 for (auto loop
: loops_list (cfun
, 0))
937 if (loop
->simduid
&& !is_used_p (loop
->simduid
))
938 loop
->simduid
= NULL_TREE
;
941 cfun
->has_local_explicit_reg_vars
= false;
943 /* Remove unmarked local and global vars from local_decls. */
944 num
= vec_safe_length (cfun
->local_decls
);
945 for (srcidx
= 0, dstidx
= 0; srcidx
< num
; srcidx
++)
947 var
= (*cfun
->local_decls
)[srcidx
];
950 if (!is_used_p (var
))
953 if (cfun
->nonlocal_goto_save_area
954 && TREE_OPERAND (cfun
->nonlocal_goto_save_area
, 0) == var
)
955 cfun
->nonlocal_goto_save_area
= NULL
;
956 /* Release any default def associated with var. */
957 if ((def
= ssa_default_def (cfun
, var
)) != NULL_TREE
)
959 set_ssa_default_def (cfun
, var
, NULL_TREE
);
960 release_ssa_name (def
);
965 if (VAR_P (var
) && DECL_HARD_REGISTER (var
) && !is_global_var (var
))
966 cfun
->has_local_explicit_reg_vars
= true;
968 if (srcidx
!= dstidx
)
969 (*cfun
->local_decls
)[dstidx
] = var
;
974 statistics_counter_event (cfun
, "unused VAR_DECLs removed", num
- dstidx
);
975 cfun
->local_decls
->truncate (dstidx
);
978 remove_unused_scope_block_p (DECL_INITIAL (current_function_decl
),
979 polymorphic_ctor_dtor_p (current_function_decl
,
981 clear_unused_block_pointer ();
983 BITMAP_FREE (usedvars
);
985 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
987 fprintf (dump_file
, "Scope blocks after cleanups:\n");
988 dump_scope_blocks (dump_file
, dump_flags
);
991 timevar_pop (TV_REMOVE_UNUSED
);
994 /* Allocate and return a new live range information object base on MAP. */
996 static tree_live_info_p
997 new_tree_live_info (var_map map
)
999 tree_live_info_p live
;
1002 live
= XNEW (struct tree_live_info_d
);
1004 live
->num_blocks
= last_basic_block_for_fn (cfun
);
1006 bitmap_obstack_initialize (&live
->livein_obstack
);
1007 bitmap_obstack_initialize (&live
->liveout_obstack
);
1009 live
->livein
= XCNEWVEC (bitmap_head
, last_basic_block_for_fn (cfun
));
1010 live
->liveout
= XCNEWVEC (bitmap_head
, last_basic_block_for_fn (cfun
));
1011 for (unsigned i
= 0; map
->vec_bbs
.iterate (i
, &bb
); ++i
)
1013 bitmap_initialize (&live
->livein
[bb
->index
], &live
->livein_obstack
);
1014 bitmap_initialize (&live
->liveout
[bb
->index
], &live
->liveout_obstack
);
1017 live
->work_stack
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
1018 live
->stack_top
= live
->work_stack
;
1024 /* Free storage for live range info object LIVE. */
1027 delete_tree_live_info (tree_live_info_p live
)
1031 bitmap_obstack_release (&live
->livein_obstack
);
1032 free (live
->livein
);
1036 bitmap_obstack_release (&live
->liveout_obstack
);
1037 free (live
->liveout
);
1039 free (live
->work_stack
);
1044 /* Visit basic block BB and propagate any required live on entry bits from
1045 LIVE into the predecessors. VISITED is the bitmap of visited blocks.
1046 TMP is a temporary work bitmap which is passed in to avoid reallocating
1050 loe_visit_block (tree_live_info_p live
, basic_block bb
, sbitmap visited
)
1055 basic_block pred_bb
;
1058 gcc_checking_assert (!bitmap_bit_p (visited
, bb
->index
));
1059 bitmap_set_bit (visited
, bb
->index
);
1061 loe
= live_on_entry (live
, bb
);
1063 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1066 if (!region_contains_p (live
->map
, pred_bb
))
1068 /* Variables live-on-entry from BB that aren't defined in the
1069 predecessor block. This should be the live on entry vars to pred.
1070 Note that liveout is the DEFs in a block while live on entry is
1072 Add these bits to live-on-entry for the pred. if there are any
1073 changes, and pred_bb has been visited already, add it to the
1075 change
= bitmap_ior_and_compl_into (live_on_entry (live
, pred_bb
),
1076 loe
, &live
->liveout
[pred_bb
->index
]);
1078 && bitmap_bit_p (visited
, pred_bb
->index
))
1080 bitmap_clear_bit (visited
, pred_bb
->index
);
1081 *(live
->stack_top
)++ = pred_bb
->index
;
1087 /* Using LIVE, fill in all the live-on-entry blocks between the defs and uses
1088 of all the variables. */
1091 live_worklist (tree_live_info_p live
)
1095 auto_sbitmap
visited (last_basic_block_for_fn (cfun
) + 1);
1097 bitmap_clear (visited
);
1099 /* Visit region's blocks in reverse order and propagate live on entry values
1100 into the predecessors blocks. */
1101 for (unsigned i
= live
->map
->vec_bbs
.length () - 1;
1102 live
->map
->vec_bbs
.iterate (i
, &bb
); --i
)
1103 loe_visit_block (live
, bb
, visited
);
1105 /* Process any blocks which require further iteration. */
1106 while (live
->stack_top
!= live
->work_stack
)
1108 b
= *--(live
->stack_top
);
1109 loe_visit_block (live
, BASIC_BLOCK_FOR_FN (cfun
, b
), visited
);
1114 /* Calculate the initial live on entry vector for SSA_NAME using immediate_use
1115 links. Set the live on entry fields in LIVE. Def's are marked temporarily
1116 in the liveout vector. */
1119 set_var_live_on_entry (tree ssa_name
, tree_live_info_p live
)
1124 basic_block def_bb
= NULL
;
1125 imm_use_iterator imm_iter
;
1127 p
= var_to_partition (live
->map
, ssa_name
);
1128 if (p
== NO_PARTITION
)
1131 stmt
= SSA_NAME_DEF_STMT (ssa_name
);
1134 def_bb
= gimple_bb (stmt
);
1135 /* Mark defs in liveout bitmap temporarily. */
1136 if (def_bb
&& region_contains_p (live
->map
, def_bb
))
1137 bitmap_set_bit (&live
->liveout
[def_bb
->index
], p
);
1140 def_bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1142 /* An undefined local variable does not need to be very alive. */
1143 if (ssa_undefined_value_p (ssa_name
, false))
1146 /* Visit each use of SSA_NAME and if it isn't in the same block as the def,
1147 add it to the list of live on entry blocks. */
1148 FOR_EACH_IMM_USE_FAST (use
, imm_iter
, ssa_name
)
1150 gimple
*use_stmt
= USE_STMT (use
);
1151 basic_block add_block
= NULL
;
1153 if (gimple_code (use_stmt
) == GIMPLE_PHI
)
1155 /* Uses in PHI's are considered to be live at exit of the SRC block
1156 as this is where a copy would be inserted. Check to see if it is
1157 defined in that block, or whether its live on entry. */
1158 int index
= PHI_ARG_INDEX_FROM_USE (use
);
1159 edge e
= gimple_phi_arg_edge (as_a
<gphi
*> (use_stmt
), index
);
1160 if (e
->src
!= def_bb
&& region_contains_p (live
->map
, e
->src
))
1163 else if (is_gimple_debug (use_stmt
))
1167 /* If its not defined in this block, its live on entry. */
1168 basic_block use_bb
= gimple_bb (use_stmt
);
1169 if (use_bb
!= def_bb
&& region_contains_p (live
->map
, use_bb
))
1173 /* If there was a live on entry use, set the bit. */
1175 bitmap_set_bit (&live
->livein
[add_block
->index
], p
);
1180 /* Calculate the live on exit vectors based on the entry info in LIVEINFO. */
1183 calculate_live_on_exit (tree_live_info_p liveinfo
)
1189 /* live on entry calculations used liveout vectors for defs, clear them. */
1190 for (unsigned i
= 0; liveinfo
->map
->vec_bbs
.iterate (i
, &bb
); ++i
)
1191 bitmap_clear (&liveinfo
->liveout
[bb
->index
]);
1193 /* Set all the live-on-exit bits for uses in PHIs. */
1194 FOR_EACH_BB_FN (bb
, cfun
)
1199 /* Mark the PHI arguments which are live on exit to the pred block. */
1200 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1202 gphi
*phi
= gsi
.phi ();
1203 if (virtual_operand_p (gimple_phi_result (phi
)))
1205 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1207 tree t
= PHI_ARG_DEF (phi
, i
);
1210 if (TREE_CODE (t
) != SSA_NAME
)
1213 p
= var_to_partition (liveinfo
->map
, t
);
1214 if (p
== NO_PARTITION
)
1216 e
= gimple_phi_arg_edge (phi
, i
);
1217 if (region_contains_p (liveinfo
->map
, e
->src
))
1218 bitmap_set_bit (&liveinfo
->liveout
[e
->src
->index
], p
);
1222 if (!region_contains_p (liveinfo
->map
, bb
))
1225 /* Add each successors live on entry to this bock live on exit. */
1226 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1227 if (region_contains_p (liveinfo
->map
, e
->dest
))
1228 bitmap_ior_into (&liveinfo
->liveout
[bb
->index
],
1229 live_on_entry (liveinfo
, e
->dest
));
1234 /* Given partition map MAP, calculate all the live on entry bitmaps for
1235 each partition. Return a new live info object. */
1238 calculate_live_ranges (var_map map
, bool want_livein
)
1242 tree_live_info_p live
;
1244 live
= new_tree_live_info (map
);
1245 for (i
= 0; i
< num_var_partitions (map
); i
++)
1247 var
= partition_to_var (map
, i
);
1248 if (var
!= NULL_TREE
)
1249 set_var_live_on_entry (var
, live
);
1252 live_worklist (live
);
1255 verify_live_on_entry (live
);
1257 calculate_live_on_exit (live
);
1261 bitmap_obstack_release (&live
->livein_obstack
);
1262 free (live
->livein
);
1263 live
->livein
= NULL
;
1269 /* Data structure for compute_live_vars* functions. */
1271 struct compute_live_vars_data
{
1272 /* Vector of bitmaps for live vars indices at the end of basic blocks,
1273 indexed by bb->index. ACTIVE[ENTRY_BLOCK] must be empty bitmap,
1274 ACTIVE[EXIT_BLOCK] is used for STOP_AFTER. */
1275 vec
<bitmap_head
> active
;
1276 /* Work bitmap of currently live variables. */
1278 /* Set of interesting variables. Variables with uids not in this
1279 hash_map are not tracked. */
1280 live_vars_map
*vars
;
1283 /* Callback for walk_stmt_load_store_addr_ops. If OP is a VAR_DECL with
1284 uid set in DATA->vars, enter its corresponding index into bitmap
1288 compute_live_vars_visit (gimple
*, tree op
, tree
, void *pdata
)
1290 compute_live_vars_data
*data
= (compute_live_vars_data
*) pdata
;
1291 op
= get_base_address (op
);
1292 if (op
&& VAR_P (op
))
1293 if (unsigned int *v
= data
->vars
->get (DECL_UID (op
)))
1294 bitmap_set_bit (data
->work
, *v
);
1298 /* Helper routine for compute_live_vars, calculating the sets of live
1299 variables at the end of BB, leaving the result in DATA->work.
1300 If STOP_AFTER is non-NULL, stop processing after that stmt. */
1303 compute_live_vars_1 (basic_block bb
, compute_live_vars_data
*data
,
1308 gimple_stmt_iterator gsi
;
1309 walk_stmt_load_store_addr_fn visit
= compute_live_vars_visit
;
1311 bitmap_clear (data
->work
);
1312 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1313 bitmap_ior_into (data
->work
, &data
->active
[e
->src
->index
]);
1315 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1316 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), data
, NULL
, NULL
, visit
);
1317 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1319 gimple
*stmt
= gsi_stmt (gsi
);
1321 if (gimple_clobber_p (stmt
))
1323 tree lhs
= gimple_assign_lhs (stmt
);
1325 if (unsigned int *v
= data
->vars
->get (DECL_UID (lhs
)))
1326 bitmap_clear_bit (data
->work
, *v
);
1328 else if (!is_gimple_debug (stmt
))
1329 walk_stmt_load_store_addr_ops (stmt
, data
, visit
, visit
, visit
);
1330 if (stmt
== stop_after
)
1335 /* For function FN and live_vars_map (hash map from DECL_UIDs to a dense set of
1336 indexes of automatic variables VARS, compute which of those variables are
1337 (might be) live at the end of each basic block. */
1340 compute_live_vars (struct function
*fn
, live_vars_map
*vars
)
1342 vec
<bitmap_head
> active
;
1344 /* We approximate the live range of a stack variable by taking the first
1345 mention of its name as starting point(s), and by the end-of-scope
1346 death clobber added by gimplify as ending point(s) of the range.
1347 This overapproximates in the case we for instance moved an address-taken
1348 operation upward, without also moving a dereference to it upwards.
1349 But it's conservatively correct as a variable never can hold values
1350 before its name is mentioned at least once.
1352 We then do a mostly classical bitmap liveness algorithm. */
1354 active
.create (last_basic_block_for_fn (fn
));
1355 active
.quick_grow_cleared (last_basic_block_for_fn (fn
));
1356 for (int i
= 0; i
< last_basic_block_for_fn (fn
); i
++)
1357 bitmap_initialize (&active
[i
], &bitmap_default_obstack
);
1359 bitmap work
= BITMAP_ALLOC (NULL
);
1361 int *rpo
= XNEWVEC (int, last_basic_block_for_fn (fn
));
1362 int n_bbs
= pre_and_rev_post_order_compute_fn (fn
, NULL
, rpo
, false);
1364 bool changed
= true;
1365 compute_live_vars_data data
= { active
, work
, vars
};
1370 for (i
= 0; i
< n_bbs
; i
++)
1372 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, rpo
[i
]);
1373 compute_live_vars_1 (bb
, &data
, NULL
);
1374 if (bitmap_ior_into (&active
[bb
->index
], work
))
1385 /* For ACTIVE computed by compute_live_vars, compute a bitmap of variables
1386 live after the STOP_AFTER statement and return that bitmap. */
1389 live_vars_at_stmt (vec
<bitmap_head
> &active
, live_vars_map
*vars
,
1392 bitmap work
= BITMAP_ALLOC (NULL
);
1393 compute_live_vars_data data
= { active
, work
, vars
};
1394 basic_block bb
= gimple_bb (stop_after
);
1395 compute_live_vars_1 (bb
, &data
, stop_after
);
1399 /* Destroy what compute_live_vars has returned when it is no longer needed. */
1402 destroy_live_vars (vec
<bitmap_head
> &active
)
1404 unsigned len
= active
.length ();
1405 for (unsigned i
= 0; i
< len
; i
++)
1406 bitmap_clear (&active
[i
]);
1411 /* Output partition map MAP to file F. */
1414 dump_var_map (FILE *f
, var_map map
)
1420 fprintf (f
, "\nPartition map \n\n");
1422 for (x
= 0; x
< map
->num_partitions
; x
++)
1424 if (map
->view_to_partition
!= NULL
)
1425 p
= map
->view_to_partition
[x
];
1429 if (ssa_name (p
) == NULL_TREE
1430 || virtual_operand_p (ssa_name (p
)))
1434 for (y
= 1; y
< num_ssa_names
; y
++)
1436 p
= partition_find (map
->var_partition
, y
);
1437 if (map
->partition_to_view
)
1438 p
= map
->partition_to_view
[p
];
1443 fprintf (f
, "Partition %d (", x
);
1444 print_generic_expr (f
, partition_to_var (map
, p
), TDF_SLIM
);
1447 fprintf (f
, "%d ", y
);
1457 /* Generic dump for the above. */
1460 debug (_var_map
&ref
)
1462 dump_var_map (stderr
, &ref
);
1466 debug (_var_map
*ptr
)
1471 fprintf (stderr
, "<nil>\n");
1475 /* Output live range info LIVE to file F, controlled by FLAG. */
1478 dump_live_info (FILE *f
, tree_live_info_p live
, int flag
)
1482 var_map map
= live
->map
;
1485 if ((flag
& LIVEDUMP_ENTRY
) && live
->livein
)
1487 FOR_EACH_BB_FN (bb
, cfun
)
1489 fprintf (f
, "\nLive on entry to BB%d : ", bb
->index
);
1490 EXECUTE_IF_SET_IN_BITMAP (&live
->livein
[bb
->index
], 0, i
, bi
)
1492 print_generic_expr (f
, partition_to_var (map
, i
), TDF_SLIM
);
1499 if ((flag
& LIVEDUMP_EXIT
) && live
->liveout
)
1501 FOR_EACH_BB_FN (bb
, cfun
)
1503 fprintf (f
, "\nLive on exit from BB%d : ", bb
->index
);
1504 EXECUTE_IF_SET_IN_BITMAP (&live
->liveout
[bb
->index
], 0, i
, bi
)
1506 print_generic_expr (f
, partition_to_var (map
, i
), TDF_SLIM
);
1515 /* Generic dump for the above. */
1518 debug (tree_live_info_d
&ref
)
1520 dump_live_info (stderr
, &ref
, 0);
1524 debug (tree_live_info_d
*ptr
)
1529 fprintf (stderr
, "<nil>\n");
1533 /* Verify that the info in LIVE matches the current cfg. */
1536 verify_live_on_entry (tree_live_info_p live
)
1545 var_map map
= live
->map
;
1547 /* Check for live on entry partitions and report those with a DEF in
1548 the program. This will typically mean an optimization has done
1550 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1552 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1554 int entry_block
= e
->dest
->index
;
1555 if (!region_contains_p (live
->map
, e
->dest
))
1557 for (i
= 0; i
< (unsigned)num_var_partitions (map
); i
++)
1562 var
= partition_to_var (map
, i
);
1563 stmt
= SSA_NAME_DEF_STMT (var
);
1564 tmp
= gimple_bb (stmt
);
1565 if (SSA_NAME_VAR (var
))
1566 d
= ssa_default_def (cfun
, SSA_NAME_VAR (var
));
1568 loe
= live_on_entry (live
, e
->dest
);
1569 if (loe
&& bitmap_bit_p (loe
, i
))
1571 if (!gimple_nop_p (stmt
))
1574 print_generic_expr (stderr
, var
, TDF_SLIM
);
1575 fprintf (stderr
, " is defined ");
1577 fprintf (stderr
, " in BB%d, ", tmp
->index
);
1578 fprintf (stderr
, "by:\n");
1579 print_gimple_stmt (stderr
, stmt
, 0, TDF_SLIM
);
1580 fprintf (stderr
, "\nIt is also live-on-entry to entry BB %d",
1582 fprintf (stderr
, " So it appears to have multiple defs.\n");
1589 print_generic_expr (stderr
, var
, TDF_SLIM
);
1590 fprintf (stderr
, " is live-on-entry to BB%d ",
1594 fprintf (stderr
, " but is not the default def of ");
1595 print_generic_expr (stderr
, d
, TDF_SLIM
);
1596 fprintf (stderr
, "\n");
1599 fprintf (stderr
, " and there is no default def.\n");
1606 /* An undefined local variable does not need to be very
1608 if (ssa_undefined_value_p (var
, false))
1611 /* The only way this var shouldn't be marked live on entry is
1612 if it occurs in a PHI argument of the block. */
1616 for (gsi
= gsi_start_phis (e
->dest
);
1617 !gsi_end_p (gsi
) && !ok
;
1620 gphi
*phi
= gsi
.phi ();
1621 if (virtual_operand_p (gimple_phi_result (phi
)))
1623 for (z
= 0; z
< gimple_phi_num_args (phi
); z
++)
1624 if (var
== gimple_phi_arg_def (phi
, z
))
1632 /* Expand adds unused default defs for PARM_DECLs and
1633 RESULT_DECLs. They're ok. */
1634 if (has_zero_uses (var
)
1635 && SSA_NAME_VAR (var
)
1636 && !VAR_P (SSA_NAME_VAR (var
)))
1639 print_generic_expr (stderr
, var
, TDF_SLIM
);
1640 fprintf (stderr
, " is not marked live-on-entry to entry BB%d ",
1642 fprintf (stderr
, "but it is a default def so it should be.\n");
1646 gcc_assert (num
<= 0);
1650 /* Virtual operand liveness analysis data init. */
1653 virtual_operand_live::init ()
1655 liveout
= XCNEWVEC (tree
, last_basic_block_for_fn (cfun
) + 1);
1656 liveout
[ENTRY_BLOCK
] = ssa_default_def (cfun
, gimple_vop (cfun
));
1659 /* Compute live-in of BB from cached live-out. */
1662 virtual_operand_live::get_live_in (basic_block bb
)
1664 /* A virtual PHI is a convenient cache for live-in. */
1665 gphi
*phi
= get_virtual_phi (bb
);
1667 return gimple_phi_result (phi
);
1672 /* Since we don't have a virtual PHI and we don't know whether there's
1673 a downstream virtual use (and thus PHIs are inserted where necessary)
1674 we now have to check each incoming edge live-out. */
1677 tree livein
= NULL_TREE
;
1678 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1679 if (e
->flags
& EDGE_DFS_BACK
)
1680 /* We can ignore backedges since if there's a def there it would
1681 have forced a PHI in the source because it also acts as use
1685 livein
= get_live_out (e
->src
);
1686 else if (get_live_out (e
->src
) != livein
)
1687 /* When there's no virtual use downstream this indicates a point
1688 where we'd insert a PHI merging the different live virtual
1695 /* Compute live-out of BB. */
1698 virtual_operand_live::get_live_out (basic_block bb
)
1703 if (liveout
[bb
->index
])
1704 return liveout
[bb
->index
];
1706 tree lo
= NULL_TREE
;
1707 for (auto gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
1709 gimple
*stmt
= gsi_stmt (gsi
);
1710 if (gimple_vdef (stmt
))
1712 lo
= gimple_vdef (stmt
);
1715 if (gimple_vuse (stmt
))
1717 lo
= gimple_vuse (stmt
);
1722 lo
= get_live_in (bb
);
1723 liveout
[bb
->index
] = lo
;