poly_int: expand_vector_ubsan_overflow
[official-gcc.git] / gcc / tree-dfa.c
blob3358763b466ee8d686fbb1fdf08b1b5f22378e71
1 /* Data flow functions for trees.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
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 "tree-pass.h"
29 #include "ssa.h"
30 #include "tree-pretty-print.h"
31 #include "fold-const.h"
32 #include "stor-layout.h"
33 #include "langhooks.h"
34 #include "gimple-iterator.h"
35 #include "gimple-walk.h"
36 #include "tree-dfa.h"
38 /* Build and maintain data flow information for trees. */
40 /* Counters used to display DFA and SSA statistics. */
41 struct dfa_stats_d
43 long num_defs;
44 long num_uses;
45 long num_phis;
46 long num_phi_args;
47 size_t max_num_phi_args;
48 long num_vdefs;
49 long num_vuses;
53 /* Local functions. */
54 static void collect_dfa_stats (struct dfa_stats_d *);
57 /*---------------------------------------------------------------------------
58 Dataflow analysis (DFA) routines
59 ---------------------------------------------------------------------------*/
61 /* Renumber all of the gimple stmt uids. */
63 void
64 renumber_gimple_stmt_uids (void)
66 basic_block bb;
68 set_gimple_stmt_max_uid (cfun, 0);
69 FOR_ALL_BB_FN (bb, cfun)
71 gimple_stmt_iterator bsi;
72 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
74 gimple *stmt = gsi_stmt (bsi);
75 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
77 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
79 gimple *stmt = gsi_stmt (bsi);
80 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
85 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
86 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
88 void
89 renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
91 int i;
93 set_gimple_stmt_max_uid (cfun, 0);
94 for (i = 0; i < n_blocks; i++)
96 basic_block bb = blocks[i];
97 gimple_stmt_iterator bsi;
98 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
100 gimple *stmt = gsi_stmt (bsi);
101 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
103 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
105 gimple *stmt = gsi_stmt (bsi);
106 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
113 /*---------------------------------------------------------------------------
114 Debugging functions
115 ---------------------------------------------------------------------------*/
117 /* Dump variable VAR and its may-aliases to FILE. */
119 void
120 dump_variable (FILE *file, tree var)
122 if (TREE_CODE (var) == SSA_NAME)
124 if (POINTER_TYPE_P (TREE_TYPE (var)))
125 dump_points_to_info_for (file, var);
126 var = SSA_NAME_VAR (var);
129 if (var == NULL_TREE)
131 fprintf (file, "<nil>");
132 return;
135 print_generic_expr (file, var, dump_flags);
137 fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
138 if (DECL_PT_UID (var) != DECL_UID (var))
139 fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var));
141 fprintf (file, ", ");
142 print_generic_expr (file, TREE_TYPE (var), dump_flags);
144 if (TREE_ADDRESSABLE (var))
145 fprintf (file, ", is addressable");
147 if (is_global_var (var))
148 fprintf (file, ", is global");
150 if (TREE_THIS_VOLATILE (var))
151 fprintf (file, ", is volatile");
153 if (cfun && ssa_default_def (cfun, var))
155 fprintf (file, ", default def: ");
156 print_generic_expr (file, ssa_default_def (cfun, var), dump_flags);
159 if (DECL_INITIAL (var))
161 fprintf (file, ", initial: ");
162 print_generic_expr (file, DECL_INITIAL (var), dump_flags);
165 fprintf (file, "\n");
169 /* Dump variable VAR and its may-aliases to stderr. */
171 DEBUG_FUNCTION void
172 debug_variable (tree var)
174 dump_variable (stderr, var);
178 /* Dump various DFA statistics to FILE. */
180 void
181 dump_dfa_stats (FILE *file)
183 struct dfa_stats_d dfa_stats;
185 unsigned long size, total = 0;
186 const char * const fmt_str = "%-30s%-13s%12s\n";
187 const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
188 const char * const fmt_str_3 = "%-43s%11lu%c\n";
189 const char *funcname
190 = lang_hooks.decl_printable_name (current_function_decl, 2);
192 collect_dfa_stats (&dfa_stats);
194 fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
196 fprintf (file, "---------------------------------------------------------\n");
197 fprintf (file, fmt_str, "", " Number of ", "Memory");
198 fprintf (file, fmt_str, "", " instances ", "used ");
199 fprintf (file, "---------------------------------------------------------\n");
201 size = dfa_stats.num_uses * sizeof (tree *);
202 total += size;
203 fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
204 SCALE (size), LABEL (size));
206 size = dfa_stats.num_defs * sizeof (tree *);
207 total += size;
208 fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
209 SCALE (size), LABEL (size));
211 size = dfa_stats.num_vuses * sizeof (tree *);
212 total += size;
213 fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
214 SCALE (size), LABEL (size));
216 size = dfa_stats.num_vdefs * sizeof (tree *);
217 total += size;
218 fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
219 SCALE (size), LABEL (size));
221 size = dfa_stats.num_phis * sizeof (struct gphi);
222 total += size;
223 fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
224 SCALE (size), LABEL (size));
226 size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
227 total += size;
228 fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
229 SCALE (size), LABEL (size));
231 fprintf (file, "---------------------------------------------------------\n");
232 fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
233 LABEL (total));
234 fprintf (file, "---------------------------------------------------------\n");
235 fprintf (file, "\n");
237 if (dfa_stats.num_phis)
238 fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
239 (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
240 (long) dfa_stats.max_num_phi_args);
242 fprintf (file, "\n");
246 /* Dump DFA statistics on stderr. */
248 DEBUG_FUNCTION void
249 debug_dfa_stats (void)
251 dump_dfa_stats (stderr);
255 /* Collect DFA statistics and store them in the structure pointed to by
256 DFA_STATS_P. */
258 static void
259 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
261 basic_block bb;
263 gcc_assert (dfa_stats_p);
265 memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
267 /* Walk all the statements in the function counting references. */
268 FOR_EACH_BB_FN (bb, cfun)
270 for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
271 gsi_next (&si))
273 gphi *phi = si.phi ();
274 dfa_stats_p->num_phis++;
275 dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
276 if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
277 dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi);
280 for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si);
281 gsi_next (&si))
283 gimple *stmt = gsi_stmt (si);
284 dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
285 dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
286 dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
287 dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0;
293 /*---------------------------------------------------------------------------
294 Miscellaneous helpers
295 ---------------------------------------------------------------------------*/
297 /* Lookup VAR UID in the default_defs hashtable and return the associated
298 variable. */
300 tree
301 ssa_default_def (struct function *fn, tree var)
303 struct tree_decl_minimal ind;
304 struct tree_ssa_name in;
305 gcc_assert (VAR_P (var)
306 || TREE_CODE (var) == PARM_DECL
307 || TREE_CODE (var) == RESULT_DECL);
309 /* Always NULL_TREE for rtl function dumps. */
310 if (!fn->gimple_df)
311 return NULL_TREE;
313 in.var = (tree)&ind;
314 ind.uid = DECL_UID (var);
315 return DEFAULT_DEFS (fn)->find_with_hash ((tree)&in, DECL_UID (var));
318 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
319 of function FN. */
321 void
322 set_ssa_default_def (struct function *fn, tree var, tree def)
324 struct tree_decl_minimal ind;
325 struct tree_ssa_name in;
327 gcc_assert (VAR_P (var)
328 || TREE_CODE (var) == PARM_DECL
329 || TREE_CODE (var) == RESULT_DECL);
330 in.var = (tree)&ind;
331 ind.uid = DECL_UID (var);
332 if (!def)
334 tree *loc = DEFAULT_DEFS (fn)->find_slot_with_hash ((tree)&in,
335 DECL_UID (var),
336 NO_INSERT);
337 if (loc)
339 SSA_NAME_IS_DEFAULT_DEF (*(tree *)loc) = false;
340 DEFAULT_DEFS (fn)->clear_slot (loc);
342 return;
344 gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var);
345 tree *loc = DEFAULT_DEFS (fn)->find_slot_with_hash ((tree)&in,
346 DECL_UID (var), INSERT);
348 /* Default definition might be changed by tail call optimization. */
349 if (*loc)
350 SSA_NAME_IS_DEFAULT_DEF (*loc) = false;
352 /* Mark DEF as the default definition for VAR. */
353 *loc = def;
354 SSA_NAME_IS_DEFAULT_DEF (def) = true;
357 /* Retrieve or create a default definition for VAR. */
359 tree
360 get_or_create_ssa_default_def (struct function *fn, tree var)
362 tree ddef = ssa_default_def (fn, var);
363 if (ddef == NULL_TREE)
365 ddef = make_ssa_name_fn (fn, var, gimple_build_nop ());
366 set_ssa_default_def (fn, var, ddef);
368 return ddef;
372 /* If EXP is a handled component reference for a structure, return the
373 base variable. The access range is delimited by bit positions *POFFSET and
374 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
375 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
376 and *PMAX_SIZE are equal, the access is non-variable. If *PREVERSE is
377 true, the storage order of the reference is reversed. */
379 tree
380 get_ref_base_and_extent (tree exp, poly_int64_pod *poffset,
381 poly_int64_pod *psize,
382 poly_int64_pod *pmax_size,
383 bool *preverse)
385 poly_offset_int bitsize = -1;
386 poly_offset_int maxsize;
387 tree size_tree = NULL_TREE;
388 poly_offset_int bit_offset = 0;
389 bool seen_variable_array_ref = false;
391 /* First get the final access size and the storage order from just the
392 outermost expression. */
393 if (TREE_CODE (exp) == COMPONENT_REF)
394 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
395 else if (TREE_CODE (exp) == BIT_FIELD_REF)
396 size_tree = TREE_OPERAND (exp, 1);
397 else if (!VOID_TYPE_P (TREE_TYPE (exp)))
399 machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
400 if (mode == BLKmode)
401 size_tree = TYPE_SIZE (TREE_TYPE (exp));
402 else
403 bitsize = GET_MODE_BITSIZE (mode);
405 if (size_tree != NULL_TREE
406 && poly_int_tree_p (size_tree))
407 bitsize = wi::to_poly_offset (size_tree);
409 *preverse = reverse_storage_order_for_component_p (exp);
411 /* Initially, maxsize is the same as the accessed element size.
412 In the following it will only grow (or become -1). */
413 maxsize = bitsize;
415 /* Compute cumulative bit-offset for nested component-refs and array-refs,
416 and find the ultimate containing object. */
417 while (1)
419 switch (TREE_CODE (exp))
421 case BIT_FIELD_REF:
422 bit_offset += wi::to_poly_offset (TREE_OPERAND (exp, 2));
423 break;
425 case COMPONENT_REF:
427 tree field = TREE_OPERAND (exp, 1);
428 tree this_offset = component_ref_field_offset (exp);
430 if (this_offset && poly_int_tree_p (this_offset))
432 poly_offset_int woffset = (wi::to_poly_offset (this_offset)
433 << LOG2_BITS_PER_UNIT);
434 woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
435 bit_offset += woffset;
437 /* If we had seen a variable array ref already and we just
438 referenced the last field of a struct or a union member
439 then we have to adjust maxsize by the padding at the end
440 of our field. */
441 if (seen_variable_array_ref && known_size_p (maxsize))
443 tree stype = TREE_TYPE (TREE_OPERAND (exp, 0));
444 tree next = DECL_CHAIN (field);
445 while (next && TREE_CODE (next) != FIELD_DECL)
446 next = DECL_CHAIN (next);
447 if (!next
448 || TREE_CODE (stype) != RECORD_TYPE)
450 tree fsize = DECL_SIZE_UNIT (field);
451 tree ssize = TYPE_SIZE_UNIT (stype);
452 if (fsize == NULL
453 || !poly_int_tree_p (fsize)
454 || ssize == NULL
455 || !poly_int_tree_p (ssize))
456 maxsize = -1;
457 else
459 poly_offset_int tem
460 = (wi::to_poly_offset (ssize)
461 - wi::to_poly_offset (fsize));
462 tem <<= LOG2_BITS_PER_UNIT;
463 tem -= woffset;
464 maxsize += tem;
469 else
471 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
472 /* We need to adjust maxsize to the whole structure bitsize.
473 But we can subtract any constant offset seen so far,
474 because that would get us out of the structure otherwise. */
475 if (known_size_p (maxsize)
476 && csize
477 && poly_int_tree_p (csize))
478 maxsize = wi::to_poly_offset (csize) - bit_offset;
479 else
480 maxsize = -1;
483 break;
485 case ARRAY_REF:
486 case ARRAY_RANGE_REF:
488 tree index = TREE_OPERAND (exp, 1);
489 tree low_bound, unit_size;
491 /* If the resulting bit-offset is constant, track it. */
492 if (poly_int_tree_p (index)
493 && (low_bound = array_ref_low_bound (exp),
494 poly_int_tree_p (low_bound))
495 && (unit_size = array_ref_element_size (exp),
496 TREE_CODE (unit_size) == INTEGER_CST))
498 poly_offset_int woffset
499 = wi::sext (wi::to_poly_offset (index)
500 - wi::to_poly_offset (low_bound),
501 TYPE_PRECISION (TREE_TYPE (index)));
502 woffset *= wi::to_offset (unit_size);
503 woffset <<= LOG2_BITS_PER_UNIT;
504 bit_offset += woffset;
506 /* An array ref with a constant index up in the structure
507 hierarchy will constrain the size of any variable array ref
508 lower in the access hierarchy. */
509 seen_variable_array_ref = false;
511 else
513 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
514 /* We need to adjust maxsize to the whole array bitsize.
515 But we can subtract any constant offset seen so far,
516 because that would get us outside of the array otherwise. */
517 if (known_size_p (maxsize)
518 && asize
519 && poly_int_tree_p (asize))
520 maxsize = wi::to_poly_offset (asize) - bit_offset;
521 else
522 maxsize = -1;
524 /* Remember that we have seen an array ref with a variable
525 index. */
526 seen_variable_array_ref = true;
529 break;
531 case REALPART_EXPR:
532 break;
534 case IMAGPART_EXPR:
535 bit_offset += bitsize;
536 break;
538 case VIEW_CONVERT_EXPR:
539 break;
541 case TARGET_MEM_REF:
542 /* Via the variable index or index2 we can reach the
543 whole object. Still hand back the decl here. */
544 if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
545 && (TMR_INDEX (exp) || TMR_INDEX2 (exp)))
547 exp = TREE_OPERAND (TMR_BASE (exp), 0);
548 bit_offset = 0;
549 maxsize = -1;
550 goto done;
552 /* Fallthru. */
553 case MEM_REF:
554 /* We need to deal with variable arrays ending structures such as
555 struct { int length; int a[1]; } x; x.a[d]
556 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
557 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
558 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
559 where we do not know maxsize for variable index accesses to
560 the array. The simplest way to conservatively deal with this
561 is to punt in the case that offset + maxsize reaches the
562 base type boundary. This needs to include possible trailing
563 padding that is there for alignment purposes. */
564 if (seen_variable_array_ref
565 && known_size_p (maxsize)
566 && (TYPE_SIZE (TREE_TYPE (exp)) == NULL_TREE
567 || !poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp)))
568 || (maybe_eq
569 (bit_offset + maxsize,
570 wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp)))))))
571 maxsize = -1;
573 /* Hand back the decl for MEM[&decl, off]. */
574 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
576 if (integer_zerop (TREE_OPERAND (exp, 1)))
577 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
578 else
580 poly_offset_int off = mem_ref_offset (exp);
581 off <<= LOG2_BITS_PER_UNIT;
582 off += bit_offset;
583 poly_int64 off_hwi;
584 if (off.to_shwi (&off_hwi))
586 bit_offset = off_hwi;
587 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
591 goto done;
593 default:
594 goto done;
597 exp = TREE_OPERAND (exp, 0);
600 done:
601 if (!bitsize.to_shwi (psize) || maybe_lt (*psize, 0))
603 *poffset = 0;
604 *psize = -1;
605 *pmax_size = -1;
607 return exp;
610 /* ??? Due to negative offsets in ARRAY_REF we can end up with
611 negative bit_offset here. We might want to store a zero offset
612 in this case. */
613 if (!bit_offset.to_shwi (poffset))
615 *poffset = 0;
616 *pmax_size = -1;
618 return exp;
621 /* In case of a decl or constant base object we can do better. */
623 if (DECL_P (exp))
625 if (flag_unconstrained_commons && VAR_P (exp) && DECL_COMMON (exp))
627 tree sz_tree = TYPE_SIZE (TREE_TYPE (exp));
628 /* If size is unknown, or we have read to the end, assume there
629 may be more to the structure than we are told. */
630 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
631 || (seen_variable_array_ref
632 && (sz_tree == NULL_TREE
633 || !poly_int_tree_p (sz_tree)
634 || maybe_eq (bit_offset + maxsize,
635 wi::to_poly_offset (sz_tree)))))
636 maxsize = -1;
638 /* If maxsize is unknown adjust it according to the size of the
639 base decl. */
640 else if (!known_size_p (maxsize)
641 && DECL_SIZE (exp)
642 && poly_int_tree_p (DECL_SIZE (exp)))
643 maxsize = wi::to_poly_offset (DECL_SIZE (exp)) - bit_offset;
645 else if (CONSTANT_CLASS_P (exp))
647 /* If maxsize is unknown adjust it according to the size of the
648 base type constant. */
649 if (!known_size_p (maxsize)
650 && TYPE_SIZE (TREE_TYPE (exp))
651 && poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp))))
652 maxsize = (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp)))
653 - bit_offset);
656 if (!maxsize.to_shwi (pmax_size)
657 || maybe_lt (*pmax_size, 0)
658 || !endpoint_representable_p (*poffset, *pmax_size))
659 *pmax_size = -1;
661 /* Punt if *POFFSET + *PSIZE overflows in HOST_WIDE_INT, the callers don't
662 check for such overflows individually and assume it works. */
663 if (!endpoint_representable_p (*poffset, *psize))
665 *poffset = 0;
666 *psize = -1;
667 *pmax_size = -1;
669 return exp;
672 return exp;
675 /* Like get_ref_base_and_extent, but for cases in which we only care
676 about constant-width accesses at constant offsets. Return null
677 if the access is anything else. */
679 tree
680 get_ref_base_and_extent_hwi (tree exp, HOST_WIDE_INT *poffset,
681 HOST_WIDE_INT *psize, bool *preverse)
683 poly_int64 offset, size, max_size;
684 HOST_WIDE_INT const_offset, const_size;
685 bool reverse;
686 tree decl = get_ref_base_and_extent (exp, &offset, &size, &max_size,
687 &reverse);
688 if (!offset.is_constant (&const_offset)
689 || !size.is_constant (&const_size)
690 || const_offset < 0
691 || !known_size_p (max_size)
692 || maybe_ne (max_size, const_size))
693 return NULL_TREE;
695 *poffset = const_offset;
696 *psize = const_size;
697 *preverse = reverse;
698 return decl;
701 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
702 denotes the starting address of the memory access EXP.
703 Returns NULL_TREE if the offset is not constant or any component
704 is not BITS_PER_UNIT-aligned.
705 VALUEIZE if non-NULL is used to valueize SSA names. It should return
706 its argument or a constant if the argument is known to be constant. */
708 tree
709 get_addr_base_and_unit_offset_1 (tree exp, poly_int64_pod *poffset,
710 tree (*valueize) (tree))
712 poly_int64 byte_offset = 0;
714 /* Compute cumulative byte-offset for nested component-refs and array-refs,
715 and find the ultimate containing object. */
716 while (1)
718 switch (TREE_CODE (exp))
720 case BIT_FIELD_REF:
722 poly_int64 this_byte_offset;
723 poly_uint64 this_bit_offset;
724 if (!poly_int_tree_p (TREE_OPERAND (exp, 2), &this_bit_offset)
725 || !multiple_p (this_bit_offset, BITS_PER_UNIT,
726 &this_byte_offset))
727 return NULL_TREE;
728 byte_offset += this_byte_offset;
730 break;
732 case COMPONENT_REF:
734 tree field = TREE_OPERAND (exp, 1);
735 tree this_offset = component_ref_field_offset (exp);
736 poly_int64 hthis_offset;
738 if (!this_offset
739 || !poly_int_tree_p (this_offset, &hthis_offset)
740 || (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field))
741 % BITS_PER_UNIT))
742 return NULL_TREE;
744 hthis_offset += (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field))
745 / BITS_PER_UNIT);
746 byte_offset += hthis_offset;
748 break;
750 case ARRAY_REF:
751 case ARRAY_RANGE_REF:
753 tree index = TREE_OPERAND (exp, 1);
754 tree low_bound, unit_size;
756 if (valueize
757 && TREE_CODE (index) == SSA_NAME)
758 index = (*valueize) (index);
760 /* If the resulting bit-offset is constant, track it. */
761 if (poly_int_tree_p (index)
762 && (low_bound = array_ref_low_bound (exp),
763 poly_int_tree_p (low_bound))
764 && (unit_size = array_ref_element_size (exp),
765 TREE_CODE (unit_size) == INTEGER_CST))
767 poly_offset_int woffset
768 = wi::sext (wi::to_poly_offset (index)
769 - wi::to_poly_offset (low_bound),
770 TYPE_PRECISION (TREE_TYPE (index)));
771 woffset *= wi::to_offset (unit_size);
772 byte_offset += woffset.force_shwi ();
774 else
775 return NULL_TREE;
777 break;
779 case REALPART_EXPR:
780 break;
782 case IMAGPART_EXPR:
783 byte_offset += TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (exp)));
784 break;
786 case VIEW_CONVERT_EXPR:
787 break;
789 case MEM_REF:
791 tree base = TREE_OPERAND (exp, 0);
792 if (valueize
793 && TREE_CODE (base) == SSA_NAME)
794 base = (*valueize) (base);
796 /* Hand back the decl for MEM[&decl, off]. */
797 if (TREE_CODE (base) == ADDR_EXPR)
799 if (!integer_zerop (TREE_OPERAND (exp, 1)))
801 poly_offset_int off = mem_ref_offset (exp);
802 byte_offset += off.force_shwi ();
804 exp = TREE_OPERAND (base, 0);
806 goto done;
809 case TARGET_MEM_REF:
811 tree base = TREE_OPERAND (exp, 0);
812 if (valueize
813 && TREE_CODE (base) == SSA_NAME)
814 base = (*valueize) (base);
816 /* Hand back the decl for MEM[&decl, off]. */
817 if (TREE_CODE (base) == ADDR_EXPR)
819 if (TMR_INDEX (exp) || TMR_INDEX2 (exp))
820 return NULL_TREE;
821 if (!integer_zerop (TMR_OFFSET (exp)))
823 poly_offset_int off = mem_ref_offset (exp);
824 byte_offset += off.force_shwi ();
826 exp = TREE_OPERAND (base, 0);
828 goto done;
831 default:
832 goto done;
835 exp = TREE_OPERAND (exp, 0);
837 done:
839 *poffset = byte_offset;
840 return exp;
843 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
844 denotes the starting address of the memory access EXP.
845 Returns NULL_TREE if the offset is not constant or any component
846 is not BITS_PER_UNIT-aligned. */
848 tree
849 get_addr_base_and_unit_offset (tree exp, poly_int64_pod *poffset)
851 return get_addr_base_and_unit_offset_1 (exp, poffset, NULL);
854 /* Returns true if STMT references an SSA_NAME that has
855 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
857 bool
858 stmt_references_abnormal_ssa_name (gimple *stmt)
860 ssa_op_iter oi;
861 use_operand_p use_p;
863 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
865 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p)))
866 return true;
869 return false;
872 /* If STMT takes any abnormal PHI values as input, replace them with
873 local copies. */
875 void
876 replace_abnormal_ssa_names (gimple *stmt)
878 ssa_op_iter oi;
879 use_operand_p use_p;
881 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
883 tree op = USE_FROM_PTR (use_p);
884 if (TREE_CODE (op) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op))
886 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
887 tree new_name = make_ssa_name (TREE_TYPE (op));
888 gassign *assign = gimple_build_assign (new_name, op);
889 gsi_insert_before (&gsi, assign, GSI_SAME_STMT);
890 SET_USE (use_p, new_name);
895 /* Pair of tree and a sorting index, for dump_enumerated_decls. */
896 struct GTY(()) numbered_tree
898 tree t;
899 int num;
903 /* Compare two declarations references by their DECL_UID / sequence number.
904 Called via qsort. */
906 static int
907 compare_decls_by_uid (const void *pa, const void *pb)
909 const numbered_tree *nt_a = ((const numbered_tree *)pa);
910 const numbered_tree *nt_b = ((const numbered_tree *)pb);
912 if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t))
913 return DECL_UID (nt_a->t) - DECL_UID (nt_b->t);
914 return nt_a->num - nt_b->num;
917 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
918 static tree
919 dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data)
921 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
922 vec<numbered_tree> *list = (vec<numbered_tree> *) wi->info;
923 numbered_tree nt;
925 if (!DECL_P (*tp))
926 return NULL_TREE;
927 nt.t = *tp;
928 nt.num = list->length ();
929 list->safe_push (nt);
930 *walk_subtrees = 0;
931 return NULL_TREE;
934 /* Find all the declarations used by the current function, sort them by uid,
935 and emit the sorted list. Each declaration is tagged with a sequence
936 number indicating when it was found during statement / tree walking,
937 so that TDF_NOUID comparisons of anonymous declarations are still
938 meaningful. Where a declaration was encountered more than once, we
939 emit only the sequence number of the first encounter.
940 FILE is the dump file where to output the list and FLAGS is as in
941 print_generic_expr. */
942 void
943 dump_enumerated_decls (FILE *file, dump_flags_t flags)
945 basic_block bb;
946 struct walk_stmt_info wi;
947 auto_vec<numbered_tree, 40> decl_list;
949 memset (&wi, '\0', sizeof (wi));
950 wi.info = (void *) &decl_list;
951 FOR_EACH_BB_FN (bb, cfun)
953 gimple_stmt_iterator gsi;
955 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
956 if (!is_gimple_debug (gsi_stmt (gsi)))
957 walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi);
959 decl_list.qsort (compare_decls_by_uid);
960 if (decl_list.length ())
962 unsigned ix;
963 numbered_tree *ntp;
964 tree last = NULL_TREE;
966 fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n",
967 current_function_name ());
968 FOR_EACH_VEC_ELT (decl_list, ix, ntp)
970 if (ntp->t == last)
971 continue;
972 fprintf (file, "%d: ", ntp->num);
973 print_generic_decl (file, ntp->t, flags);
974 fprintf (file, "\n");
975 last = ntp->t;