Branch data Line data Source code
1 : : /* Generic routines for manipulating SSA_NAME expressions
2 : : Copyright (C) 2003-2025 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
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)
9 : : any later version.
10 : :
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.
15 : :
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/>. */
19 : :
20 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "tree.h"
25 : : #include "gimple.h"
26 : : #include "tree-pass.h"
27 : : #include "ssa.h"
28 : : #include "gimple-pretty-print.h"
29 : : #include "gimple-iterator.h"
30 : : #include "stor-layout.h"
31 : : #include "tree-into-ssa.h"
32 : : #include "tree-ssa.h"
33 : : #include "cfgloop.h"
34 : : #include "tree-scalar-evolution.h"
35 : : #include "value-query.h"
36 : : #include "value-range-storage.h"
37 : :
38 : : /* Rewriting a function into SSA form can create a huge number of SSA_NAMEs,
39 : : many of which may be thrown away shortly after their creation if jumps
40 : : were threaded through PHI nodes.
41 : :
42 : : While our garbage collection mechanisms will handle this situation, it
43 : : is extremely wasteful to create nodes and throw them away, especially
44 : : when the nodes can be reused.
45 : :
46 : : For PR 8361, we can significantly reduce the number of nodes allocated
47 : : and thus the total amount of memory allocated by managing SSA_NAMEs a
48 : : little. This additionally helps reduce the amount of work done by the
49 : : garbage collector. Similar results have been seen on a wider variety
50 : : of tests (such as the compiler itself).
51 : :
52 : : Right now we maintain our free list on a per-function basis. It may
53 : : or may not make sense to maintain the free list for the duration of
54 : : a compilation unit.
55 : :
56 : : External code should rely solely upon HIGHEST_SSA_VERSION and the
57 : : externally defined functions. External code should not know about
58 : : the details of the free list management.
59 : :
60 : : External code should also not assume the version number on nodes is
61 : : monotonically increasing. We reuse the version number when we
62 : : reuse an SSA_NAME expression. This helps keep arrays and bitmaps
63 : : more compact. */
64 : :
65 : :
66 : : /* Version numbers with special meanings. We start allocating new version
67 : : numbers after the special ones. */
68 : : #define UNUSED_NAME_VERSION 0
69 : :
70 : : unsigned int ssa_name_nodes_reused;
71 : : unsigned int ssa_name_nodes_created;
72 : :
73 : : #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames
74 : : #define FREE_SSANAMES_QUEUE(fun) (fun)->gimple_df->free_ssanames_queue
75 : :
76 : : /* Return TRUE if NAME has global range info. */
77 : :
78 : : inline bool
79 : 968090456 : range_info_p (const_tree name)
80 : : {
81 : 968090456 : return SSA_NAME_RANGE_INFO (name);
82 : : }
83 : :
84 : : /* Return TRUE if R fits in the global range of NAME. */
85 : :
86 : : inline bool
87 : 3162405 : range_info_fits_p (tree name, const vrange &r)
88 : : {
89 : 3162405 : gcc_checking_assert (range_info_p (name));
90 : 3162405 : vrange_storage *mem = SSA_NAME_RANGE_INFO (name);
91 : 3162405 : return mem->fits_p (r);
92 : : }
93 : :
94 : : /* Allocate a new global range for NAME and set it to R. Return the
95 : : allocation slot. */
96 : :
97 : : inline void *
98 : 16571506 : range_info_alloc (tree name, const vrange &r)
99 : : {
100 : 16571506 : vrange_storage *mem = ggc_alloc_vrange_storage (r);
101 : 16571506 : SSA_NAME_RANGE_INFO (name) = mem;
102 : 16571506 : return mem;
103 : : }
104 : :
105 : : /* Free storage allocated for the global range for NAME. */
106 : :
107 : : inline void
108 : 580242 : range_info_free (tree name)
109 : : {
110 : 580242 : vrange_storage *mem = SSA_NAME_RANGE_INFO (name);
111 : 580242 : ggc_free (mem);
112 : 580242 : }
113 : :
114 : : /* Return the global range for NAME in R. */
115 : :
116 : : inline void
117 : 296822176 : range_info_get_range (const_tree name, vrange &r)
118 : : {
119 : 296822176 : SSA_NAME_RANGE_INFO (name)->get_vrange (r, TREE_TYPE (name));
120 : 296822176 : }
121 : :
122 : : /* Set the global range for NAME from R. Return TRUE if successfull,
123 : : or FALSE if we can't set a range of NAME's type. */
124 : :
125 : : inline bool
126 : 19153669 : range_info_set_range (tree name, const vrange &r)
127 : : {
128 : 19153669 : if (!range_info_p (name) || !range_info_fits_p (name, r))
129 : : {
130 : 16571506 : if (range_info_p (name))
131 : 580242 : range_info_free (name);
132 : :
133 : 16571506 : return range_info_alloc (name, r);
134 : : }
135 : : else
136 : : {
137 : 2582163 : SSA_NAME_RANGE_INFO (name)->set_vrange (r);
138 : 2582163 : return true;
139 : : }
140 : : }
141 : :
142 : : /* Initialize management of SSA_NAMEs to default SIZE. If SIZE is
143 : : zero use default. */
144 : :
145 : : void
146 : 3272922 : init_ssanames (struct function *fn, int size)
147 : : {
148 : 3272922 : if (!size)
149 : 3189547 : vec_alloc (SSANAMES (fn), 50);
150 : : else
151 : 83375 : vec_safe_reserve (SSANAMES (fn), size, true);
152 : :
153 : : /* Version 0 is special, so reserve the first slot in the table. Though
154 : : currently unused, we may use version 0 in alias analysis as part of
155 : : the heuristics used to group aliases when the alias sets are too
156 : : large.
157 : :
158 : : We use vec::quick_push here because we know that SSA_NAMES has at
159 : : least 50 elements reserved in it. */
160 : 3272922 : SSANAMES (fn)->quick_push (NULL_TREE);
161 : 3272922 : FREE_SSANAMES (fn) = NULL;
162 : 3272922 : FREE_SSANAMES_QUEUE (fn) = NULL;
163 : :
164 : 3272922 : fn->gimple_df->ssa_renaming_needed = 0;
165 : 3272922 : fn->gimple_df->rename_vops = 0;
166 : 3272922 : }
167 : :
168 : : /* Finalize management of SSA_NAMEs. */
169 : :
170 : : void
171 : 3164121 : fini_ssanames (struct function *fn)
172 : : {
173 : 3164121 : unsigned i;
174 : 3164121 : tree name;
175 : : /* Some SSA names leak into global tree data structures so we can't simply
176 : : ggc_free them. But make sure to clear references to stmts since we now
177 : : ggc_free the CFG itself. */
178 : 93288305 : FOR_EACH_VEC_SAFE_ELT (SSANAMES (fn), i, name)
179 : 90124184 : if (name)
180 : 65092956 : SSA_NAME_DEF_STMT (name) = NULL;
181 : 3164121 : vec_free (SSANAMES (fn));
182 : 3164121 : vec_free (FREE_SSANAMES (fn));
183 : 3164121 : vec_free (FREE_SSANAMES_QUEUE (fn));
184 : 3164121 : }
185 : :
186 : : /* Dump some simple statistics regarding the re-use of SSA_NAME nodes. */
187 : :
188 : : void
189 : 0 : ssanames_print_statistics (void)
190 : : {
191 : 0 : fprintf (stderr, "%-32s" PRsa (11) "\n", "SSA_NAME nodes allocated:",
192 : 0 : SIZE_AMOUNT (ssa_name_nodes_created));
193 : 0 : fprintf (stderr, "%-32s" PRsa (11) "\n", "SSA_NAME nodes reused:",
194 : 0 : SIZE_AMOUNT (ssa_name_nodes_reused));
195 : 0 : }
196 : :
197 : : /* Verify the state of the SSA_NAME lists.
198 : :
199 : : There must be no duplicates on the free list.
200 : : Every name on the free list must be marked as on the free list.
201 : : Any name on the free list must not appear in the IL.
202 : : No names can be leaked. */
203 : :
204 : : DEBUG_FUNCTION void
205 : 0 : verify_ssaname_freelists (struct function *fun)
206 : : {
207 : 0 : if (!gimple_in_ssa_p (fun))
208 : 0 : return;
209 : :
210 : 0 : auto_bitmap names_in_il;
211 : :
212 : : /* Walk the entire IL noting every SSA_NAME we see. */
213 : 0 : basic_block bb;
214 : 0 : FOR_EACH_BB_FN (bb, fun)
215 : : {
216 : 0 : tree t;
217 : : /* First note the result and arguments of PHI nodes. */
218 : 0 : for (gphi_iterator gsi = gsi_start_phis (bb);
219 : 0 : !gsi_end_p (gsi);
220 : 0 : gsi_next (&gsi))
221 : : {
222 : 0 : gphi *phi = gsi.phi ();
223 : 0 : t = gimple_phi_result (phi);
224 : 0 : bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t));
225 : :
226 : 0 : for (unsigned int i = 0; i < gimple_phi_num_args (phi); i++)
227 : : {
228 : 0 : t = gimple_phi_arg_def (phi, i);
229 : 0 : if (TREE_CODE (t) == SSA_NAME)
230 : 0 : bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t));
231 : : }
232 : : }
233 : :
234 : : /* Then note the operands of each statement. */
235 : 0 : for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
236 : 0 : !gsi_end_p (gsi);
237 : 0 : gsi_next (&gsi))
238 : : {
239 : 0 : ssa_op_iter iter;
240 : 0 : gimple *stmt = gsi_stmt (gsi);
241 : 0 : FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, SSA_OP_ALL_OPERANDS)
242 : 0 : bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t));
243 : : }
244 : : }
245 : :
246 : : /* Now walk the free list noting what we find there and verifying
247 : : there are no duplicates. */
248 : 0 : auto_bitmap names_in_freelists;
249 : 0 : if (FREE_SSANAMES (fun))
250 : : {
251 : 0 : for (unsigned int i = 0; i < FREE_SSANAMES (fun)->length (); i++)
252 : : {
253 : 0 : tree t = (*FREE_SSANAMES (fun))[i];
254 : :
255 : : /* Verify that the name is marked as being in the free list. */
256 : 0 : gcc_assert (SSA_NAME_IN_FREE_LIST (t));
257 : :
258 : : /* Verify the name has not already appeared in the free list and
259 : : note it in the list of names found in the free list. */
260 : 0 : gcc_assert (!bitmap_bit_p (names_in_freelists, SSA_NAME_VERSION (t)));
261 : 0 : bitmap_set_bit (names_in_freelists, SSA_NAME_VERSION (t));
262 : : }
263 : : }
264 : :
265 : : /* Similarly for the names in the pending free list. */
266 : 0 : if (FREE_SSANAMES_QUEUE (fun))
267 : : {
268 : 0 : for (unsigned int i = 0; i < FREE_SSANAMES_QUEUE (fun)->length (); i++)
269 : : {
270 : 0 : tree t = (*FREE_SSANAMES_QUEUE (fun))[i];
271 : :
272 : : /* Verify that the name is marked as being in the free list. */
273 : 0 : gcc_assert (SSA_NAME_IN_FREE_LIST (t));
274 : :
275 : : /* Verify the name has not already appeared in the free list and
276 : : note it in the list of names found in the free list. */
277 : 0 : gcc_assert (!bitmap_bit_p (names_in_freelists, SSA_NAME_VERSION (t)));
278 : 0 : bitmap_set_bit (names_in_freelists, SSA_NAME_VERSION (t));
279 : : }
280 : : }
281 : :
282 : : /* If any name appears in both the IL and the freelists, then
283 : : something horrible has happened. */
284 : 0 : bool intersect_p = bitmap_intersect_p (names_in_il, names_in_freelists);
285 : 0 : gcc_assert (!intersect_p);
286 : :
287 : : /* Names can be queued up for release if there is an ssa update
288 : : pending. Pretend we saw them in the IL. */
289 : 0 : if (names_to_release)
290 : 0 : bitmap_ior_into (names_in_il, names_to_release);
291 : :
292 : : /* Function splitting can "lose" SSA_NAMEs in an effort to ensure that
293 : : debug/non-debug compilations have the same SSA_NAMEs. So for each
294 : : lost SSA_NAME, see if it's likely one from that wart. These will always
295 : : be marked as default definitions. So we loosely assume that anything
296 : : marked as a default definition isn't leaked by pretending they are
297 : : in the IL. */
298 : 0 : for (unsigned int i = UNUSED_NAME_VERSION + 1; i < num_ssa_names; i++)
299 : 0 : if (ssa_name (i) && SSA_NAME_IS_DEFAULT_DEF (ssa_name (i)))
300 : 0 : bitmap_set_bit (names_in_il, i);
301 : :
302 : 0 : unsigned int i;
303 : 0 : bitmap_iterator bi;
304 : 0 : auto_bitmap all_names;
305 : 0 : bitmap_set_range (all_names, UNUSED_NAME_VERSION + 1, num_ssa_names - 1);
306 : 0 : bitmap_ior_into (names_in_il, names_in_freelists);
307 : :
308 : : /* Any name not mentioned in the IL and not in the feelists
309 : : has been leaked. */
310 : 0 : EXECUTE_IF_AND_COMPL_IN_BITMAP(all_names, names_in_il,
311 : : UNUSED_NAME_VERSION + 1, i, bi)
312 : 0 : gcc_assert (!ssa_name (i));
313 : 0 : }
314 : :
315 : : /* Move all SSA_NAMEs from FREE_SSA_NAMES_QUEUE to FREE_SSA_NAMES.
316 : :
317 : : We do not, but should have a mode to verify the state of the SSA_NAMEs
318 : : lists. In particular at this point every name must be in the IL,
319 : : on the free list or in the queue. Anything else is an error. */
320 : :
321 : : void
322 : 621408817 : flush_ssaname_freelist (void)
323 : : {
324 : : /* If there were any SSA names released reset the SCEV cache. */
325 : 621408817 : if (! vec_safe_is_empty (FREE_SSANAMES_QUEUE (cfun)))
326 : 10595805 : scev_reset_htab ();
327 : 621408817 : vec_safe_splice (FREE_SSANAMES (cfun), FREE_SSANAMES_QUEUE (cfun));
328 : 621408817 : vec_safe_truncate (FREE_SSANAMES_QUEUE (cfun), 0);
329 : 621408817 : }
330 : :
331 : : /* Initialize SSA_NAME_IMM_USE_NODE of a SSA NAME. */
332 : :
333 : : void
334 : 148307375 : init_ssa_name_imm_use (tree name)
335 : : {
336 : 148307375 : use_operand_p imm;
337 : 148307375 : imm = &(SSA_NAME_IMM_USE_NODE (name));
338 : 148307375 : imm->use = NULL;
339 : 148307375 : imm->prev = imm;
340 : 148307375 : imm->next = imm;
341 : 148307375 : imm->loc.ssa_name = name;
342 : 148307375 : }
343 : :
344 : : /* Return an SSA_NAME node for variable VAR defined in statement STMT
345 : : in function FN. STMT may be an empty statement for artificial
346 : : references (e.g., default definitions created when a variable is
347 : : used without a preceding definition). If VERISON is not zero then
348 : : allocate the SSA name with that version. */
349 : :
350 : : tree
351 : 146419877 : make_ssa_name_fn (struct function *fn, tree var, gimple *stmt,
352 : : unsigned int version)
353 : : {
354 : 146419877 : tree t;
355 : 146419877 : gcc_assert (VAR_P (var)
356 : : || TREE_CODE (var) == PARM_DECL
357 : : || TREE_CODE (var) == RESULT_DECL
358 : : || (TYPE_P (var) && is_gimple_reg_type (var)));
359 : :
360 : : /* Get the specified SSA name version. */
361 : 146419877 : if (version != 0)
362 : : {
363 : 4407 : t = make_node (SSA_NAME);
364 : 4407 : SSA_NAME_VERSION (t) = version;
365 : 4407 : if (version >= SSANAMES (fn)->length ())
366 : 706 : vec_safe_grow_cleared (SSANAMES (fn), version + 1, true);
367 : 4407 : gcc_assert ((*SSANAMES (fn))[version] == NULL);
368 : 4407 : (*SSANAMES (fn))[version] = t;
369 : 4407 : ssa_name_nodes_created++;
370 : : }
371 : : /* If our free list has an element, then use it. */
372 : 146415470 : else if (!vec_safe_is_empty (FREE_SSANAMES (fn)))
373 : : {
374 : 30430842 : t = FREE_SSANAMES (fn)->pop ();
375 : 30430842 : ssa_name_nodes_reused++;
376 : :
377 : : /* The node was cleared out when we put it on the free list, so
378 : : there is no need to do so again here. */
379 : 30430842 : gcc_assert ((*SSANAMES (fn))[SSA_NAME_VERSION (t)] == NULL);
380 : 30430842 : (*SSANAMES (fn))[SSA_NAME_VERSION (t)] = t;
381 : : }
382 : : else
383 : : {
384 : 115984628 : t = make_node (SSA_NAME);
385 : 115984628 : SSA_NAME_VERSION (t) = SSANAMES (fn)->length ();
386 : 115984628 : vec_safe_push (SSANAMES (fn), t);
387 : 115984628 : ssa_name_nodes_created++;
388 : : }
389 : :
390 : 146419877 : if (TYPE_P (var))
391 : : {
392 : 55222854 : TREE_TYPE (t) = TYPE_MAIN_VARIANT (var);
393 : 55222854 : SET_SSA_NAME_VAR_OR_IDENTIFIER (t, NULL_TREE);
394 : : }
395 : : else
396 : : {
397 : 91197023 : TREE_TYPE (t) = TREE_TYPE (var);
398 : 134101679 : SET_SSA_NAME_VAR_OR_IDENTIFIER (t, var);
399 : : }
400 : 146419877 : SSA_NAME_DEF_STMT (t) = stmt;
401 : 146419877 : if (POINTER_TYPE_P (TREE_TYPE (t)))
402 : 29596591 : SSA_NAME_PTR_INFO (t) = NULL;
403 : : else
404 : 116823286 : SSA_NAME_RANGE_INFO (t) = NULL;
405 : :
406 : 146419877 : SSA_NAME_IN_FREE_LIST (t) = 0;
407 : 146419877 : SSA_NAME_IS_DEFAULT_DEF (t) = 0;
408 : 146419877 : init_ssa_name_imm_use (t);
409 : :
410 : 146419877 : return t;
411 : : }
412 : :
413 : : /* Update the range information for NAME, intersecting into an existing
414 : : range if applicable. Return TRUE if the range was updated. */
415 : :
416 : : bool
417 : 43946068 : set_range_info (tree name, const vrange &r)
418 : : {
419 : 43946068 : if (r.undefined_p () || r.varying_p ())
420 : : return false;
421 : :
422 : : // Pick up the current range, or VARYING if none.
423 : 43796067 : tree type = TREE_TYPE (name);
424 : 43796067 : if (POINTER_TYPE_P (type))
425 : : {
426 : 6390537 : struct ptr_info_def *pi = get_ptr_info (name);
427 : : // If R is nonnull and pi is not, set nonnull.
428 : 6390537 : if (r.nonzero_p () && (!pi || pi->pt.null))
429 : 2440639 : set_ptr_nonnull (name);
430 : : else
431 : : return false;
432 : : }
433 : : else
434 : : {
435 : 37405530 : value_range tmp (type);
436 : 37405530 : if (range_info_p (name))
437 : 29346699 : range_info_get_range (name, tmp);
438 : : else
439 : 8058831 : tmp.set_varying (type);
440 : : // If the result doesn't change, or is undefined, return false.
441 : 37405530 : if (!tmp.intersect (r) || tmp.undefined_p ())
442 : : return false;
443 : 11221236 : if (!range_info_set_range (name, tmp))
444 : : return false;
445 : 37405530 : }
446 : 13661875 : if (dump_file)
447 : : {
448 : 4039 : value_range tmp (type);
449 : 4039 : fprintf (dump_file, "Global Exported: ");
450 : 4039 : print_generic_expr (dump_file, name, TDF_SLIM);
451 : 4039 : fprintf (dump_file, " = ");
452 : 4039 : gimple_range_global (tmp, name);
453 : 4039 : tmp.dump (dump_file);
454 : 4039 : fputc ('\n', dump_file);
455 : 4039 : }
456 : : return true;
457 : : }
458 : :
459 : : /* Set nonnull attribute to pointer NAME. */
460 : :
461 : : void
462 : 6033062 : set_ptr_nonnull (tree name)
463 : : {
464 : 6033062 : gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
465 : 6033062 : struct ptr_info_def *pi = get_ptr_info (name);
466 : 6033062 : pi->pt.null = 0;
467 : 6033062 : }
468 : :
469 : : /* Update the non-zero bits bitmask of NAME. */
470 : :
471 : : void
472 : 0 : set_nonzero_bits (tree name, const wide_int &mask)
473 : : {
474 : 0 : gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
475 : :
476 : 0 : int_range<2> r (TREE_TYPE (name));
477 : 0 : r.set_nonzero_bits (mask);
478 : 0 : set_range_info (name, r);
479 : 0 : }
480 : :
481 : : /* Update the known bits of NAME.
482 : :
483 : : Zero bits in MASK cover constant values. Set bits in MASK cover
484 : : unknown values. VALUE are the known bits. */
485 : :
486 : : void
487 : 13248246 : set_bitmask (tree name, const wide_int &value, const wide_int &mask)
488 : : {
489 : 13248246 : gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
490 : :
491 : 13248246 : int_range_max r (TREE_TYPE (name));
492 : 13248246 : r.update_bitmask (irange_bitmask (value, mask));
493 : 13248246 : set_range_info (name, r);
494 : 13248246 : }
495 : :
496 : : /* Return a wide_int with potentially non-zero bits in SSA_NAME
497 : : NAME, the constant for INTEGER_CST, or -1 if unknown. */
498 : :
499 : : static wide_int
500 : 887863594 : get_nonzero_bits_1 (const_tree name)
501 : : {
502 : 887863594 : if (TREE_CODE (name) == INTEGER_CST)
503 : 163899436 : return wi::to_wide (name);
504 : :
505 : 723964158 : if (POLY_INT_CST_P (name))
506 : : return -known_alignment (wi::to_poly_wide (name));
507 : :
508 : : /* Use element_precision instead of TYPE_PRECISION so complex and
509 : : vector types get a non-zero precision. */
510 : 723964158 : unsigned int precision = element_precision (TREE_TYPE (name));
511 : :
512 : 723964158 : if (VECTOR_TYPE_P (TREE_TYPE (name)))
513 : : {
514 : 0 : tree elem = uniform_vector_p (name);
515 : 0 : if (elem)
516 : 0 : return get_nonzero_bits_1 (elem);
517 : : }
518 : :
519 : 723964158 : if (TREE_CODE (name) != SSA_NAME)
520 : 995718 : return wi::shwi (-1, precision);
521 : :
522 : 722968440 : if (POINTER_TYPE_P (TREE_TYPE (name)))
523 : : {
524 : 59827980 : struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
525 : 59827980 : if (pi && pi->align)
526 : 3183431 : return wi::shwi (-(HOST_WIDE_INT) pi->align
527 : 6366862 : | (HOST_WIDE_INT) pi->misalign, precision);
528 : 56644549 : return wi::shwi (-1, precision);
529 : : }
530 : :
531 : 663140460 : if (!range_info_p (name) || !irange::supports_p (TREE_TYPE (name)))
532 : 447468775 : return wi::shwi (-1, precision);
533 : :
534 : 215671685 : int_range_max tmp;
535 : 215671685 : range_info_get_range (name, tmp);
536 : 215671685 : return tmp.get_nonzero_bits ();
537 : 215671685 : }
538 : :
539 : : /* Return a wide_int with potentially non-zero bits in SSA_NAME
540 : : NAME, the constant for INTEGER_CST, or -1 if unknown.
541 : : In addition to what get_nonzero_bits_1 handles, this handles one
542 : : level of BIT_AND_EXPR, either as a def_stmt or tree directly. */
543 : :
544 : : wide_int
545 : 830839969 : get_nonzero_bits (const_tree name)
546 : : {
547 : 830839969 : if (TREE_CODE (name) == BIT_AND_EXPR)
548 : 3685254 : return (get_nonzero_bits_1 (TREE_OPERAND (name, 0))
549 : 5527881 : & get_nonzero_bits_1 (TREE_OPERAND (name, 1)));
550 : 828997342 : if (TREE_CODE (name) == SSA_NAME)
551 : : {
552 : 683229935 : gimple *g = SSA_NAME_DEF_STMT (name);
553 : 683229935 : if (g
554 : 683229834 : && is_gimple_assign (g)
555 : 1182506952 : && gimple_assign_rhs_code (g) == BIT_AND_EXPR)
556 : 55180998 : return (get_nonzero_bits_1 (name)
557 : 110361996 : & get_nonzero_bits_1 (gimple_assign_rhs1 (g))
558 : 82771497 : & get_nonzero_bits_1 (gimple_assign_rhs2 (g)));
559 : : }
560 : 801406843 : return get_nonzero_bits_1 (name);
561 : : }
562 : :
563 : : /* Return a wide_int with known non-zero bits in SSA_NAME
564 : : NAME (bits whose values aren't known are also clear), the constant
565 : : for INTEGER_CST, or 0 if unknown. */
566 : :
567 : : static wide_int
568 : 371327872 : get_known_nonzero_bits_1 (const_tree name)
569 : : {
570 : 371327872 : if (TREE_CODE (name) == INTEGER_CST)
571 : 173509435 : return wi::to_wide (name);
572 : :
573 : : /* Use element_precision instead of TYPE_PRECISION so complex and
574 : : vector types get a non-zero precision. */
575 : 197818437 : unsigned int precision = element_precision (TREE_TYPE (name));
576 : 197818437 : if (TREE_CODE (name) != SSA_NAME || POINTER_TYPE_P (TREE_TYPE (name)))
577 : 14743 : return wi::shwi (0, precision);
578 : :
579 : 197803694 : if (!range_info_p (name) || !irange::supports_p (TREE_TYPE (name)))
580 : 153932335 : return wi::shwi (0, precision);
581 : :
582 : 43871359 : int_range_max tmp;
583 : 43871359 : range_info_get_range (name, tmp);
584 : 43871359 : if (tmp.undefined_p ())
585 : 0 : return wi::shwi (0, precision);
586 : 43871359 : irange_bitmask bm = tmp.get_bitmask ();
587 : 43871397 : return wi::bit_and_not (bm.value (), bm.mask ());
588 : 43871359 : }
589 : :
590 : : /* Return a wide_int with known non-zero bits in SSA_NAME
591 : : NAME, the constant for INTEGER_CST, or -1 if unknown.
592 : : In addition to what get_known_nonzero_bits_1 handles, this handles one
593 : : level of BIT_IOR_EXPR, either as a def_stmt or tree directly. */
594 : :
595 : : wide_int
596 : 363049162 : get_known_nonzero_bits (const_tree name)
597 : : {
598 : 363049162 : if (TREE_CODE (name) == BIT_IOR_EXPR)
599 : 549980 : return (get_known_nonzero_bits_1 (TREE_OPERAND (name, 0))
600 : 824970 : | get_known_nonzero_bits_1 (TREE_OPERAND (name, 1)));
601 : 362774172 : if (TREE_CODE (name) == SSA_NAME)
602 : : {
603 : 189294014 : gimple *g = SSA_NAME_DEF_STMT (name);
604 : 189294014 : if (g
605 : 189294014 : && is_gimple_assign (g)
606 : 315048670 : && gimple_assign_rhs_code (g) == BIT_IOR_EXPR)
607 : 8003720 : return (get_known_nonzero_bits_1 (name)
608 : 16007440 : | get_known_nonzero_bits_1 (gimple_assign_rhs1 (g))
609 : 12005580 : | get_known_nonzero_bits_1 (gimple_assign_rhs2 (g)));
610 : : }
611 : 358772312 : return get_known_nonzero_bits_1 (name);
612 : : }
613 : :
614 : : /* Return TRUE is OP, an SSA_NAME has a range of values [0..1], false
615 : : otherwise.
616 : :
617 : : This can be because it is a boolean type, any unsigned integral
618 : : type with a single bit of precision, or has known range of [0..1]
619 : : via range analysis. */
620 : :
621 : : bool
622 : 27543805 : ssa_name_has_boolean_range (tree op)
623 : : {
624 : 27543805 : gcc_assert (TREE_CODE (op) == SSA_NAME);
625 : :
626 : : /* An integral type with a single bit of precision. */
627 : 54523796 : if (INTEGRAL_TYPE_P (TREE_TYPE (op))
628 : 21256105 : && TYPE_UNSIGNED (TREE_TYPE (op))
629 : 39739186 : && TYPE_PRECISION (TREE_TYPE (op)) == 1)
630 : : return true;
631 : :
632 : : /* An integral type with more precision, but the object
633 : : only takes on values [0..1] as determined by range
634 : : analysis. */
635 : 47210700 : if (INTEGRAL_TYPE_P (TREE_TYPE (op))
636 : 40923000 : && (TYPE_PRECISION (TREE_TYPE (op)) > 1))
637 : : {
638 : 17598431 : int_range<2> r;
639 : 35196862 : if (get_range_query (cfun)->range_of_expr (r, op)
640 : 17598431 : && r == range_true_and_false (TREE_TYPE (op)))
641 : : return true;
642 : :
643 : 17083834 : if (wi::eq_p (get_nonzero_bits (op), 1))
644 : : return true;
645 : 17598431 : }
646 : :
647 : : return false;
648 : : }
649 : :
650 : : /* We no longer need the SSA_NAME expression VAR, release it so that
651 : : it may be reused.
652 : :
653 : : Note it is assumed that no calls to make_ssa_name will be made
654 : : until all uses of the ssa name are released and that the only
655 : : use of the SSA_NAME expression is to check its SSA_NAME_VAR. All
656 : : other fields must be assumed clobbered. */
657 : :
658 : : void
659 : 81463034 : release_ssa_name_fn (struct function *fn, tree var)
660 : : {
661 : 81463034 : if (!var)
662 : : return;
663 : :
664 : : /* Never release the default definition for a symbol. It's a
665 : : special SSA name that should always exist once it's created. */
666 : 81463034 : if (SSA_NAME_IS_DEFAULT_DEF (var))
667 : : return;
668 : :
669 : : /* If VAR has been registered for SSA updating, don't remove it.
670 : : After update_ssa has run, the name will be released. */
671 : 81463034 : if (name_registered_for_update_p (var))
672 : : {
673 : 843591 : release_ssa_name_after_update_ssa (var);
674 : 843591 : return;
675 : : }
676 : :
677 : : /* release_ssa_name can be called multiple times on a single SSA_NAME.
678 : : However, it should only end up on our free list one time. We
679 : : keep a status bit in the SSA_NAME node itself to indicate it has
680 : : been put on the free list.
681 : :
682 : : Note that once on the freelist you cannot reference the SSA_NAME's
683 : : defining statement. */
684 : 80619443 : if (! SSA_NAME_IN_FREE_LIST (var))
685 : : {
686 : 80619443 : int saved_ssa_name_version = SSA_NAME_VERSION (var);
687 : 80619443 : use_operand_p imm = &(SSA_NAME_IMM_USE_NODE (var));
688 : :
689 : 80619443 : if (MAY_HAVE_DEBUG_BIND_STMTS)
690 : 53562866 : insert_debug_temp_for_var_def (NULL, var);
691 : :
692 : 80619443 : if (flag_checking)
693 : 80618843 : verify_imm_links (stderr, var);
694 : 90018683 : while (imm->next != imm)
695 : 90018683 : delink_imm_use (imm->next);
696 : :
697 : 80619443 : (*SSANAMES (fn))[SSA_NAME_VERSION (var)] = NULL_TREE;
698 : 80619443 : memset (var, 0, tree_size (var));
699 : :
700 : 80619443 : imm->prev = imm;
701 : 80619443 : imm->next = imm;
702 : 80619443 : imm->loc.ssa_name = var;
703 : :
704 : : /* First put back the right tree node so that the tree checking
705 : : macros do not complain. */
706 : 80619443 : TREE_SET_CODE (var, SSA_NAME);
707 : :
708 : : /* Restore the version number. */
709 : 80619443 : SSA_NAME_VERSION (var) = saved_ssa_name_version;
710 : :
711 : : /* Note this SSA_NAME is now in the first list. */
712 : 80619443 : SSA_NAME_IN_FREE_LIST (var) = 1;
713 : :
714 : : /* Put in a non-NULL TREE_TYPE so dumping code will not ICE
715 : : if it happens to come along a released SSA name and tries
716 : : to inspect its type. */
717 : 80619443 : TREE_TYPE (var) = error_mark_node;
718 : :
719 : : /* And finally queue it so that it will be put on the free list. */
720 : 80619443 : vec_safe_push (FREE_SSANAMES_QUEUE (fn), var);
721 : : }
722 : : }
723 : :
724 : : /* If the alignment of the pointer described by PI is known, return true and
725 : : store the alignment and the deviation from it into *ALIGNP and *MISALIGNP
726 : : respectively. Otherwise return false. */
727 : :
728 : : bool
729 : 47565737 : get_ptr_info_alignment (struct ptr_info_def *pi, unsigned int *alignp,
730 : : unsigned int *misalignp)
731 : : {
732 : 47565737 : if (pi->align)
733 : : {
734 : 5887709 : *alignp = pi->align;
735 : 5887709 : *misalignp = pi->misalign;
736 : 5887709 : return true;
737 : : }
738 : : else
739 : : return false;
740 : : }
741 : :
742 : : /* State that the pointer described by PI has unknown alignment. */
743 : :
744 : : void
745 : 15399991 : mark_ptr_info_alignment_unknown (struct ptr_info_def *pi)
746 : : {
747 : 15399991 : pi->align = 0;
748 : 15399991 : pi->misalign = 0;
749 : 15399991 : }
750 : :
751 : : /* Store the power-of-two byte alignment and the deviation from that
752 : : alignment of pointer described by PI to ALIOGN and MISALIGN
753 : : respectively. */
754 : :
755 : : void
756 : 1618144 : set_ptr_info_alignment (struct ptr_info_def *pi, unsigned int align,
757 : : unsigned int misalign)
758 : : {
759 : 1618144 : gcc_checking_assert (align != 0);
760 : 1618144 : gcc_assert ((align & (align - 1)) == 0);
761 : 1618144 : gcc_assert ((misalign & ~(align - 1)) == 0);
762 : :
763 : 1618144 : pi->align = align;
764 : 1618144 : pi->misalign = misalign;
765 : 1618144 : }
766 : :
767 : : /* If pointer described by PI has known alignment, increase its known
768 : : misalignment by INCREMENT modulo its current alignment. */
769 : :
770 : : void
771 : 0 : adjust_ptr_info_misalignment (struct ptr_info_def *pi, poly_uint64 increment)
772 : : {
773 : 0 : if (pi->align != 0)
774 : : {
775 : 0 : increment += pi->misalign;
776 : 0 : if (!known_misalignment (increment, pi->align, &pi->misalign))
777 : : {
778 : : pi->align = known_alignment (increment);
779 : : pi->misalign = 0;
780 : : }
781 : : }
782 : 0 : }
783 : :
784 : : /* Return the alias information associated with pointer T. It creates a
785 : : new instance if none existed. */
786 : :
787 : : struct ptr_info_def *
788 : 37199817 : get_ptr_info (tree t)
789 : : {
790 : 37199817 : struct ptr_info_def *pi;
791 : :
792 : 37199817 : gcc_assert (POINTER_TYPE_P (TREE_TYPE (t)));
793 : :
794 : 37199817 : pi = SSA_NAME_PTR_INFO (t);
795 : 37199817 : if (pi == NULL)
796 : : {
797 : 14747211 : pi = ggc_cleared_alloc<ptr_info_def> ();
798 : 14747211 : pt_solution_reset (&pi->pt);
799 : 14747211 : mark_ptr_info_alignment_unknown (pi);
800 : 14747211 : SSA_NAME_PTR_INFO (t) = pi;
801 : : }
802 : :
803 : 37199817 : return pi;
804 : : }
805 : :
806 : :
807 : : /* Creates a new SSA name using the template NAME tobe defined by
808 : : statement STMT in function FN. */
809 : :
810 : : tree
811 : 18951490 : copy_ssa_name_fn (struct function *fn, tree name, gimple *stmt)
812 : : {
813 : 18951490 : tree new_name;
814 : :
815 : 18951490 : if (SSA_NAME_VAR (name))
816 : 12263456 : new_name = make_ssa_name_fn (fn, SSA_NAME_VAR (name), stmt);
817 : : else
818 : : {
819 : 6688034 : new_name = make_ssa_name_fn (fn, TREE_TYPE (name), stmt);
820 : 13376068 : SET_SSA_NAME_VAR_OR_IDENTIFIER (new_name, SSA_NAME_IDENTIFIER (name));
821 : : }
822 : :
823 : 18951490 : return new_name;
824 : : }
825 : :
826 : :
827 : : /* Creates a duplicate of the ptr_info_def at PTR_INFO for use by
828 : : the SSA name NAME. */
829 : :
830 : : void
831 : 2917731 : duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info)
832 : : {
833 : 2917731 : struct ptr_info_def *new_ptr_info;
834 : :
835 : 2917731 : gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
836 : 2917731 : gcc_assert (!SSA_NAME_PTR_INFO (name));
837 : :
838 : 2917731 : if (!ptr_info)
839 : : return;
840 : :
841 : 2917678 : new_ptr_info = ggc_alloc<ptr_info_def> ();
842 : 2917678 : *new_ptr_info = *ptr_info;
843 : :
844 : 2917678 : SSA_NAME_PTR_INFO (name) = new_ptr_info;
845 : : }
846 : :
847 : : void
848 : 7932433 : duplicate_ssa_name_range_info (tree name, tree src)
849 : : {
850 : 7932433 : gcc_checking_assert (!POINTER_TYPE_P (TREE_TYPE (src)));
851 : 7932433 : gcc_checking_assert (!range_info_p (name));
852 : :
853 : 7932433 : if (range_info_p (src))
854 : : {
855 : 7932433 : value_range src_range (TREE_TYPE (src));
856 : 7932433 : range_info_get_range (src, src_range);
857 : 7932433 : range_info_set_range (name, src_range);
858 : 7932433 : }
859 : 7932433 : }
860 : :
861 : : /* For a SSA copy DEST = SRC duplicate SSA info present on DEST to SRC
862 : : to preserve it in case DEST is eliminated to SRC. */
863 : :
864 : : void
865 : 52090350 : maybe_duplicate_ssa_info_at_copy (tree dest, tree src)
866 : : {
867 : : /* While points-to info is flow-insensitive we have to avoid copying
868 : : info from not executed regions invoking UB to dominating defs. */
869 : 52090350 : if (gimple_bb (SSA_NAME_DEF_STMT (src))
870 : 52090350 : != gimple_bb (SSA_NAME_DEF_STMT (dest)))
871 : : return;
872 : :
873 : 64894470 : if (POINTER_TYPE_P (TREE_TYPE (dest))
874 : 18001574 : && SSA_NAME_PTR_INFO (dest)
875 : 49750072 : && ! SSA_NAME_PTR_INFO (src))
876 : 397826 : duplicate_ssa_name_ptr_info (src, SSA_NAME_PTR_INFO (dest));
877 : 80620638 : else if (INTEGRAL_TYPE_P (TREE_TYPE (dest))
878 : 19349525 : && SSA_NAME_RANGE_INFO (dest)
879 : 41512593 : && ! SSA_NAME_RANGE_INFO (src))
880 : 77950 : duplicate_ssa_name_range_info (src, dest);
881 : : }
882 : :
883 : :
884 : : /* Creates a duplicate of a ssa name NAME tobe defined by statement STMT
885 : : in function FN. */
886 : :
887 : : tree
888 : 17140902 : duplicate_ssa_name_fn (struct function *fn, tree name, gimple *stmt)
889 : : {
890 : 17140902 : tree new_name = copy_ssa_name_fn (fn, name, stmt);
891 : 17140902 : if (POINTER_TYPE_P (TREE_TYPE (name)))
892 : : {
893 : 2152576 : struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name);
894 : :
895 : 2152576 : if (old_ptr_info)
896 : 1912075 : duplicate_ssa_name_ptr_info (new_name, old_ptr_info);
897 : : }
898 : 14988326 : else if (range_info_p (name))
899 : 4011814 : duplicate_ssa_name_range_info (new_name, name);
900 : :
901 : 17140902 : return new_name;
902 : : }
903 : :
904 : :
905 : : /* Reset all flow sensitive data on NAME such as range-info, nonzero
906 : : bits and alignment. */
907 : :
908 : : void
909 : 2985676 : reset_flow_sensitive_info (tree name)
910 : : {
911 : 2985676 : if (POINTER_TYPE_P (TREE_TYPE (name)))
912 : : {
913 : : /* points-to info is not flow-sensitive. */
914 : 315969 : if (SSA_NAME_PTR_INFO (name))
915 : : {
916 : : /* [E]VRP can derive context sensitive alignment info and
917 : : non-nullness properties. We must reset both. */
918 : 313694 : mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (name));
919 : 313694 : SSA_NAME_PTR_INFO (name)->pt.null = 1;
920 : : }
921 : : }
922 : : else
923 : 2669707 : SSA_NAME_RANGE_INFO (name) = NULL;
924 : 2985676 : }
925 : :
926 : : /* Clear all flow sensitive data from all statements and PHI definitions
927 : : in BB. */
928 : :
929 : : void
930 : 1382818 : reset_flow_sensitive_info_in_bb (basic_block bb)
931 : : {
932 : 4171683 : for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
933 : 1406047 : gsi_next (&gsi))
934 : : {
935 : 1406047 : gimple *stmt = gsi_stmt (gsi);
936 : 1406047 : ssa_op_iter i;
937 : 1406047 : tree op;
938 : 1688379 : FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF)
939 : 282332 : reset_flow_sensitive_info (op);
940 : : }
941 : :
942 : 1403778 : for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
943 : 20960 : gsi_next (&gsi))
944 : : {
945 : 20960 : tree phi_def = gimple_phi_result (gsi.phi ());
946 : 20960 : reset_flow_sensitive_info (phi_def);
947 : : }
948 : 1382818 : }
949 : :
950 : : /* Release all the SSA_NAMEs created by STMT. */
951 : :
952 : : void
953 : 69163243 : release_defs (gimple *stmt)
954 : : {
955 : 69163243 : tree def;
956 : 69163243 : ssa_op_iter iter;
957 : :
958 : 118994946 : FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
959 : 49831703 : if (TREE_CODE (def) == SSA_NAME)
960 : 49242061 : release_ssa_name (def);
961 : 69163243 : }
962 : :
963 : :
964 : : /* Replace the symbol associated with SSA_NAME with SYM. */
965 : :
966 : : void
967 : 12341 : replace_ssa_name_symbol (tree ssa_name, tree sym)
968 : : {
969 : 12341 : SET_SSA_NAME_VAR_OR_IDENTIFIER (ssa_name, sym);
970 : 12341 : TREE_TYPE (ssa_name) = TREE_TYPE (sym);
971 : 12341 : }
972 : :
973 : : /* Release the vector of free SSA_NAMEs and compact the vector of SSA_NAMEs
974 : : that are live. */
975 : :
976 : : static void
977 : 2871368 : release_free_names_and_compact_live_names (function *fun)
978 : : {
979 : 2871368 : unsigned i, j;
980 : 2871368 : int n = vec_safe_length (FREE_SSANAMES (fun));
981 : :
982 : : /* Now release the freelist. */
983 : 2871368 : vec_free (FREE_SSANAMES (fun));
984 : :
985 : : /* And compact the SSA number space. We make sure to not change the
986 : : relative order of SSA versions. */
987 : 81806234 : for (i = 1, j = 1; i < fun->gimple_df->ssa_names->length (); ++i)
988 : : {
989 : 78934866 : tree name = ssa_name (i);
990 : 78934866 : if (name)
991 : : {
992 : 50434183 : if (i != j)
993 : : {
994 : 31362575 : SSA_NAME_VERSION (name) = j;
995 : 31362575 : (*fun->gimple_df->ssa_names)[j] = name;
996 : : }
997 : 50434183 : j++;
998 : : }
999 : : }
1000 : 2871368 : fun->gimple_df->ssa_names->truncate (j);
1001 : :
1002 : 2871368 : statistics_counter_event (fun, "SSA names released", n);
1003 : 2871368 : statistics_counter_event (fun, "SSA name holes removed", i - j);
1004 : 2871368 : if (dump_file)
1005 : 252 : fprintf (dump_file, "Released %i names, %.2f%%, removed %i holes\n",
1006 : 252 : n, n * 100.0 / num_ssa_names, i - j);
1007 : 2871368 : }
1008 : :
1009 : : /* Return SSA names that are unused to GGC memory and compact the SSA
1010 : : version namespace. This is used to keep footprint of compiler during
1011 : : interprocedural optimization. */
1012 : :
1013 : : namespace {
1014 : :
1015 : : const pass_data pass_data_release_ssa_names =
1016 : : {
1017 : : GIMPLE_PASS, /* type */
1018 : : "release_ssa", /* name */
1019 : : OPTGROUP_NONE, /* optinfo_flags */
1020 : : TV_TREE_SSA_OTHER, /* tv_id */
1021 : : PROP_ssa, /* properties_required */
1022 : : 0, /* properties_provided */
1023 : : 0, /* properties_destroyed */
1024 : : TODO_remove_unused_locals, /* todo_flags_start */
1025 : : 0, /* todo_flags_finish */
1026 : : };
1027 : :
1028 : : class pass_release_ssa_names : public gimple_opt_pass
1029 : : {
1030 : : public:
1031 : 286682 : pass_release_ssa_names (gcc::context *ctxt)
1032 : 573364 : : gimple_opt_pass (pass_data_release_ssa_names, ctxt)
1033 : : {}
1034 : :
1035 : : /* opt_pass methods: */
1036 : : unsigned int execute (function *) final override;
1037 : :
1038 : : }; // class pass_release_ssa_names
1039 : :
1040 : : unsigned int
1041 : 2871368 : pass_release_ssa_names::execute (function *fun)
1042 : : {
1043 : 2871368 : release_free_names_and_compact_live_names (fun);
1044 : 2871368 : return 0;
1045 : : }
1046 : :
1047 : : } // anon namespace
1048 : :
1049 : : gimple_opt_pass *
1050 : 286682 : make_pass_release_ssa_names (gcc::context *ctxt)
1051 : : {
1052 : 286682 : return new pass_release_ssa_names (ctxt);
1053 : : }
1054 : :
1055 : : /* Save and restore of flow sensitive information. */
1056 : :
1057 : : /* Save off the flow sensitive info from NAME. */
1058 : :
1059 : : void
1060 : 2151030 : flow_sensitive_info_storage::save (tree name)
1061 : : {
1062 : 2151030 : gcc_assert (state == 0);
1063 : 2151030 : if (!POINTER_TYPE_P (TREE_TYPE (name)))
1064 : : {
1065 : 2137097 : range_info = SSA_NAME_RANGE_INFO (name);
1066 : 2137097 : state = 1;
1067 : 2137097 : return;
1068 : : }
1069 : 13933 : state = -1;
1070 : 13933 : auto ptr_info = SSA_NAME_PTR_INFO (name);
1071 : 13933 : if (ptr_info)
1072 : : {
1073 : 13318 : align = ptr_info->align;
1074 : 13318 : misalign = ptr_info->misalign;
1075 : 13318 : null = SSA_NAME_PTR_INFO (name)->pt.null;
1076 : : }
1077 : : else
1078 : : {
1079 : 615 : align = 0;
1080 : 615 : misalign = 0;
1081 : 615 : null = true;
1082 : : }
1083 : : }
1084 : :
1085 : : /* Restore the flow sensitive info from NAME. */
1086 : :
1087 : : void
1088 : 2151030 : flow_sensitive_info_storage::restore (tree name)
1089 : : {
1090 : 2151030 : gcc_assert (state != 0);
1091 : 2151030 : if (!POINTER_TYPE_P (TREE_TYPE (name)))
1092 : : {
1093 : 2137097 : gcc_assert (state == 1);
1094 : 2137097 : SSA_NAME_RANGE_INFO (name) = range_info;
1095 : 2137097 : return;
1096 : : }
1097 : 13933 : gcc_assert (state == -1);
1098 : 13933 : auto ptr_info = SSA_NAME_PTR_INFO (name);
1099 : : /* If there was no flow sensitive info on the pointer
1100 : : just return, there is nothing to restore to. */
1101 : 13933 : if (!ptr_info)
1102 : : return;
1103 : 13318 : if (align != 0)
1104 : 329 : set_ptr_info_alignment (ptr_info, align, misalign);
1105 : : else
1106 : 12989 : mark_ptr_info_alignment_unknown (ptr_info);
1107 : 13318 : SSA_NAME_PTR_INFO (name)->pt.null = null;
1108 : : }
1109 : :
1110 : : /* Save off the flow sensitive info from NAME.
1111 : : And reset the flow sensitive info of NAME. */
1112 : :
1113 : : void
1114 : 2151030 : flow_sensitive_info_storage::save_and_clear (tree name)
1115 : : {
1116 : 2151030 : save (name);
1117 : 2151030 : reset_flow_sensitive_info (name);
1118 : 2151030 : }
1119 : :
1120 : : /* Clear the storage. */
1121 : : void
1122 : 0 : flow_sensitive_info_storage::clear_storage (void)
1123 : : {
1124 : 0 : state = 0;
1125 : 0 : }
|
