1 /* Data flow functions for trees.
2 Copyright (C) 2001-2024 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 the gimple stmt uids in one block. The caller is responsible
63 of calling set_gimple_stmt_max_uid (fun, 0) at some point. */
66 renumber_gimple_stmt_uids_in_block (struct function
*fun
, basic_block bb
)
68 gimple_stmt_iterator bsi
;
69 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
71 gimple
*stmt
= gsi_stmt (bsi
);
72 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (fun
));
74 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
76 gimple
*stmt
= gsi_stmt (bsi
);
77 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (fun
));
81 /* Renumber all of the gimple stmt uids. */
84 renumber_gimple_stmt_uids (struct function
*fun
)
88 set_gimple_stmt_max_uid (fun
, 0);
89 FOR_ALL_BB_FN (bb
, fun
)
90 renumber_gimple_stmt_uids_in_block (fun
, bb
);
93 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
94 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
97 renumber_gimple_stmt_uids_in_blocks (basic_block
*blocks
, int n_blocks
)
101 set_gimple_stmt_max_uid (cfun
, 0);
102 for (i
= 0; i
< n_blocks
; i
++)
103 renumber_gimple_stmt_uids_in_block (cfun
, blocks
[i
]);
108 /*---------------------------------------------------------------------------
110 ---------------------------------------------------------------------------*/
112 /* Dump variable VAR and its may-aliases to FILE. */
115 dump_variable (FILE *file
, tree var
)
117 if (TREE_CODE (var
) == SSA_NAME
)
119 if (POINTER_TYPE_P (TREE_TYPE (var
)))
120 dump_points_to_info_for (file
, var
);
121 var
= SSA_NAME_VAR (var
);
124 if (var
== NULL_TREE
)
126 fprintf (file
, "<nil>");
130 print_generic_expr (file
, var
, dump_flags
);
132 fprintf (file
, ", UID D.%u", (unsigned) DECL_UID (var
));
133 if (DECL_PT_UID (var
) != DECL_UID (var
))
134 fprintf (file
, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var
));
136 fprintf (file
, ", ");
137 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
139 if (TREE_ADDRESSABLE (var
))
140 fprintf (file
, ", is addressable");
142 if (is_global_var (var
))
143 fprintf (file
, ", is global");
145 if (TREE_THIS_VOLATILE (var
))
146 fprintf (file
, ", is volatile");
148 if (cfun
&& ssa_default_def (cfun
, var
))
150 fprintf (file
, ", default def: ");
151 print_generic_expr (file
, ssa_default_def (cfun
, var
), dump_flags
);
154 if (DECL_INITIAL (var
))
156 fprintf (file
, ", initial: ");
157 print_generic_expr (file
, DECL_INITIAL (var
), dump_flags
);
160 fprintf (file
, "\n");
164 /* Dump variable VAR and its may-aliases to stderr. */
167 debug_variable (tree var
)
169 dump_variable (stderr
, var
);
173 /* Dump various DFA statistics to FILE. */
176 dump_dfa_stats (FILE *file
)
178 struct dfa_stats_d dfa_stats
;
180 unsigned long size
, total
= 0;
181 const char * const fmt_str
= "%-30s%-13s%12s\n";
182 const char * const fmt_str_1
= "%-30s%13lu" PRsa (11) "\n";
183 const char * const fmt_str_3
= "%-43s" PRsa (11) "\n";
185 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
187 collect_dfa_stats (&dfa_stats
);
189 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
191 fprintf (file
, "---------------------------------------------------------\n");
192 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
193 fprintf (file
, fmt_str
, "", " instances ", "used ");
194 fprintf (file
, "---------------------------------------------------------\n");
196 size
= dfa_stats
.num_uses
* sizeof (tree
*);
198 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
201 size
= dfa_stats
.num_defs
* sizeof (tree
*);
203 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
206 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
208 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
211 size
= dfa_stats
.num_vdefs
* sizeof (tree
*);
213 fprintf (file
, fmt_str_1
, "VDEF operands", dfa_stats
.num_vdefs
,
216 size
= dfa_stats
.num_phis
* sizeof (struct gphi
);
218 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
221 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
223 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
226 fprintf (file
, "---------------------------------------------------------\n");
227 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data",
228 SIZE_AMOUNT (total
));
229 fprintf (file
, "---------------------------------------------------------\n");
230 fprintf (file
, "\n");
232 if (dfa_stats
.num_phis
)
233 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: "
234 HOST_SIZE_T_PRINT_DEC
")\n",
235 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
236 (fmt_size_t
) dfa_stats
.max_num_phi_args
);
238 fprintf (file
, "\n");
242 /* Dump DFA statistics on stderr. */
245 debug_dfa_stats (void)
247 dump_dfa_stats (stderr
);
251 /* Collect DFA statistics and store them in the structure pointed to by
255 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p ATTRIBUTE_UNUSED
)
259 gcc_assert (dfa_stats_p
);
261 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
263 /* Walk all the statements in the function counting references. */
264 FOR_EACH_BB_FN (bb
, cfun
)
266 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
269 gphi
*phi
= si
.phi ();
270 dfa_stats_p
->num_phis
++;
271 dfa_stats_p
->num_phi_args
+= gimple_phi_num_args (phi
);
272 if (gimple_phi_num_args (phi
) > dfa_stats_p
->max_num_phi_args
)
273 dfa_stats_p
->max_num_phi_args
= gimple_phi_num_args (phi
);
276 for (gimple_stmt_iterator si
= gsi_start_bb (bb
); !gsi_end_p (si
);
279 gimple
*stmt
= gsi_stmt (si
);
280 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_DEF
);
281 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_USE
);
282 dfa_stats_p
->num_vdefs
+= gimple_vdef (stmt
) ? 1 : 0;
283 dfa_stats_p
->num_vuses
+= gimple_vuse (stmt
) ? 1 : 0;
289 /*---------------------------------------------------------------------------
290 Miscellaneous helpers
291 ---------------------------------------------------------------------------*/
293 /* Lookup VAR UID in the default_defs hashtable and return the associated
297 ssa_default_def (struct function
*fn
, tree var
)
299 struct tree_decl_minimal ind
;
300 struct tree_ssa_name in
;
301 gcc_assert (VAR_P (var
)
302 || TREE_CODE (var
) == PARM_DECL
303 || TREE_CODE (var
) == RESULT_DECL
);
305 /* Always NULL_TREE for rtl function dumps. */
310 ind
.uid
= DECL_UID (var
);
311 return DEFAULT_DEFS (fn
)->find_with_hash ((tree
)&in
, DECL_UID (var
));
314 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
318 set_ssa_default_def (struct function
*fn
, tree var
, tree def
)
320 struct tree_decl_minimal ind
;
321 struct tree_ssa_name in
;
323 gcc_assert (VAR_P (var
)
324 || TREE_CODE (var
) == PARM_DECL
325 || TREE_CODE (var
) == RESULT_DECL
);
327 ind
.uid
= DECL_UID (var
);
330 tree
*loc
= DEFAULT_DEFS (fn
)->find_slot_with_hash ((tree
)&in
,
335 SSA_NAME_IS_DEFAULT_DEF (*(tree
*)loc
) = false;
336 DEFAULT_DEFS (fn
)->clear_slot (loc
);
340 gcc_assert (TREE_CODE (def
) == SSA_NAME
&& SSA_NAME_VAR (def
) == var
);
341 tree
*loc
= DEFAULT_DEFS (fn
)->find_slot_with_hash ((tree
)&in
,
342 DECL_UID (var
), INSERT
);
344 /* Default definition might be changed by tail call optimization. */
346 SSA_NAME_IS_DEFAULT_DEF (*loc
) = false;
348 /* Mark DEF as the default definition for VAR. */
350 SSA_NAME_IS_DEFAULT_DEF (def
) = true;
353 /* Retrieve or create a default definition for VAR. */
356 get_or_create_ssa_default_def (struct function
*fn
, tree var
)
358 tree ddef
= ssa_default_def (fn
, var
);
359 if (ddef
== NULL_TREE
)
361 ddef
= make_ssa_name_fn (fn
, var
, gimple_build_nop ());
362 set_ssa_default_def (fn
, var
, ddef
);
368 /* If EXP is a handled component reference for a structure, return the
369 base variable. The access range is delimited by bit positions *POFFSET and
370 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
371 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
372 and *PMAX_SIZE are equal, the access is non-variable. If *PREVERSE is
373 true, the storage order of the reference is reversed. */
376 get_ref_base_and_extent (tree exp
, poly_int64
*poffset
,
378 poly_int64
*pmax_size
,
381 poly_offset_int bitsize
= -1;
382 poly_offset_int maxsize
;
383 tree size_tree
= NULL_TREE
;
384 poly_offset_int bit_offset
= 0;
385 bool seen_variable_array_ref
= false;
387 /* First get the final access size and the storage order from just the
388 outermost expression. */
389 if (TREE_CODE (exp
) == COMPONENT_REF
)
390 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
391 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
392 size_tree
= TREE_OPERAND (exp
, 1);
393 else if (TREE_CODE (exp
) == WITH_SIZE_EXPR
)
395 size_tree
= TREE_OPERAND (exp
, 1);
396 exp
= TREE_OPERAND (exp
, 0);
398 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
400 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
402 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
404 bitsize
= GET_MODE_BITSIZE (mode
);
406 if (size_tree
!= NULL_TREE
407 && poly_int_tree_p (size_tree
))
408 bitsize
= wi::to_poly_offset (size_tree
);
410 *preverse
= reverse_storage_order_for_component_p (exp
);
412 /* Initially, maxsize is the same as the accessed element size.
413 In the following it will only grow (or become -1). */
416 /* Compute cumulative bit-offset for nested component-refs and array-refs,
417 and find the ultimate containing object. */
420 switch (TREE_CODE (exp
))
423 bit_offset
+= wi::to_poly_offset (TREE_OPERAND (exp
, 2));
428 tree field
= TREE_OPERAND (exp
, 1);
429 tree this_offset
= component_ref_field_offset (exp
);
431 if (this_offset
&& poly_int_tree_p (this_offset
))
433 poly_offset_int woffset
= (wi::to_poly_offset (this_offset
)
434 << LOG2_BITS_PER_UNIT
);
435 woffset
+= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
436 bit_offset
+= woffset
;
438 /* If we had seen a variable array ref already and we just
439 referenced the last field of a struct or a union member
440 then we have to adjust maxsize by the padding at the end
442 if (seen_variable_array_ref
)
444 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
445 tree next
= DECL_CHAIN (field
);
446 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
447 next
= DECL_CHAIN (next
);
449 || TREE_CODE (stype
) != RECORD_TYPE
)
451 tree fsize
= DECL_SIZE (field
);
452 tree ssize
= TYPE_SIZE (stype
);
454 || !poly_int_tree_p (fsize
)
456 || !poly_int_tree_p (ssize
))
458 else if (known_size_p (maxsize
))
461 = (wi::to_poly_offset (ssize
)
462 - wi::to_poly_offset (fsize
));
467 /* An component ref with an adjacent field up in the
468 structure hierarchy constrains the size of any variable
469 array ref lower in the access hierarchy. */
471 seen_variable_array_ref
= false;
476 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
477 /* We need to adjust maxsize to the whole structure bitsize.
478 But we can subtract any constant offset seen so far,
479 because that would get us out of the structure otherwise. */
480 if (known_size_p (maxsize
)
482 && poly_int_tree_p (csize
))
483 maxsize
= wi::to_poly_offset (csize
) - bit_offset
;
491 case ARRAY_RANGE_REF
:
493 tree index
= TREE_OPERAND (exp
, 1);
494 tree low_bound
, unit_size
;
496 /* If the resulting bit-offset is constant, track it. */
497 if (poly_int_tree_p (index
)
498 && (low_bound
= array_ref_low_bound (exp
),
499 poly_int_tree_p (low_bound
))
500 && (unit_size
= array_ref_element_size (exp
),
501 TREE_CODE (unit_size
) == INTEGER_CST
))
503 poly_offset_int woffset
504 = wi::sext (wi::to_poly_offset (index
)
505 - wi::to_poly_offset (low_bound
),
506 TYPE_PRECISION (sizetype
));
507 woffset
*= wi::to_offset (unit_size
);
508 woffset
<<= LOG2_BITS_PER_UNIT
;
509 bit_offset
+= woffset
;
511 /* An array ref with a constant index up in the structure
512 hierarchy will constrain the size of any variable array ref
513 lower in the access hierarchy. */
514 seen_variable_array_ref
= false;
518 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
519 /* We need to adjust maxsize to the whole array bitsize.
520 But we can subtract any constant offset seen so far,
521 because that would get us outside of the array otherwise. */
522 if (known_size_p (maxsize
)
524 && poly_int_tree_p (asize
))
525 maxsize
= wi::to_poly_offset (asize
) - bit_offset
;
529 /* Remember that we have seen an array ref with a variable
531 seen_variable_array_ref
= true;
535 query
= get_range_query (cfun
);
537 if (TREE_CODE (index
) == SSA_NAME
538 && (low_bound
= array_ref_low_bound (exp
),
539 poly_int_tree_p (low_bound
))
540 && (unit_size
= array_ref_element_size (exp
),
541 TREE_CODE (unit_size
) == INTEGER_CST
)
542 && query
->range_of_expr (vr
, index
)
544 && !vr
.undefined_p ())
546 wide_int min
= vr
.lower_bound ();
547 wide_int max
= vr
.upper_bound ();
548 poly_offset_int lbound
= wi::to_poly_offset (low_bound
);
549 /* Try to constrain maxsize with range information. */
551 = offset_int::from (max
, TYPE_SIGN (TREE_TYPE (index
)));
552 if (known_lt (lbound
, omax
))
554 poly_offset_int rmaxsize
;
555 rmaxsize
= (omax
- lbound
+ 1)
556 * wi::to_offset (unit_size
) << LOG2_BITS_PER_UNIT
;
557 if (!known_size_p (maxsize
)
558 || known_lt (rmaxsize
, maxsize
))
560 /* If we know an upper bound below the declared
561 one this is no longer variable. */
562 if (known_size_p (maxsize
))
563 seen_variable_array_ref
= false;
567 /* Try to adjust bit_offset with range information. */
569 = offset_int::from (min
, TYPE_SIGN (TREE_TYPE (index
)));
570 if (known_le (lbound
, omin
))
572 poly_offset_int woffset
573 = wi::sext (omin
- lbound
,
574 TYPE_PRECISION (sizetype
));
575 woffset
*= wi::to_offset (unit_size
);
576 woffset
<<= LOG2_BITS_PER_UNIT
;
577 bit_offset
+= woffset
;
578 if (known_size_p (maxsize
))
590 bit_offset
+= bitsize
;
593 case VIEW_CONVERT_EXPR
:
597 /* Via the variable index or index2 we can reach the
598 whole object. Still hand back the decl here. */
599 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
600 && (TMR_INDEX (exp
) || TMR_INDEX2 (exp
)))
602 exp
= TREE_OPERAND (TMR_BASE (exp
), 0);
609 /* We need to deal with variable arrays ending structures such as
610 struct { int length; int a[1]; } x; x.a[d]
611 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
612 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
613 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
614 where we do not know maxsize for variable index accesses to
615 the array. The simplest way to conservatively deal with this
616 is to punt in the case that offset + maxsize reaches the
617 base type boundary. This needs to include possible trailing
618 padding that is there for alignment purposes. */
619 if (seen_variable_array_ref
620 && known_size_p (maxsize
)
621 && (TYPE_SIZE (TREE_TYPE (exp
)) == NULL_TREE
622 || !poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp
)))
624 (bit_offset
+ maxsize
,
625 wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp
)))))))
628 /* Hand back the decl for MEM[&decl, off]. */
629 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
631 if (integer_zerop (TREE_OPERAND (exp
, 1)))
632 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
635 poly_offset_int off
= mem_ref_offset (exp
);
636 off
<<= LOG2_BITS_PER_UNIT
;
639 if (off
.to_shwi (&off_hwi
))
641 bit_offset
= off_hwi
;
642 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
652 exp
= TREE_OPERAND (exp
, 0);
656 if (!bitsize
.to_shwi (psize
) || maybe_lt (*psize
, 0))
665 /* ??? Due to negative offsets in ARRAY_REF we can end up with
666 negative bit_offset here. We might want to store a zero offset
668 if (!bit_offset
.to_shwi (poffset
))
676 /* In case of a decl or constant base object we can do better. */
681 && ((flag_unconstrained_commons
&& DECL_COMMON (exp
))
682 || (DECL_EXTERNAL (exp
) && seen_variable_array_ref
)))
684 tree sz_tree
= TYPE_SIZE (TREE_TYPE (exp
));
685 /* If size is unknown, or we have read to the end, assume there
686 may be more to the structure than we are told. */
687 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
688 || (seen_variable_array_ref
689 && (sz_tree
== NULL_TREE
690 || !poly_int_tree_p (sz_tree
)
691 || maybe_eq (bit_offset
+ maxsize
,
692 wi::to_poly_offset (sz_tree
)))))
695 /* If maxsize is unknown adjust it according to the size of the
697 else if (!known_size_p (maxsize
)
699 && poly_int_tree_p (DECL_SIZE (exp
)))
700 maxsize
= wi::to_poly_offset (DECL_SIZE (exp
)) - bit_offset
;
702 else if (CONSTANT_CLASS_P (exp
))
704 /* If maxsize is unknown adjust it according to the size of the
705 base type constant. */
706 if (!known_size_p (maxsize
)
707 && TYPE_SIZE (TREE_TYPE (exp
))
708 && poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp
))))
709 maxsize
= (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp
)))
713 if (!maxsize
.to_shwi (pmax_size
)
714 || maybe_lt (*pmax_size
, 0)
715 || !endpoint_representable_p (*poffset
, *pmax_size
))
718 /* Punt if *POFFSET + *PSIZE overflows in HOST_WIDE_INT, the callers don't
719 check for such overflows individually and assume it works. */
720 if (!endpoint_representable_p (*poffset
, *psize
))
732 /* Like get_ref_base_and_extent, but for cases in which we only care
733 about constant-width accesses at constant offsets. Return null
734 if the access is anything else. */
737 get_ref_base_and_extent_hwi (tree exp
, HOST_WIDE_INT
*poffset
,
738 HOST_WIDE_INT
*psize
, bool *preverse
)
740 poly_int64 offset
, size
, max_size
;
741 HOST_WIDE_INT const_offset
, const_size
;
743 tree decl
= get_ref_base_and_extent (exp
, &offset
, &size
, &max_size
,
745 if (!offset
.is_constant (&const_offset
)
746 || !size
.is_constant (&const_size
)
748 || !known_size_p (max_size
)
749 || maybe_ne (max_size
, const_size
))
752 *poffset
= const_offset
;
758 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
759 denotes the starting address of the memory access EXP.
760 Returns NULL_TREE if the offset is not constant or any component
761 is not BITS_PER_UNIT-aligned.
762 VALUEIZE if non-NULL is used to valueize SSA names. It should return
763 its argument or a constant if the argument is known to be constant. */
766 get_addr_base_and_unit_offset_1 (tree exp
, poly_int64
*poffset
,
767 tree (*valueize
) (tree
))
769 poly_int64 byte_offset
= 0;
771 /* Compute cumulative byte-offset for nested component-refs and array-refs,
772 and find the ultimate containing object. */
775 switch (TREE_CODE (exp
))
779 poly_int64 this_byte_offset
;
780 poly_uint64 this_bit_offset
;
781 if (!poly_int_tree_p (TREE_OPERAND (exp
, 2), &this_bit_offset
)
782 || !multiple_p (this_bit_offset
, BITS_PER_UNIT
,
785 byte_offset
+= this_byte_offset
;
791 tree field
= TREE_OPERAND (exp
, 1);
792 tree this_offset
= component_ref_field_offset (exp
);
793 poly_int64 hthis_offset
;
796 || !poly_int_tree_p (this_offset
, &hthis_offset
)
797 || (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
801 hthis_offset
+= (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
803 byte_offset
+= hthis_offset
;
808 case ARRAY_RANGE_REF
:
810 tree index
= TREE_OPERAND (exp
, 1);
811 tree low_bound
, unit_size
;
814 && TREE_CODE (index
) == SSA_NAME
)
815 index
= (*valueize
) (index
);
816 if (!poly_int_tree_p (index
))
818 low_bound
= array_ref_low_bound (exp
);
820 && TREE_CODE (low_bound
) == SSA_NAME
)
821 low_bound
= (*valueize
) (low_bound
);
822 if (!poly_int_tree_p (low_bound
))
824 unit_size
= array_ref_element_size (exp
);
825 if (TREE_CODE (unit_size
) != INTEGER_CST
)
828 /* If the resulting bit-offset is constant, track it. */
829 poly_offset_int woffset
830 = wi::sext (wi::to_poly_offset (index
)
831 - wi::to_poly_offset (low_bound
),
832 TYPE_PRECISION (sizetype
));
833 woffset
*= wi::to_offset (unit_size
);
834 byte_offset
+= woffset
.force_shwi ();
842 byte_offset
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (exp
)));
845 case VIEW_CONVERT_EXPR
:
850 tree base
= TREE_OPERAND (exp
, 0);
852 && TREE_CODE (base
) == SSA_NAME
)
853 base
= (*valueize
) (base
);
855 /* Hand back the decl for MEM[&decl, off]. */
856 if (TREE_CODE (base
) == ADDR_EXPR
)
858 if (!integer_zerop (TREE_OPERAND (exp
, 1)))
860 poly_offset_int off
= mem_ref_offset (exp
);
861 byte_offset
+= off
.force_shwi ();
863 exp
= TREE_OPERAND (base
, 0);
870 tree base
= TREE_OPERAND (exp
, 0);
872 && TREE_CODE (base
) == SSA_NAME
)
873 base
= (*valueize
) (base
);
875 /* Hand back the decl for MEM[&decl, off]. */
876 if (TREE_CODE (base
) == ADDR_EXPR
)
878 if (TMR_INDEX (exp
) || TMR_INDEX2 (exp
))
880 if (!integer_zerop (TMR_OFFSET (exp
)))
882 poly_offset_int off
= mem_ref_offset (exp
);
883 byte_offset
+= off
.force_shwi ();
885 exp
= TREE_OPERAND (base
, 0);
894 exp
= TREE_OPERAND (exp
, 0);
898 *poffset
= byte_offset
;
902 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
903 denotes the starting address of the memory access EXP.
904 Returns NULL_TREE if the offset is not constant or any component
905 is not BITS_PER_UNIT-aligned. */
908 get_addr_base_and_unit_offset (tree exp
, poly_int64
*poffset
)
910 return get_addr_base_and_unit_offset_1 (exp
, poffset
, NULL
);
913 /* Returns true if STMT references an SSA_NAME that has
914 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
917 stmt_references_abnormal_ssa_name (gimple
*stmt
)
922 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
924 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))
931 /* If STMT takes any abnormal PHI values as input, replace them with
935 replace_abnormal_ssa_names (gimple
*stmt
)
940 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
942 tree op
= USE_FROM_PTR (use_p
);
943 if (TREE_CODE (op
) == SSA_NAME
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op
))
945 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
946 tree new_name
= make_ssa_name (TREE_TYPE (op
));
947 gassign
*assign
= gimple_build_assign (new_name
, op
);
948 gsi_insert_before (&gsi
, assign
, GSI_SAME_STMT
);
949 SET_USE (use_p
, new_name
);
954 /* Pair of tree and a sorting index, for dump_enumerated_decls. */
955 struct GTY(()) numbered_tree
962 /* Compare two declarations references by their DECL_UID / sequence number.
966 compare_decls_by_uid (const void *pa
, const void *pb
)
968 const numbered_tree
*nt_a
= ((const numbered_tree
*)pa
);
969 const numbered_tree
*nt_b
= ((const numbered_tree
*)pb
);
971 if (DECL_UID (nt_a
->t
) != DECL_UID (nt_b
->t
))
972 return DECL_UID (nt_a
->t
) - DECL_UID (nt_b
->t
);
973 return nt_a
->num
- nt_b
->num
;
976 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
978 dump_enumerated_decls_push (tree
*tp
, int *walk_subtrees
, void *data
)
980 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
981 vec
<numbered_tree
> *list
= (vec
<numbered_tree
> *) wi
->info
;
987 nt
.num
= list
->length ();
988 list
->safe_push (nt
);
993 /* Find all the declarations used by the current function, sort them by uid,
994 and emit the sorted list. Each declaration is tagged with a sequence
995 number indicating when it was found during statement / tree walking,
996 so that TDF_NOUID comparisons of anonymous declarations are still
997 meaningful. Where a declaration was encountered more than once, we
998 emit only the sequence number of the first encounter.
999 FILE is the dump file where to output the list and FLAGS is as in
1000 print_generic_expr. */
1002 dump_enumerated_decls (FILE *file
, dump_flags_t flags
)
1008 struct walk_stmt_info wi
;
1009 auto_vec
<numbered_tree
, 40> decl_list
;
1011 memset (&wi
, '\0', sizeof (wi
));
1012 wi
.info
= (void *) &decl_list
;
1013 FOR_EACH_BB_FN (bb
, cfun
)
1015 gimple_stmt_iterator gsi
;
1017 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1018 if (!is_gimple_debug (gsi_stmt (gsi
)))
1019 walk_gimple_stmt (&gsi
, NULL
, dump_enumerated_decls_push
, &wi
);
1021 decl_list
.qsort (compare_decls_by_uid
);
1022 if (decl_list
.length ())
1026 tree last
= NULL_TREE
;
1028 fprintf (file
, "Declarations used by %s, sorted by DECL_UID:\n",
1029 current_function_name ());
1030 FOR_EACH_VEC_ELT (decl_list
, ix
, ntp
)
1034 fprintf (file
, "%d: ", ntp
->num
);
1035 print_generic_decl (file
, ntp
->t
, flags
);
1036 fprintf (file
, "\n");