1 /* Generic routines for manipulating SSA_NAME expressions
2 Copyright (C) 2003-2022 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "tree-pass.h"
28 #include "gimple-iterator.h"
29 #include "stor-layout.h"
30 #include "tree-into-ssa.h"
33 #include "tree-scalar-evolution.h"
34 #include "value-query.h"
36 /* Rewriting a function into SSA form can create a huge number of SSA_NAMEs,
37 many of which may be thrown away shortly after their creation if jumps
38 were threaded through PHI nodes.
40 While our garbage collection mechanisms will handle this situation, it
41 is extremely wasteful to create nodes and throw them away, especially
42 when the nodes can be reused.
44 For PR 8361, we can significantly reduce the number of nodes allocated
45 and thus the total amount of memory allocated by managing SSA_NAMEs a
46 little. This additionally helps reduce the amount of work done by the
47 garbage collector. Similar results have been seen on a wider variety
48 of tests (such as the compiler itself).
50 Right now we maintain our free list on a per-function basis. It may
51 or may not make sense to maintain the free list for the duration of
54 External code should rely solely upon HIGHEST_SSA_VERSION and the
55 externally defined functions. External code should not know about
56 the details of the free list management.
58 External code should also not assume the version number on nodes is
59 monotonically increasing. We reuse the version number when we
60 reuse an SSA_NAME expression. This helps keep arrays and bitmaps
64 /* Version numbers with special meanings. We start allocating new version
65 numbers after the special ones. */
66 #define UNUSED_NAME_VERSION 0
68 unsigned int ssa_name_nodes_reused
;
69 unsigned int ssa_name_nodes_created
;
71 #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames
72 #define FREE_SSANAMES_QUEUE(fun) (fun)->gimple_df->free_ssanames_queue
75 /* Initialize management of SSA_NAMEs to default SIZE. If SIZE is
79 init_ssanames (struct function
*fn
, int size
)
82 vec_alloc (SSANAMES (fn
), 50);
84 vec_safe_reserve (SSANAMES (fn
), size
, true);
86 /* Version 0 is special, so reserve the first slot in the table. Though
87 currently unused, we may use version 0 in alias analysis as part of
88 the heuristics used to group aliases when the alias sets are too
91 We use vec::quick_push here because we know that SSA_NAMES has at
92 least 50 elements reserved in it. */
93 SSANAMES (fn
)->quick_push (NULL_TREE
);
94 FREE_SSANAMES (fn
) = NULL
;
95 FREE_SSANAMES_QUEUE (fn
) = NULL
;
97 fn
->gimple_df
->ssa_renaming_needed
= 0;
98 fn
->gimple_df
->rename_vops
= 0;
101 /* Finalize management of SSA_NAMEs. */
104 fini_ssanames (struct function
*fn
)
108 /* Some SSA names leak into global tree data structures so we can't simply
109 ggc_free them. But make sure to clear references to stmts since we now
110 ggc_free the CFG itself. */
111 FOR_EACH_VEC_SAFE_ELT (SSANAMES (fn
), i
, name
)
113 SSA_NAME_DEF_STMT (name
) = NULL
;
114 vec_free (SSANAMES (fn
));
115 vec_free (FREE_SSANAMES (fn
));
116 vec_free (FREE_SSANAMES_QUEUE (fn
));
119 /* Dump some simple statistics regarding the re-use of SSA_NAME nodes. */
122 ssanames_print_statistics (void)
124 fprintf (stderr
, "%-32s" PRsa (11) "\n", "SSA_NAME nodes allocated:",
125 SIZE_AMOUNT (ssa_name_nodes_created
));
126 fprintf (stderr
, "%-32s" PRsa (11) "\n", "SSA_NAME nodes reused:",
127 SIZE_AMOUNT (ssa_name_nodes_reused
));
130 /* Verify the state of the SSA_NAME lists.
132 There must be no duplicates on the free list.
133 Every name on the free list must be marked as on the free list.
134 Any name on the free list must not appear in the IL.
135 No names can be leaked. */
138 verify_ssaname_freelists (struct function
*fun
)
140 if (!gimple_in_ssa_p (fun
))
143 auto_bitmap names_in_il
;
145 /* Walk the entire IL noting every SSA_NAME we see. */
147 FOR_EACH_BB_FN (bb
, fun
)
150 /* First note the result and arguments of PHI nodes. */
151 for (gphi_iterator gsi
= gsi_start_phis (bb
);
155 gphi
*phi
= gsi
.phi ();
156 t
= gimple_phi_result (phi
);
157 bitmap_set_bit (names_in_il
, SSA_NAME_VERSION (t
));
159 for (unsigned int i
= 0; i
< gimple_phi_num_args (phi
); i
++)
161 t
= gimple_phi_arg_def (phi
, i
);
162 if (TREE_CODE (t
) == SSA_NAME
)
163 bitmap_set_bit (names_in_il
, SSA_NAME_VERSION (t
));
167 /* Then note the operands of each statement. */
168 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
173 gimple
*stmt
= gsi_stmt (gsi
);
174 FOR_EACH_SSA_TREE_OPERAND (t
, stmt
, iter
, SSA_OP_ALL_OPERANDS
)
175 bitmap_set_bit (names_in_il
, SSA_NAME_VERSION (t
));
179 /* Now walk the free list noting what we find there and verifying
180 there are no duplicates. */
181 auto_bitmap names_in_freelists
;
182 if (FREE_SSANAMES (fun
))
184 for (unsigned int i
= 0; i
< FREE_SSANAMES (fun
)->length (); i
++)
186 tree t
= (*FREE_SSANAMES (fun
))[i
];
188 /* Verify that the name is marked as being in the free list. */
189 gcc_assert (SSA_NAME_IN_FREE_LIST (t
));
191 /* Verify the name has not already appeared in the free list and
192 note it in the list of names found in the free list. */
193 gcc_assert (!bitmap_bit_p (names_in_freelists
, SSA_NAME_VERSION (t
)));
194 bitmap_set_bit (names_in_freelists
, SSA_NAME_VERSION (t
));
198 /* Similarly for the names in the pending free list. */
199 if (FREE_SSANAMES_QUEUE (fun
))
201 for (unsigned int i
= 0; i
< FREE_SSANAMES_QUEUE (fun
)->length (); i
++)
203 tree t
= (*FREE_SSANAMES_QUEUE (fun
))[i
];
205 /* Verify that the name is marked as being in the free list. */
206 gcc_assert (SSA_NAME_IN_FREE_LIST (t
));
208 /* Verify the name has not already appeared in the free list and
209 note it in the list of names found in the free list. */
210 gcc_assert (!bitmap_bit_p (names_in_freelists
, SSA_NAME_VERSION (t
)));
211 bitmap_set_bit (names_in_freelists
, SSA_NAME_VERSION (t
));
215 /* If any name appears in both the IL and the freelists, then
216 something horrible has happened. */
217 bool intersect_p
= bitmap_intersect_p (names_in_il
, names_in_freelists
);
218 gcc_assert (!intersect_p
);
220 /* Names can be queued up for release if there is an ssa update
221 pending. Pretend we saw them in the IL. */
222 if (names_to_release
)
223 bitmap_ior_into (names_in_il
, names_to_release
);
225 /* Function splitting can "lose" SSA_NAMEs in an effort to ensure that
226 debug/non-debug compilations have the same SSA_NAMEs. So for each
227 lost SSA_NAME, see if it's likely one from that wart. These will always
228 be marked as default definitions. So we loosely assume that anything
229 marked as a default definition isn't leaked by pretending they are
231 for (unsigned int i
= UNUSED_NAME_VERSION
+ 1; i
< num_ssa_names
; i
++)
232 if (ssa_name (i
) && SSA_NAME_IS_DEFAULT_DEF (ssa_name (i
)))
233 bitmap_set_bit (names_in_il
, i
);
237 auto_bitmap all_names
;
238 bitmap_set_range (all_names
, UNUSED_NAME_VERSION
+ 1, num_ssa_names
- 1);
239 bitmap_ior_into (names_in_il
, names_in_freelists
);
241 /* Any name not mentioned in the IL and not in the feelists
243 EXECUTE_IF_AND_COMPL_IN_BITMAP(all_names
, names_in_il
,
244 UNUSED_NAME_VERSION
+ 1, i
, bi
)
245 gcc_assert (!ssa_name (i
));
248 /* Move all SSA_NAMEs from FREE_SSA_NAMES_QUEUE to FREE_SSA_NAMES.
250 We do not, but should have a mode to verify the state of the SSA_NAMEs
251 lists. In particular at this point every name must be in the IL,
252 on the free list or in the queue. Anything else is an error. */
255 flush_ssaname_freelist (void)
257 /* If there were any SSA names released reset the SCEV cache. */
258 if (! vec_safe_is_empty (FREE_SSANAMES_QUEUE (cfun
)))
260 vec_safe_splice (FREE_SSANAMES (cfun
), FREE_SSANAMES_QUEUE (cfun
));
261 vec_safe_truncate (FREE_SSANAMES_QUEUE (cfun
), 0);
264 /* Initialize SSA_NAME_IMM_USE_NODE of a SSA NAME. */
267 init_ssa_name_imm_use (tree name
)
270 imm
= &(SSA_NAME_IMM_USE_NODE (name
));
274 imm
->loc
.ssa_name
= name
;
277 /* Return an SSA_NAME node for variable VAR defined in statement STMT
278 in function FN. STMT may be an empty statement for artificial
279 references (e.g., default definitions created when a variable is
280 used without a preceding definition). If VERISON is not zero then
281 allocate the SSA name with that version. */
284 make_ssa_name_fn (struct function
*fn
, tree var
, gimple
*stmt
,
285 unsigned int version
)
288 gcc_assert (VAR_P (var
)
289 || TREE_CODE (var
) == PARM_DECL
290 || TREE_CODE (var
) == RESULT_DECL
291 || (TYPE_P (var
) && is_gimple_reg_type (var
)));
293 /* Get the specified SSA name version. */
296 t
= make_node (SSA_NAME
);
297 SSA_NAME_VERSION (t
) = version
;
298 if (version
>= SSANAMES (fn
)->length ())
299 vec_safe_grow_cleared (SSANAMES (fn
), version
+ 1, true);
300 gcc_assert ((*SSANAMES (fn
))[version
] == NULL
);
301 (*SSANAMES (fn
))[version
] = t
;
302 ssa_name_nodes_created
++;
304 /* If our free list has an element, then use it. */
305 else if (!vec_safe_is_empty (FREE_SSANAMES (fn
)))
307 t
= FREE_SSANAMES (fn
)->pop ();
308 ssa_name_nodes_reused
++;
310 /* The node was cleared out when we put it on the free list, so
311 there is no need to do so again here. */
312 gcc_assert ((*SSANAMES (fn
))[SSA_NAME_VERSION (t
)] == NULL
);
313 (*SSANAMES (fn
))[SSA_NAME_VERSION (t
)] = t
;
317 t
= make_node (SSA_NAME
);
318 SSA_NAME_VERSION (t
) = SSANAMES (fn
)->length ();
319 vec_safe_push (SSANAMES (fn
), t
);
320 ssa_name_nodes_created
++;
325 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (var
);
326 SET_SSA_NAME_VAR_OR_IDENTIFIER (t
, NULL_TREE
);
330 TREE_TYPE (t
) = TREE_TYPE (var
);
331 SET_SSA_NAME_VAR_OR_IDENTIFIER (t
, var
);
333 SSA_NAME_DEF_STMT (t
) = stmt
;
334 if (POINTER_TYPE_P (TREE_TYPE (t
)))
335 SSA_NAME_PTR_INFO (t
) = NULL
;
337 SSA_NAME_RANGE_INFO (t
) = NULL
;
339 SSA_NAME_IN_FREE_LIST (t
) = 0;
340 SSA_NAME_IS_DEFAULT_DEF (t
) = 0;
341 init_ssa_name_imm_use (t
);
346 /* Helper function for set_range_info.
348 Store range information RANGE_TYPE, MIN, and MAX to tree ssa_name
352 set_range_info_raw (tree name
, enum value_range_kind range_type
,
353 const wide_int_ref
&min
, const wide_int_ref
&max
)
355 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name
)));
356 gcc_assert (range_type
== VR_RANGE
|| range_type
== VR_ANTI_RANGE
);
357 range_info_def
*ri
= SSA_NAME_RANGE_INFO (name
);
358 unsigned int precision
= TYPE_PRECISION (TREE_TYPE (name
));
360 /* Allocate if not available. */
363 size_t size
= (sizeof (range_info_def
)
364 + trailing_wide_ints
<3>::extra_size (precision
));
365 ri
= static_cast<range_info_def
*> (ggc_internal_alloc (size
));
366 ri
->ints
.set_precision (precision
);
367 SSA_NAME_RANGE_INFO (name
) = ri
;
368 ri
->set_nonzero_bits (wi::shwi (-1, precision
));
371 /* Record the range type. */
372 if (SSA_NAME_RANGE_TYPE (name
) != range_type
)
373 SSA_NAME_ANTI_RANGE_P (name
) = (range_type
== VR_ANTI_RANGE
);
375 /* Set the values. */
379 /* If it is a range, try to improve nonzero_bits from the min/max. */
380 if (range_type
== VR_RANGE
)
382 wide_int xorv
= ri
->get_min () ^ ri
->get_max ();
384 xorv
= wi::mask (precision
- wi::clz (xorv
), false, precision
);
385 ri
->set_nonzero_bits (ri
->get_nonzero_bits () & (ri
->get_min () | xorv
));
389 /* Store range information RANGE_TYPE, MIN, and MAX to tree ssa_name
390 NAME while making sure we don't store useless range info. */
393 set_range_info (tree name
, enum value_range_kind range_type
,
394 const wide_int_ref
&min
, const wide_int_ref
&max
)
396 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name
)));
398 tree type
= TREE_TYPE (name
);
399 if (range_type
== VR_VARYING
)
401 /* SSA_NAME_RANGE_TYPE can only hold a VR_RANGE or
402 VR_ANTI_RANGE. Denormalize VR_VARYING to VR_RANGE. */
403 range_type
= VR_RANGE
;
404 gcc_checking_assert (min
== wi::min_value (type
));
405 gcc_checking_assert (max
== wi::max_value (type
));
408 /* A range of the entire domain is really no range at all. */
409 if (min
== wi::min_value (TYPE_PRECISION (type
), TYPE_SIGN (type
))
410 && max
== wi::max_value (TYPE_PRECISION (type
), TYPE_SIGN (type
)))
412 range_info_def
*ri
= SSA_NAME_RANGE_INFO (name
);
415 if (ri
->get_nonzero_bits () == -1)
418 SSA_NAME_RANGE_INFO (name
) = NULL
;
423 set_range_info_raw (name
, range_type
, min
, max
);
426 /* Store range information for NAME from a value_range. */
429 set_range_info (tree name
, const value_range
&vr
)
431 wide_int min
= wi::to_wide (vr
.min ());
432 wide_int max
= wi::to_wide (vr
.max ());
433 set_range_info (name
, vr
.kind (), min
, max
);
436 /* Set nonnull attribute to pointer NAME. */
439 set_ptr_nonnull (tree name
)
441 gcc_assert (POINTER_TYPE_P (TREE_TYPE (name
)));
442 struct ptr_info_def
*pi
= get_ptr_info (name
);
446 /* Change non-zero bits bitmask of NAME. */
449 set_nonzero_bits (tree name
, const wide_int_ref
&mask
)
451 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name
)));
452 if (SSA_NAME_RANGE_INFO (name
) == NULL
)
456 set_range_info_raw (name
, VR_RANGE
,
457 wi::to_wide (TYPE_MIN_VALUE (TREE_TYPE (name
))),
458 wi::to_wide (TYPE_MAX_VALUE (TREE_TYPE (name
))));
460 range_info_def
*ri
= SSA_NAME_RANGE_INFO (name
);
461 ri
->set_nonzero_bits (mask
);
464 /* Return a widest_int with potentially non-zero bits in SSA_NAME
465 NAME, the constant for INTEGER_CST, or -1 if unknown. */
468 get_nonzero_bits (const_tree name
)
470 if (TREE_CODE (name
) == INTEGER_CST
)
471 return wi::to_wide (name
);
473 /* Use element_precision instead of TYPE_PRECISION so complex and
474 vector types get a non-zero precision. */
475 unsigned int precision
= element_precision (TREE_TYPE (name
));
476 if (POINTER_TYPE_P (TREE_TYPE (name
)))
478 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (name
);
480 return wi::shwi (-(HOST_WIDE_INT
) pi
->align
481 | (HOST_WIDE_INT
) pi
->misalign
, precision
);
482 return wi::shwi (-1, precision
);
485 range_info_def
*ri
= SSA_NAME_RANGE_INFO (name
);
487 return wi::shwi (-1, precision
);
489 return ri
->get_nonzero_bits ();
492 /* Return TRUE is OP, an SSA_NAME has a range of values [0..1], false
495 This can be because it is a boolean type, any unsigned integral
496 type with a single bit of precision, or has known range of [0..1]
497 via range analysis. */
500 ssa_name_has_boolean_range (tree op
)
502 gcc_assert (TREE_CODE (op
) == SSA_NAME
);
504 /* Boolean types always have a range [0..1]. */
505 if (TREE_CODE (TREE_TYPE (op
)) == BOOLEAN_TYPE
)
508 /* An integral type with a single bit of precision. */
509 if (INTEGRAL_TYPE_P (TREE_TYPE (op
))
510 && TYPE_UNSIGNED (TREE_TYPE (op
))
511 && TYPE_PRECISION (TREE_TYPE (op
)) == 1)
514 /* An integral type with more precision, but the object
515 only takes on values [0..1] as determined by range
517 if (INTEGRAL_TYPE_P (TREE_TYPE (op
))
518 && (TYPE_PRECISION (TREE_TYPE (op
)) > 1))
520 int_range
<2> onezero (build_zero_cst (TREE_TYPE (op
)),
521 build_one_cst (TREE_TYPE (op
)));
523 if (get_range_query (cfun
)->range_of_expr (r
, op
) && r
== onezero
)
526 if (wi::eq_p (get_nonzero_bits (op
), 1))
533 /* We no longer need the SSA_NAME expression VAR, release it so that
536 Note it is assumed that no calls to make_ssa_name will be made
537 until all uses of the ssa name are released and that the only
538 use of the SSA_NAME expression is to check its SSA_NAME_VAR. All
539 other fields must be assumed clobbered. */
542 release_ssa_name_fn (struct function
*fn
, tree var
)
547 /* Never release the default definition for a symbol. It's a
548 special SSA name that should always exist once it's created. */
549 if (SSA_NAME_IS_DEFAULT_DEF (var
))
552 /* If VAR has been registered for SSA updating, don't remove it.
553 After update_ssa has run, the name will be released. */
554 if (name_registered_for_update_p (var
))
556 release_ssa_name_after_update_ssa (var
);
560 /* release_ssa_name can be called multiple times on a single SSA_NAME.
561 However, it should only end up on our free list one time. We
562 keep a status bit in the SSA_NAME node itself to indicate it has
563 been put on the free list.
565 Note that once on the freelist you cannot reference the SSA_NAME's
566 defining statement. */
567 if (! SSA_NAME_IN_FREE_LIST (var
))
569 int saved_ssa_name_version
= SSA_NAME_VERSION (var
);
570 use_operand_p imm
= &(SSA_NAME_IMM_USE_NODE (var
));
572 if (MAY_HAVE_DEBUG_BIND_STMTS
)
573 insert_debug_temp_for_var_def (NULL
, var
);
576 verify_imm_links (stderr
, var
);
577 while (imm
->next
!= imm
)
578 delink_imm_use (imm
->next
);
580 (*SSANAMES (fn
))[SSA_NAME_VERSION (var
)] = NULL_TREE
;
581 memset (var
, 0, tree_size (var
));
585 imm
->loc
.ssa_name
= var
;
587 /* First put back the right tree node so that the tree checking
588 macros do not complain. */
589 TREE_SET_CODE (var
, SSA_NAME
);
591 /* Restore the version number. */
592 SSA_NAME_VERSION (var
) = saved_ssa_name_version
;
594 /* Note this SSA_NAME is now in the first list. */
595 SSA_NAME_IN_FREE_LIST (var
) = 1;
597 /* Put in a non-NULL TREE_TYPE so dumping code will not ICE
598 if it happens to come along a released SSA name and tries
599 to inspect its type. */
600 TREE_TYPE (var
) = error_mark_node
;
602 /* And finally queue it so that it will be put on the free list. */
603 vec_safe_push (FREE_SSANAMES_QUEUE (fn
), var
);
607 /* If the alignment of the pointer described by PI is known, return true and
608 store the alignment and the deviation from it into *ALIGNP and *MISALIGNP
609 respectively. Otherwise return false. */
612 get_ptr_info_alignment (struct ptr_info_def
*pi
, unsigned int *alignp
,
613 unsigned int *misalignp
)
618 *misalignp
= pi
->misalign
;
625 /* State that the pointer described by PI has unknown alignment. */
628 mark_ptr_info_alignment_unknown (struct ptr_info_def
*pi
)
634 /* Store the power-of-two byte alignment and the deviation from that
635 alignment of pointer described by PI to ALIOGN and MISALIGN
639 set_ptr_info_alignment (struct ptr_info_def
*pi
, unsigned int align
,
640 unsigned int misalign
)
642 gcc_checking_assert (align
!= 0);
643 gcc_assert ((align
& (align
- 1)) == 0);
644 gcc_assert ((misalign
& ~(align
- 1)) == 0);
647 pi
->misalign
= misalign
;
650 /* If pointer described by PI has known alignment, increase its known
651 misalignment by INCREMENT modulo its current alignment. */
654 adjust_ptr_info_misalignment (struct ptr_info_def
*pi
, poly_uint64 increment
)
658 increment
+= pi
->misalign
;
659 if (!known_misalignment (increment
, pi
->align
, &pi
->misalign
))
661 pi
->align
= known_alignment (increment
);
667 /* Return the alias information associated with pointer T. It creates a
668 new instance if none existed. */
670 struct ptr_info_def
*
671 get_ptr_info (tree t
)
673 struct ptr_info_def
*pi
;
675 gcc_assert (POINTER_TYPE_P (TREE_TYPE (t
)));
677 pi
= SSA_NAME_PTR_INFO (t
);
680 pi
= ggc_cleared_alloc
<ptr_info_def
> ();
681 pt_solution_reset (&pi
->pt
);
682 mark_ptr_info_alignment_unknown (pi
);
683 SSA_NAME_PTR_INFO (t
) = pi
;
690 /* Creates a new SSA name using the template NAME tobe defined by
691 statement STMT in function FN. */
694 copy_ssa_name_fn (struct function
*fn
, tree name
, gimple
*stmt
)
698 if (SSA_NAME_VAR (name
))
699 new_name
= make_ssa_name_fn (fn
, SSA_NAME_VAR (name
), stmt
);
702 new_name
= make_ssa_name_fn (fn
, TREE_TYPE (name
), stmt
);
703 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_name
, SSA_NAME_IDENTIFIER (name
));
710 /* Creates a duplicate of the ptr_info_def at PTR_INFO for use by
711 the SSA name NAME. */
714 duplicate_ssa_name_ptr_info (tree name
, struct ptr_info_def
*ptr_info
)
716 struct ptr_info_def
*new_ptr_info
;
718 gcc_assert (POINTER_TYPE_P (TREE_TYPE (name
)));
719 gcc_assert (!SSA_NAME_PTR_INFO (name
));
724 new_ptr_info
= ggc_alloc
<ptr_info_def
> ();
725 *new_ptr_info
= *ptr_info
;
727 SSA_NAME_PTR_INFO (name
) = new_ptr_info
;
730 /* Creates a duplicate of the range_info_def at RANGE_INFO of type
731 RANGE_TYPE for use by the SSA name NAME. */
733 duplicate_ssa_name_range_info (tree name
, enum value_range_kind range_type
,
734 struct range_info_def
*range_info
)
736 struct range_info_def
*new_range_info
;
738 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name
)));
739 gcc_assert (!SSA_NAME_RANGE_INFO (name
));
744 unsigned int precision
= TYPE_PRECISION (TREE_TYPE (name
));
745 size_t size
= (sizeof (range_info_def
)
746 + trailing_wide_ints
<3>::extra_size (precision
));
747 new_range_info
= static_cast<range_info_def
*> (ggc_internal_alloc (size
));
748 memcpy (new_range_info
, range_info
, size
);
750 gcc_assert (range_type
== VR_RANGE
|| range_type
== VR_ANTI_RANGE
);
751 SSA_NAME_ANTI_RANGE_P (name
) = (range_type
== VR_ANTI_RANGE
);
752 SSA_NAME_RANGE_INFO (name
) = new_range_info
;
756 duplicate_ssa_name_range_info (tree name
, tree src
)
758 gcc_checking_assert (!POINTER_TYPE_P (TREE_TYPE (src
)));
759 duplicate_ssa_name_range_info (name
,
760 SSA_NAME_RANGE_TYPE (src
),
761 SSA_NAME_RANGE_INFO (src
));
765 /* Creates a duplicate of a ssa name NAME tobe defined by statement STMT
769 duplicate_ssa_name_fn (struct function
*fn
, tree name
, gimple
*stmt
)
771 tree new_name
= copy_ssa_name_fn (fn
, name
, stmt
);
772 if (POINTER_TYPE_P (TREE_TYPE (name
)))
774 struct ptr_info_def
*old_ptr_info
= SSA_NAME_PTR_INFO (name
);
777 duplicate_ssa_name_ptr_info (new_name
, old_ptr_info
);
781 struct range_info_def
*old_range_info
= SSA_NAME_RANGE_INFO (name
);
784 duplicate_ssa_name_range_info (new_name
, SSA_NAME_RANGE_TYPE (name
),
792 /* Reset all flow sensitive data on NAME such as range-info, nonzero
793 bits and alignment. */
796 reset_flow_sensitive_info (tree name
)
798 if (POINTER_TYPE_P (TREE_TYPE (name
)))
800 /* points-to info is not flow-sensitive. */
801 if (SSA_NAME_PTR_INFO (name
))
803 /* [E]VRP can derive context sensitive alignment info and
804 non-nullness properties. We must reset both. */
805 mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (name
));
806 SSA_NAME_PTR_INFO (name
)->pt
.null
= 1;
810 SSA_NAME_RANGE_INFO (name
) = NULL
;
813 /* Clear all flow sensitive data from all statements and PHI definitions
817 reset_flow_sensitive_info_in_bb (basic_block bb
)
819 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
822 gimple
*stmt
= gsi_stmt (gsi
);
825 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, i
, SSA_OP_DEF
)
826 reset_flow_sensitive_info (op
);
829 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
832 tree phi_def
= gimple_phi_result (gsi
.phi ());
833 reset_flow_sensitive_info (phi_def
);
837 /* Release all the SSA_NAMEs created by STMT. */
840 release_defs (gimple
*stmt
)
845 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
846 if (TREE_CODE (def
) == SSA_NAME
)
847 release_ssa_name (def
);
851 /* Replace the symbol associated with SSA_NAME with SYM. */
854 replace_ssa_name_symbol (tree ssa_name
, tree sym
)
856 SET_SSA_NAME_VAR_OR_IDENTIFIER (ssa_name
, sym
);
857 TREE_TYPE (ssa_name
) = TREE_TYPE (sym
);
860 /* Release the vector of free SSA_NAMEs and compact the vector of SSA_NAMEs
864 release_free_names_and_compact_live_names (function
*fun
)
867 int n
= vec_safe_length (FREE_SSANAMES (fun
));
869 /* Now release the freelist. */
870 vec_free (FREE_SSANAMES (fun
));
872 /* And compact the SSA number space. We make sure to not change the
873 relative order of SSA versions. */
874 for (i
= 1, j
= 1; i
< fun
->gimple_df
->ssa_names
->length (); ++i
)
876 tree name
= ssa_name (i
);
881 SSA_NAME_VERSION (name
) = j
;
882 (*fun
->gimple_df
->ssa_names
)[j
] = name
;
887 fun
->gimple_df
->ssa_names
->truncate (j
);
889 statistics_counter_event (fun
, "SSA names released", n
);
890 statistics_counter_event (fun
, "SSA name holes removed", i
- j
);
892 fprintf (dump_file
, "Released %i names, %.2f%%, removed %i holes\n",
893 n
, n
* 100.0 / num_ssa_names
, i
- j
);
896 /* Return SSA names that are unused to GGC memory and compact the SSA
897 version namespace. This is used to keep footprint of compiler during
898 interprocedural optimization. */
902 const pass_data pass_data_release_ssa_names
=
904 GIMPLE_PASS
, /* type */
905 "release_ssa", /* name */
906 OPTGROUP_NONE
, /* optinfo_flags */
907 TV_TREE_SSA_OTHER
, /* tv_id */
908 PROP_ssa
, /* properties_required */
909 0, /* properties_provided */
910 0, /* properties_destroyed */
911 TODO_remove_unused_locals
, /* todo_flags_start */
912 0, /* todo_flags_finish */
915 class pass_release_ssa_names
: public gimple_opt_pass
918 pass_release_ssa_names (gcc::context
*ctxt
)
919 : gimple_opt_pass (pass_data_release_ssa_names
, ctxt
)
922 /* opt_pass methods: */
923 virtual unsigned int execute (function
*);
925 }; // class pass_release_ssa_names
928 pass_release_ssa_names::execute (function
*fun
)
930 release_free_names_and_compact_live_names (fun
);
937 make_pass_release_ssa_names (gcc::context
*ctxt
)
939 return new pass_release_ssa_names (ctxt
);