1 /* Data flow functions for trees.
2 Copyright (C) 2001-2022 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)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "tree-pass.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"
37 #include "gimple-range.h"
39 /* Build and maintain data flow information for trees. */
41 /* Counters used to display DFA and SSA statistics. */
48 size_t max_num_phi_args
;
54 /* Local functions. */
55 static void collect_dfa_stats (struct dfa_stats_d
*);
58 /*---------------------------------------------------------------------------
59 Dataflow analysis (DFA) routines
60 ---------------------------------------------------------------------------*/
62 /* Renumber all of the gimple stmt uids. */
65 renumber_gimple_stmt_uids (struct function
*fun
)
69 set_gimple_stmt_max_uid (fun
, 0);
70 FOR_ALL_BB_FN (bb
, fun
)
72 gimple_stmt_iterator bsi
;
73 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
75 gimple
*stmt
= gsi_stmt (bsi
);
76 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (fun
));
78 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
80 gimple
*stmt
= gsi_stmt (bsi
);
81 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (fun
));
86 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
87 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
90 renumber_gimple_stmt_uids_in_blocks (basic_block
*blocks
, int n_blocks
)
94 set_gimple_stmt_max_uid (cfun
, 0);
95 for (i
= 0; i
< n_blocks
; i
++)
97 basic_block bb
= blocks
[i
];
98 gimple_stmt_iterator bsi
;
99 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
101 gimple
*stmt
= gsi_stmt (bsi
);
102 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
104 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
106 gimple
*stmt
= gsi_stmt (bsi
);
107 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
114 /*---------------------------------------------------------------------------
116 ---------------------------------------------------------------------------*/
118 /* Dump variable VAR and its may-aliases to FILE. */
121 dump_variable (FILE *file
, tree var
)
123 if (TREE_CODE (var
) == SSA_NAME
)
125 if (POINTER_TYPE_P (TREE_TYPE (var
)))
126 dump_points_to_info_for (file
, var
);
127 var
= SSA_NAME_VAR (var
);
130 if (var
== NULL_TREE
)
132 fprintf (file
, "<nil>");
136 print_generic_expr (file
, var
, dump_flags
);
138 fprintf (file
, ", UID D.%u", (unsigned) DECL_UID (var
));
139 if (DECL_PT_UID (var
) != DECL_UID (var
))
140 fprintf (file
, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var
));
142 fprintf (file
, ", ");
143 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
145 if (TREE_ADDRESSABLE (var
))
146 fprintf (file
, ", is addressable");
148 if (is_global_var (var
))
149 fprintf (file
, ", is global");
151 if (TREE_THIS_VOLATILE (var
))
152 fprintf (file
, ", is volatile");
154 if (cfun
&& ssa_default_def (cfun
, var
))
156 fprintf (file
, ", default def: ");
157 print_generic_expr (file
, ssa_default_def (cfun
, var
), dump_flags
);
160 if (DECL_INITIAL (var
))
162 fprintf (file
, ", initial: ");
163 print_generic_expr (file
, DECL_INITIAL (var
), dump_flags
);
166 fprintf (file
, "\n");
170 /* Dump variable VAR and its may-aliases to stderr. */
173 debug_variable (tree var
)
175 dump_variable (stderr
, var
);
179 /* Dump various DFA statistics to FILE. */
182 dump_dfa_stats (FILE *file
)
184 struct dfa_stats_d dfa_stats
;
186 unsigned long size
, total
= 0;
187 const char * const fmt_str
= "%-30s%-13s%12s\n";
188 const char * const fmt_str_1
= "%-30s%13lu" PRsa (11) "\n";
189 const char * const fmt_str_3
= "%-43s" PRsa (11) "\n";
191 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
193 collect_dfa_stats (&dfa_stats
);
195 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
197 fprintf (file
, "---------------------------------------------------------\n");
198 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
199 fprintf (file
, fmt_str
, "", " instances ", "used ");
200 fprintf (file
, "---------------------------------------------------------\n");
202 size
= dfa_stats
.num_uses
* sizeof (tree
*);
204 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
207 size
= dfa_stats
.num_defs
* sizeof (tree
*);
209 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
212 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
214 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
217 size
= dfa_stats
.num_vdefs
* sizeof (tree
*);
219 fprintf (file
, fmt_str_1
, "VDEF operands", dfa_stats
.num_vdefs
,
222 size
= dfa_stats
.num_phis
* sizeof (struct gphi
);
224 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
227 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
229 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
232 fprintf (file
, "---------------------------------------------------------\n");
233 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data",
234 SIZE_AMOUNT (total
));
235 fprintf (file
, "---------------------------------------------------------\n");
236 fprintf (file
, "\n");
238 if (dfa_stats
.num_phis
)
239 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
240 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
241 (long) dfa_stats
.max_num_phi_args
);
243 fprintf (file
, "\n");
247 /* Dump DFA statistics on stderr. */
250 debug_dfa_stats (void)
252 dump_dfa_stats (stderr
);
256 /* Collect DFA statistics and store them in the structure pointed to by
260 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p ATTRIBUTE_UNUSED
)
264 gcc_assert (dfa_stats_p
);
266 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
268 /* Walk all the statements in the function counting references. */
269 FOR_EACH_BB_FN (bb
, cfun
)
271 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
274 gphi
*phi
= si
.phi ();
275 dfa_stats_p
->num_phis
++;
276 dfa_stats_p
->num_phi_args
+= gimple_phi_num_args (phi
);
277 if (gimple_phi_num_args (phi
) > dfa_stats_p
->max_num_phi_args
)
278 dfa_stats_p
->max_num_phi_args
= gimple_phi_num_args (phi
);
281 for (gimple_stmt_iterator si
= gsi_start_bb (bb
); !gsi_end_p (si
);
284 gimple
*stmt
= gsi_stmt (si
);
285 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_DEF
);
286 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_USE
);
287 dfa_stats_p
->num_vdefs
+= gimple_vdef (stmt
) ? 1 : 0;
288 dfa_stats_p
->num_vuses
+= gimple_vuse (stmt
) ? 1 : 0;
294 /*---------------------------------------------------------------------------
295 Miscellaneous helpers
296 ---------------------------------------------------------------------------*/
298 /* Lookup VAR UID in the default_defs hashtable and return the associated
302 ssa_default_def (struct function
*fn
, tree var
)
304 struct tree_decl_minimal ind
;
305 struct tree_ssa_name in
;
306 gcc_assert (VAR_P (var
)
307 || TREE_CODE (var
) == PARM_DECL
308 || TREE_CODE (var
) == RESULT_DECL
);
310 /* Always NULL_TREE for rtl function dumps. */
315 ind
.uid
= DECL_UID (var
);
316 return DEFAULT_DEFS (fn
)->find_with_hash ((tree
)&in
, DECL_UID (var
));
319 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
323 set_ssa_default_def (struct function
*fn
, tree var
, tree def
)
325 struct tree_decl_minimal ind
;
326 struct tree_ssa_name in
;
328 gcc_assert (VAR_P (var
)
329 || TREE_CODE (var
) == PARM_DECL
330 || TREE_CODE (var
) == RESULT_DECL
);
332 ind
.uid
= DECL_UID (var
);
335 tree
*loc
= DEFAULT_DEFS (fn
)->find_slot_with_hash ((tree
)&in
,
340 SSA_NAME_IS_DEFAULT_DEF (*(tree
*)loc
) = false;
341 DEFAULT_DEFS (fn
)->clear_slot (loc
);
345 gcc_assert (TREE_CODE (def
) == SSA_NAME
&& SSA_NAME_VAR (def
) == var
);
346 tree
*loc
= DEFAULT_DEFS (fn
)->find_slot_with_hash ((tree
)&in
,
347 DECL_UID (var
), INSERT
);
349 /* Default definition might be changed by tail call optimization. */
351 SSA_NAME_IS_DEFAULT_DEF (*loc
) = false;
353 /* Mark DEF as the default definition for VAR. */
355 SSA_NAME_IS_DEFAULT_DEF (def
) = true;
358 /* Retrieve or create a default definition for VAR. */
361 get_or_create_ssa_default_def (struct function
*fn
, tree var
)
363 tree ddef
= ssa_default_def (fn
, var
);
364 if (ddef
== NULL_TREE
)
366 ddef
= make_ssa_name_fn (fn
, var
, gimple_build_nop ());
367 set_ssa_default_def (fn
, var
, ddef
);
373 /* If EXP is a handled component reference for a structure, return the
374 base variable. The access range is delimited by bit positions *POFFSET and
375 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
376 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
377 and *PMAX_SIZE are equal, the access is non-variable. If *PREVERSE is
378 true, the storage order of the reference is reversed. */
381 get_ref_base_and_extent (tree exp
, poly_int64_pod
*poffset
,
382 poly_int64_pod
*psize
,
383 poly_int64_pod
*pmax_size
,
386 poly_offset_int bitsize
= -1;
387 poly_offset_int maxsize
;
388 tree size_tree
= NULL_TREE
;
389 poly_offset_int bit_offset
= 0;
390 bool seen_variable_array_ref
= false;
392 /* First get the final access size and the storage order from just the
393 outermost expression. */
394 if (TREE_CODE (exp
) == COMPONENT_REF
)
395 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
396 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
397 size_tree
= TREE_OPERAND (exp
, 1);
398 else if (TREE_CODE (exp
) == WITH_SIZE_EXPR
)
400 size_tree
= TREE_OPERAND (exp
, 1);
401 exp
= TREE_OPERAND (exp
, 0);
403 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
405 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
407 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
409 bitsize
= GET_MODE_BITSIZE (mode
);
411 if (size_tree
!= NULL_TREE
412 && poly_int_tree_p (size_tree
))
413 bitsize
= wi::to_poly_offset (size_tree
);
415 *preverse
= reverse_storage_order_for_component_p (exp
);
417 /* Initially, maxsize is the same as the accessed element size.
418 In the following it will only grow (or become -1). */
421 /* Compute cumulative bit-offset for nested component-refs and array-refs,
422 and find the ultimate containing object. */
425 switch (TREE_CODE (exp
))
428 bit_offset
+= wi::to_poly_offset (TREE_OPERAND (exp
, 2));
433 tree field
= TREE_OPERAND (exp
, 1);
434 tree this_offset
= component_ref_field_offset (exp
);
436 if (this_offset
&& poly_int_tree_p (this_offset
))
438 poly_offset_int woffset
= (wi::to_poly_offset (this_offset
)
439 << LOG2_BITS_PER_UNIT
);
440 woffset
+= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
441 bit_offset
+= woffset
;
443 /* If we had seen a variable array ref already and we just
444 referenced the last field of a struct or a union member
445 then we have to adjust maxsize by the padding at the end
447 if (seen_variable_array_ref
)
449 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
450 tree next
= DECL_CHAIN (field
);
451 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
452 next
= DECL_CHAIN (next
);
454 || TREE_CODE (stype
) != RECORD_TYPE
)
456 tree fsize
= DECL_SIZE_UNIT (field
);
457 tree ssize
= TYPE_SIZE_UNIT (stype
);
459 || !poly_int_tree_p (fsize
)
461 || !poly_int_tree_p (ssize
))
463 else if (known_size_p (maxsize
))
466 = (wi::to_poly_offset (ssize
)
467 - wi::to_poly_offset (fsize
));
468 tem
<<= LOG2_BITS_PER_UNIT
;
473 /* An component ref with an adjacent field up in the
474 structure hierarchy constrains the size of any variable
475 array ref lower in the access hierarchy. */
477 seen_variable_array_ref
= false;
482 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
483 /* We need to adjust maxsize to the whole structure bitsize.
484 But we can subtract any constant offset seen so far,
485 because that would get us out of the structure otherwise. */
486 if (known_size_p (maxsize
)
488 && poly_int_tree_p (csize
))
489 maxsize
= wi::to_poly_offset (csize
) - bit_offset
;
497 case ARRAY_RANGE_REF
:
499 tree index
= TREE_OPERAND (exp
, 1);
500 tree low_bound
, unit_size
;
502 /* If the resulting bit-offset is constant, track it. */
503 if (poly_int_tree_p (index
)
504 && (low_bound
= array_ref_low_bound (exp
),
505 poly_int_tree_p (low_bound
))
506 && (unit_size
= array_ref_element_size (exp
),
507 TREE_CODE (unit_size
) == INTEGER_CST
))
509 poly_offset_int woffset
510 = wi::sext (wi::to_poly_offset (index
)
511 - wi::to_poly_offset (low_bound
),
512 TYPE_PRECISION (sizetype
));
513 woffset
*= wi::to_offset (unit_size
);
514 woffset
<<= LOG2_BITS_PER_UNIT
;
515 bit_offset
+= woffset
;
517 /* An array ref with a constant index up in the structure
518 hierarchy will constrain the size of any variable array ref
519 lower in the access hierarchy. */
520 seen_variable_array_ref
= false;
524 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
525 /* We need to adjust maxsize to the whole array bitsize.
526 But we can subtract any constant offset seen so far,
527 because that would get us outside of the array otherwise. */
528 if (known_size_p (maxsize
)
530 && poly_int_tree_p (asize
))
531 maxsize
= wi::to_poly_offset (asize
) - bit_offset
;
535 /* Remember that we have seen an array ref with a variable
537 seen_variable_array_ref
= true;
542 query
= get_range_query (cfun
);
544 query
= get_global_range_query ();
546 if (TREE_CODE (index
) == SSA_NAME
547 && (low_bound
= array_ref_low_bound (exp
),
548 poly_int_tree_p (low_bound
))
549 && (unit_size
= array_ref_element_size (exp
),
550 TREE_CODE (unit_size
) == INTEGER_CST
)
551 && query
->range_of_expr (vr
, index
)
552 && vr
.kind () == VR_RANGE
)
554 wide_int min
= vr
.lower_bound ();
555 wide_int max
= vr
.upper_bound ();
556 poly_offset_int lbound
= wi::to_poly_offset (low_bound
);
557 /* Try to constrain maxsize with range information. */
559 = offset_int::from (max
, TYPE_SIGN (TREE_TYPE (index
)));
560 if (known_lt (lbound
, omax
))
562 poly_offset_int rmaxsize
;
563 rmaxsize
= (omax
- lbound
+ 1)
564 * wi::to_offset (unit_size
) << LOG2_BITS_PER_UNIT
;
565 if (!known_size_p (maxsize
)
566 || known_lt (rmaxsize
, maxsize
))
568 /* If we know an upper bound below the declared
569 one this is no longer variable. */
570 if (known_size_p (maxsize
))
571 seen_variable_array_ref
= false;
575 /* Try to adjust bit_offset with range information. */
577 = offset_int::from (min
, TYPE_SIGN (TREE_TYPE (index
)));
578 if (known_le (lbound
, omin
))
580 poly_offset_int woffset
581 = wi::sext (omin
- lbound
,
582 TYPE_PRECISION (sizetype
));
583 woffset
*= wi::to_offset (unit_size
);
584 woffset
<<= LOG2_BITS_PER_UNIT
;
585 bit_offset
+= woffset
;
586 if (known_size_p (maxsize
))
598 bit_offset
+= bitsize
;
601 case VIEW_CONVERT_EXPR
:
605 /* Via the variable index or index2 we can reach the
606 whole object. Still hand back the decl here. */
607 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
608 && (TMR_INDEX (exp
) || TMR_INDEX2 (exp
)))
610 exp
= TREE_OPERAND (TMR_BASE (exp
), 0);
617 /* We need to deal with variable arrays ending structures such as
618 struct { int length; int a[1]; } x; x.a[d]
619 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
620 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
621 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
622 where we do not know maxsize for variable index accesses to
623 the array. The simplest way to conservatively deal with this
624 is to punt in the case that offset + maxsize reaches the
625 base type boundary. This needs to include possible trailing
626 padding that is there for alignment purposes. */
627 if (seen_variable_array_ref
628 && known_size_p (maxsize
)
629 && (TYPE_SIZE (TREE_TYPE (exp
)) == NULL_TREE
630 || !poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp
)))
632 (bit_offset
+ maxsize
,
633 wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp
)))))))
636 /* Hand back the decl for MEM[&decl, off]. */
637 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
639 if (integer_zerop (TREE_OPERAND (exp
, 1)))
640 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
643 poly_offset_int off
= mem_ref_offset (exp
);
644 off
<<= LOG2_BITS_PER_UNIT
;
647 if (off
.to_shwi (&off_hwi
))
649 bit_offset
= off_hwi
;
650 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
660 exp
= TREE_OPERAND (exp
, 0);
664 if (!bitsize
.to_shwi (psize
) || maybe_lt (*psize
, 0))
673 /* ??? Due to negative offsets in ARRAY_REF we can end up with
674 negative bit_offset here. We might want to store a zero offset
676 if (!bit_offset
.to_shwi (poffset
))
684 /* In case of a decl or constant base object we can do better. */
689 && ((flag_unconstrained_commons
&& DECL_COMMON (exp
))
690 || (DECL_EXTERNAL (exp
) && seen_variable_array_ref
)))
692 tree sz_tree
= TYPE_SIZE (TREE_TYPE (exp
));
693 /* If size is unknown, or we have read to the end, assume there
694 may be more to the structure than we are told. */
695 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
696 || (seen_variable_array_ref
697 && (sz_tree
== NULL_TREE
698 || !poly_int_tree_p (sz_tree
)
699 || maybe_eq (bit_offset
+ maxsize
,
700 wi::to_poly_offset (sz_tree
)))))
703 /* If maxsize is unknown adjust it according to the size of the
705 else if (!known_size_p (maxsize
)
707 && poly_int_tree_p (DECL_SIZE (exp
)))
708 maxsize
= wi::to_poly_offset (DECL_SIZE (exp
)) - bit_offset
;
710 else if (CONSTANT_CLASS_P (exp
))
712 /* If maxsize is unknown adjust it according to the size of the
713 base type constant. */
714 if (!known_size_p (maxsize
)
715 && TYPE_SIZE (TREE_TYPE (exp
))
716 && poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp
))))
717 maxsize
= (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp
)))
721 if (!maxsize
.to_shwi (pmax_size
)
722 || maybe_lt (*pmax_size
, 0)
723 || !endpoint_representable_p (*poffset
, *pmax_size
))
726 /* Punt if *POFFSET + *PSIZE overflows in HOST_WIDE_INT, the callers don't
727 check for such overflows individually and assume it works. */
728 if (!endpoint_representable_p (*poffset
, *psize
))
740 /* Like get_ref_base_and_extent, but for cases in which we only care
741 about constant-width accesses at constant offsets. Return null
742 if the access is anything else. */
745 get_ref_base_and_extent_hwi (tree exp
, HOST_WIDE_INT
*poffset
,
746 HOST_WIDE_INT
*psize
, bool *preverse
)
748 poly_int64 offset
, size
, max_size
;
749 HOST_WIDE_INT const_offset
, const_size
;
751 tree decl
= get_ref_base_and_extent (exp
, &offset
, &size
, &max_size
,
753 if (!offset
.is_constant (&const_offset
)
754 || !size
.is_constant (&const_size
)
756 || !known_size_p (max_size
)
757 || maybe_ne (max_size
, const_size
))
760 *poffset
= const_offset
;
766 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
767 denotes the starting address of the memory access EXP.
768 Returns NULL_TREE if the offset is not constant or any component
769 is not BITS_PER_UNIT-aligned.
770 VALUEIZE if non-NULL is used to valueize SSA names. It should return
771 its argument or a constant if the argument is known to be constant. */
774 get_addr_base_and_unit_offset_1 (tree exp
, poly_int64_pod
*poffset
,
775 tree (*valueize
) (tree
))
777 poly_int64 byte_offset
= 0;
779 /* Compute cumulative byte-offset for nested component-refs and array-refs,
780 and find the ultimate containing object. */
783 switch (TREE_CODE (exp
))
787 poly_int64 this_byte_offset
;
788 poly_uint64 this_bit_offset
;
789 if (!poly_int_tree_p (TREE_OPERAND (exp
, 2), &this_bit_offset
)
790 || !multiple_p (this_bit_offset
, BITS_PER_UNIT
,
793 byte_offset
+= this_byte_offset
;
799 tree field
= TREE_OPERAND (exp
, 1);
800 tree this_offset
= component_ref_field_offset (exp
);
801 poly_int64 hthis_offset
;
804 || !poly_int_tree_p (this_offset
, &hthis_offset
)
805 || (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
809 hthis_offset
+= (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
811 byte_offset
+= hthis_offset
;
816 case ARRAY_RANGE_REF
:
818 tree index
= TREE_OPERAND (exp
, 1);
819 tree low_bound
, unit_size
;
822 && TREE_CODE (index
) == SSA_NAME
)
823 index
= (*valueize
) (index
);
824 if (!poly_int_tree_p (index
))
826 low_bound
= array_ref_low_bound (exp
);
828 && TREE_CODE (low_bound
) == SSA_NAME
)
829 low_bound
= (*valueize
) (low_bound
);
830 if (!poly_int_tree_p (low_bound
))
832 unit_size
= array_ref_element_size (exp
);
833 if (TREE_CODE (unit_size
) != INTEGER_CST
)
836 /* If the resulting bit-offset is constant, track it. */
837 poly_offset_int woffset
838 = wi::sext (wi::to_poly_offset (index
)
839 - wi::to_poly_offset (low_bound
),
840 TYPE_PRECISION (sizetype
));
841 woffset
*= wi::to_offset (unit_size
);
842 byte_offset
+= woffset
.force_shwi ();
850 byte_offset
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (exp
)));
853 case VIEW_CONVERT_EXPR
:
858 tree base
= TREE_OPERAND (exp
, 0);
860 && TREE_CODE (base
) == SSA_NAME
)
861 base
= (*valueize
) (base
);
863 /* Hand back the decl for MEM[&decl, off]. */
864 if (TREE_CODE (base
) == ADDR_EXPR
)
866 if (!integer_zerop (TREE_OPERAND (exp
, 1)))
868 poly_offset_int off
= mem_ref_offset (exp
);
869 byte_offset
+= off
.force_shwi ();
871 exp
= TREE_OPERAND (base
, 0);
878 tree base
= TREE_OPERAND (exp
, 0);
880 && TREE_CODE (base
) == SSA_NAME
)
881 base
= (*valueize
) (base
);
883 /* Hand back the decl for MEM[&decl, off]. */
884 if (TREE_CODE (base
) == ADDR_EXPR
)
886 if (TMR_INDEX (exp
) || TMR_INDEX2 (exp
))
888 if (!integer_zerop (TMR_OFFSET (exp
)))
890 poly_offset_int off
= mem_ref_offset (exp
);
891 byte_offset
+= off
.force_shwi ();
893 exp
= TREE_OPERAND (base
, 0);
902 exp
= TREE_OPERAND (exp
, 0);
906 *poffset
= byte_offset
;
910 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
911 denotes the starting address of the memory access EXP.
912 Returns NULL_TREE if the offset is not constant or any component
913 is not BITS_PER_UNIT-aligned. */
916 get_addr_base_and_unit_offset (tree exp
, poly_int64_pod
*poffset
)
918 return get_addr_base_and_unit_offset_1 (exp
, poffset
, NULL
);
921 /* Returns true if STMT references an SSA_NAME that has
922 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
925 stmt_references_abnormal_ssa_name (gimple
*stmt
)
930 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
932 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))
939 /* If STMT takes any abnormal PHI values as input, replace them with
943 replace_abnormal_ssa_names (gimple
*stmt
)
948 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
950 tree op
= USE_FROM_PTR (use_p
);
951 if (TREE_CODE (op
) == SSA_NAME
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op
))
953 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
954 tree new_name
= make_ssa_name (TREE_TYPE (op
));
955 gassign
*assign
= gimple_build_assign (new_name
, op
);
956 gsi_insert_before (&gsi
, assign
, GSI_SAME_STMT
);
957 SET_USE (use_p
, new_name
);
962 /* Pair of tree and a sorting index, for dump_enumerated_decls. */
963 struct GTY(()) numbered_tree
970 /* Compare two declarations references by their DECL_UID / sequence number.
974 compare_decls_by_uid (const void *pa
, const void *pb
)
976 const numbered_tree
*nt_a
= ((const numbered_tree
*)pa
);
977 const numbered_tree
*nt_b
= ((const numbered_tree
*)pb
);
979 if (DECL_UID (nt_a
->t
) != DECL_UID (nt_b
->t
))
980 return DECL_UID (nt_a
->t
) - DECL_UID (nt_b
->t
);
981 return nt_a
->num
- nt_b
->num
;
984 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
986 dump_enumerated_decls_push (tree
*tp
, int *walk_subtrees
, void *data
)
988 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
989 vec
<numbered_tree
> *list
= (vec
<numbered_tree
> *) wi
->info
;
995 nt
.num
= list
->length ();
996 list
->safe_push (nt
);
1001 /* Find all the declarations used by the current function, sort them by uid,
1002 and emit the sorted list. Each declaration is tagged with a sequence
1003 number indicating when it was found during statement / tree walking,
1004 so that TDF_NOUID comparisons of anonymous declarations are still
1005 meaningful. Where a declaration was encountered more than once, we
1006 emit only the sequence number of the first encounter.
1007 FILE is the dump file where to output the list and FLAGS is as in
1008 print_generic_expr. */
1010 dump_enumerated_decls (FILE *file
, dump_flags_t flags
)
1016 struct walk_stmt_info wi
;
1017 auto_vec
<numbered_tree
, 40> decl_list
;
1019 memset (&wi
, '\0', sizeof (wi
));
1020 wi
.info
= (void *) &decl_list
;
1021 FOR_EACH_BB_FN (bb
, cfun
)
1023 gimple_stmt_iterator gsi
;
1025 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1026 if (!is_gimple_debug (gsi_stmt (gsi
)))
1027 walk_gimple_stmt (&gsi
, NULL
, dump_enumerated_decls_push
, &wi
);
1029 decl_list
.qsort (compare_decls_by_uid
);
1030 if (decl_list
.length ())
1034 tree last
= NULL_TREE
;
1036 fprintf (file
, "Declarations used by %s, sorted by DECL_UID:\n",
1037 current_function_name ());
1038 FOR_EACH_VEC_ELT (decl_list
, ix
, ntp
)
1042 fprintf (file
, "%d: ", ntp
->num
);
1043 print_generic_decl (file
, ntp
->t
, flags
);
1044 fprintf (file
, "\n");