1 /* Data flow functions for trees.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005 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 2, 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 COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
27 #include "pointer-set.h"
31 #include "hard-reg-set.h"
32 #include "basic-block.h"
37 #include "langhooks.h"
40 #include "diagnostic.h"
41 #include "tree-dump.h"
42 #include "tree-gimple.h"
43 #include "tree-flow.h"
44 #include "tree-inline.h"
45 #include "tree-pass.h"
50 /* Build and maintain data flow information for trees. */
52 /* Counters used to display DFA and SSA statistics. */
68 /* Local functions. */
69 static void collect_dfa_stats (struct dfa_stats_d
*);
70 static tree
collect_dfa_stats_r (tree
*, int *, void *);
71 static tree
find_vars_r (tree
*, int *, void *);
74 /*---------------------------------------------------------------------------
75 Dataflow analysis (DFA) routines
76 ---------------------------------------------------------------------------*/
77 /* Find all the variables referenced in the function. This function
78 builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
80 Note that this function does not look for statement operands, it simply
81 determines what variables are referenced in the program and detects
82 various attributes for each variable used by alias analysis and the
86 find_referenced_vars (void)
89 block_stmt_iterator si
;
92 for (si
= bsi_start (bb
); !bsi_end_p (si
); bsi_next (&si
))
94 tree
*stmt_p
= bsi_stmt_ptr (si
);
95 walk_tree (stmt_p
, find_vars_r
, NULL
, NULL
);
101 struct tree_opt_pass pass_referenced_vars
=
105 find_referenced_vars
, /* execute */
108 0, /* static_pass_number */
109 TV_FIND_REFERENCED_VARS
, /* tv_id */
110 PROP_gimple_leh
| PROP_cfg
, /* properties_required */
111 PROP_referenced_vars
, /* properties_provided */
112 0, /* properties_destroyed */
113 0, /* todo_flags_start */
114 0, /* todo_flags_finish */
119 /*---------------------------------------------------------------------------
121 ---------------------------------------------------------------------------*/
122 /* Create a new annotation for a _DECL node T. */
125 create_var_ann (tree t
)
130 gcc_assert (DECL_P (t
));
131 gcc_assert (!t
->base
.ann
|| t
->base
.ann
->common
.type
== VAR_ANN
);
133 ann
= GGC_CNEW (struct var_ann_d
);
135 ann
->common
.type
= VAR_ANN
;
137 t
->base
.ann
= (tree_ann_t
) ann
;
142 /* Create a new annotation for a FUNCTION_DECL node T. */
145 create_function_ann (tree t
)
150 gcc_assert (TREE_CODE (t
) == FUNCTION_DECL
);
151 gcc_assert (!t
->base
.ann
|| t
->base
.ann
->common
.type
== FUNCTION_ANN
);
153 ann
= ggc_alloc (sizeof (*ann
));
154 memset ((void *) ann
, 0, sizeof (*ann
));
156 ann
->common
.type
= FUNCTION_ANN
;
158 t
->base
.ann
= (tree_ann_t
) ann
;
163 /* Create a new annotation for a statement node T. */
166 create_stmt_ann (tree t
)
170 gcc_assert (is_gimple_stmt (t
));
171 gcc_assert (!t
->base
.ann
|| t
->base
.ann
->common
.type
== STMT_ANN
);
173 ann
= GGC_CNEW (struct stmt_ann_d
);
175 ann
->common
.type
= STMT_ANN
;
177 /* Since we just created the annotation, mark the statement modified. */
178 ann
->modified
= true;
180 t
->base
.ann
= (tree_ann_t
) ann
;
185 /* Create a new annotation for a tree T. */
188 create_tree_common_ann (tree t
)
190 tree_ann_common_t ann
;
193 gcc_assert (!t
->base
.ann
|| t
->base
.ann
->common
.type
== TREE_ANN_COMMON
);
195 ann
= GGC_CNEW (struct tree_ann_common_d
);
197 ann
->type
= TREE_ANN_COMMON
;
198 t
->base
.ann
= (tree_ann_t
) ann
;
203 /* Build a temporary. Make sure and register it to be renamed. */
206 make_rename_temp (tree type
, const char *prefix
)
208 tree t
= create_tmp_var (type
, prefix
);
210 if (TREE_CODE (type
) == COMPLEX_TYPE
)
211 DECL_COMPLEX_GIMPLE_REG_P (t
) = 1;
213 if (gimple_referenced_vars (cfun
))
215 add_referenced_var (t
);
216 mark_sym_for_renaming (t
);
224 /*---------------------------------------------------------------------------
226 ---------------------------------------------------------------------------*/
227 /* Dump the list of all the referenced variables in the current function to
231 dump_referenced_vars (FILE *file
)
234 referenced_var_iterator rvi
;
236 fprintf (file
, "\nReferenced variables in %s: %u\n\n",
237 get_name (current_function_decl
), (unsigned) num_referenced_vars
);
239 FOR_EACH_REFERENCED_VAR (var
, rvi
)
241 fprintf (file
, "Variable: ");
242 dump_variable (file
, var
);
243 fprintf (file
, "\n");
248 /* Dump the list of all the referenced variables to stderr. */
251 debug_referenced_vars (void)
253 dump_referenced_vars (stderr
);
257 /* Dump sub-variables for VAR to FILE. */
260 dump_subvars_for (FILE *file
, tree var
)
262 subvar_t sv
= get_subvars_for_var (var
);
267 fprintf (file
, "{ ");
269 for (; sv
; sv
= sv
->next
)
271 print_generic_expr (file
, sv
->var
, dump_flags
);
279 /* Dumb sub-variables for VAR to stderr. */
282 debug_subvars_for (tree var
)
284 dump_subvars_for (stderr
, var
);
288 /* Dump variable VAR and its may-aliases to FILE. */
291 dump_variable (FILE *file
, tree var
)
295 if (TREE_CODE (var
) == SSA_NAME
)
297 if (POINTER_TYPE_P (TREE_TYPE (var
)))
298 dump_points_to_info_for (file
, var
);
299 var
= SSA_NAME_VAR (var
);
302 if (var
== NULL_TREE
)
304 fprintf (file
, "<nil>");
308 print_generic_expr (file
, var
, dump_flags
);
312 fprintf (file
, ", UID %u", (unsigned) DECL_UID (var
));
314 fprintf (file
, ", ");
315 print_generic_expr (file
, TREE_TYPE (var
), dump_flags
);
317 if (ann
&& ann
->symbol_mem_tag
)
319 fprintf (file
, ", symbol memory tag: ");
320 print_generic_expr (file
, ann
->symbol_mem_tag
, dump_flags
);
323 if (ann
&& ann
->is_aliased
)
324 fprintf (file
, ", is aliased");
326 if (TREE_ADDRESSABLE (var
))
327 fprintf (file
, ", is addressable");
329 if (is_global_var (var
))
330 fprintf (file
, ", is global");
332 if (TREE_THIS_VOLATILE (var
))
333 fprintf (file
, ", is volatile");
335 if (is_call_clobbered (var
))
337 fprintf (file
, ", call clobbered");
338 if (dump_flags
& TDF_DETAILS
)
340 var_ann_t va
= var_ann (var
);
341 unsigned int escape_mask
= va
->escape_mask
;
343 fprintf (file
, " (");
344 if (escape_mask
& ESCAPE_STORED_IN_GLOBAL
)
345 fprintf (file
, ", stored in global");
346 if (escape_mask
& ESCAPE_TO_ASM
)
347 fprintf (file
, ", goes through ASM");
348 if (escape_mask
& ESCAPE_TO_CALL
)
349 fprintf (file
, ", passed to call");
350 if (escape_mask
& ESCAPE_BAD_CAST
)
351 fprintf (file
, ", bad cast");
352 if (escape_mask
& ESCAPE_TO_RETURN
)
353 fprintf (file
, ", returned from func");
354 if (escape_mask
& ESCAPE_TO_PURE_CONST
)
355 fprintf (file
, ", passed to pure/const");
356 if (escape_mask
& ESCAPE_IS_GLOBAL
)
357 fprintf (file
, ", is global var");
358 if (escape_mask
& ESCAPE_IS_PARM
)
359 fprintf (file
, ", is incoming pointer");
360 if (escape_mask
& ESCAPE_UNKNOWN
)
361 fprintf (file
, ", unknown escape");
362 fprintf (file
, " )");
366 if (gimple_default_def (cfun
, var
))
368 fprintf (file
, ", default def: ");
369 print_generic_expr (file
, gimple_default_def (cfun
, var
), dump_flags
);
372 if (may_aliases (var
))
374 fprintf (file
, ", may aliases: ");
375 dump_may_aliases_for (file
, var
);
378 if (get_subvars_for_var (var
))
380 fprintf (file
, ", sub-vars: ");
381 dump_subvars_for (file
, var
);
384 fprintf (file
, "\n");
388 /* Dump variable VAR and its may-aliases to stderr. */
391 debug_variable (tree var
)
393 dump_variable (stderr
, var
);
397 /* Dump various DFA statistics to FILE. */
400 dump_dfa_stats (FILE *file
)
402 struct dfa_stats_d dfa_stats
;
404 unsigned long size
, total
= 0;
405 const char * const fmt_str
= "%-30s%-13s%12s\n";
406 const char * const fmt_str_1
= "%-30s%13lu%11lu%c\n";
407 const char * const fmt_str_3
= "%-43s%11lu%c\n";
409 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
411 collect_dfa_stats (&dfa_stats
);
413 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
415 fprintf (file
, "---------------------------------------------------------\n");
416 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
417 fprintf (file
, fmt_str
, "", " instances ", "used ");
418 fprintf (file
, "---------------------------------------------------------\n");
420 size
= num_referenced_vars
* sizeof (tree
);
422 fprintf (file
, fmt_str_1
, "Referenced variables", (unsigned long)num_referenced_vars
,
423 SCALE (size
), LABEL (size
));
425 size
= dfa_stats
.num_stmt_anns
* sizeof (struct stmt_ann_d
);
427 fprintf (file
, fmt_str_1
, "Statements annotated", dfa_stats
.num_stmt_anns
,
428 SCALE (size
), LABEL (size
));
430 size
= dfa_stats
.num_var_anns
* sizeof (struct var_ann_d
);
432 fprintf (file
, fmt_str_1
, "Variables annotated", dfa_stats
.num_var_anns
,
433 SCALE (size
), LABEL (size
));
435 size
= dfa_stats
.num_uses
* sizeof (tree
*);
437 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
438 SCALE (size
), LABEL (size
));
440 size
= dfa_stats
.num_defs
* sizeof (tree
*);
442 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
443 SCALE (size
), LABEL (size
));
445 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
447 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
448 SCALE (size
), LABEL (size
));
450 size
= dfa_stats
.num_v_may_defs
* sizeof (tree
*);
452 fprintf (file
, fmt_str_1
, "V_MAY_DEF operands", dfa_stats
.num_v_may_defs
,
453 SCALE (size
), LABEL (size
));
455 size
= dfa_stats
.num_v_must_defs
* sizeof (tree
*);
457 fprintf (file
, fmt_str_1
, "V_MUST_DEF operands", dfa_stats
.num_v_must_defs
,
458 SCALE (size
), LABEL (size
));
460 size
= dfa_stats
.num_phis
* sizeof (struct tree_phi_node
);
462 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
463 SCALE (size
), LABEL (size
));
465 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
467 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
468 SCALE (size
), LABEL (size
));
470 fprintf (file
, "---------------------------------------------------------\n");
471 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data", SCALE (total
),
473 fprintf (file
, "---------------------------------------------------------\n");
474 fprintf (file
, "\n");
476 if (dfa_stats
.num_phis
)
477 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %d)\n",
478 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
479 dfa_stats
.max_num_phi_args
);
481 fprintf (file
, "\n");
485 /* Dump DFA statistics on stderr. */
488 debug_dfa_stats (void)
490 dump_dfa_stats (stderr
);
494 /* Collect DFA statistics and store them in the structure pointed to by
498 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p
)
500 struct pointer_set_t
*pset
;
502 block_stmt_iterator i
;
504 gcc_assert (dfa_stats_p
);
506 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
508 /* Walk all the trees in the function counting references. Start at
509 basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries. */
510 pset
= pointer_set_create ();
512 for (i
= bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS
));
513 !bsi_end_p (i
); bsi_next (&i
))
514 walk_tree (bsi_stmt_ptr (i
), collect_dfa_stats_r
, (void *) dfa_stats_p
,
517 pointer_set_destroy (pset
);
522 for (phi
= phi_nodes (bb
); phi
; phi
= PHI_CHAIN (phi
))
524 dfa_stats_p
->num_phis
++;
525 dfa_stats_p
->num_phi_args
+= PHI_NUM_ARGS (phi
);
526 if (PHI_NUM_ARGS (phi
) > dfa_stats_p
->max_num_phi_args
)
527 dfa_stats_p
->max_num_phi_args
= PHI_NUM_ARGS (phi
);
533 /* Callback for walk_tree to collect DFA statistics for a tree and its
537 collect_dfa_stats_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
541 struct dfa_stats_d
*dfa_stats_p
= (struct dfa_stats_d
*)data
;
545 switch (ann_type (t
->base
.ann
))
549 dfa_stats_p
->num_stmt_anns
++;
550 dfa_stats_p
->num_defs
+= NUM_SSA_OPERANDS (t
, SSA_OP_DEF
);
551 dfa_stats_p
->num_uses
+= NUM_SSA_OPERANDS (t
, SSA_OP_USE
);
552 dfa_stats_p
->num_v_may_defs
+= NUM_SSA_OPERANDS (t
, SSA_OP_VMAYDEF
);
553 dfa_stats_p
->num_vuses
+= NUM_SSA_OPERANDS (t
, SSA_OP_VUSE
);
554 dfa_stats_p
->num_v_must_defs
+=
555 NUM_SSA_OPERANDS (t
, SSA_OP_VMUSTDEF
);
560 dfa_stats_p
->num_var_anns
++;
572 /*---------------------------------------------------------------------------
573 Miscellaneous helpers
574 ---------------------------------------------------------------------------*/
575 /* Callback for walk_tree. Used to collect variables referenced in
579 find_vars_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
581 /* If T is a regular variable that the optimizers are interested
582 in, add it to the list of variables. */
584 add_referenced_var (*tp
);
586 /* Type, _DECL and constant nodes have no interesting children.
588 else if (IS_TYPE_OR_DECL_P (*tp
) || CONSTANT_CLASS_P (*tp
))
594 /* Lookup UID in the referenced_vars hashtable and return the associated
598 referenced_var_lookup (unsigned int uid
)
600 struct int_tree_map
*h
, in
;
602 h
= (struct int_tree_map
*) htab_find_with_hash (gimple_referenced_vars (cfun
),
604 gcc_assert (h
|| uid
== 0);
610 /* Check if TO is in the referenced_vars hash table and insert it if not.
611 Return true if it required insertion. */
614 referenced_var_check_and_insert (tree to
)
616 struct int_tree_map
*h
, in
;
618 unsigned int uid
= DECL_UID (to
);
622 h
= (struct int_tree_map
*) htab_find_with_hash (gimple_referenced_vars (cfun
),
627 /* DECL_UID has already been entered in the table. Verify that it is
628 the same entry as TO. See PR 27793. */
629 gcc_assert (h
->to
== to
);
633 h
= GGC_NEW (struct int_tree_map
);
636 loc
= htab_find_slot_with_hash (gimple_referenced_vars (cfun
),
638 *(struct int_tree_map
**) loc
= h
;
642 /* Lookup VAR UID in the default_defs hashtable and return the associated
646 gimple_default_def (struct function
*fn
, tree var
)
648 struct int_tree_map
*h
, in
;
649 gcc_assert (SSA_VAR_P (var
));
650 in
.uid
= DECL_UID (var
);
651 h
= (struct int_tree_map
*) htab_find_with_hash (DEFAULT_DEFS (fn
),
659 /* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
662 set_default_def (tree var
, tree def
)
664 struct int_tree_map in
;
665 struct int_tree_map
*h
;
668 gcc_assert (SSA_VAR_P (var
));
669 in
.uid
= DECL_UID (var
);
670 if (!def
&& gimple_default_def (cfun
, var
))
672 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (cfun
), &in
,
673 DECL_UID (var
), INSERT
);
674 htab_remove_elt (DEFAULT_DEFS (cfun
), *loc
);
677 gcc_assert (TREE_CODE (def
) == SSA_NAME
);
678 loc
= htab_find_slot_with_hash (DEFAULT_DEFS (cfun
), &in
,
679 DECL_UID (var
), INSERT
);
680 /* Default definition might be changed by tail call optimization. */
683 h
= GGC_NEW (struct int_tree_map
);
684 h
->uid
= DECL_UID (var
);
686 *(struct int_tree_map
**) loc
= h
;
690 h
= (struct int_tree_map
*) *loc
;
695 /* Add VAR to the list of referenced variables if it isn't already there. */
698 add_referenced_var (tree var
)
702 v_ann
= get_var_ann (var
);
703 gcc_assert (DECL_P (var
));
705 /* Insert VAR into the referenced_vars has table if it isn't present. */
706 if (referenced_var_check_and_insert (var
))
708 /* This is the first time we found this variable, annotate it with
709 attributes that are intrinsic to the variable. */
711 /* Tag's don't have DECL_INITIAL. */
715 /* Scan DECL_INITIAL for pointer variables as they may contain
716 address arithmetic referencing the address of other
718 if (DECL_INITIAL (var
)
719 /* Initializers of external variables are not useful to the
721 && !DECL_EXTERNAL (var
)
722 /* It's not necessary to walk the initial value of non-constant
723 variables because it cannot be propagated by the
725 && (TREE_CONSTANT (var
) || TREE_READONLY (var
)))
726 walk_tree (&DECL_INITIAL (var
), find_vars_r
, NULL
, 0);
731 /* Return the virtual variable associated to the non-scalar variable VAR. */
734 get_virtual_var (tree var
)
738 if (TREE_CODE (var
) == SSA_NAME
)
739 var
= SSA_NAME_VAR (var
);
741 while (TREE_CODE (var
) == REALPART_EXPR
|| TREE_CODE (var
) == IMAGPART_EXPR
742 || handled_component_p (var
))
743 var
= TREE_OPERAND (var
, 0);
745 /* Treating GIMPLE registers as virtual variables makes no sense.
746 Also complain if we couldn't extract a _DECL out of the original
748 gcc_assert (SSA_VAR_P (var
));
749 gcc_assert (!is_gimple_reg (var
));
754 /* Mark all the non-SSA variables found in STMT's operands to be
755 processed by update_ssa. */
758 mark_new_vars_to_rename (tree stmt
)
762 bitmap vars_in_vops_to_rename
;
763 bool found_exposed_symbol
= false;
764 int v_may_defs_before
, v_may_defs_after
;
765 int v_must_defs_before
, v_must_defs_after
;
767 if (TREE_CODE (stmt
) == PHI_NODE
)
771 vars_in_vops_to_rename
= BITMAP_ALLOC (NULL
);
773 /* Before re-scanning the statement for operands, mark the existing
774 virtual operands to be renamed again. We do this because when new
775 symbols are exposed, the virtual operands that were here before due to
776 aliasing will probably be removed by the call to get_stmt_operand.
777 Therefore, we need to flag them to be renamed beforehand.
779 We flag them in a separate bitmap because we don't really want to
780 rename them if there are not any newly exposed symbols in the
781 statement operands. */
782 v_may_defs_before
= NUM_SSA_OPERANDS (stmt
, SSA_OP_VMAYDEF
);
783 v_must_defs_before
= NUM_SSA_OPERANDS (stmt
, SSA_OP_VMUSTDEF
);
785 FOR_EACH_SSA_TREE_OPERAND (val
, stmt
, iter
,
786 SSA_OP_VMAYDEF
| SSA_OP_VUSE
| SSA_OP_VMUSTDEF
)
789 val
= SSA_NAME_VAR (val
);
790 bitmap_set_bit (vars_in_vops_to_rename
, DECL_UID (val
));
793 /* Now force an operand re-scan on the statement and mark any newly
794 exposed variables. */
797 v_may_defs_after
= NUM_SSA_OPERANDS (stmt
, SSA_OP_VMAYDEF
);
798 v_must_defs_after
= NUM_SSA_OPERANDS (stmt
, SSA_OP_VMUSTDEF
);
800 FOR_EACH_SSA_TREE_OPERAND (val
, stmt
, iter
, SSA_OP_ALL_OPERANDS
)
803 found_exposed_symbol
= true;
804 mark_sym_for_renaming (val
);
807 /* If we found any newly exposed symbols, or if there are fewer VDEF
808 operands in the statement, add the variables we had set in
809 VARS_IN_VOPS_TO_RENAME to VARS_TO_RENAME. We need to check for
810 vanishing VDEFs because in those cases, the names that were formerly
811 generated by this statement are not going to be available anymore. */
812 if (found_exposed_symbol
813 || v_may_defs_before
> v_may_defs_after
814 || v_must_defs_before
> v_must_defs_after
)
815 mark_set_for_renaming (vars_in_vops_to_rename
);
817 BITMAP_FREE (vars_in_vops_to_rename
);
820 /* Find all variables within the gimplified statement that were not previously
821 visible to the function and add them to the referenced variables list. */
824 find_new_referenced_vars_1 (tree
*tp
, int *walk_subtrees
,
825 void *data ATTRIBUTE_UNUSED
)
829 if (TREE_CODE (t
) == VAR_DECL
&& !var_ann (t
))
831 add_referenced_var (t
);
832 mark_sym_for_renaming (t
);
835 if (IS_TYPE_OR_DECL_P (t
))
842 find_new_referenced_vars (tree
*stmt_p
)
844 walk_tree (stmt_p
, find_new_referenced_vars_1
, NULL
, NULL
);
848 /* If REF is a handled component reference for a structure, return the
849 base variable. The access range is delimited by bit positions *POFFSET and
850 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
851 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
852 and *PMAX_SIZE are equal, the access is non-variable. */
855 get_ref_base_and_extent (tree exp
, HOST_WIDE_INT
*poffset
,
856 HOST_WIDE_INT
*psize
,
857 HOST_WIDE_INT
*pmax_size
)
859 HOST_WIDE_INT bitsize
= -1;
860 HOST_WIDE_INT maxsize
= -1;
861 tree size_tree
= NULL_TREE
;
862 tree bit_offset
= bitsize_zero_node
;
863 bool seen_variable_array_ref
= false;
865 gcc_assert (!SSA_VAR_P (exp
));
867 /* First get the final access size from just the outermost expression. */
868 if (TREE_CODE (exp
) == COMPONENT_REF
)
869 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
870 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
871 size_tree
= TREE_OPERAND (exp
, 1);
874 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
876 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
878 bitsize
= GET_MODE_BITSIZE (mode
);
880 if (size_tree
!= NULL_TREE
)
882 if (! host_integerp (size_tree
, 1))
885 bitsize
= TREE_INT_CST_LOW (size_tree
);
888 /* Initially, maxsize is the same as the accessed element size.
889 In the following it will only grow (or become -1). */
892 /* Compute cumulative bit-offset for nested component-refs and array-refs,
893 and find the ultimate containing object. */
896 switch (TREE_CODE (exp
))
899 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
,
900 TREE_OPERAND (exp
, 2));
905 tree field
= TREE_OPERAND (exp
, 1);
906 tree this_offset
= component_ref_field_offset (exp
);
908 if (this_offset
&& TREE_CODE (this_offset
) == INTEGER_CST
)
910 this_offset
= size_binop (MULT_EXPR
,
911 fold_convert (bitsizetype
,
914 bit_offset
= size_binop (PLUS_EXPR
,
915 bit_offset
, this_offset
);
916 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
,
917 DECL_FIELD_BIT_OFFSET (field
));
921 tree csize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
922 /* We need to adjust maxsize to the whole structure bitsize.
923 But we can subtract any constant offset seen sofar,
924 because that would get us out of the structure otherwise. */
926 && csize
&& host_integerp (csize
, 1))
928 maxsize
= (TREE_INT_CST_LOW (csize
)
929 - TREE_INT_CST_LOW (bit_offset
));
938 case ARRAY_RANGE_REF
:
940 tree index
= TREE_OPERAND (exp
, 1);
941 tree low_bound
= array_ref_low_bound (exp
);
942 tree unit_size
= array_ref_element_size (exp
);
944 if (! integer_zerop (low_bound
))
945 index
= fold_build2 (MINUS_EXPR
, TREE_TYPE (index
),
947 index
= size_binop (MULT_EXPR
,
948 fold_convert (sizetype
, index
), unit_size
);
949 if (TREE_CODE (index
) == INTEGER_CST
)
951 index
= size_binop (MULT_EXPR
,
952 fold_convert (bitsizetype
, index
),
954 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
, index
);
956 /* An array ref with a constant index up in the structure
957 hierarchy will constrain the size of any variable array ref
958 lower in the access hierarchy. */
959 seen_variable_array_ref
= false;
963 tree asize
= TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
964 /* We need to adjust maxsize to the whole array bitsize.
965 But we can subtract any constant offset seen sofar,
966 because that would get us outside of the array otherwise. */
968 && asize
&& host_integerp (asize
, 1))
970 maxsize
= (TREE_INT_CST_LOW (asize
)
971 - TREE_INT_CST_LOW (bit_offset
));
976 /* Remember that we have seen an array ref with a variable
978 seen_variable_array_ref
= true;
987 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
,
988 bitsize_int (bitsize
));
991 case VIEW_CONVERT_EXPR
:
992 /* ??? We probably should give up here and bail out. */
999 exp
= TREE_OPERAND (exp
, 0);
1003 /* We need to deal with variable arrays ending structures such as
1004 struct { int length; int a[1]; } x; x.a[d]
1005 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
1006 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
1007 where we do not know maxsize for variable index accesses to
1008 the array. The simplest way to conservatively deal with this
1009 is to punt in the case that offset + maxsize reaches the
1010 base type boundary. */
1011 if (seen_variable_array_ref
1013 && host_integerp (TYPE_SIZE (TREE_TYPE (exp
)), 1)
1014 && TREE_INT_CST_LOW (bit_offset
) + maxsize
1015 == TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))))
1018 /* ??? Due to negative offsets in ARRAY_REF we can end up with
1019 negative bit_offset here. We might want to store a zero offset
1021 *poffset
= TREE_INT_CST_LOW (bit_offset
);
1023 *pmax_size
= maxsize
;