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"
28 #include "pointer-set.h"
31 #include "basic-block.h"
35 #include "langhooks.h"
38 #include "tree-pretty-print.h"
39 #include "tree-dump.h"
41 #include "tree-flow.h"
42 #include "tree-inline.h"
43 #include "tree-pass.h"
48 /* Build and maintain data flow information for trees. */
50 /* Counters used to display DFA and SSA statistics. */
58 size_t max_num_phi_args
;
64 /* Local functions. */
65 static void collect_dfa_stats (struct dfa_stats_d
*);
66 static tree
find_vars_r (tree
*, int *, void *);
69 /*---------------------------------------------------------------------------
70 Dataflow analysis (DFA) routines
71 ---------------------------------------------------------------------------*/
72 /* Find all the variables referenced in the function. This function
73 builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
75 Note that this function does not look for statement operands, it simply
76 determines what variables are referenced in the program and detects
77 various attributes for each variable used by alias analysis and the
81 find_referenced_vars (void)
84 gimple_stmt_iterator si
;
88 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
90 gimple stmt
= gsi_stmt (si
);
91 if (is_gimple_debug (stmt
))
93 find_referenced_vars_in (gsi_stmt (si
));
96 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
97 find_referenced_vars_in (gsi_stmt (si
));
103 struct gimple_opt_pass pass_referenced_vars
=
107 "*referenced_vars", /* name */
109 find_referenced_vars
, /* execute */
112 0, /* static_pass_number */
113 TV_FIND_REFERENCED_VARS
, /* tv_id */
114 PROP_gimple_leh
| PROP_cfg
, /* properties_required */
115 PROP_referenced_vars
, /* properties_provided */
116 0, /* properties_destroyed */
117 TODO_dump_func
, /* todo_flags_start */
118 TODO_dump_func
/* todo_flags_finish */
123 /*---------------------------------------------------------------------------
125 ---------------------------------------------------------------------------*/
126 /* Create a new annotation for a _DECL node T. */
129 create_var_ann (tree t
)
134 gcc_assert (TREE_CODE (t
) == VAR_DECL
135 || TREE_CODE (t
) == PARM_DECL
136 || TREE_CODE (t
) == RESULT_DECL
);
138 ann
= ggc_alloc_cleared_var_ann_d ();
139 *DECL_VAR_ANN_PTR (t
) = ann
;
144 /* Renumber all of the gimple stmt uids. */
147 renumber_gimple_stmt_uids (void)
151 set_gimple_stmt_max_uid (cfun
, 0);
154 gimple_stmt_iterator bsi
;
155 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
157 gimple stmt
= gsi_stmt (bsi
);
158 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
163 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
164 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
167 renumber_gimple_stmt_uids_in_blocks (basic_block
*blocks
, int n_blocks
)
171 set_gimple_stmt_max_uid (cfun
, 0);
172 for (i
= 0; i
< n_blocks
; i
++)
174 basic_block bb
= blocks
[i
];
175 gimple_stmt_iterator bsi
;
176 for (bsi
= gsi_start_phis (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
178 gimple stmt
= gsi_stmt (bsi
);
179 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
181 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
183 gimple stmt
= gsi_stmt (bsi
);
184 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
189 /* Build a temporary. Make sure and register it to be renamed. */
192 make_rename_temp (tree type
, const char *prefix
)
194 tree t
= create_tmp_reg (type
, prefix
);
196 if (gimple_referenced_vars (cfun
))
198 add_referenced_var (t
);
199 mark_sym_for_renaming (t
);
207 /*---------------------------------------------------------------------------
209 ---------------------------------------------------------------------------*/
210 /* Dump the list of all the referenced variables in the current function to
214 dump_referenced_vars (FILE *file
)
217 referenced_var_iterator rvi
;
219 fprintf (file
, "\nReferenced variables in %s: %u\n\n",
220 get_name (current_function_decl
), (unsigned) num_referenced_vars
);
222 FOR_EACH_REFERENCED_VAR (var
, rvi
)
224 fprintf (file
, "Variable: ");
225 dump_variable (file
, var
);
228 fprintf (file
, "\n");
232 /* Dump the list of all the referenced variables to stderr. */
235 debug_referenced_vars (void)
237 dump_referenced_vars (stderr
);
241 /* Dump variable VAR and its may-aliases to FILE. */
244 dump_variable (FILE *file
, tree var
)
246 if (TREE_CODE (var
) == SSA_NAME
)
248 if (POINTER_TYPE_P (TREE_TYPE (var
)))
249 dump_points_to_info_for (file
, var
);
250 var
= SSA_NAME_VAR (var
);
253 if (var
== NULL_TREE
)
255 fprintf (file
, "<nil>");
259 print_generic_expr (file
, var
, dump_flags
);
261 fprintf (file
, ", UID D.%u", (unsigned) DECL_UID (var
));
262 if (DECL_PT_UID (var
) != DECL_UID (var
))
263 fprintf (file
, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var
));
265 fprintf (file
, ", ");
266 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
268 if (TREE_ADDRESSABLE (var
))
269 fprintf (file
, ", is addressable");
271 if (is_global_var (var
))
272 fprintf (file
, ", is global");
274 if (TREE_THIS_VOLATILE (var
))
275 fprintf (file
, ", is volatile");
277 if (cfun
&& gimple_default_def (cfun
, var
))
279 fprintf (file
, ", default def: ");
280 print_generic_expr (file
, gimple_default_def (cfun
, var
), dump_flags
);
283 if (DECL_INITIAL (var
))
285 fprintf (file
, ", initial: ");
286 print_generic_expr (file
, DECL_INITIAL (var
), dump_flags
);
289 fprintf (file
, "\n");
293 /* Dump variable VAR and its may-aliases to stderr. */
296 debug_variable (tree var
)
298 dump_variable (stderr
, var
);
302 /* Dump various DFA statistics to FILE. */
305 dump_dfa_stats (FILE *file
)
307 struct dfa_stats_d dfa_stats
;
309 unsigned long size
, total
= 0;
310 const char * const fmt_str
= "%-30s%-13s%12s\n";
311 const char * const fmt_str_1
= "%-30s%13lu%11lu%c\n";
312 const char * const fmt_str_3
= "%-43s%11lu%c\n";
314 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
316 collect_dfa_stats (&dfa_stats
);
318 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
320 fprintf (file
, "---------------------------------------------------------\n");
321 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
322 fprintf (file
, fmt_str
, "", " instances ", "used ");
323 fprintf (file
, "---------------------------------------------------------\n");
325 size
= num_referenced_vars
* sizeof (tree
);
327 fprintf (file
, fmt_str_1
, "Referenced variables", (unsigned long)num_referenced_vars
,
328 SCALE (size
), LABEL (size
));
330 size
= dfa_stats
.num_var_anns
* sizeof (struct var_ann_d
);
332 fprintf (file
, fmt_str_1
, "Variables annotated", dfa_stats
.num_var_anns
,
333 SCALE (size
), LABEL (size
));
335 size
= dfa_stats
.num_uses
* sizeof (tree
*);
337 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
338 SCALE (size
), LABEL (size
));
340 size
= dfa_stats
.num_defs
* sizeof (tree
*);
342 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
343 SCALE (size
), LABEL (size
));
345 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
347 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
348 SCALE (size
), LABEL (size
));
350 size
= dfa_stats
.num_vdefs
* sizeof (tree
*);
352 fprintf (file
, fmt_str_1
, "VDEF operands", dfa_stats
.num_vdefs
,
353 SCALE (size
), LABEL (size
));
355 size
= dfa_stats
.num_phis
* sizeof (struct gimple_statement_phi
);
357 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
358 SCALE (size
), LABEL (size
));
360 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
362 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
363 SCALE (size
), LABEL (size
));
365 fprintf (file
, "---------------------------------------------------------\n");
366 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data", SCALE (total
),
368 fprintf (file
, "---------------------------------------------------------\n");
369 fprintf (file
, "\n");
371 if (dfa_stats
.num_phis
)
372 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
373 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
374 (long) dfa_stats
.max_num_phi_args
);
376 fprintf (file
, "\n");
380 /* Dump DFA statistics on stderr. */
383 debug_dfa_stats (void)
385 dump_dfa_stats (stderr
);
389 /* Collect DFA statistics and store them in the structure pointed to by
393 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p ATTRIBUTE_UNUSED
)
396 referenced_var_iterator vi
;
399 gcc_assert (dfa_stats_p
);
401 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
403 /* Count all the variable annotations. */
404 FOR_EACH_REFERENCED_VAR (var
, vi
)
406 dfa_stats_p
->num_var_anns
++;
408 /* Walk all the statements in the function counting references. */
411 gimple_stmt_iterator si
;
413 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
415 gimple phi
= gsi_stmt (si
);
416 dfa_stats_p
->num_phis
++;
417 dfa_stats_p
->num_phi_args
+= gimple_phi_num_args (phi
);
418 if (gimple_phi_num_args (phi
) > dfa_stats_p
->max_num_phi_args
)
419 dfa_stats_p
->max_num_phi_args
= gimple_phi_num_args (phi
);
422 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
424 gimple stmt
= gsi_stmt (si
);
425 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_DEF
);
426 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (stmt
, SSA_OP_USE
);
427 dfa_stats_p
->num_vdefs
+= gimple_vdef (stmt
) ? 1 : 0;
428 dfa_stats_p
->num_vuses
+= gimple_vuse (stmt
) ? 1 : 0;
434 /*---------------------------------------------------------------------------
435 Miscellaneous helpers
436 ---------------------------------------------------------------------------*/
437 /* Callback for walk_tree. Used to collect variables referenced in
441 find_vars_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
443 /* If we are reading the lto info back in, we need to rescan the
445 if (TREE_CODE (*tp
) == SSA_NAME
)
446 add_referenced_var (SSA_NAME_VAR (*tp
));
448 /* If T is a regular variable that the optimizers are interested
449 in, add it to the list of variables. */
450 else if (SSA_VAR_P (*tp
))
451 add_referenced_var (*tp
);
453 /* Type, _DECL and constant nodes have no interesting children.
455 else if (IS_TYPE_OR_DECL_P (*tp
) || CONSTANT_CLASS_P (*tp
))
461 /* Find referenced variables in STMT. In contrast with
462 find_new_referenced_vars, this function will not mark newly found
463 variables for renaming. */
466 find_referenced_vars_in (gimple stmt
)
470 if (gimple_code (stmt
) != GIMPLE_PHI
)
472 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
473 walk_tree (gimple_op_ptr (stmt
, i
), find_vars_r
, NULL
, NULL
);
477 walk_tree (gimple_phi_result_ptr (stmt
), find_vars_r
, NULL
, NULL
);
479 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
481 tree arg
= gimple_phi_arg_def (stmt
, i
);
482 walk_tree (&arg
, find_vars_r
, NULL
, NULL
);
488 /* Lookup UID in the referenced_vars hashtable and return the associated
492 referenced_var_lookup (unsigned int uid
)
495 struct tree_decl_minimal in
;
497 h
= (tree
) htab_find_with_hash (gimple_referenced_vars (cfun
), &in
, uid
);
498 gcc_assert (h
|| uid
== 0);
502 /* Check if TO is in the referenced_vars hash table and insert it if not.
503 Return true if it required insertion. */
506 referenced_var_check_and_insert (tree to
)
509 struct tree_decl_minimal in
;
510 unsigned int uid
= DECL_UID (to
);
513 h
= (tree
) htab_find_with_hash (gimple_referenced_vars (cfun
), &in
, uid
);
516 /* DECL_UID has already been entered in the table. Verify that it is
517 the same entry as TO. See PR 27793. */
518 gcc_assert (h
== to
);
522 loc
= (tree
*) htab_find_slot_with_hash (gimple_referenced_vars (cfun
),
528 /* Lookup VAR UID in the default_defs hashtable and return the associated
532 gimple_default_def (struct function
*fn
, tree var
)
534 struct tree_decl_minimal ind
;
535 struct tree_ssa_name in
;
536 gcc_assert (SSA_VAR_P (var
));
538 ind
.uid
= DECL_UID (var
);
539 return (tree
) htab_find_with_hash (DEFAULT_DEFS (fn
), &in
, DECL_UID (var
));
542 /* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
545 set_default_def (tree var
, tree def
)
547 struct tree_decl_minimal ind
;
548 struct tree_ssa_name in
;
551 gcc_assert (SSA_VAR_P (var
));
553 ind
.uid
= DECL_UID (var
);
556 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (cfun
), &in
,
557 DECL_UID (var
), INSERT
);
559 htab_remove_elt (DEFAULT_DEFS (cfun
), *loc
);
562 gcc_assert (TREE_CODE (def
) == SSA_NAME
&& SSA_NAME_VAR (def
) == var
);
563 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (cfun
), &in
,
564 DECL_UID (var
), INSERT
);
566 /* Default definition might be changed by tail call optimization. */
568 SSA_NAME_IS_DEFAULT_DEF (*(tree
*) loc
) = false;
571 /* Mark DEF as the default definition for VAR. */
572 SSA_NAME_IS_DEFAULT_DEF (def
) = true;
575 /* Add VAR to the list of referenced variables if it isn't already there. */
578 add_referenced_var (tree var
)
581 gcc_assert (DECL_P (var
));
583 /* Insert VAR into the referenced_vars has table if it isn't present. */
584 if (referenced_var_check_and_insert (var
))
586 /* Scan DECL_INITIAL for pointer variables as they may contain
587 address arithmetic referencing the address of other
588 variables. As we are only interested in directly referenced
589 globals or referenced locals restrict this to initializers
590 than can refer to local variables. */
591 if (DECL_INITIAL (var
)
592 && DECL_CONTEXT (var
) == current_function_decl
)
593 walk_tree (&DECL_INITIAL (var
), find_vars_r
, NULL
, 0);
601 /* Remove VAR from the list. */
604 remove_referenced_var (tree var
)
607 struct tree_decl_minimal in
;
609 unsigned int uid
= DECL_UID (var
);
611 /* Preserve var_anns of globals. */
612 if (!is_global_var (var
)
613 && (v_ann
= var_ann (var
)))
616 *DECL_VAR_ANN_PTR (var
) = NULL
;
618 gcc_assert (DECL_P (var
));
620 loc
= htab_find_slot_with_hash (gimple_referenced_vars (cfun
), &in
, uid
,
622 htab_clear_slot (gimple_referenced_vars (cfun
), loc
);
626 /* Return the virtual variable associated to the non-scalar variable VAR. */
629 get_virtual_var (tree var
)
633 if (TREE_CODE (var
) == SSA_NAME
)
634 var
= SSA_NAME_VAR (var
);
636 while (TREE_CODE (var
) == REALPART_EXPR
|| TREE_CODE (var
) == IMAGPART_EXPR
637 || handled_component_p (var
))
638 var
= TREE_OPERAND (var
, 0);
640 /* Treating GIMPLE registers as virtual variables makes no sense.
641 Also complain if we couldn't extract a _DECL out of the original
643 gcc_assert (SSA_VAR_P (var
));
644 gcc_assert (!is_gimple_reg (var
));
649 /* Mark all the naked symbols in STMT for SSA renaming. */
652 mark_symbols_for_renaming (gimple stmt
)
659 /* Mark all the operands for renaming. */
660 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_OPERANDS
)
662 mark_sym_for_renaming (op
);
666 /* Find all variables within the gimplified statement that were not
667 previously visible to the function and add them to the referenced
671 find_new_referenced_vars_1 (tree
*tp
, int *walk_subtrees
,
672 void *data ATTRIBUTE_UNUSED
)
676 if (TREE_CODE (t
) == VAR_DECL
&& !var_ann (t
))
678 add_referenced_var (t
);
679 mark_sym_for_renaming (t
);
682 if (IS_TYPE_OR_DECL_P (t
))
689 /* Find any new referenced variables in STMT. */
692 find_new_referenced_vars (gimple stmt
)
694 walk_gimple_op (stmt
, find_new_referenced_vars_1
, NULL
);
698 /* If EXP is a handled component reference for a structure, return the
699 base variable. The access range is delimited by bit positions *POFFSET and
700 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
701 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
702 and *PMAX_SIZE are equal, the access is non-variable. */
705 get_ref_base_and_extent (tree exp
, HOST_WIDE_INT
*poffset
,
706 HOST_WIDE_INT
*psize
,
707 HOST_WIDE_INT
*pmax_size
)
709 HOST_WIDE_INT bitsize
= -1;
710 HOST_WIDE_INT maxsize
= -1;
711 tree size_tree
= NULL_TREE
;
712 HOST_WIDE_INT bit_offset
= 0;
713 bool seen_variable_array_ref
= false;
715 /* First get the final access size from just the outermost expression. */
716 if (TREE_CODE (exp
) == COMPONENT_REF
)
717 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
718 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
719 size_tree
= TREE_OPERAND (exp
, 1);
720 else if (!VOID_TYPE_P (TREE_TYPE (exp
)))
722 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
724 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
726 bitsize
= GET_MODE_BITSIZE (mode
);
728 if (size_tree
!= NULL_TREE
)
730 if (! host_integerp (size_tree
, 1))
733 bitsize
= TREE_INT_CST_LOW (size_tree
);
736 /* Initially, maxsize is the same as the accessed element size.
737 In the following it will only grow (or become -1). */
740 /* Compute cumulative bit-offset for nested component-refs and array-refs,
741 and find the ultimate containing object. */
744 switch (TREE_CODE (exp
))
747 bit_offset
+= TREE_INT_CST_LOW (TREE_OPERAND (exp
, 2));
752 tree field
= TREE_OPERAND (exp
, 1);
753 tree this_offset
= component_ref_field_offset (exp
);
756 && TREE_CODE (this_offset
) == INTEGER_CST
757 && host_integerp (this_offset
, 0))
759 HOST_WIDE_INT hthis_offset
= TREE_INT_CST_LOW (this_offset
);
760 hthis_offset
*= BITS_PER_UNIT
;
762 += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
));
763 bit_offset
+= hthis_offset
;
765 /* If we had seen a variable array ref already and we just
766 referenced the last field of a struct or a union member
767 then we have to adjust maxsize by the padding at the end
769 if (seen_variable_array_ref
772 tree stype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
773 tree next
= TREE_CHAIN (field
);
774 while (next
&& TREE_CODE (next
) != FIELD_DECL
)
775 next
= TREE_CHAIN (next
);
777 || TREE_CODE (stype
) != RECORD_TYPE
)
779 tree fsize
= DECL_SIZE_UNIT (field
);
780 tree ssize
= TYPE_SIZE_UNIT (stype
);
781 if (host_integerp (fsize
, 0)
782 && host_integerp (ssize
, 0))
783 maxsize
+= ((TREE_INT_CST_LOW (ssize
)
784 - TREE_INT_CST_LOW (fsize
))
785 * BITS_PER_UNIT
- hthis_offset
);
793 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
794 /* We need to adjust maxsize to the whole structure bitsize.
795 But we can subtract any constant offset seen so far,
796 because that would get us out of the structure otherwise. */
797 if (maxsize
!= -1 && csize
&& host_integerp (csize
, 1))
798 maxsize
= TREE_INT_CST_LOW (csize
) - bit_offset
;
806 case ARRAY_RANGE_REF
:
808 tree index
= TREE_OPERAND (exp
, 1);
809 tree low_bound
, unit_size
;
811 /* If the resulting bit-offset is constant, track it. */
812 if (TREE_CODE (index
) == INTEGER_CST
813 && host_integerp (index
, 0)
814 && (low_bound
= array_ref_low_bound (exp
),
815 host_integerp (low_bound
, 0))
816 && (unit_size
= array_ref_element_size (exp
),
817 host_integerp (unit_size
, 1)))
819 HOST_WIDE_INT hindex
= TREE_INT_CST_LOW (index
);
821 hindex
-= TREE_INT_CST_LOW (low_bound
);
822 hindex
*= TREE_INT_CST_LOW (unit_size
);
823 hindex
*= BITS_PER_UNIT
;
824 bit_offset
+= hindex
;
826 /* An array ref with a constant index up in the structure
827 hierarchy will constrain the size of any variable array ref
828 lower in the access hierarchy. */
829 seen_variable_array_ref
= false;
833 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
834 /* We need to adjust maxsize to the whole array bitsize.
835 But we can subtract any constant offset seen so far,
836 because that would get us outside of the array otherwise. */
837 if (maxsize
!= -1 && asize
&& host_integerp (asize
, 1))
838 maxsize
= TREE_INT_CST_LOW (asize
) - bit_offset
;
842 /* Remember that we have seen an array ref with a variable
844 seen_variable_array_ref
= true;
853 bit_offset
+= bitsize
;
856 case VIEW_CONVERT_EXPR
:
860 /* Hand back the decl for MEM[&decl, off]. */
861 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
863 if (integer_zerop (TREE_OPERAND (exp
, 1)))
864 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
867 double_int off
= mem_ref_offset (exp
);
868 off
= double_int_lshift (off
,
870 ? 3 : exact_log2 (BITS_PER_UNIT
),
871 HOST_BITS_PER_DOUBLE_INT
, true);
872 off
= double_int_add (off
, shwi_to_double_int (bit_offset
));
873 if (double_int_fits_in_shwi_p (off
))
875 bit_offset
= double_int_to_shwi (off
);
876 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
886 exp
= TREE_OPERAND (exp
, 0);
890 /* We need to deal with variable arrays ending structures such as
891 struct { int length; int a[1]; } x; x.a[d]
892 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
893 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
894 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
895 where we do not know maxsize for variable index accesses to
896 the array. The simplest way to conservatively deal with this
897 is to punt in the case that offset + maxsize reaches the
898 base type boundary. This needs to include possible trailing padding
899 that is there for alignment purposes.
901 That is of course only true if the base object is not a decl. */
905 /* If maxsize is unknown adjust it according to the size of the
908 && host_integerp (DECL_SIZE (exp
), 1))
909 maxsize
= TREE_INT_CST_LOW (DECL_SIZE (exp
)) - bit_offset
;
911 else if (seen_variable_array_ref
913 && (!host_integerp (TYPE_SIZE (TREE_TYPE (exp
)), 1)
914 || (bit_offset
+ maxsize
915 == (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))))))
918 /* ??? Due to negative offsets in ARRAY_REF we can end up with
919 negative bit_offset here. We might want to store a zero offset
921 *poffset
= bit_offset
;
923 *pmax_size
= maxsize
;
928 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
929 denotes the starting address of the memory access EXP.
930 Returns NULL_TREE if the offset is not constant or any component
931 is not BITS_PER_UNIT-aligned. */
934 get_addr_base_and_unit_offset (tree exp
, HOST_WIDE_INT
*poffset
)
936 HOST_WIDE_INT byte_offset
= 0;
938 /* Compute cumulative byte-offset for nested component-refs and array-refs,
939 and find the ultimate containing object. */
942 switch (TREE_CODE (exp
))
949 tree field
= TREE_OPERAND (exp
, 1);
950 tree this_offset
= component_ref_field_offset (exp
);
951 HOST_WIDE_INT hthis_offset
;
954 || TREE_CODE (this_offset
) != INTEGER_CST
955 || (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
959 hthis_offset
= TREE_INT_CST_LOW (this_offset
);
960 hthis_offset
+= (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field
))
962 byte_offset
+= hthis_offset
;
967 case ARRAY_RANGE_REF
:
969 tree index
= TREE_OPERAND (exp
, 1);
970 tree low_bound
, unit_size
;
972 /* If the resulting bit-offset is constant, track it. */
973 if (TREE_CODE (index
) == INTEGER_CST
974 && (low_bound
= array_ref_low_bound (exp
),
975 TREE_CODE (low_bound
) == INTEGER_CST
)
976 && (unit_size
= array_ref_element_size (exp
),
977 TREE_CODE (unit_size
) == INTEGER_CST
))
979 HOST_WIDE_INT hindex
= TREE_INT_CST_LOW (index
);
981 hindex
-= TREE_INT_CST_LOW (low_bound
);
982 hindex
*= TREE_INT_CST_LOW (unit_size
);
983 byte_offset
+= hindex
;
994 byte_offset
+= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (exp
)));
997 case VIEW_CONVERT_EXPR
:
1001 /* Hand back the decl for MEM[&decl, off]. */
1002 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
)
1004 if (!integer_zerop (TREE_OPERAND (exp
, 1)))
1006 double_int off
= mem_ref_offset (exp
);
1007 gcc_assert (off
.high
== -1 || off
.high
== 0);
1008 byte_offset
+= double_int_to_shwi (off
);
1010 exp
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
1018 exp
= TREE_OPERAND (exp
, 0);
1022 *poffset
= byte_offset
;
1026 /* Returns true if STMT references an SSA_NAME that has
1027 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
1030 stmt_references_abnormal_ssa_name (gimple stmt
)
1033 use_operand_p use_p
;
1035 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, oi
, SSA_OP_USE
)
1037 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p
)))