Line data Source code
1 : /* Liveness for SSA trees.
2 : Copyright (C) 2003-2026 Free Software Foundation, Inc.
3 : Contributed by Andrew MacLeod <amacleod@redhat.com>
4 :
5 : This file is part of GCC.
6 :
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)
10 : any later version.
11 :
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.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with GCC; see the file COPYING3. If not see
19 : <http://www.gnu.org/licenses/>. */
20 :
21 : #include "config.h"
22 : #include "system.h"
23 : #include "coretypes.h"
24 : #include "backend.h"
25 : #include "rtl.h"
26 : #include "tree.h"
27 : #include "gimple.h"
28 : #include "timevar.h"
29 : #include "ssa.h"
30 : #include "cgraph.h"
31 : #include "gimple-pretty-print.h"
32 : #include "diagnostic-core.h"
33 : #include "gimple-iterator.h"
34 : #include "tree-dfa.h"
35 : #include "dumpfile.h"
36 : #include "tree-ssa-live.h"
37 : #include "debug.h"
38 : #include "tree-ssa.h"
39 : #include "ipa-utils.h"
40 : #include "cfgloop.h"
41 : #include "stringpool.h"
42 : #include "attribs.h"
43 : #include "optinfo.h"
44 : #include "gimple-walk.h"
45 : #include "cfganal.h"
46 : #include "tree-cfg.h"
47 :
48 : static void verify_live_on_entry (tree_live_info_p);
49 :
50 :
51 : /* VARMAP maintains a mapping from SSA version number to real variables.
52 :
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.
56 :
57 : At the end of out-of-ssa, each partition becomes a "real" variable and is
58 : rewritten as a compiler variable.
59 :
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. */
63 :
64 :
65 : /* Remove the base table in MAP. */
66 :
67 : static void
68 4432937 : var_map_base_fini (var_map map)
69 : {
70 : /* Free the basevar info if it is present. */
71 4432937 : if (map->partition_to_base_index != NULL)
72 : {
73 1477646 : free (map->partition_to_base_index);
74 1477646 : map->partition_to_base_index = NULL;
75 1477646 : map->num_basevars = 0;
76 : }
77 4432937 : }
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
81 : will be coalesced. */
82 :
83 : var_map
84 1477646 : init_var_map (int size, class loop *loop, bitmap bitint)
85 : {
86 1477646 : var_map map;
87 :
88 1477646 : map = (var_map) xmalloc (sizeof (struct _var_map));
89 1477646 : map->var_partition = partition_new (size);
90 :
91 1477646 : map->partition_to_view = NULL;
92 1477646 : map->view_to_partition = NULL;
93 1477646 : map->num_partitions = size;
94 1477646 : map->partition_size = size;
95 1477646 : map->num_basevars = 0;
96 1477646 : map->partition_to_base_index = NULL;
97 1477646 : map->vec_bbs = vNULL;
98 1477646 : if (loop)
99 : {
100 0 : map->bmp_bbs = BITMAP_ALLOC (NULL);
101 0 : map->outofssa_p = false;
102 0 : basic_block *bbs = get_loop_body_in_dom_order (loop);
103 0 : for (unsigned i = 0; i < loop->num_nodes; ++i)
104 : {
105 0 : bitmap_set_bit (map->bmp_bbs, bbs[i]->index);
106 0 : map->vec_bbs.safe_push (bbs[i]);
107 : }
108 0 : free (bbs);
109 : }
110 : else
111 : {
112 1477646 : map->bmp_bbs = NULL;
113 1477646 : map->outofssa_p = bitint == NULL;
114 1477646 : map->bitint = bitint;
115 1477646 : basic_block bb;
116 2955292 : map->vec_bbs.reserve_exact (n_basic_blocks_for_fn (cfun)
117 1477646 : - NUM_FIXED_BLOCKS);
118 14077803 : FOR_EACH_BB_FN (bb, cfun)
119 12600157 : map->vec_bbs.quick_push (bb);
120 : }
121 1477646 : return map;
122 : }
123 :
124 :
125 : /* Free memory associated with MAP. */
126 :
127 : void
128 1477645 : delete_var_map (var_map map)
129 : {
130 1477645 : var_map_base_fini (map);
131 1477645 : partition_delete (map->var_partition);
132 1477645 : free (map->partition_to_view);
133 1477645 : free (map->view_to_partition);
134 1477645 : if (map->bmp_bbs)
135 0 : BITMAP_FREE (map->bmp_bbs);
136 1477645 : map->vec_bbs.release ();
137 1477645 : free (map);
138 1477645 : }
139 :
140 :
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. */
144 :
145 : int
146 5380982 : var_union (var_map map, tree var1, tree var2)
147 : {
148 5380982 : int p1, p2, p3;
149 :
150 5380982 : gcc_assert (TREE_CODE (var1) == SSA_NAME);
151 5380982 : gcc_assert (TREE_CODE (var2) == SSA_NAME);
152 :
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. */
156 :
157 5380982 : p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1));
158 5380982 : p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2));
159 :
160 5380982 : gcc_assert (p1 != NO_PARTITION);
161 5380982 : gcc_assert (p2 != NO_PARTITION);
162 :
163 5380982 : if (p1 == p2)
164 : p3 = p1;
165 : else
166 5380982 : p3 = partition_union (map->var_partition, p1, p2);
167 :
168 5380982 : if (map->partition_to_view)
169 5380982 : p3 = map->partition_to_view[p3];
170 :
171 5380982 : return p3;
172 : }
173 :
174 :
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
179 : denser.
180 :
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.
187 :
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. */
191 :
192 :
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
195 : varmap. */
196 :
197 : static bitmap
198 2955292 : partition_view_init (var_map map)
199 : {
200 2955292 : bitmap used;
201 2955292 : int tmp;
202 2955292 : unsigned int x;
203 :
204 2955292 : used = BITMAP_ALLOC (NULL);
205 :
206 : /* Already in a view? Abandon the old one. */
207 2955292 : if (map->partition_to_view)
208 : {
209 1477646 : free (map->partition_to_view);
210 1477646 : map->partition_to_view = NULL;
211 : }
212 2955292 : if (map->view_to_partition)
213 : {
214 1477646 : free (map->view_to_partition);
215 1477646 : map->view_to_partition = NULL;
216 : }
217 :
218 : /* Find out which partitions are actually referenced. */
219 148275002 : for (x = 0; x < map->partition_size; x++)
220 : {
221 145319710 : tmp = partition_find (map->var_partition, x);
222 338862882 : if (ssa_name (tmp) != NULL_TREE && !virtual_operand_p (ssa_name (tmp))
223 208224884 : && (!has_zero_uses (ssa_name (tmp))
224 4168513 : || !SSA_NAME_IS_DEFAULT_DEF (ssa_name (tmp))
225 3488398 : || (SSA_NAME_VAR (ssa_name (tmp))
226 3488398 : && !VAR_P (SSA_NAME_VAR (ssa_name (tmp))))))
227 62409186 : bitmap_set_bit (used, tmp);
228 : }
229 :
230 2955292 : map->num_partitions = map->partition_size;
231 2955292 : return used;
232 : }
233 :
234 :
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. */
239 :
240 : static void
241 2955292 : partition_view_fini (var_map map, bitmap selected)
242 : {
243 2955292 : bitmap_iterator bi;
244 2955292 : unsigned count, i, x, limit;
245 :
246 2955292 : gcc_assert (selected);
247 :
248 2955292 : count = bitmap_count_bits (selected);
249 2955292 : limit = map->partition_size;
250 :
251 : /* If its a one-to-one ratio, we don't need any view compaction. */
252 2955292 : if (count < limit)
253 : {
254 2955292 : map->partition_to_view = (int *)xmalloc (limit * sizeof (int));
255 2955292 : memset (map->partition_to_view, 0xff, (limit * sizeof (int)));
256 2955292 : map->view_to_partition = (int *)xmalloc (count * sizeof (int));
257 :
258 2955292 : i = 0;
259 : /* Give each selected partition an index. */
260 40069650 : EXECUTE_IF_SET_IN_BITMAP (selected, 0, x, bi)
261 : {
262 37114358 : map->partition_to_view[x] = i;
263 37114358 : map->view_to_partition[i] = x;
264 37114358 : i++;
265 : }
266 2955292 : gcc_assert (i == count);
267 2955292 : map->num_partitions = i;
268 : }
269 :
270 2955292 : BITMAP_FREE (selected);
271 2955292 : }
272 :
273 :
274 : /* Create a partition view which includes all the used partitions in MAP. */
275 :
276 : void
277 1477646 : partition_view_normal (var_map map)
278 : {
279 1477646 : bitmap used;
280 :
281 1477646 : used = partition_view_init (map);
282 1477646 : partition_view_fini (map, used);
283 :
284 1477646 : var_map_base_fini (map);
285 1477646 : }
286 :
287 :
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
290 : as well. */
291 :
292 : void
293 1477646 : partition_view_bitmap (var_map map, bitmap only)
294 : {
295 1477646 : bitmap used;
296 1477646 : bitmap new_partitions = BITMAP_ALLOC (NULL);
297 1477646 : unsigned x, p;
298 1477646 : bitmap_iterator bi;
299 :
300 1477646 : used = partition_view_init (map);
301 12768393 : EXECUTE_IF_SET_IN_BITMAP (only, 0, x, bi)
302 : {
303 11290747 : p = partition_find (map->var_partition, x);
304 11290747 : gcc_assert (bitmap_bit_p (used, p));
305 11290747 : bitmap_set_bit (new_partitions, p);
306 : }
307 1477646 : partition_view_fini (map, new_partitions);
308 :
309 1477646 : var_map_base_fini (map);
310 1477646 : }
311 :
312 :
313 : static bitmap usedvars;
314 :
315 : /* Mark VAR as used, so that it'll be preserved during rtl expansion.
316 : Returns true if VAR wasn't marked before. */
317 :
318 : static inline bool
319 179404041 : set_is_used (tree var)
320 : {
321 179404041 : return bitmap_set_bit (usedvars, DECL_UID (var));
322 : }
323 :
324 : /* Return true if VAR is marked as used. */
325 :
326 : static inline bool
327 192164647 : is_used_p (tree var)
328 : {
329 192164647 : return bitmap_bit_p (usedvars, DECL_UID (var));
330 : }
331 :
332 : static inline void mark_all_vars_used (tree *);
333 :
334 : /* Helper function for mark_all_vars_used, called via walk_tree. */
335 :
336 : static tree
337 1062502803 : mark_all_vars_used_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
338 : {
339 1062502803 : tree t = *tp;
340 1062502803 : enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
341 1062502803 : tree b;
342 :
343 1062502803 : if (TREE_CODE (t) == SSA_NAME)
344 : {
345 402491897 : *walk_subtrees = 0;
346 402491897 : t = SSA_NAME_VAR (t);
347 : if (!t)
348 : return NULL;
349 : }
350 :
351 792674165 : if (IS_EXPR_CODE_CLASS (c)
352 792674165 : && (b = TREE_BLOCK (t)) != NULL)
353 76885300 : TREE_USED (b) = true;
354 :
355 : /* Ignore TMR_OFFSET and TMR_STEP for TARGET_MEM_REFS, as those
356 : fields do not contain vars. */
357 792674165 : if (TREE_CODE (t) == TARGET_MEM_REF)
358 : {
359 1702874 : mark_all_vars_used (&TMR_BASE (t));
360 1702874 : mark_all_vars_used (&TMR_INDEX (t));
361 1702874 : mark_all_vars_used (&TMR_INDEX2 (t));
362 1702874 : *walk_subtrees = 0;
363 1702874 : return NULL;
364 : }
365 :
366 : /* Only need to mark VAR_DECLS; parameters and return results are not
367 : eliminated as unused. */
368 790971291 : if (VAR_P (t))
369 : {
370 : /* When a global var becomes used for the first time also walk its
371 : initializer (non global ones don't have any). */
372 220463310 : if (set_is_used (t) && is_global_var (t)
373 186476282 : && DECL_CONTEXT (t) == current_function_decl)
374 1062513 : mark_all_vars_used (&DECL_INITIAL (t));
375 : }
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 611567250 : 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. */
383 6313804 : TREE_USED (t) = 1;
384 :
385 790971291 : if (IS_TYPE_OR_DECL_P (t))
386 355432530 : *walk_subtrees = 0;
387 :
388 : return NULL;
389 : }
390 :
391 : /* Mark the scope block SCOPE and its subblocks unused when they can be
392 : possibly eliminated if dead. */
393 :
394 : static void
395 115451116 : mark_scope_block_unused (tree scope)
396 : {
397 115451116 : tree t;
398 115451116 : TREE_USED (scope) = false;
399 115451116 : if (!(*debug_hooks->ignore_block) (scope))
400 481232 : TREE_USED (scope) = true;
401 219352407 : for (t = BLOCK_SUBBLOCKS (scope); t ; t = BLOCK_CHAIN (t))
402 103901291 : mark_scope_block_unused (t);
403 115451116 : }
404 :
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. */
417 :
418 : static bool
419 115451116 : remove_unused_scope_block_p (tree scope, bool in_ctor_dtor_block)
420 : {
421 115451116 : tree *t, *next;
422 115451116 : bool unused = !TREE_USED (scope);
423 115451116 : int nsubblocks = 0;
424 :
425 : /* For ipa-polymorphic-call.cc purposes, preserve blocks:
426 : 1) with BLOCK_ABSTRACT_ORIGIN of a ctor/dtor or their clones */
427 115451116 : if (inlined_polymorphic_ctor_dtor_block_p (scope, true))
428 : {
429 : in_ctor_dtor_block = true;
430 : unused = false;
431 : }
432 : /* 2) inside such blocks, the outermost block with block_ultimate_origin
433 : being a FUNCTION_DECL. */
434 99088369 : else if (in_ctor_dtor_block)
435 : {
436 13353429 : tree fn = block_ultimate_origin (scope);
437 13353429 : if (fn && TREE_CODE (fn) == FUNCTION_DECL)
438 : {
439 115451116 : in_ctor_dtor_block = false;
440 115451116 : unused = false;
441 : }
442 : }
443 :
444 233634049 : for (t = &BLOCK_VARS (scope); *t; t = next)
445 : {
446 118182933 : next = &DECL_CHAIN (*t);
447 :
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.
451 :
452 : TODO: We can actually look into cgraph to see if function
453 : will be output to file. */
454 118182933 : if (TREE_CODE (*t) == FUNCTION_DECL)
455 : unused = false;
456 :
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 117843132 : else if (VAR_P (*t) && DECL_HAS_VALUE_EXPR_P (*t))
465 : unused = false;
466 :
467 : /* Remove everything we don't generate debug info for. */
468 116291822 : else if (DECL_IGNORED_P (*t))
469 : {
470 4245397 : *t = DECL_CHAIN (*t);
471 4245397 : next = t;
472 : }
473 :
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 112046425 : else if (is_used_p (*t))
479 : unused = false;
480 98254017 : 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. */
492 : unused = false;
493 :
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
496 : a lot of memory.
497 :
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.
502 :
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. */
510 :
511 97475473 : else if (TREE_CODE (*t) == TYPE_DECL
512 93114781 : || debug_info_level == DINFO_LEVEL_NORMAL
513 2350690 : || debug_info_level == DINFO_LEVEL_VERBOSE)
514 : ;
515 : else
516 : {
517 2341346 : *t = DECL_CHAIN (*t);
518 2341346 : next = t;
519 : }
520 : }
521 :
522 219352407 : for (t = &BLOCK_SUBBLOCKS (scope); *t ;)
523 103901291 : if (remove_unused_scope_block_p (*t, in_ctor_dtor_block))
524 : {
525 8525756 : if (BLOCK_SUBBLOCKS (*t))
526 : {
527 2865862 : tree next = BLOCK_CHAIN (*t);
528 2865862 : tree supercontext = BLOCK_SUPERCONTEXT (*t);
529 :
530 2865862 : *t = BLOCK_SUBBLOCKS (*t);
531 3557121 : while (BLOCK_CHAIN (*t))
532 : {
533 691259 : BLOCK_SUPERCONTEXT (*t) = supercontext;
534 691259 : t = &BLOCK_CHAIN (*t);
535 : }
536 2865862 : BLOCK_CHAIN (*t) = next;
537 2865862 : BLOCK_SUPERCONTEXT (*t) = supercontext;
538 2865862 : t = &BLOCK_CHAIN (*t);
539 2865862 : nsubblocks ++;
540 : }
541 : else
542 5659894 : *t = BLOCK_CHAIN (*t);
543 : }
544 : else
545 : {
546 95375535 : t = &BLOCK_CHAIN (*t);
547 95375535 : nsubblocks ++;
548 : }
549 :
550 :
551 115451116 : if (!unused)
552 : ;
553 : /* Outer scope is always used. */
554 27174735 : else if (!BLOCK_SUPERCONTEXT (scope)
555 27174735 : || TREE_CODE (BLOCK_SUPERCONTEXT (scope)) == FUNCTION_DECL)
556 : unused = false;
557 : /* Innermost blocks with no live variables nor statements can be always
558 : eliminated. */
559 26021949 : else if (!nsubblocks)
560 : ;
561 : /* When not generating debug info we can eliminate info on unused
562 : variables. */
563 20362055 : else if (!flag_auto_profile
564 20362055 : && debug_info_level == DINFO_LEVEL_NONE
565 22062532 : && !optinfo_wants_inlining_info_p ())
566 : {
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 1700409 : if (inlined_function_outer_scope_p (scope))
571 : {
572 1427148 : gcc_assert (TREE_CODE (BLOCK_ORIGIN (scope)) == FUNCTION_DECL);
573 : unused = false;
574 : }
575 : }
576 18661646 : else if (BLOCK_VARS (scope) || BLOCK_NUM_NONLOCALIZED_VARS (scope))
577 : unused = false;
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 2736596 : else if (inlined_function_outer_scope_p (scope))
583 : unused = false;
584 : else
585 : /* Verfify that only blocks with source location set
586 : are entry points to the inlined functions. */
587 2592601 : gcc_assert (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope))
588 : == UNKNOWN_LOCATION);
589 :
590 115451116 : TREE_USED (scope) = !unused;
591 115451116 : return unused;
592 : }
593 :
594 : /* Mark all VAR_DECLS under *EXPR_P as used, so that they won't be
595 : eliminated during the tree->rtl conversion process. */
596 :
597 : static inline void
598 796098101 : mark_all_vars_used (tree *expr_p)
599 : {
600 796098101 : walk_tree (expr_p, mark_all_vars_used_1, NULL, NULL);
601 796098101 : }
602 :
603 : /* Helper function for clear_unused_block_pointer, called via walk_tree. */
604 :
605 : static tree
606 483166315 : clear_unused_block_pointer_1 (tree *tp, int *, void *)
607 : {
608 79835914 : if (EXPR_P (*tp) && TREE_BLOCK (*tp)
609 537958172 : && !TREE_USED (TREE_BLOCK (*tp)))
610 1334364 : TREE_SET_BLOCK (*tp, NULL);
611 483166315 : return NULL_TREE;
612 : }
613 :
614 : /* Clear references to unused BLOCKs from DECL_VALUE_EXPRs of variables
615 : in BLOCK. */
616 :
617 : static void
618 106925360 : clear_unused_block_pointer_in_block (tree block)
619 : {
620 214975228 : for (tree t = BLOCK_VARS (block); t; t = DECL_CHAIN (t))
621 108049868 : if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
622 : {
623 1551310 : tree val = DECL_VALUE_EXPR (t);
624 1551310 : walk_tree (&val, clear_unused_block_pointer_1, NULL, NULL);
625 : }
626 202300895 : for (tree t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
627 95375535 : clear_unused_block_pointer_in_block (t);
628 106925360 : }
629 :
630 : /* Set all block pointer in debug or clobber stmt to NULL if the block
631 : is unused, so that they will not be streamed out. */
632 :
633 : static void
634 11549825 : clear_unused_block_pointer (void)
635 : {
636 11549825 : basic_block bb;
637 11549825 : gimple_stmt_iterator gsi;
638 :
639 91907482 : FOR_EACH_BB_FN (bb, cfun)
640 720203771 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
641 : {
642 561216079 : unsigned i;
643 561216079 : tree b;
644 561216079 : gimple *stmt;
645 :
646 559492158 : next:
647 561216079 : stmt = gsi_stmt (gsi);
648 561216079 : if (!is_gimple_debug (stmt) && !gimple_clobber_p (stmt))
649 263515883 : continue;
650 297700196 : b = gimple_block (stmt);
651 297700196 : if (b && !TREE_USED (b))
652 : {
653 : /* Elide debug marker stmts that have an associated BLOCK from an
654 : inline instance removed with also the outermost scope BLOCK of
655 : said inline instance removed. If the outermost scope BLOCK of
656 : said inline instance is preserved use that in place of the
657 : removed BLOCK. That keeps the marker associated to the correct
658 : inline instance (or no inline instance in case it was not from
659 : an inline instance). */
660 7292001 : if (gimple_debug_nonbind_marker_p (stmt)
661 9172994 : && BLOCK_ABSTRACT_ORIGIN (b))
662 : {
663 2266321 : while (TREE_CODE (b) == BLOCK
664 2266321 : && !inlined_function_outer_scope_p (b))
665 400360 : b = BLOCK_SUPERCONTEXT (b);
666 1865961 : if (TREE_CODE (b) == BLOCK)
667 : {
668 1864126 : if (TREE_USED (b))
669 : {
670 136504 : gimple_set_block (stmt, b);
671 136504 : continue;
672 : }
673 1727622 : gsi_remove (&gsi, true);
674 1727622 : if (gsi_end_p (gsi))
675 : break;
676 1723921 : goto next;
677 : }
678 : }
679 5427875 : gimple_set_block (stmt, NULL);
680 : }
681 751272834 : for (i = 0; i < gimple_num_ops (stmt); i++)
682 455436764 : walk_tree (gimple_op_ptr (stmt, i), clear_unused_block_pointer_1,
683 : NULL, NULL);
684 : }
685 :
686 : /* Walk all variables mentioned in the functions BLOCK tree and clear
687 : DECL_VALUE_EXPR from unused blocks where present. */
688 11549825 : clear_unused_block_pointer_in_block (DECL_INITIAL (current_function_decl));
689 11549825 : }
690 :
691 : /* Dump scope blocks starting at SCOPE to FILE. INDENT is the
692 : indentation level and FLAGS is as in print_generic_expr. */
693 :
694 : static void
695 4448 : dump_scope_block (FILE *file, int indent, tree scope, dump_flags_t flags)
696 : {
697 4448 : tree var, t;
698 4448 : unsigned int i;
699 :
700 4448 : fprintf (file, "\n%*s{ Scope block #%i%s",indent, "" , BLOCK_NUMBER (scope),
701 4448 : TREE_USED (scope) ? "" : " (unused)");
702 4448 : if (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope)) != UNKNOWN_LOCATION)
703 : {
704 947 : expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (scope));
705 947 : fprintf (file, " %s:%i:%i", s.file, s.line, s.column);
706 947 : if (has_discriminator (BLOCK_SOURCE_LOCATION (scope)))
707 58 : fprintf (file, " discrim %i",
708 29 : get_discriminator_from_loc (BLOCK_SOURCE_LOCATION (scope)));
709 : }
710 4448 : if (BLOCK_ABSTRACT_ORIGIN (scope))
711 : {
712 2055 : tree origin = block_ultimate_origin (scope);
713 2055 : if (origin)
714 : {
715 2055 : fprintf (file, " Originating from :");
716 2055 : if (DECL_P (origin))
717 947 : print_generic_decl (file, origin, flags);
718 : else
719 1108 : fprintf (file, "#%i", BLOCK_NUMBER (origin));
720 : }
721 : }
722 4448 : if (BLOCK_FRAGMENT_ORIGIN (scope))
723 0 : fprintf (file, " Fragment of : #%i",
724 0 : BLOCK_NUMBER (BLOCK_FRAGMENT_ORIGIN (scope)));
725 4448 : else if (BLOCK_FRAGMENT_CHAIN (scope))
726 : {
727 0 : fprintf (file, " Fragment chain :");
728 0 : for (t = BLOCK_FRAGMENT_CHAIN (scope); t ;
729 0 : t = BLOCK_FRAGMENT_CHAIN (t))
730 0 : fprintf (file, " #%i", BLOCK_NUMBER (t));
731 : }
732 4448 : fprintf (file, " \n");
733 8310 : for (var = BLOCK_VARS (scope); var; var = DECL_CHAIN (var))
734 : {
735 3862 : fprintf (file, "%*s", indent, "");
736 3862 : print_generic_decl (file, var, flags);
737 3862 : fprintf (file, "\n");
738 : }
739 4448 : for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (scope); i++)
740 : {
741 0 : fprintf (file, "%*s",indent, "");
742 0 : print_generic_decl (file, BLOCK_NONLOCALIZED_VAR (scope, i),
743 : flags);
744 0 : fprintf (file, " (nonlocalized)\n");
745 : }
746 6898 : for (t = BLOCK_SUBBLOCKS (scope); t ; t = BLOCK_CHAIN (t))
747 2450 : dump_scope_block (file, indent + 2, t, flags);
748 4448 : fprintf (file, "\n%*s}\n",indent, "");
749 4448 : }
750 :
751 : /* Dump the tree of lexical scopes starting at SCOPE to stderr. FLAGS
752 : is as in print_generic_expr. */
753 :
754 : DEBUG_FUNCTION void
755 0 : debug_scope_block (tree scope, dump_flags_t flags)
756 : {
757 0 : dump_scope_block (stderr, 0, scope, flags);
758 0 : }
759 :
760 :
761 : /* Dump the tree of lexical scopes of current_function_decl to FILE.
762 : FLAGS is as in print_generic_expr. */
763 :
764 : void
765 1998 : dump_scope_blocks (FILE *file, dump_flags_t flags)
766 : {
767 1998 : dump_scope_block (file, 0, DECL_INITIAL (current_function_decl), flags);
768 1998 : }
769 :
770 :
771 : /* Dump the tree of lexical scopes of current_function_decl to stderr.
772 : FLAGS is as in print_generic_expr. */
773 :
774 : DEBUG_FUNCTION void
775 0 : debug_scope_blocks (dump_flags_t flags)
776 : {
777 0 : dump_scope_blocks (stderr, flags);
778 0 : }
779 :
780 : /* Remove local variables that are not referenced in the IL. */
781 :
782 : void
783 12869011 : remove_unused_locals (void)
784 : {
785 12869011 : basic_block bb;
786 12869011 : tree var;
787 12869011 : unsigned srcidx, dstidx, num;
788 12869011 : bool have_local_clobbers = false;
789 :
790 : /* Removing declarations from lexical blocks when not optimizing is
791 : not only a waste of time, it actually causes differences in stack
792 : layout. */
793 12869011 : if (!optimize)
794 1319186 : return;
795 :
796 11549825 : timevar_push (TV_REMOVE_UNUSED);
797 :
798 11549825 : mark_scope_block_unused (DECL_INITIAL (current_function_decl));
799 :
800 11549825 : usedvars = BITMAP_ALLOC (NULL);
801 11549825 : auto_bitmap useddebug;
802 :
803 : /* Walk the CFG marking all referenced symbols. */
804 91907482 : FOR_EACH_BB_FN (bb, cfun)
805 : {
806 80357657 : gimple_stmt_iterator gsi;
807 80357657 : size_t i;
808 80357657 : edge_iterator ei;
809 80357657 : edge e;
810 :
811 : /* Walk the statements. */
812 727752481 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
813 : {
814 567037167 : gimple *stmt = gsi_stmt (gsi);
815 567037167 : tree b = gimple_block (stmt);
816 :
817 : /* If we wanted to mark the block referenced by the inline
818 : entry point marker as used, this would be a good spot to
819 : do it. If the block is not otherwise used, the stmt will
820 : be cleaned up in clean_unused_block_pointer. */
821 567037167 : if (is_gimple_debug (stmt))
822 : {
823 290290234 : if (gimple_debug_bind_p (stmt))
824 : {
825 219714914 : tree var = gimple_debug_bind_get_var (stmt);
826 219714914 : if (VAR_P (var))
827 : {
828 206907788 : if (!gimple_debug_bind_get_value (stmt))
829 : /* Run the 2nd phase. */
830 : have_local_clobbers = true;
831 : else
832 109424739 : bitmap_set_bit (useddebug, DECL_UID (var));
833 : }
834 : }
835 290290234 : continue;
836 290290234 : }
837 :
838 276746933 : if (gimple_clobber_p (stmt))
839 : {
840 13230909 : have_local_clobbers = true;
841 13230909 : continue;
842 : }
843 :
844 263516024 : if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT))
845 : {
846 291586 : have_local_clobbers = true;
847 291586 : continue;
848 : }
849 :
850 263224438 : if (b)
851 239299257 : TREE_USED (b) = true;
852 :
853 1003695598 : for (i = 0; i < gimple_num_ops (stmt); i++)
854 740471160 : mark_all_vars_used (gimple_op_ptr (gsi_stmt (gsi), i));
855 : }
856 :
857 80357657 : for (gphi_iterator gpi = gsi_start_phis (bb);
858 107502582 : !gsi_end_p (gpi);
859 27144925 : gsi_next (&gpi))
860 : {
861 27144925 : use_operand_p arg_p;
862 27144925 : ssa_op_iter i;
863 27144925 : tree def;
864 27144925 : gphi *phi = gpi.phi ();
865 :
866 54289850 : if (virtual_operand_p (gimple_phi_result (phi)))
867 12440732 : continue;
868 :
869 14704193 : def = gimple_phi_result (phi);
870 14704193 : mark_all_vars_used (&def);
871 :
872 49455806 : FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_ALL_USES)
873 : {
874 34751613 : tree arg = USE_FROM_PTR (arg_p);
875 34751613 : int index = PHI_ARG_INDEX_FROM_USE (arg_p);
876 34751613 : tree block =
877 34751613 : LOCATION_BLOCK (gimple_phi_arg_location (phi, index));
878 20535315 : if (block != NULL)
879 20531813 : TREE_USED (block) = true;
880 34751613 : mark_all_vars_used (&arg);
881 : }
882 : }
883 :
884 192338226 : FOR_EACH_EDGE (e, ei, bb->succs)
885 111980569 : if (LOCATION_BLOCK (e->goto_locus) != NULL)
886 23718081 : TREE_USED (LOCATION_BLOCK (e->goto_locus)) = true;
887 : }
888 :
889 : /* We do a two-pass approach about the out-of-scope clobbers. We want
890 : to remove them if they are the only references to a local variable,
891 : but we want to retain them when there's any other. So the first pass
892 : ignores them, and the second pass (if there were any) tries to remove
893 : them. We do the same for .DEFERRED_INIT. */
894 11549825 : if (have_local_clobbers)
895 61574170 : FOR_EACH_BB_FN (bb, cfun)
896 : {
897 56753544 : gimple_stmt_iterator gsi;
898 :
899 595921178 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
900 : {
901 482414090 : gimple *stmt = gsi_stmt (gsi);
902 482414090 : tree b = gimple_block (stmt);
903 :
904 482414090 : if (gimple_clobber_p (stmt))
905 : {
906 13230909 : tree lhs = gimple_assign_lhs (stmt);
907 13230909 : tree base = get_base_address (lhs);
908 : /* Remove clobbers referencing unused vars, or clobbers
909 : with MEM_REF lhs referencing uninitialized pointers. */
910 12085439 : if ((VAR_P (base) && !is_used_p (base))
911 24270626 : || (TREE_CODE (lhs) == MEM_REF
912 1298909 : && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME
913 1144663 : && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (lhs, 0))
914 592827 : && (TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (lhs, 0)))
915 : != PARM_DECL)))
916 : {
917 1049199 : unlink_stmt_vdef (stmt);
918 1049199 : gsi_remove (&gsi, true);
919 1049199 : release_defs (stmt);
920 1049199 : continue;
921 : }
922 12181710 : if (b)
923 7558062 : TREE_USED (b) = true;
924 : }
925 469183181 : else if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT))
926 : {
927 291586 : tree lhs = gimple_call_lhs (stmt);
928 291586 : tree base = get_base_address (lhs);
929 241005 : if ((DECL_P (base) && !is_used_p (base))
930 532454 : || (TREE_CODE (lhs) == MEM_REF
931 138 : && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME
932 105 : && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (lhs, 0))
933 4 : && (TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (lhs, 0)))
934 : != PARM_DECL)))
935 : {
936 141 : unlink_stmt_vdef (stmt);
937 141 : gsi_remove (&gsi, true);
938 141 : release_defs (stmt);
939 141 : continue;
940 : }
941 291445 : if (b)
942 291428 : TREE_USED (b) = true;
943 : }
944 468891595 : else if (gimple_debug_bind_p (stmt))
945 : {
946 216599508 : tree var = gimple_debug_bind_get_var (stmt);
947 221371256 : if (VAR_P (var)
948 204057818 : && !bitmap_bit_p (useddebug, DECL_UID (var))
949 221875223 : && !is_used_p (var))
950 : {
951 4771748 : if (dump_file && (dump_flags & TDF_DETAILS))
952 0 : fprintf (dump_file, "Dead debug bind reset to %u\n",
953 0 : DECL_UID (var));
954 4771748 : gsi_remove (&gsi, true);
955 4771748 : continue;
956 : }
957 : }
958 476593002 : gsi_next (&gsi);
959 : }
960 : }
961 :
962 11549825 : if (cfun->has_simduid_loops)
963 : {
964 123385 : for (auto loop : loops_list (cfun, 0))
965 45235 : if (loop->simduid && !is_used_p (loop->simduid))
966 26332 : loop->simduid = NULL_TREE;
967 : }
968 :
969 11549825 : cfun->has_local_explicit_reg_vars = false;
970 :
971 : /* Remove unmarked local and global vars from local_decls. */
972 11549825 : num = vec_safe_length (cfun->local_decls);
973 74054748 : for (srcidx = 0, dstidx = 0; srcidx < num; srcidx++)
974 : {
975 62504923 : var = (*cfun->local_decls)[srcidx];
976 62504923 : if (VAR_P (var))
977 : {
978 62504923 : if (!is_used_p (var))
979 : {
980 27397991 : tree def;
981 27397991 : if (cfun->nonlocal_goto_save_area
982 27397991 : && TREE_OPERAND (cfun->nonlocal_goto_save_area, 0) == var)
983 10 : cfun->nonlocal_goto_save_area = NULL;
984 : /* Release any default def associated with var. */
985 27397991 : if ((def = ssa_default_def (cfun, var)) != NULL_TREE)
986 : {
987 1096117 : set_ssa_default_def (cfun, var, NULL_TREE);
988 1096117 : release_ssa_name (def);
989 : }
990 27397991 : continue;
991 27397991 : }
992 : }
993 35106932 : if (VAR_P (var) && DECL_HARD_REGISTER (var) && !is_global_var (var))
994 6591 : cfun->has_local_explicit_reg_vars = true;
995 :
996 35106932 : if (srcidx != dstidx)
997 14844667 : (*cfun->local_decls)[dstidx] = var;
998 35106932 : dstidx++;
999 : }
1000 11549825 : if (dstidx != num)
1001 : {
1002 4175665 : statistics_counter_event (cfun, "unused VAR_DECLs removed", num - dstidx);
1003 4175665 : cfun->local_decls->truncate (dstidx);
1004 : }
1005 :
1006 11549825 : remove_unused_scope_block_p (DECL_INITIAL (current_function_decl),
1007 11549825 : polymorphic_ctor_dtor_p (current_function_decl,
1008 : true) != NULL_TREE);
1009 11549825 : clear_unused_block_pointer ();
1010 :
1011 11549825 : BITMAP_FREE (usedvars);
1012 :
1013 11549825 : if (dump_file && (dump_flags & TDF_DETAILS))
1014 : {
1015 1996 : fprintf (dump_file, "Scope blocks after cleanups:\n");
1016 1996 : dump_scope_blocks (dump_file, dump_flags);
1017 : }
1018 :
1019 11549825 : timevar_pop (TV_REMOVE_UNUSED);
1020 11549825 : }
1021 :
1022 : /* Allocate and return a new live range information object base on MAP. */
1023 :
1024 : static tree_live_info_p
1025 1293864 : new_tree_live_info (var_map map)
1026 : {
1027 1293864 : tree_live_info_p live;
1028 1293864 : basic_block bb;
1029 :
1030 1293864 : live = XNEW (struct tree_live_info_d);
1031 1293864 : live->map = map;
1032 1293864 : live->num_blocks = last_basic_block_for_fn (cfun);
1033 :
1034 1293864 : bitmap_obstack_initialize (&live->livein_obstack);
1035 1293864 : bitmap_obstack_initialize (&live->liveout_obstack);
1036 :
1037 1293864 : live->livein = XCNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
1038 1293864 : live->liveout = XCNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
1039 13100600 : for (unsigned i = 0; map->vec_bbs.iterate (i, &bb); ++i)
1040 : {
1041 11806736 : bitmap_initialize (&live->livein[bb->index], &live->livein_obstack);
1042 11806736 : bitmap_initialize (&live->liveout[bb->index], &live->liveout_obstack);
1043 : }
1044 :
1045 1293864 : live->work_stack = XNEWVEC (int, last_basic_block_for_fn (cfun));
1046 1293864 : live->stack_top = live->work_stack;
1047 :
1048 1293864 : return live;
1049 : }
1050 :
1051 :
1052 : /* Free storage for live range info object LIVE. */
1053 :
1054 : void
1055 1293864 : delete_tree_live_info (tree_live_info_p live)
1056 : {
1057 1293864 : if (live->livein)
1058 : {
1059 0 : bitmap_obstack_release (&live->livein_obstack);
1060 0 : free (live->livein);
1061 : }
1062 1293864 : if (live->liveout)
1063 : {
1064 1293864 : bitmap_obstack_release (&live->liveout_obstack);
1065 1293864 : free (live->liveout);
1066 : }
1067 1293864 : free (live->work_stack);
1068 1293864 : free (live);
1069 1293864 : }
1070 :
1071 :
1072 : /* Visit basic block BB and propagate any required live on entry bits from
1073 : LIVE into the predecessors. VISITED is the bitmap of visited blocks.
1074 : TMP is a temporary work bitmap which is passed in to avoid reallocating
1075 : it each time. */
1076 :
1077 : static void
1078 13494212 : loe_visit_block (tree_live_info_p live, basic_block bb, sbitmap visited)
1079 : {
1080 13494212 : edge e;
1081 13494212 : bool change;
1082 13494212 : edge_iterator ei;
1083 13494212 : basic_block pred_bb;
1084 13494212 : bitmap loe;
1085 :
1086 13494212 : gcc_checking_assert (!bitmap_bit_p (visited, bb->index));
1087 13494212 : bitmap_set_bit (visited, bb->index);
1088 :
1089 13494212 : loe = live_on_entry (live, bb);
1090 :
1091 33182802 : FOR_EACH_EDGE (e, ei, bb->preds)
1092 : {
1093 19688590 : pred_bb = e->src;
1094 19688590 : if (!region_contains_p (live->map, pred_bb))
1095 1311219 : continue;
1096 : /* Variables live-on-entry from BB that aren't defined in the
1097 : predecessor block. This should be the live on entry vars to pred.
1098 : Note that liveout is the DEFs in a block while live on entry is
1099 : being calculated.
1100 : Add these bits to live-on-entry for the pred. if there are any
1101 : changes, and pred_bb has been visited already, add it to the
1102 : revisit stack. */
1103 18377371 : change = bitmap_ior_and_compl_into (live_on_entry (live, pred_bb),
1104 18377371 : loe, &live->liveout[pred_bb->index]);
1105 18377371 : if (change
1106 18377371 : && bitmap_bit_p (visited, pred_bb->index))
1107 : {
1108 1687476 : bitmap_clear_bit (visited, pred_bb->index);
1109 1687476 : *(live->stack_top)++ = pred_bb->index;
1110 : }
1111 : }
1112 13494212 : }
1113 :
1114 :
1115 : /* Using LIVE, fill in all the live-on-entry blocks between the defs and uses
1116 : of all the variables. */
1117 :
1118 : static void
1119 1293864 : live_worklist (tree_live_info_p live)
1120 : {
1121 1293864 : unsigned b;
1122 1293864 : basic_block bb;
1123 1293864 : auto_sbitmap visited (last_basic_block_for_fn (cfun) + 1);
1124 :
1125 1293864 : bitmap_clear (visited);
1126 :
1127 : /* Visit region's blocks in reverse order and propagate live on entry values
1128 : into the predecessors blocks. */
1129 14394464 : for (unsigned i = live->map->vec_bbs.length () - 1;
1130 13100600 : live->map->vec_bbs.iterate (i, &bb); --i)
1131 11806736 : loe_visit_block (live, bb, visited);
1132 :
1133 : /* Process any blocks which require further iteration. */
1134 2981340 : while (live->stack_top != live->work_stack)
1135 : {
1136 1687476 : b = *--(live->stack_top);
1137 1687476 : loe_visit_block (live, BASIC_BLOCK_FOR_FN (cfun, b), visited);
1138 : }
1139 1293864 : }
1140 :
1141 :
1142 : /* Calculate the initial live on entry vector for SSA_NAME using immediate_use
1143 : links. Set the live on entry fields in LIVE. Def's are marked temporarily
1144 : in the liveout vector. */
1145 :
1146 : static void
1147 11290747 : set_var_live_on_entry (tree ssa_name, tree_live_info_p live)
1148 : {
1149 11290747 : int p;
1150 11290747 : gimple *stmt;
1151 11290747 : use_operand_p use;
1152 11290747 : basic_block def_bb = NULL;
1153 11290747 : imm_use_iterator imm_iter;
1154 :
1155 11290747 : p = var_to_partition (live->map, ssa_name);
1156 11290747 : if (p == NO_PARTITION)
1157 731387 : return;
1158 :
1159 11290747 : stmt = SSA_NAME_DEF_STMT (ssa_name);
1160 11290747 : if (stmt)
1161 : {
1162 11290747 : def_bb = gimple_bb (stmt);
1163 : /* Mark defs in liveout bitmap temporarily. */
1164 11290747 : if (def_bb && region_contains_p (live->map, def_bb))
1165 7618463 : bitmap_set_bit (&live->liveout[def_bb->index], p);
1166 : }
1167 : else
1168 0 : def_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
1169 :
1170 : /* An undefined local variable does not need to be very alive. */
1171 11290747 : if (ssa_undefined_value_p (ssa_name, false))
1172 : return;
1173 :
1174 : /* Visit each use of SSA_NAME and if it isn't in the same block as the def,
1175 : add it to the list of live on entry blocks. */
1176 45522031 : FOR_EACH_IMM_USE_FAST (use, imm_iter, ssa_name)
1177 : {
1178 24403311 : gimple *use_stmt = USE_STMT (use);
1179 24403311 : basic_block add_block = NULL;
1180 :
1181 24403311 : if (gimple_code (use_stmt) == GIMPLE_PHI)
1182 : {
1183 : /* Uses in PHI's are considered to be live at exit of the SRC block
1184 : as this is where a copy would be inserted. Check to see if it is
1185 : defined in that block, or whether its live on entry. */
1186 5810647 : int index = PHI_ARG_INDEX_FROM_USE (use);
1187 5810647 : edge e = gimple_phi_arg_edge (as_a <gphi *> (use_stmt), index);
1188 5810647 : if (e->src != def_bb && region_contains_p (live->map, e->src))
1189 1850283 : add_block = e->src;
1190 : }
1191 18592664 : else if (is_gimple_debug (use_stmt))
1192 4904640 : continue;
1193 : else
1194 : {
1195 : /* If its not defined in this block, its live on entry. */
1196 13688024 : basic_block use_bb = gimple_bb (use_stmt);
1197 13688024 : if (use_bb != def_bb && region_contains_p (live->map, use_bb))
1198 : add_block = use_bb;
1199 : }
1200 :
1201 : /* If there was a live on entry use, set the bit. */
1202 10731289 : if (add_block)
1203 10731289 : bitmap_set_bit (&live->livein[add_block->index], p);
1204 10559360 : }
1205 : }
1206 :
1207 :
1208 : /* Calculate the live on exit vectors based on the entry info in LIVEINFO. */
1209 :
1210 : static void
1211 1293864 : calculate_live_on_exit (tree_live_info_p liveinfo)
1212 : {
1213 1293864 : basic_block bb;
1214 1293864 : edge e;
1215 1293864 : edge_iterator ei;
1216 :
1217 : /* live on entry calculations used liveout vectors for defs, clear them. */
1218 13100600 : for (unsigned i = 0; liveinfo->map->vec_bbs.iterate (i, &bb); ++i)
1219 11806736 : bitmap_clear (&liveinfo->liveout[bb->index]);
1220 :
1221 : /* Set all the live-on-exit bits for uses in PHIs. */
1222 13100600 : FOR_EACH_BB_FN (bb, cfun)
1223 : {
1224 11806736 : gphi_iterator gsi;
1225 11806736 : size_t i;
1226 :
1227 : /* Mark the PHI arguments which are live on exit to the pred block. */
1228 14719215 : for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1229 : {
1230 2912479 : gphi *phi = gsi.phi ();
1231 5824958 : if (virtual_operand_p (gimple_phi_result (phi)))
1232 5656 : continue;
1233 10033272 : for (i = 0; i < gimple_phi_num_args (phi); i++)
1234 : {
1235 7126449 : tree t = PHI_ARG_DEF (phi, i);
1236 7126449 : int p;
1237 :
1238 7126449 : if (TREE_CODE (t) != SSA_NAME)
1239 1288563 : continue;
1240 :
1241 5837886 : p = var_to_partition (liveinfo->map, t);
1242 5837886 : if (p == NO_PARTITION)
1243 1434 : continue;
1244 5836452 : e = gimple_phi_arg_edge (phi, i);
1245 5836452 : if (region_contains_p (liveinfo->map, e->src))
1246 5836204 : bitmap_set_bit (&liveinfo->liveout[e->src->index], p);
1247 : }
1248 : }
1249 :
1250 11806736 : if (!region_contains_p (liveinfo->map, bb))
1251 0 : continue;
1252 :
1253 : /* Add each successors live on entry to this bock live on exit. */
1254 28985218 : FOR_EACH_EDGE (e, ei, bb->succs)
1255 17178482 : if (region_contains_p (liveinfo->map, e->dest))
1256 15908051 : bitmap_ior_into (&liveinfo->liveout[bb->index],
1257 15908051 : live_on_entry (liveinfo, e->dest));
1258 : }
1259 1293864 : }
1260 :
1261 :
1262 : /* Given partition map MAP, calculate all the live on entry bitmaps for
1263 : each partition. Return a new live info object. */
1264 :
1265 : tree_live_info_p
1266 1293864 : calculate_live_ranges (var_map map, bool want_livein)
1267 : {
1268 1293864 : tree var;
1269 1293864 : unsigned i;
1270 1293864 : tree_live_info_p live;
1271 :
1272 1293864 : live = new_tree_live_info (map);
1273 13878475 : for (i = 0; i < num_var_partitions (map); i++)
1274 : {
1275 11290747 : var = partition_to_var (map, i);
1276 11290747 : if (var != NULL_TREE)
1277 11290747 : set_var_live_on_entry (var, live);
1278 : }
1279 :
1280 1293864 : live_worklist (live);
1281 :
1282 1293864 : if (flag_checking)
1283 1293847 : verify_live_on_entry (live);
1284 :
1285 1293864 : calculate_live_on_exit (live);
1286 :
1287 1293864 : if (!want_livein)
1288 : {
1289 1293864 : bitmap_obstack_release (&live->livein_obstack);
1290 1293864 : free (live->livein);
1291 1293864 : live->livein = NULL;
1292 : }
1293 :
1294 1293864 : return live;
1295 : }
1296 :
1297 : /* Data structure for compute_live_vars* functions. */
1298 :
1299 : struct compute_live_vars_data {
1300 : /* Vector of bitmaps for live vars indices at the end of basic blocks,
1301 : indexed by bb->index. ACTIVE[ENTRY_BLOCK] must be empty bitmap,
1302 : ACTIVE[EXIT_BLOCK] is used for STOP_AFTER. */
1303 : vec<bitmap_head> active;
1304 : /* Work bitmap of currently live variables. */
1305 : bitmap work;
1306 : /* Set of interesting variables. Variables with uids not in this
1307 : hash_map are not tracked. */
1308 : live_vars_map *vars;
1309 : };
1310 :
1311 : /* Callback for walk_stmt_load_store_addr_ops. If OP is a VAR_DECL with
1312 : uid set in DATA->vars, enter its corresponding index into bitmap
1313 : DATA->work. */
1314 :
1315 : static bool
1316 26836428 : compute_live_vars_visit (gimple *, tree op, tree, void *pdata)
1317 : {
1318 26836428 : compute_live_vars_data *data = (compute_live_vars_data *) pdata;
1319 26836428 : op = get_base_address (op);
1320 26836428 : if (op && VAR_P (op))
1321 17728676 : if (unsigned int *v = data->vars->get (DECL_UID (op)))
1322 13997760 : bitmap_set_bit (data->work, *v);
1323 26836428 : return false;
1324 : }
1325 :
1326 : /* Helper routine for compute_live_vars, calculating the sets of live
1327 : variables at the end of BB, leaving the result in DATA->work.
1328 : If STOP_AFTER is non-NULL, stop processing after that stmt. */
1329 :
1330 : static void
1331 12904093 : compute_live_vars_1 (basic_block bb, compute_live_vars_data *data,
1332 : gimple *stop_after)
1333 : {
1334 12904093 : edge e;
1335 12904093 : edge_iterator ei;
1336 12904093 : gimple_stmt_iterator gsi;
1337 12904093 : walk_stmt_load_store_addr_fn visit = compute_live_vars_visit;
1338 :
1339 12904093 : bitmap_clear (data->work);
1340 31287163 : FOR_EACH_EDGE (e, ei, bb->preds)
1341 18383070 : bitmap_ior_into (data->work, &data->active[e->src->index]);
1342 :
1343 18394169 : for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1344 5490076 : walk_stmt_load_store_addr_ops (gsi_stmt (gsi), data, NULL, NULL, visit);
1345 167895704 : for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1346 : {
1347 155260754 : gimple *stmt = gsi_stmt (gsi);
1348 :
1349 155260754 : if (gimple_clobber_p (stmt))
1350 : {
1351 3904771 : tree lhs = gimple_assign_lhs (stmt);
1352 3904771 : if (VAR_P (lhs))
1353 3656739 : if (unsigned int *v = data->vars->get (DECL_UID (lhs)))
1354 3081172 : bitmap_clear_bit (data->work, *v);
1355 : }
1356 151355983 : else if (!is_gimple_debug (stmt))
1357 40652676 : walk_stmt_load_store_addr_ops (stmt, data, visit, visit, visit);
1358 155260754 : if (stmt == stop_after)
1359 : break;
1360 : }
1361 12904093 : }
1362 :
1363 : /* For function FN and live_vars_map (hash map from DECL_UIDs to a dense set of
1364 : indexes of automatic variables VARS, compute which of those variables are
1365 : (might be) live at the end of each basic block. */
1366 :
1367 : vec<bitmap_head>
1368 341239 : compute_live_vars (struct function *fn, live_vars_map *vars)
1369 : {
1370 341239 : vec<bitmap_head> active;
1371 :
1372 : /* We approximate the live range of a stack variable by taking the first
1373 : mention of its name as starting point(s), and by the end-of-scope
1374 : death clobber added by gimplify as ending point(s) of the range.
1375 : This overapproximates in the case we for instance moved an address-taken
1376 : operation upward, without also moving a dereference to it upwards.
1377 : But it's conservatively correct as a variable never can hold values
1378 : before its name is mentioned at least once.
1379 :
1380 : We then do a mostly classical bitmap liveness algorithm. */
1381 :
1382 341239 : active.create (last_basic_block_for_fn (fn));
1383 341239 : active.quick_grow_cleared (last_basic_block_for_fn (fn));
1384 7313620 : for (int i = 0; i < last_basic_block_for_fn (fn); i++)
1385 6972381 : bitmap_initialize (&active[i], &bitmap_default_obstack);
1386 :
1387 341239 : bitmap work = BITMAP_ALLOC (NULL);
1388 :
1389 341239 : int *rpo = XNEWVEC (int, last_basic_block_for_fn (fn));
1390 341239 : int n_bbs = pre_and_rev_post_order_compute_fn (fn, NULL, rpo, false);
1391 :
1392 341239 : bool changed = true;
1393 341239 : compute_live_vars_data data = { active, work, vars };
1394 932210 : while (changed)
1395 : {
1396 : int i;
1397 : changed = false;
1398 13225921 : for (i = 0; i < n_bbs; i++)
1399 : {
1400 12634950 : basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
1401 12634950 : compute_live_vars_1 (bb, &data, NULL);
1402 12634950 : if (bitmap_ior_into (&active[bb->index], work))
1403 4819297 : changed = true;
1404 : }
1405 : }
1406 :
1407 341239 : free (rpo);
1408 341239 : BITMAP_FREE (work);
1409 :
1410 341239 : return active;
1411 : }
1412 :
1413 : /* For ACTIVE computed by compute_live_vars, compute a bitmap of variables
1414 : live after the STOP_AFTER statement and return that bitmap. */
1415 :
1416 : bitmap
1417 269143 : live_vars_at_stmt (vec<bitmap_head> &active, live_vars_map *vars,
1418 : gimple *stop_after)
1419 : {
1420 269143 : bitmap work = BITMAP_ALLOC (NULL);
1421 269143 : compute_live_vars_data data = { active, work, vars };
1422 269143 : basic_block bb = gimple_bb (stop_after);
1423 269143 : compute_live_vars_1 (bb, &data, stop_after);
1424 269143 : return work;
1425 : }
1426 :
1427 : /* Destroy what compute_live_vars has returned when it is no longer needed. */
1428 :
1429 : void
1430 341239 : destroy_live_vars (vec<bitmap_head> &active)
1431 : {
1432 341239 : unsigned len = active.length ();
1433 7313620 : for (unsigned i = 0; i < len; i++)
1434 6972381 : bitmap_clear (&active[i]);
1435 :
1436 341239 : active.release ();
1437 341239 : }
1438 :
1439 : /* Output partition map MAP to file F. */
1440 :
1441 : void
1442 358 : dump_var_map (FILE *f, var_map map)
1443 : {
1444 358 : int t;
1445 358 : unsigned x, y;
1446 358 : int p;
1447 :
1448 358 : fprintf (f, "\nPartition map \n\n");
1449 :
1450 1819 : for (x = 0; x < map->num_partitions; x++)
1451 : {
1452 1103 : if (map->view_to_partition != NULL)
1453 465 : p = map->view_to_partition[x];
1454 : else
1455 638 : p = x;
1456 :
1457 1103 : if (ssa_name (p) == NULL_TREE
1458 2040 : || virtual_operand_p (ssa_name (p)))
1459 381 : continue;
1460 :
1461 : t = 0;
1462 9754 : for (y = 1; y < num_ssa_names; y++)
1463 : {
1464 9032 : p = partition_find (map->var_partition, y);
1465 9032 : if (map->partition_to_view)
1466 5711 : p = map->partition_to_view[p];
1467 9032 : if (p == (int)x)
1468 : {
1469 754 : if (t++ == 0)
1470 : {
1471 722 : fprintf (f, "Partition %d (", x);
1472 722 : print_generic_expr (f, partition_to_var (map, p), TDF_SLIM);
1473 722 : fprintf (f, " - ");
1474 : }
1475 754 : fprintf (f, "%d ", y);
1476 : }
1477 : }
1478 722 : if (t != 0)
1479 722 : fprintf (f, ")\n");
1480 : }
1481 358 : fprintf (f, "\n");
1482 358 : }
1483 :
1484 :
1485 : /* Generic dump for the above. */
1486 :
1487 : DEBUG_FUNCTION void
1488 0 : debug (_var_map &ref)
1489 : {
1490 0 : dump_var_map (stderr, &ref);
1491 0 : }
1492 :
1493 : DEBUG_FUNCTION void
1494 0 : debug (_var_map *ptr)
1495 : {
1496 0 : if (ptr)
1497 0 : debug (*ptr);
1498 : else
1499 0 : fprintf (stderr, "<nil>\n");
1500 0 : }
1501 :
1502 :
1503 : /* Output live range info LIVE to file F, controlled by FLAG. */
1504 :
1505 : void
1506 64 : dump_live_info (FILE *f, tree_live_info_p live, int flag)
1507 : {
1508 64 : basic_block bb;
1509 64 : unsigned i;
1510 64 : var_map map = live->map;
1511 64 : bitmap_iterator bi;
1512 :
1513 64 : if ((flag & LIVEDUMP_ENTRY) && live->livein)
1514 : {
1515 0 : FOR_EACH_BB_FN (bb, cfun)
1516 : {
1517 0 : fprintf (f, "\nLive on entry to BB%d : ", bb->index);
1518 0 : EXECUTE_IF_SET_IN_BITMAP (&live->livein[bb->index], 0, i, bi)
1519 : {
1520 0 : print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
1521 0 : fprintf (f, " ");
1522 : }
1523 0 : fprintf (f, "\n");
1524 : }
1525 : }
1526 :
1527 64 : if ((flag & LIVEDUMP_EXIT) && live->liveout)
1528 : {
1529 0 : FOR_EACH_BB_FN (bb, cfun)
1530 : {
1531 0 : fprintf (f, "\nLive on exit from BB%d : ", bb->index);
1532 0 : EXECUTE_IF_SET_IN_BITMAP (&live->liveout[bb->index], 0, i, bi)
1533 : {
1534 0 : print_generic_expr (f, partition_to_var (map, i), TDF_SLIM);
1535 0 : fprintf (f, " ");
1536 : }
1537 0 : fprintf (f, "\n");
1538 : }
1539 : }
1540 64 : }
1541 :
1542 :
1543 : /* Generic dump for the above. */
1544 :
1545 : DEBUG_FUNCTION void
1546 0 : debug (tree_live_info_d &ref)
1547 : {
1548 0 : dump_live_info (stderr, &ref, 0);
1549 0 : }
1550 :
1551 : DEBUG_FUNCTION void
1552 0 : debug (tree_live_info_d *ptr)
1553 : {
1554 0 : if (ptr)
1555 0 : debug (*ptr);
1556 : else
1557 0 : fprintf (stderr, "<nil>\n");
1558 0 : }
1559 :
1560 :
1561 : /* Verify that the info in LIVE matches the current cfg. */
1562 :
1563 : static void
1564 1293847 : verify_live_on_entry (tree_live_info_p live)
1565 : {
1566 1293847 : unsigned i;
1567 1293847 : tree var;
1568 1293847 : gimple *stmt;
1569 1293847 : basic_block bb;
1570 1293847 : edge e;
1571 1293847 : int num;
1572 1293847 : edge_iterator ei;
1573 1293847 : var_map map = live->map;
1574 :
1575 : /* Check for live on entry partitions and report those with a DEF in
1576 : the program. This will typically mean an optimization has done
1577 : something wrong. */
1578 1293847 : bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
1579 1293847 : num = 0;
1580 2587694 : FOR_EACH_EDGE (e, ei, bb->succs)
1581 : {
1582 1293847 : int entry_block = e->dest->index;
1583 1293847 : if (!region_contains_p (live->map, e->dest))
1584 0 : continue;
1585 12584538 : for (i = 0; i < (unsigned)num_var_partitions (map); i++)
1586 : {
1587 11290691 : basic_block tmp;
1588 11290691 : tree d = NULL_TREE;
1589 11290691 : bitmap loe;
1590 11290691 : var = partition_to_var (map, i);
1591 11290691 : stmt = SSA_NAME_DEF_STMT (var);
1592 11290691 : tmp = gimple_bb (stmt);
1593 11290691 : if (SSA_NAME_VAR (var))
1594 7954589 : d = ssa_default_def (cfun, SSA_NAME_VAR (var));
1595 :
1596 11290691 : loe = live_on_entry (live, e->dest);
1597 11290691 : if (loe && bitmap_bit_p (loe, i))
1598 : {
1599 1973283 : if (!gimple_nop_p (stmt))
1600 : {
1601 0 : num++;
1602 0 : print_generic_expr (stderr, var, TDF_SLIM);
1603 0 : fprintf (stderr, " is defined ");
1604 0 : if (tmp)
1605 0 : fprintf (stderr, " in BB%d, ", tmp->index);
1606 0 : fprintf (stderr, "by:\n");
1607 0 : print_gimple_stmt (stderr, stmt, 0, TDF_SLIM);
1608 0 : fprintf (stderr, "\nIt is also live-on-entry to entry BB %d",
1609 : entry_block);
1610 0 : fprintf (stderr, " So it appears to have multiple defs.\n");
1611 : }
1612 : else
1613 : {
1614 1973283 : if (d != var)
1615 : {
1616 0 : num++;
1617 0 : print_generic_expr (stderr, var, TDF_SLIM);
1618 0 : fprintf (stderr, " is live-on-entry to BB%d ",
1619 : entry_block);
1620 0 : if (d)
1621 : {
1622 0 : fprintf (stderr, " but is not the default def of ");
1623 0 : print_generic_expr (stderr, d, TDF_SLIM);
1624 0 : fprintf (stderr, "\n");
1625 : }
1626 : else
1627 0 : fprintf (stderr, " and there is no default def.\n");
1628 : }
1629 : }
1630 : }
1631 : else
1632 9317408 : if (d == var)
1633 : {
1634 : /* An undefined local variable does not need to be very
1635 : alive. */
1636 1698974 : if (ssa_undefined_value_p (var, false))
1637 1698974 : continue;
1638 :
1639 : /* The only way this var shouldn't be marked live on entry is
1640 : if it occurs in a PHI argument of the block. */
1641 973630 : size_t z;
1642 973630 : bool ok = false;
1643 973630 : gphi_iterator gsi;
1644 973630 : for (gsi = gsi_start_phis (e->dest);
1645 973858 : !gsi_end_p (gsi) && !ok;
1646 228 : gsi_next (&gsi))
1647 : {
1648 228 : gphi *phi = gsi.phi ();
1649 456 : if (virtual_operand_p (gimple_phi_result (phi)))
1650 0 : continue;
1651 361 : for (z = 0; z < gimple_phi_num_args (phi); z++)
1652 296 : if (var == gimple_phi_arg_def (phi, z))
1653 : {
1654 : ok = true;
1655 : break;
1656 : }
1657 : }
1658 973630 : if (ok)
1659 163 : continue;
1660 : /* Expand adds unused default defs for PARM_DECLs and
1661 : RESULT_DECLs. They're ok. */
1662 973467 : if (has_zero_uses (var)
1663 973467 : && SSA_NAME_VAR (var)
1664 1946934 : && !VAR_P (SSA_NAME_VAR (var)))
1665 973467 : continue;
1666 0 : num++;
1667 0 : print_generic_expr (stderr, var, TDF_SLIM);
1668 0 : fprintf (stderr, " is not marked live-on-entry to entry BB%d ",
1669 : entry_block);
1670 0 : fprintf (stderr, "but it is a default def so it should be.\n");
1671 : }
1672 : }
1673 : }
1674 1293847 : gcc_assert (num <= 0);
1675 1293847 : }
1676 :
1677 :
1678 : /* Virtual operand liveness analysis data init. */
1679 :
1680 : void
1681 196543 : virtual_operand_live::init ()
1682 : {
1683 196543 : liveout = XCNEWVEC (tree, last_basic_block_for_fn (cfun) + 1);
1684 196543 : liveout[ENTRY_BLOCK] = ssa_default_def (cfun, gimple_vop (cfun));
1685 196543 : }
1686 :
1687 : /* Compute live-in of BB from cached live-out. */
1688 :
1689 : tree
1690 1800756 : virtual_operand_live::get_live_in (basic_block bb)
1691 : {
1692 : /* A virtual PHI is a convenient cache for live-in. */
1693 1800756 : gphi *phi = get_virtual_phi (bb);
1694 1800756 : if (phi)
1695 568422 : return gimple_phi_result (phi);
1696 :
1697 1232334 : if (!liveout)
1698 196543 : init ();
1699 :
1700 : /* Since we don't have a virtual PHI and we don't know whether there's
1701 : a downstream virtual use (and thus PHIs are inserted where necessary)
1702 : we now have to check each incoming edge live-out. */
1703 1232334 : edge_iterator ei;
1704 1232334 : edge e;
1705 1232334 : tree livein = NULL_TREE;
1706 1232334 : bool first = true;
1707 2688515 : FOR_EACH_EDGE (e, ei, bb->preds)
1708 1456212 : if (e->flags & EDGE_DFS_BACK)
1709 : /* We can ignore backedges since if there's a def there it would
1710 : have forced a PHI in the source because it also acts as use
1711 : downstream. */
1712 71215 : continue;
1713 1384997 : else if (first)
1714 : {
1715 1232334 : livein = get_live_out (e->src);
1716 1232334 : first = false;
1717 : }
1718 152663 : else if (get_live_out (e->src) != livein)
1719 : /* When there's no virtual use downstream this indicates a point
1720 : where we'd insert a PHI merging the different live virtual
1721 : operands. */
1722 : return NULL_TREE;
1723 :
1724 : return livein;
1725 : }
1726 :
1727 : /* Compute live-out of BB. */
1728 :
1729 : tree
1730 1384997 : virtual_operand_live::get_live_out (basic_block bb)
1731 : {
1732 1384997 : if (!liveout)
1733 0 : init ();
1734 :
1735 1384997 : if (liveout[bb->index])
1736 : return liveout[bb->index];
1737 :
1738 802785 : tree lo = NULL_TREE;
1739 4065984 : for (auto gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
1740 : {
1741 2999003 : gimple *stmt = gsi_stmt (gsi);
1742 3912884 : if (gimple_vdef (stmt))
1743 : {
1744 : lo = gimple_vdef (stmt);
1745 : break;
1746 : }
1747 3612850 : if (gimple_vuse (stmt))
1748 : {
1749 : lo = gimple_vuse (stmt);
1750 : break;
1751 : }
1752 : }
1753 802785 : if (!lo)
1754 264196 : lo = get_live_in (bb);
1755 802785 : liveout[bb->index] = lo;
1756 802785 : return lo;
1757 : }
|
