1 /* Data flow functions for trees.
2 Copyright (C) 2001-2015 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"
29 #include "fold-const.h"
30 #include "stor-layout.h"
33 #include "hard-reg-set.h"
35 #include "dominance.h"
37 #include "basic-block.h"
38 #include "langhooks.h"
40 #include "tree-pretty-print.h"
41 #include "tree-ssa-alias.h"
42 #include "internal-fn.h"
43 #include "gimple-expr.h"
46 #include "gimple-iterator.h"
47 #include "gimple-walk.h"
48 #include "gimple-ssa.h"
49 #include "tree-phinodes.h"
50 #include "ssa-iterators.h"
51 #include "stringpool.h"
52 #include "tree-ssanames.h"
54 #include "insn-config.h"
64 #include "tree-inline.h"
65 #include "tree-pass.h"
68 /* Build and maintain data flow information for trees. */
70 /* Counters used to display DFA and SSA statistics. */
77 size_t max_num_phi_args
;
83 /* Local functions. */
84 static void collect_dfa_stats (struct dfa_stats_d
*);
87 /*---------------------------------------------------------------------------
88 Dataflow analysis (DFA) routines
89 ---------------------------------------------------------------------------*/
91 /* Renumber all of the gimple stmt uids. */
94 renumber_gimple_stmt_uids (void)
98 set_gimple_stmt_max_uid (cfun
, 0);
99 FOR_ALL_BB_FN (bb
, cfun
)
101 gimple_stmt_iterator bsi
;
102 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
104 gimple stmt
= gsi_stmt (bsi
);
105 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
107 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
109 gimple stmt
= gsi_stmt (bsi
);
110 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
115 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
116 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
119 renumber_gimple_stmt_uids_in_blocks (basic_block
*blocks
, int n_blocks
)
123 set_gimple_stmt_max_uid (cfun
, 0);
124 for (i
= 0; i
< n_blocks
; i
++)
126 basic_block bb
= blocks
[i
];
127 gimple_stmt_iterator bsi
;
128 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
130 gimple stmt
= gsi_stmt (bsi
);
131 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
133 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
135 gimple stmt
= gsi_stmt (bsi
);
136 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
143 /*---------------------------------------------------------------------------
145 ---------------------------------------------------------------------------*/
147 /* Dump variable VAR and its may-aliases to FILE. */
150 dump_variable (FILE *file
, tree var
)
152 if (TREE_CODE (var
) == SSA_NAME
)
154 if (POINTER_TYPE_P (TREE_TYPE (var
)))
155 dump_points_to_info_for (file
, var
);
156 var
= SSA_NAME_VAR (var
);
159 if (var
== NULL_TREE
)
161 fprintf (file
, "<nil>");
165 print_generic_expr (file
, var
, dump_flags
);
167 fprintf (file
, ", UID D.%u", (unsigned) DECL_UID (var
));
168 if (DECL_PT_UID (var
) != DECL_UID (var
))
169 fprintf (file
, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var
));
171 fprintf (file
, ", ");
172 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
174 if (TREE_ADDRESSABLE (var
))
175 fprintf (file
, ", is addressable");
177 if (is_global_var (var
))
178 fprintf (file
, ", is global");
180 if (TREE_THIS_VOLATILE (var
))
181 fprintf (file
, ", is volatile");
183 if (cfun
&& ssa_default_def (cfun
, var
))
185 fprintf (file
, ", default def: ");
186 print_generic_expr (file
, ssa_default_def (cfun
, var
), dump_flags
);
189 if (DECL_INITIAL (var
))
191 fprintf (file
, ", initial: ");
192 print_generic_expr (file
, DECL_INITIAL (var
), dump_flags
);
195 fprintf (file
, "\n");
199 /* Dump variable VAR and its may-aliases to stderr. */
202 debug_variable (tree var
)
204 dump_variable (stderr
, var
);
208 /* Dump various DFA statistics to FILE. */
211 dump_dfa_stats (FILE *file
)
213 struct dfa_stats_d dfa_stats
;
215 unsigned long size
, total
= 0;
216 const char * const fmt_str
= "%-30s%-13s%12s\n";
217 const char * const fmt_str_1
= "%-30s%13lu%11lu%c\n";
218 const char * const fmt_str_3
= "%-43s%11lu%c\n";
220 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
222 collect_dfa_stats (&dfa_stats
);
224 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
226 fprintf (file
, "---------------------------------------------------------\n");
227 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
228 fprintf (file
, fmt_str
, "", " instances ", "used ");
229 fprintf (file
, "---------------------------------------------------------\n");
231 size
= dfa_stats
.num_uses
* sizeof (tree
*);
233 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
234 SCALE (size
), LABEL (size
));
236 size
= dfa_stats
.num_defs
* sizeof (tree
*);
238 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
239 SCALE (size
), LABEL (size
));
241 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
243 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
244 SCALE (size
), LABEL (size
));
246 size
= dfa_stats
.num_vdefs
* sizeof (tree
*);
248 fprintf (file
, fmt_str_1
, "VDEF operands", dfa_stats
.num_vdefs
,
249 SCALE (size
), LABEL (size
));
251 size
= dfa_stats
.num_phis
* sizeof (struct gphi
);
253 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
254 SCALE (size
), LABEL (size
));
256 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
258 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
259 SCALE (size
), LABEL (size
));
261 fprintf (file
, "---------------------------------------------------------\n");
262 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data", SCALE (total
),
264 fprintf (file
, "---------------------------------------------------------\n");
265 fprintf (file
, "\n");
267 if (dfa_stats
.num_phis
)
268 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
269 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
270 (long) dfa_stats
.max_num_phi_args
);
272 fprintf (file
, "\n");
276 /* Dump DFA statistics on stderr. */
279 debug_dfa_stats (void)
281 dump_dfa_stats (stderr
);
285 /* Collect DFA statistics and store them in the structure pointed to by
289 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p ATTRIBUTE_UNUSED
)
293 gcc_assert (dfa_stats_p
);
295 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
297 /* Walk all the statements in the function counting references. */
298 FOR_EACH_BB_FN (bb
, cfun
)
300 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
303 gphi
*phi
= si
.phi ();
304 dfa_stats_p
->num_phis
++;
305 dfa_stats_p
->num_phi_args
+= gimple_phi_num_args (phi
);
306 if (gimple_phi_num_args (phi
) > dfa_stats_p
->max_num_phi_args
)
307 dfa_stats_p
->max_num_phi_args
= gimple_phi_num_args (phi
);
310 for (gimple_stmt_iterator si
= gsi_start_bb (bb
); !gsi_end_p (si
);
313 gimple stmt
= gsi_stmt (si
);
314 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_DEF
);
315 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_USE
);
316 dfa_stats_p
->num_vdefs
+= gimple_vdef (stmt
) ? 1 : 0;
317 dfa_stats_p
->num_vuses
+= gimple_vuse (stmt
) ? 1 : 0;
323 /*---------------------------------------------------------------------------
324 Miscellaneous helpers
325 ---------------------------------------------------------------------------*/
327 /* Lookup VAR UID in the default_defs hashtable and return the associated
331 ssa_default_def (struct function
*fn
, tree var
)
333 struct tree_decl_minimal ind
;
334 struct tree_ssa_name in
;
335 gcc_assert (TREE_CODE (var
) == VAR_DECL
336 || TREE_CODE (var
) == PARM_DECL
337 || TREE_CODE (var
) == RESULT_DECL
);
339 ind
.uid
= DECL_UID (var
);
340 return DEFAULT_DEFS (fn
)->find_with_hash ((tree
)&in
, DECL_UID (var
));
343 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
347 set_ssa_default_def (struct function
*fn
, tree var
, tree def
)
349 struct tree_decl_minimal ind
;
350 struct tree_ssa_name in
;
352 gcc_assert (TREE_CODE (var
) == VAR_DECL
353 || TREE_CODE (var
) == PARM_DECL
354 || TREE_CODE (var
) == RESULT_DECL
);
356 ind
.uid
= DECL_UID (var
);
359 tree
*loc
= DEFAULT_DEFS (fn
)->find_slot_with_hash ((tree
)&in
,
364 SSA_NAME_IS_DEFAULT_DEF (*(tree
*)loc
) = false;
365 DEFAULT_DEFS (fn
)->clear_slot (loc
);
369 gcc_assert (TREE_CODE (def
) == SSA_NAME
&& SSA_NAME_VAR (def
) == var
);
370 tree
*loc
= DEFAULT_DEFS (fn
)->find_slot_with_hash ((tree
)&in
,
371 DECL_UID (var
), INSERT
);
373 /* Default definition might be changed by tail call optimization. */
375 SSA_NAME_IS_DEFAULT_DEF (*loc
) = false;
377 /* Mark DEF as the default definition for VAR. */
379 SSA_NAME_IS_DEFAULT_DEF (def
) = true;
382 /* Retrieve or create a default definition for VAR. */
385 get_or_create_ssa_default_def (struct function
*fn
, tree var
)
387 tree ddef
= ssa_default_def (fn
, var
);
388 if (ddef
== NULL_TREE
)
390 ddef
= make_ssa_name_fn (fn
, var
, gimple_build_nop ());
391 set_ssa_default_def (fn
, var
, ddef
);
397 /* If EXP is a handled component reference for a structure, return the
398 base variable. The access range is delimited by bit positions *POFFSET and
399 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
400 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
401 and *PMAX_SIZE are equal, the access is non-variable. If *PREVERSE is
402 true, the storage order of the reference is reversed. */
405 get_ref_base_and_extent (tree exp
, HOST_WIDE_INT
*poffset
,
406 HOST_WIDE_INT
*psize
,
407 HOST_WIDE_INT
*pmax_size
,
410 offset_int bitsize
= -1;
412 tree size_tree
= NULL_TREE
;
413 offset_int bit_offset
= 0;
414 bool seen_variable_array_ref
= false;
416 /* First get the final access size and the storage order from just the
417 outermost expression. */
418 if (TREE_CODE (exp
) == COMPONENT_REF
)
419 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
420 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
421 size_tree
= TREE_OPERAND (exp
, 1);
422 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
424 machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
426 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
428 bitsize
= int (GET_MODE_PRECISION (mode
));
430 if (size_tree
!= NULL_TREE
431 && TREE_CODE (size_tree
) == INTEGER_CST
)
432 bitsize
= wi::to_offset (size_tree
);
434 *preverse
= reverse_storage_order_for_component_p (exp
);
436 /* Initially, maxsize is the same as the accessed element size.
437 In the following it will only grow (or become -1). */
440 /* Compute cumulative bit-offset for nested component-refs and array-refs,
441 and find the ultimate containing object. */
444 switch (TREE_CODE (exp
))
447 bit_offset
+= wi::to_offset (TREE_OPERAND (exp
, 2));
452 tree field
= TREE_OPERAND (exp
, 1);
453 tree this_offset
= component_ref_field_offset (exp
);
455 if (this_offset
&& TREE_CODE (this_offset
) == INTEGER_CST
)
457 offset_int woffset
= wi::lshift (wi::to_offset (this_offset
),
459 woffset
+= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
460 bit_offset
+= woffset
;
462 /* If we had seen a variable array ref already and we just
463 referenced the last field of a struct or a union member
464 then we have to adjust maxsize by the padding at the end
466 if (seen_variable_array_ref
&& maxsize
!= -1)
468 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
469 tree next
= DECL_CHAIN (field
);
470 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
471 next
= DECL_CHAIN (next
);
473 || TREE_CODE (stype
) != RECORD_TYPE
)
475 tree fsize
= DECL_SIZE_UNIT (field
);
476 tree ssize
= TYPE_SIZE_UNIT (stype
);
478 || TREE_CODE (fsize
) != INTEGER_CST
480 || TREE_CODE (ssize
) != INTEGER_CST
)
484 offset_int tem
= (wi::to_offset (ssize
)
485 - wi::to_offset (fsize
));
486 tem
= wi::lshift (tem
, LOG2_BITS_PER_UNIT
);
495 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
496 /* We need to adjust maxsize to the whole structure bitsize.
497 But we can subtract any constant offset seen so far,
498 because that would get us out of the structure otherwise. */
501 && TREE_CODE (csize
) == INTEGER_CST
)
502 maxsize
= wi::to_offset (csize
) - bit_offset
;
510 case ARRAY_RANGE_REF
:
512 tree index
= TREE_OPERAND (exp
, 1);
513 tree low_bound
, unit_size
;
515 /* If the resulting bit-offset is constant, track it. */
516 if (TREE_CODE (index
) == INTEGER_CST
517 && (low_bound
= array_ref_low_bound (exp
),
518 TREE_CODE (low_bound
) == INTEGER_CST
)
519 && (unit_size
= array_ref_element_size (exp
),
520 TREE_CODE (unit_size
) == INTEGER_CST
))
523 = wi::sext (wi::to_offset (index
) - wi::to_offset (low_bound
),
524 TYPE_PRECISION (TREE_TYPE (index
)));
525 woffset
*= wi::to_offset (unit_size
);
526 woffset
= wi::lshift (woffset
, LOG2_BITS_PER_UNIT
);
527 bit_offset
+= woffset
;
529 /* An array ref with a constant index up in the structure
530 hierarchy will constrain the size of any variable array ref
531 lower in the access hierarchy. */
532 seen_variable_array_ref
= false;
536 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
537 /* We need to adjust maxsize to the whole array bitsize.
538 But we can subtract any constant offset seen so far,
539 because that would get us outside of the array otherwise. */
542 && TREE_CODE (asize
) == INTEGER_CST
)
543 maxsize
= wi::to_offset (asize
) - bit_offset
;
547 /* Remember that we have seen an array ref with a variable
549 seen_variable_array_ref
= true;
558 bit_offset
+= bitsize
;
561 case VIEW_CONVERT_EXPR
:
565 /* Via the variable index or index2 we can reach the
566 whole object. Still hand back the decl here. */
567 if (TREE_CODE (TMR_BASE (exp
)) == ADDR_EXPR
568 && (TMR_INDEX (exp
) || TMR_INDEX2 (exp
)))
570 exp
= TREE_OPERAND (TMR_BASE (exp
), 0);
577 /* We need to deal with variable arrays ending structures such as
578 struct { int length; int a[1]; } x; x.a[d]
579 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
580 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
581 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
582 where we do not know maxsize for variable index accesses to
583 the array. The simplest way to conservatively deal with this
584 is to punt in the case that offset + maxsize reaches the
585 base type boundary. This needs to include possible trailing
586 padding that is there for alignment purposes. */
587 if (seen_variable_array_ref
589 && (TYPE_SIZE (TREE_TYPE (exp
)) == NULL_TREE
590 || TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) != INTEGER_CST
591 || (bit_offset
+ maxsize
592 == wi::to_offset (TYPE_SIZE (TREE_TYPE (exp
))))))
595 /* Hand back the decl for MEM[&decl, off]. */
596 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
598 if (integer_zerop (TREE_OPERAND (exp
, 1)))
599 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
602 offset_int off
= mem_ref_offset (exp
);
603 off
= wi::lshift (off
, LOG2_BITS_PER_UNIT
);
605 if (wi::fits_shwi_p (off
))
608 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
618 exp
= TREE_OPERAND (exp
, 0);
621 /* We need to deal with variable arrays ending structures. */
622 if (seen_variable_array_ref
624 && (TYPE_SIZE (TREE_TYPE (exp
)) == NULL_TREE
625 || TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) != INTEGER_CST
626 || (bit_offset
+ maxsize
627 == wi::to_offset (TYPE_SIZE (TREE_TYPE (exp
))))))
631 if (!wi::fits_shwi_p (bitsize
) || wi::neg_p (bitsize
))
640 *psize
= bitsize
.to_shwi ();
642 if (!wi::fits_shwi_p (bit_offset
))
650 /* In case of a decl or constant base object we can do better. */
654 /* If maxsize is unknown adjust it according to the size of the
658 && TREE_CODE (DECL_SIZE (exp
)) == INTEGER_CST
)
659 maxsize
= wi::to_offset (DECL_SIZE (exp
)) - bit_offset
;
661 else if (CONSTANT_CLASS_P (exp
))
663 /* If maxsize is unknown adjust it according to the size of the
664 base type constant. */
666 && TYPE_SIZE (TREE_TYPE (exp
))
667 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) == INTEGER_CST
)
668 maxsize
= (wi::to_offset (TYPE_SIZE (TREE_TYPE (exp
)))
672 /* ??? Due to negative offsets in ARRAY_REF we can end up with
673 negative bit_offset here. We might want to store a zero offset
675 *poffset
= bit_offset
.to_shwi ();
676 if (!wi::fits_shwi_p (maxsize
) || wi::neg_p (maxsize
))
679 *pmax_size
= maxsize
.to_shwi ();
684 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
685 denotes the starting address of the memory access EXP.
686 Returns NULL_TREE if the offset is not constant or any component
687 is not BITS_PER_UNIT-aligned.
688 VALUEIZE if non-NULL is used to valueize SSA names. It should return
689 its argument or a constant if the argument is known to be constant. */
692 get_addr_base_and_unit_offset_1 (tree exp
, HOST_WIDE_INT
*poffset
,
693 tree (*valueize
) (tree
))
695 HOST_WIDE_INT byte_offset
= 0;
697 /* Compute cumulative byte-offset for nested component-refs and array-refs,
698 and find the ultimate containing object. */
701 switch (TREE_CODE (exp
))
705 HOST_WIDE_INT this_off
= TREE_INT_CST_LOW (TREE_OPERAND (exp
, 2));
706 if (this_off
% BITS_PER_UNIT
)
708 byte_offset
+= this_off
/ BITS_PER_UNIT
;
714 tree field
= TREE_OPERAND (exp
, 1);
715 tree this_offset
= component_ref_field_offset (exp
);
716 HOST_WIDE_INT hthis_offset
;
719 || TREE_CODE (this_offset
) != INTEGER_CST
720 || (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
724 hthis_offset
= TREE_INT_CST_LOW (this_offset
);
725 hthis_offset
+= (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
727 byte_offset
+= hthis_offset
;
732 case ARRAY_RANGE_REF
:
734 tree index
= TREE_OPERAND (exp
, 1);
735 tree low_bound
, unit_size
;
738 && TREE_CODE (index
) == SSA_NAME
)
739 index
= (*valueize
) (index
);
741 /* If the resulting bit-offset is constant, track it. */
742 if (TREE_CODE (index
) == INTEGER_CST
743 && (low_bound
= array_ref_low_bound (exp
),
744 TREE_CODE (low_bound
) == INTEGER_CST
)
745 && (unit_size
= array_ref_element_size (exp
),
746 TREE_CODE (unit_size
) == INTEGER_CST
))
749 = wi::sext (wi::to_offset (index
) - wi::to_offset (low_bound
),
750 TYPE_PRECISION (TREE_TYPE (index
)));
751 woffset
*= wi::to_offset (unit_size
);
752 byte_offset
+= woffset
.to_shwi ();
763 byte_offset
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (exp
)));
766 case VIEW_CONVERT_EXPR
:
771 tree base
= TREE_OPERAND (exp
, 0);
773 && TREE_CODE (base
) == SSA_NAME
)
774 base
= (*valueize
) (base
);
776 /* Hand back the decl for MEM[&decl, off]. */
777 if (TREE_CODE (base
) == ADDR_EXPR
)
779 if (!integer_zerop (TREE_OPERAND (exp
, 1)))
781 offset_int off
= mem_ref_offset (exp
);
782 byte_offset
+= off
.to_short_addr ();
784 exp
= TREE_OPERAND (base
, 0);
791 tree base
= TREE_OPERAND (exp
, 0);
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 (TMR_INDEX (exp
) || TMR_INDEX2 (exp
))
801 if (!integer_zerop (TMR_OFFSET (exp
)))
803 offset_int off
= mem_ref_offset (exp
);
804 byte_offset
+= off
.to_short_addr ();
806 exp
= TREE_OPERAND (base
, 0);
815 exp
= TREE_OPERAND (exp
, 0);
819 *poffset
= byte_offset
;
823 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
824 denotes the starting address of the memory access EXP.
825 Returns NULL_TREE if the offset is not constant or any component
826 is not BITS_PER_UNIT-aligned. */
829 get_addr_base_and_unit_offset (tree exp
, HOST_WIDE_INT
*poffset
)
831 return get_addr_base_and_unit_offset_1 (exp
, poffset
, NULL
);
834 /* Returns true if STMT references an SSA_NAME that has
835 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
838 stmt_references_abnormal_ssa_name (gimple stmt
)
843 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
845 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))
852 /* Pair of tree and a sorting index, for dump_enumerated_decls. */
853 struct GTY(()) numbered_tree_d
858 typedef struct numbered_tree_d numbered_tree
;
861 /* Compare two declarations references by their DECL_UID / sequence number.
865 compare_decls_by_uid (const void *pa
, const void *pb
)
867 const numbered_tree
*nt_a
= ((const numbered_tree
*)pa
);
868 const numbered_tree
*nt_b
= ((const numbered_tree
*)pb
);
870 if (DECL_UID (nt_a
->t
) != DECL_UID (nt_b
->t
))
871 return DECL_UID (nt_a
->t
) - DECL_UID (nt_b
->t
);
872 return nt_a
->num
- nt_b
->num
;
875 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */
877 dump_enumerated_decls_push (tree
*tp
, int *walk_subtrees
, void *data
)
879 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
880 vec
<numbered_tree
> *list
= (vec
<numbered_tree
> *) wi
->info
;
886 nt
.num
= list
->length ();
887 list
->safe_push (nt
);
892 /* Find all the declarations used by the current function, sort them by uid,
893 and emit the sorted list. Each declaration is tagged with a sequence
894 number indicating when it was found during statement / tree walking,
895 so that TDF_NOUID comparisons of anonymous declarations are still
896 meaningful. Where a declaration was encountered more than once, we
897 emit only the sequence number of the first encounter.
898 FILE is the dump file where to output the list and FLAGS is as in
899 print_generic_expr. */
901 dump_enumerated_decls (FILE *file
, int flags
)
904 struct walk_stmt_info wi
;
905 auto_vec
<numbered_tree
, 40> decl_list
;
907 memset (&wi
, '\0', sizeof (wi
));
908 wi
.info
= (void *) &decl_list
;
909 FOR_EACH_BB_FN (bb
, cfun
)
911 gimple_stmt_iterator gsi
;
913 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
914 if (!is_gimple_debug (gsi_stmt (gsi
)))
915 walk_gimple_stmt (&gsi
, NULL
, dump_enumerated_decls_push
, &wi
);
917 decl_list
.qsort (compare_decls_by_uid
);
918 if (decl_list
.length ())
922 tree last
= NULL_TREE
;
924 fprintf (file
, "Declarations used by %s, sorted by DECL_UID:\n",
925 current_function_name ());
926 FOR_EACH_VEC_ELT (decl_list
, ix
, ntp
)
930 fprintf (file
, "%d: ", ntp
->num
);
931 print_generic_decl (file
, ntp
->t
, flags
);
932 fprintf (file
, "\n");