1 /* Data flow functions for trees.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
27 #include "pointer-set.h"
30 #include "basic-block.h"
34 #include "langhooks.h"
37 #include "tree-pretty-print.h"
38 #include "tree-dump.h"
40 #include "tree-flow.h"
41 #include "tree-inline.h"
42 #include "tree-pass.h"
47 /* Build and maintain data flow information for trees. */
49 /* Counters used to display DFA and SSA statistics. */
57 size_t max_num_phi_args
;
63 /* Local functions. */
64 static void collect_dfa_stats (struct dfa_stats_d
*);
65 static tree
find_vars_r (tree
*, int *, void *);
68 /*---------------------------------------------------------------------------
69 Dataflow analysis (DFA) routines
70 ---------------------------------------------------------------------------*/
71 /* Find all the variables referenced in the function. This function
72 builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
74 Note that this function does not look for statement operands, it simply
75 determines what variables are referenced in the program and detects
76 various attributes for each variable used by alias analysis and the
80 find_referenced_vars (void)
83 gimple_stmt_iterator si
;
87 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
89 gimple stmt
= gsi_stmt (si
);
90 if (is_gimple_debug (stmt
))
92 find_referenced_vars_in (gsi_stmt (si
));
95 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
96 find_referenced_vars_in (gsi_stmt (si
));
102 struct gimple_opt_pass pass_referenced_vars
=
106 "*referenced_vars", /* name */
108 find_referenced_vars
, /* execute */
111 0, /* static_pass_number */
112 TV_FIND_REFERENCED_VARS
, /* tv_id */
113 PROP_gimple_leh
| PROP_cfg
, /* properties_required */
114 PROP_referenced_vars
, /* properties_provided */
115 0, /* properties_destroyed */
116 TODO_dump_func
, /* todo_flags_start */
117 TODO_dump_func
/* todo_flags_finish */
122 /*---------------------------------------------------------------------------
124 ---------------------------------------------------------------------------*/
125 /* Create a new annotation for a _DECL node T. */
128 create_var_ann (tree t
)
133 gcc_assert (TREE_CODE (t
) == VAR_DECL
134 || TREE_CODE (t
) == PARM_DECL
135 || TREE_CODE (t
) == RESULT_DECL
);
137 ann
= ggc_alloc_cleared_var_ann_d ();
138 *DECL_VAR_ANN_PTR (t
) = ann
;
143 /* Renumber all of the gimple stmt uids. */
146 renumber_gimple_stmt_uids (void)
150 set_gimple_stmt_max_uid (cfun
, 0);
153 gimple_stmt_iterator bsi
;
154 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
156 gimple stmt
= gsi_stmt (bsi
);
157 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
162 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
163 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
166 renumber_gimple_stmt_uids_in_blocks (basic_block
*blocks
, int n_blocks
)
170 set_gimple_stmt_max_uid (cfun
, 0);
171 for (i
= 0; i
< n_blocks
; i
++)
173 basic_block bb
= blocks
[i
];
174 gimple_stmt_iterator bsi
;
175 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
177 gimple stmt
= gsi_stmt (bsi
);
178 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
180 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
182 gimple stmt
= gsi_stmt (bsi
);
183 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
188 /* Build a temporary. Make sure and register it to be renamed. */
191 make_rename_temp (tree type
, const char *prefix
)
193 tree t
= create_tmp_reg (type
, prefix
);
195 if (gimple_referenced_vars (cfun
))
197 add_referenced_var (t
);
198 mark_sym_for_renaming (t
);
206 /*---------------------------------------------------------------------------
208 ---------------------------------------------------------------------------*/
209 /* Dump the list of all the referenced variables in the current function to
213 dump_referenced_vars (FILE *file
)
216 referenced_var_iterator rvi
;
218 fprintf (file
, "\nReferenced variables in %s: %u\n\n",
219 get_name (current_function_decl
), (unsigned) num_referenced_vars
);
221 FOR_EACH_REFERENCED_VAR (var
, rvi
)
223 fprintf (file
, "Variable: ");
224 dump_variable (file
, var
);
227 fprintf (file
, "\n");
231 /* Dump the list of all the referenced variables to stderr. */
234 debug_referenced_vars (void)
236 dump_referenced_vars (stderr
);
240 /* Dump variable VAR and its may-aliases to FILE. */
243 dump_variable (FILE *file
, tree var
)
247 if (TREE_CODE (var
) == SSA_NAME
)
249 if (POINTER_TYPE_P (TREE_TYPE (var
)))
250 dump_points_to_info_for (file
, var
);
251 var
= SSA_NAME_VAR (var
);
254 if (var
== NULL_TREE
)
256 fprintf (file
, "<nil>");
260 print_generic_expr (file
, var
, dump_flags
);
264 fprintf (file
, ", UID D.%u", (unsigned) DECL_UID (var
));
265 if (DECL_PT_UID (var
) != DECL_UID (var
))
266 fprintf (file
, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var
));
268 fprintf (file
, ", ");
269 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
271 if (TREE_ADDRESSABLE (var
))
272 fprintf (file
, ", is addressable");
274 if (is_global_var (var
))
275 fprintf (file
, ", is global");
277 if (TREE_THIS_VOLATILE (var
))
278 fprintf (file
, ", is volatile");
280 if (ann
&& ann
->noalias_state
== NO_ALIAS
)
281 fprintf (file
, ", NO_ALIAS (does not alias other NO_ALIAS symbols)");
282 else if (ann
&& ann
->noalias_state
== NO_ALIAS_GLOBAL
)
283 fprintf (file
, ", NO_ALIAS_GLOBAL (does not alias other NO_ALIAS symbols"
284 " and global vars)");
285 else if (ann
&& ann
->noalias_state
== NO_ALIAS_ANYTHING
)
286 fprintf (file
, ", NO_ALIAS_ANYTHING (does not alias any other symbols)");
288 if (cfun
&& gimple_default_def (cfun
, var
))
290 fprintf (file
, ", default def: ");
291 print_generic_expr (file
, gimple_default_def (cfun
, var
), dump_flags
);
294 if (DECL_INITIAL (var
))
296 fprintf (file
, ", initial: ");
297 print_generic_expr (file
, DECL_INITIAL (var
), dump_flags
);
300 fprintf (file
, "\n");
304 /* Dump variable VAR and its may-aliases to stderr. */
307 debug_variable (tree var
)
309 dump_variable (stderr
, var
);
313 /* Dump various DFA statistics to FILE. */
316 dump_dfa_stats (FILE *file
)
318 struct dfa_stats_d dfa_stats
;
320 unsigned long size
, total
= 0;
321 const char * const fmt_str
= "%-30s%-13s%12s\n";
322 const char * const fmt_str_1
= "%-30s%13lu%11lu%c\n";
323 const char * const fmt_str_3
= "%-43s%11lu%c\n";
325 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
327 collect_dfa_stats (&dfa_stats
);
329 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
331 fprintf (file
, "---------------------------------------------------------\n");
332 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
333 fprintf (file
, fmt_str
, "", " instances ", "used ");
334 fprintf (file
, "---------------------------------------------------------\n");
336 size
= num_referenced_vars
* sizeof (tree
);
338 fprintf (file
, fmt_str_1
, "Referenced variables", (unsigned long)num_referenced_vars
,
339 SCALE (size
), LABEL (size
));
341 size
= dfa_stats
.num_var_anns
* sizeof (struct var_ann_d
);
343 fprintf (file
, fmt_str_1
, "Variables annotated", dfa_stats
.num_var_anns
,
344 SCALE (size
), LABEL (size
));
346 size
= dfa_stats
.num_uses
* sizeof (tree
*);
348 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
349 SCALE (size
), LABEL (size
));
351 size
= dfa_stats
.num_defs
* sizeof (tree
*);
353 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
354 SCALE (size
), LABEL (size
));
356 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
358 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
359 SCALE (size
), LABEL (size
));
361 size
= dfa_stats
.num_vdefs
* sizeof (tree
*);
363 fprintf (file
, fmt_str_1
, "VDEF operands", dfa_stats
.num_vdefs
,
364 SCALE (size
), LABEL (size
));
366 size
= dfa_stats
.num_phis
* sizeof (struct gimple_statement_phi
);
368 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
369 SCALE (size
), LABEL (size
));
371 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
373 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
374 SCALE (size
), LABEL (size
));
376 fprintf (file
, "---------------------------------------------------------\n");
377 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data", SCALE (total
),
379 fprintf (file
, "---------------------------------------------------------\n");
380 fprintf (file
, "\n");
382 if (dfa_stats
.num_phis
)
383 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
384 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
385 (long) dfa_stats
.max_num_phi_args
);
387 fprintf (file
, "\n");
391 /* Dump DFA statistics on stderr. */
394 debug_dfa_stats (void)
396 dump_dfa_stats (stderr
);
400 /* Collect DFA statistics and store them in the structure pointed to by
404 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p ATTRIBUTE_UNUSED
)
407 referenced_var_iterator vi
;
410 gcc_assert (dfa_stats_p
);
412 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
414 /* Count all the variable annotations. */
415 FOR_EACH_REFERENCED_VAR (var
, vi
)
417 dfa_stats_p
->num_var_anns
++;
419 /* Walk all the statements in the function counting references. */
422 gimple_stmt_iterator si
;
424 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
426 gimple phi
= gsi_stmt (si
);
427 dfa_stats_p
->num_phis
++;
428 dfa_stats_p
->num_phi_args
+= gimple_phi_num_args (phi
);
429 if (gimple_phi_num_args (phi
) > dfa_stats_p
->max_num_phi_args
)
430 dfa_stats_p
->max_num_phi_args
= gimple_phi_num_args (phi
);
433 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
435 gimple stmt
= gsi_stmt (si
);
436 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_DEF
);
437 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_USE
);
438 dfa_stats_p
->num_vdefs
+= gimple_vdef (stmt
) ? 1 : 0;
439 dfa_stats_p
->num_vuses
+= gimple_vuse (stmt
) ? 1 : 0;
445 /*---------------------------------------------------------------------------
446 Miscellaneous helpers
447 ---------------------------------------------------------------------------*/
448 /* Callback for walk_tree. Used to collect variables referenced in
452 find_vars_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
454 /* If we are reading the lto info back in, we need to rescan the
456 if (TREE_CODE (*tp
) == SSA_NAME
)
457 add_referenced_var (SSA_NAME_VAR (*tp
));
459 /* If T is a regular variable that the optimizers are interested
460 in, add it to the list of variables. */
461 else if (SSA_VAR_P (*tp
))
462 add_referenced_var (*tp
);
464 /* Type, _DECL and constant nodes have no interesting children.
466 else if (IS_TYPE_OR_DECL_P (*tp
) || CONSTANT_CLASS_P (*tp
))
472 /* Find referenced variables in STMT. In contrast with
473 find_new_referenced_vars, this function will not mark newly found
474 variables for renaming. */
477 find_referenced_vars_in (gimple stmt
)
481 if (gimple_code (stmt
) != GIMPLE_PHI
)
483 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
484 walk_tree (gimple_op_ptr (stmt
, i
), find_vars_r
, NULL
, NULL
);
488 walk_tree (gimple_phi_result_ptr (stmt
), find_vars_r
, NULL
, NULL
);
490 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
492 tree arg
= gimple_phi_arg_def (stmt
, i
);
493 walk_tree (&arg
, find_vars_r
, NULL
, NULL
);
499 /* Lookup UID in the referenced_vars hashtable and return the associated
503 referenced_var_lookup (unsigned int uid
)
506 struct tree_decl_minimal in
;
508 h
= (tree
) htab_find_with_hash (gimple_referenced_vars (cfun
), &in
, uid
);
509 gcc_assert (h
|| uid
== 0);
513 /* Check if TO is in the referenced_vars hash table and insert it if not.
514 Return true if it required insertion. */
517 referenced_var_check_and_insert (tree to
)
520 struct tree_decl_minimal in
;
521 unsigned int uid
= DECL_UID (to
);
524 h
= (tree
) htab_find_with_hash (gimple_referenced_vars (cfun
), &in
, uid
);
527 /* DECL_UID has already been entered in the table. Verify that it is
528 the same entry as TO. See PR 27793. */
529 gcc_assert (h
== to
);
533 loc
= (tree
*) htab_find_slot_with_hash (gimple_referenced_vars (cfun
),
539 /* Lookup VAR UID in the default_defs hashtable and return the associated
543 gimple_default_def (struct function
*fn
, tree var
)
545 struct tree_decl_minimal ind
;
546 struct tree_ssa_name in
;
547 gcc_assert (SSA_VAR_P (var
));
549 ind
.uid
= DECL_UID (var
);
550 return (tree
) htab_find_with_hash (DEFAULT_DEFS (fn
), &in
, DECL_UID (var
));
553 /* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
556 set_default_def (tree var
, tree def
)
558 struct tree_decl_minimal ind
;
559 struct tree_ssa_name in
;
562 gcc_assert (SSA_VAR_P (var
));
564 ind
.uid
= DECL_UID (var
);
567 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (cfun
), &in
,
568 DECL_UID (var
), INSERT
);
570 htab_remove_elt (DEFAULT_DEFS (cfun
), *loc
);
573 gcc_assert (TREE_CODE (def
) == SSA_NAME
&& SSA_NAME_VAR (def
) == var
);
574 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (cfun
), &in
,
575 DECL_UID (var
), INSERT
);
577 /* Default definition might be changed by tail call optimization. */
579 SSA_NAME_IS_DEFAULT_DEF (*(tree
*) loc
) = false;
582 /* Mark DEF as the default definition for VAR. */
583 SSA_NAME_IS_DEFAULT_DEF (def
) = true;
586 /* Add VAR to the list of referenced variables if it isn't already there. */
589 add_referenced_var (tree var
)
592 gcc_assert (DECL_P (var
));
594 /* Insert VAR into the referenced_vars has table if it isn't present. */
595 if (referenced_var_check_and_insert (var
))
597 /* Scan DECL_INITIAL for pointer variables as they may contain
598 address arithmetic referencing the address of other
599 variables. As we are only interested in directly referenced
600 globals or referenced locals restrict this to initializers
601 than can refer to local variables. */
602 if (DECL_INITIAL (var
)
603 && DECL_CONTEXT (var
) == current_function_decl
)
604 walk_tree (&DECL_INITIAL (var
), find_vars_r
, NULL
, 0);
612 /* Remove VAR from the list. */
615 remove_referenced_var (tree var
)
618 struct tree_decl_minimal in
;
620 unsigned int uid
= DECL_UID (var
);
622 /* Preserve var_anns of globals. */
623 if (!is_global_var (var
)
624 && (v_ann
= var_ann (var
)))
627 *DECL_VAR_ANN_PTR (var
) = NULL
;
629 gcc_assert (DECL_P (var
));
631 loc
= htab_find_slot_with_hash (gimple_referenced_vars (cfun
), &in
, uid
,
633 htab_clear_slot (gimple_referenced_vars (cfun
), loc
);
637 /* Return the virtual variable associated to the non-scalar variable VAR. */
640 get_virtual_var (tree var
)
644 if (TREE_CODE (var
) == SSA_NAME
)
645 var
= SSA_NAME_VAR (var
);
647 while (TREE_CODE (var
) == REALPART_EXPR
|| TREE_CODE (var
) == IMAGPART_EXPR
648 || handled_component_p (var
))
649 var
= TREE_OPERAND (var
, 0);
651 /* Treating GIMPLE registers as virtual variables makes no sense.
652 Also complain if we couldn't extract a _DECL out of the original
654 gcc_assert (SSA_VAR_P (var
));
655 gcc_assert (!is_gimple_reg (var
));
660 /* Mark all the naked symbols in STMT for SSA renaming. */
663 mark_symbols_for_renaming (gimple stmt
)
670 /* Mark all the operands for renaming. */
671 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_OPERANDS
)
673 mark_sym_for_renaming (op
);
677 /* Find all variables within the gimplified statement that were not
678 previously visible to the function and add them to the referenced
682 find_new_referenced_vars_1 (tree
*tp
, int *walk_subtrees
,
683 void *data ATTRIBUTE_UNUSED
)
687 if (TREE_CODE (t
) == VAR_DECL
&& !var_ann (t
))
689 add_referenced_var (t
);
690 mark_sym_for_renaming (t
);
693 if (IS_TYPE_OR_DECL_P (t
))
700 /* Find any new referenced variables in STMT. */
703 find_new_referenced_vars (gimple stmt
)
705 walk_gimple_op (stmt
, find_new_referenced_vars_1
, NULL
);
709 /* If EXP is a handled component reference for a structure, return the
710 base variable. The access range is delimited by bit positions *POFFSET and
711 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
712 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
713 and *PMAX_SIZE are equal, the access is non-variable. */
716 get_ref_base_and_extent (tree exp
, HOST_WIDE_INT
*poffset
,
717 HOST_WIDE_INT
*psize
,
718 HOST_WIDE_INT
*pmax_size
)
720 HOST_WIDE_INT bitsize
= -1;
721 HOST_WIDE_INT maxsize
= -1;
722 tree size_tree
= NULL_TREE
;
723 HOST_WIDE_INT bit_offset
= 0;
724 bool seen_variable_array_ref
= false;
726 /* First get the final access size from just the outermost expression. */
727 if (TREE_CODE (exp
) == COMPONENT_REF
)
728 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
729 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
730 size_tree
= TREE_OPERAND (exp
, 1);
731 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
733 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
735 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
737 bitsize
= GET_MODE_BITSIZE (mode
);
739 if (size_tree
!= NULL_TREE
)
741 if (! host_integerp (size_tree
, 1))
744 bitsize
= TREE_INT_CST_LOW (size_tree
);
747 /* Initially, maxsize is the same as the accessed element size.
748 In the following it will only grow (or become -1). */
751 /* Compute cumulative bit-offset for nested component-refs and array-refs,
752 and find the ultimate containing object. */
755 switch (TREE_CODE (exp
))
758 bit_offset
+= TREE_INT_CST_LOW (TREE_OPERAND (exp
, 2));
763 tree field
= TREE_OPERAND (exp
, 1);
764 tree this_offset
= component_ref_field_offset (exp
);
767 && TREE_CODE (this_offset
) == INTEGER_CST
768 && host_integerp (this_offset
, 0))
770 HOST_WIDE_INT hthis_offset
= TREE_INT_CST_LOW (this_offset
);
771 hthis_offset
*= BITS_PER_UNIT
;
773 += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
));
774 bit_offset
+= hthis_offset
;
776 /* If we had seen a variable array ref already and we just
777 referenced the last field of a struct or a union member
778 then we have to adjust maxsize by the padding at the end
780 if (seen_variable_array_ref
783 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
784 tree next
= TREE_CHAIN (field
);
785 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
786 next
= TREE_CHAIN (next
);
788 || TREE_CODE (stype
) != RECORD_TYPE
)
790 tree fsize
= DECL_SIZE_UNIT (field
);
791 tree ssize
= TYPE_SIZE_UNIT (stype
);
792 if (host_integerp (fsize
, 0)
793 && host_integerp (ssize
, 0))
794 maxsize
+= ((TREE_INT_CST_LOW (ssize
)
795 - TREE_INT_CST_LOW (fsize
))
796 * BITS_PER_UNIT
- hthis_offset
);
804 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
805 /* We need to adjust maxsize to the whole structure bitsize.
806 But we can subtract any constant offset seen so far,
807 because that would get us out of the structure otherwise. */
808 if (maxsize
!= -1 && csize
&& host_integerp (csize
, 1))
809 maxsize
= TREE_INT_CST_LOW (csize
) - bit_offset
;
817 case ARRAY_RANGE_REF
:
819 tree index
= TREE_OPERAND (exp
, 1);
820 tree low_bound
, unit_size
;
822 /* If the resulting bit-offset is constant, track it. */
823 if (TREE_CODE (index
) == INTEGER_CST
824 && host_integerp (index
, 0)
825 && (low_bound
= array_ref_low_bound (exp
),
826 host_integerp (low_bound
, 0))
827 && (unit_size
= array_ref_element_size (exp
),
828 host_integerp (unit_size
, 1)))
830 HOST_WIDE_INT hindex
= TREE_INT_CST_LOW (index
);
832 hindex
-= TREE_INT_CST_LOW (low_bound
);
833 hindex
*= TREE_INT_CST_LOW (unit_size
);
834 hindex
*= BITS_PER_UNIT
;
835 bit_offset
+= hindex
;
837 /* An array ref with a constant index up in the structure
838 hierarchy will constrain the size of any variable array ref
839 lower in the access hierarchy. */
840 seen_variable_array_ref
= false;
844 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
845 /* We need to adjust maxsize to the whole array bitsize.
846 But we can subtract any constant offset seen so far,
847 because that would get us outside of the array otherwise. */
848 if (maxsize
!= -1 && asize
&& host_integerp (asize
, 1))
849 maxsize
= TREE_INT_CST_LOW (asize
) - bit_offset
;
853 /* Remember that we have seen an array ref with a variable
855 seen_variable_array_ref
= true;
864 bit_offset
+= bitsize
;
867 case VIEW_CONVERT_EXPR
:
874 exp
= TREE_OPERAND (exp
, 0);
878 /* We need to deal with variable arrays ending structures such as
879 struct { int length; int a[1]; } x; x.a[d]
880 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
881 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
882 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
883 where we do not know maxsize for variable index accesses to
884 the array. The simplest way to conservatively deal with this
885 is to punt in the case that offset + maxsize reaches the
886 base type boundary. This needs to include possible trailing padding
887 that is there for alignment purposes.
889 That is of course only true if the base object is not a decl. */
893 /* If maxsize is unknown adjust it according to the size of the
896 && host_integerp (DECL_SIZE (exp
), 1))
897 maxsize
= TREE_INT_CST_LOW (DECL_SIZE (exp
)) - bit_offset
;
899 else if (seen_variable_array_ref
901 && (!host_integerp (TYPE_SIZE (TREE_TYPE (exp
)), 1)
902 || (bit_offset
+ maxsize
903 == (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))))))
906 /* ??? Due to negative offsets in ARRAY_REF we can end up with
907 negative bit_offset here. We might want to store a zero offset
909 *poffset
= bit_offset
;
911 *pmax_size
= maxsize
;
916 /* Returns true if STMT references an SSA_NAME that has
917 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
920 stmt_references_abnormal_ssa_name (gimple stmt
)
925 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
927 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))