1 /* Data flow functions for trees.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
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"
31 #include "hard-reg-set.h"
32 #include "basic-block.h"
37 #include "langhooks.h"
40 #include "diagnostic.h"
41 #include "tree-dump.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. */
60 size_t max_num_phi_args;
66 /* Local functions. */
67 static void collect_dfa_stats (struct dfa_stats_d *);
68 static tree find_vars_r (tree *, int *, void *);
71 /*---------------------------------------------------------------------------
72 Dataflow analysis (DFA) routines
73 ---------------------------------------------------------------------------*/
74 /* Find all the variables referenced in the function. This function
75 builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
77 Note that this function does not look for statement operands, it simply
78 determines what variables are referenced in the program and detects
79 various attributes for each variable used by alias analysis and the
83 find_referenced_vars (void)
86 gimple_stmt_iterator si;
90 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
92 gimple stmt = gsi_stmt (si);
93 if (is_gimple_debug (stmt))
95 find_referenced_vars_in (gsi_stmt (si));
98 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
99 find_referenced_vars_in (gsi_stmt (si));
105 struct gimple_opt_pass pass_referenced_vars =
111 find_referenced_vars, /* execute */
114 0, /* static_pass_number */
115 TV_FIND_REFERENCED_VARS, /* tv_id */
116 PROP_gimple_leh | PROP_cfg, /* properties_required */
117 PROP_referenced_vars, /* properties_provided */
118 0, /* properties_destroyed */
119 TODO_dump_func, /* todo_flags_start */
120 TODO_dump_func /* todo_flags_finish */
125 /*---------------------------------------------------------------------------
127 ---------------------------------------------------------------------------*/
128 /* Create a new annotation for a _DECL node T. */
131 create_var_ann (tree t)
136 gcc_assert (DECL_P (t));
137 gcc_assert (!t->base.ann || t->base.ann->common.type == VAR_ANN);
139 ann = GGC_CNEW (struct var_ann_d);
140 ann->common.type = VAR_ANN;
141 t->base.ann = (tree_ann_t) ann;
146 /* Renumber all of the gimple stmt uids. */
149 renumber_gimple_stmt_uids (void)
153 set_gimple_stmt_max_uid (cfun, 0);
156 gimple_stmt_iterator bsi;
157 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
159 gimple stmt = gsi_stmt (bsi);
160 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
165 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
166 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
169 renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
173 set_gimple_stmt_max_uid (cfun, 0);
174 for (i = 0; i < n_blocks; i++)
176 basic_block bb = blocks[i];
177 gimple_stmt_iterator bsi;
178 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
180 gimple stmt = gsi_stmt (bsi);
181 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
183 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
185 gimple stmt = gsi_stmt (bsi);
186 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
191 /* Create a new annotation for a tree T. */
194 create_tree_common_ann (tree t)
196 tree_ann_common_t ann;
199 gcc_assert (!t->base.ann || t->base.ann->common.type == TREE_ANN_COMMON);
201 ann = GGC_CNEW (struct tree_ann_common_d);
203 ann->type = TREE_ANN_COMMON;
204 t->base.ann = (tree_ann_t) ann;
209 /* Build a temporary. Make sure and register it to be renamed. */
212 make_rename_temp (tree type, const char *prefix)
214 tree t = create_tmp_var (type, prefix);
216 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
217 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
218 DECL_GIMPLE_REG_P (t) = 1;
220 if (gimple_referenced_vars (cfun))
222 add_referenced_var (t);
223 mark_sym_for_renaming (t);
231 /*---------------------------------------------------------------------------
233 ---------------------------------------------------------------------------*/
234 /* Dump the list of all the referenced variables in the current function to
238 dump_referenced_vars (FILE *file)
241 referenced_var_iterator rvi;
243 fprintf (file, "\nReferenced variables in %s: %u\n\n",
244 get_name (current_function_decl), (unsigned) num_referenced_vars);
246 FOR_EACH_REFERENCED_VAR (var, rvi)
248 fprintf (file, "Variable: ");
249 dump_variable (file, var);
252 fprintf (file, "\n");
256 /* Dump the list of all the referenced variables to stderr. */
259 debug_referenced_vars (void)
261 dump_referenced_vars (stderr);
265 /* Dump variable VAR and its may-aliases to FILE. */
268 dump_variable (FILE *file, tree var)
272 if (TREE_CODE (var) == SSA_NAME)
274 if (POINTER_TYPE_P (TREE_TYPE (var)))
275 dump_points_to_info_for (file, var);
276 var = SSA_NAME_VAR (var);
279 if (var == NULL_TREE)
281 fprintf (file, "<nil>");
285 print_generic_expr (file, var, dump_flags);
289 fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
291 fprintf (file, ", ");
292 print_generic_expr (file, TREE_TYPE (var), dump_flags);
294 if (TREE_ADDRESSABLE (var))
295 fprintf (file, ", is addressable");
297 if (is_global_var (var))
298 fprintf (file, ", is global");
300 if (TREE_THIS_VOLATILE (var))
301 fprintf (file, ", is volatile");
303 if (is_call_clobbered (var))
304 fprintf (file, ", call clobbered");
305 else if (is_call_used (var))
306 fprintf (file, ", call used");
308 if (ann && ann->noalias_state == NO_ALIAS)
309 fprintf (file, ", NO_ALIAS (does not alias other NO_ALIAS symbols)");
310 else if (ann && ann->noalias_state == NO_ALIAS_GLOBAL)
311 fprintf (file, ", NO_ALIAS_GLOBAL (does not alias other NO_ALIAS symbols"
312 " and global vars)");
313 else if (ann && ann->noalias_state == NO_ALIAS_ANYTHING)
314 fprintf (file, ", NO_ALIAS_ANYTHING (does not alias any other symbols)");
316 if (cfun && gimple_default_def (cfun, var))
318 fprintf (file, ", default def: ");
319 print_generic_expr (file, gimple_default_def (cfun, var), dump_flags);
322 if (DECL_INITIAL (var))
324 fprintf (file, ", initial: ");
325 print_generic_expr (file, DECL_INITIAL (var), dump_flags);
328 fprintf (file, "\n");
332 /* Dump variable VAR and its may-aliases to stderr. */
335 debug_variable (tree var)
337 dump_variable (stderr, var);
341 /* Dump various DFA statistics to FILE. */
344 dump_dfa_stats (FILE *file)
346 struct dfa_stats_d dfa_stats;
348 unsigned long size, total = 0;
349 const char * const fmt_str = "%-30s%-13s%12s\n";
350 const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
351 const char * const fmt_str_3 = "%-43s%11lu%c\n";
353 = lang_hooks.decl_printable_name (current_function_decl, 2);
355 collect_dfa_stats (&dfa_stats);
357 fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
359 fprintf (file, "---------------------------------------------------------\n");
360 fprintf (file, fmt_str, "", " Number of ", "Memory");
361 fprintf (file, fmt_str, "", " instances ", "used ");
362 fprintf (file, "---------------------------------------------------------\n");
364 size = num_referenced_vars * sizeof (tree);
366 fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
367 SCALE (size), LABEL (size));
369 size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
371 fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
372 SCALE (size), LABEL (size));
374 size = dfa_stats.num_uses * sizeof (tree *);
376 fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
377 SCALE (size), LABEL (size));
379 size = dfa_stats.num_defs * sizeof (tree *);
381 fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
382 SCALE (size), LABEL (size));
384 size = dfa_stats.num_vuses * sizeof (tree *);
386 fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
387 SCALE (size), LABEL (size));
389 size = dfa_stats.num_vdefs * sizeof (tree *);
391 fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
392 SCALE (size), LABEL (size));
394 size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
396 fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
397 SCALE (size), LABEL (size));
399 size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
401 fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
402 SCALE (size), LABEL (size));
404 fprintf (file, "---------------------------------------------------------\n");
405 fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
407 fprintf (file, "---------------------------------------------------------\n");
408 fprintf (file, "\n");
410 if (dfa_stats.num_phis)
411 fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
412 (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
413 (long) dfa_stats.max_num_phi_args);
415 fprintf (file, "\n");
419 /* Dump DFA statistics on stderr. */
422 debug_dfa_stats (void)
424 dump_dfa_stats (stderr);
428 /* Collect DFA statistics and store them in the structure pointed to by
432 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
435 referenced_var_iterator vi;
438 gcc_assert (dfa_stats_p);
440 memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
442 /* Count all the variable annotations. */
443 FOR_EACH_REFERENCED_VAR (var, vi)
445 dfa_stats_p->num_var_anns++;
447 /* Walk all the statements in the function counting references. */
450 gimple_stmt_iterator si;
452 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
454 gimple phi = gsi_stmt (si);
455 dfa_stats_p->num_phis++;
456 dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
457 if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
458 dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi);
461 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
463 gimple stmt = gsi_stmt (si);
464 dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
465 dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
466 dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
467 dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0;
473 /*---------------------------------------------------------------------------
474 Miscellaneous helpers
475 ---------------------------------------------------------------------------*/
476 /* Callback for walk_tree. Used to collect variables referenced in
480 find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
482 /* If we are reading the lto info back in, we need to rescan the
484 if (TREE_CODE (*tp) == SSA_NAME)
485 add_referenced_var (SSA_NAME_VAR (*tp));
487 /* If T is a regular variable that the optimizers are interested
488 in, add it to the list of variables. */
489 else if (SSA_VAR_P (*tp))
490 add_referenced_var (*tp);
492 /* Type, _DECL and constant nodes have no interesting children.
494 else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
500 /* Find referenced variables in STMT. In contrast with
501 find_new_referenced_vars, this function will not mark newly found
502 variables for renaming. */
505 find_referenced_vars_in (gimple stmt)
509 if (gimple_code (stmt) != GIMPLE_PHI)
511 for (i = 0; i < gimple_num_ops (stmt); i++)
512 walk_tree (gimple_op_ptr (stmt, i), find_vars_r, NULL, NULL);
516 walk_tree (gimple_phi_result_ptr (stmt), find_vars_r, NULL, NULL);
518 for (i = 0; i < gimple_phi_num_args (stmt); i++)
520 tree arg = gimple_phi_arg_def (stmt, i);
521 walk_tree (&arg, find_vars_r, NULL, NULL);
527 /* Lookup UID in the referenced_vars hashtable and return the associated
531 referenced_var_lookup (unsigned int uid)
534 struct tree_decl_minimal in;
536 h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
537 gcc_assert (h || uid == 0);
541 /* Check if TO is in the referenced_vars hash table and insert it if not.
542 Return true if it required insertion. */
545 referenced_var_check_and_insert (tree to)
548 struct tree_decl_minimal in;
549 unsigned int uid = DECL_UID (to);
552 h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
555 /* DECL_UID has already been entered in the table. Verify that it is
556 the same entry as TO. See PR 27793. */
557 gcc_assert (h == to);
561 loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (cfun),
567 /* Lookup VAR UID in the default_defs hashtable and return the associated
571 gimple_default_def (struct function *fn, tree var)
573 struct tree_decl_minimal ind;
574 struct tree_ssa_name in;
575 gcc_assert (SSA_VAR_P (var));
577 ind.uid = DECL_UID (var);
578 return (tree) htab_find_with_hash (DEFAULT_DEFS (fn), &in, DECL_UID (var));
581 /* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
584 set_default_def (tree var, tree def)
586 struct tree_decl_minimal ind;
587 struct tree_ssa_name in;
590 gcc_assert (SSA_VAR_P (var));
592 ind.uid = DECL_UID (var);
595 loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
596 DECL_UID (var), INSERT);
598 htab_remove_elt (DEFAULT_DEFS (cfun), *loc);
601 gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var);
602 loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
603 DECL_UID (var), INSERT);
605 /* Default definition might be changed by tail call optimization. */
607 SSA_NAME_IS_DEFAULT_DEF (*(tree *) loc) = false;
610 /* Mark DEF as the default definition for VAR. */
611 SSA_NAME_IS_DEFAULT_DEF (def) = true;
614 /* Add VAR to the list of referenced variables if it isn't already there. */
617 add_referenced_var (tree var)
621 v_ann = get_var_ann (var);
622 gcc_assert (DECL_P (var));
624 /* Insert VAR into the referenced_vars has table if it isn't present. */
625 if (referenced_var_check_and_insert (var))
627 /* Scan DECL_INITIAL for pointer variables as they may contain
628 address arithmetic referencing the address of other
629 variables. As we are only interested in directly referenced
630 globals or referenced locals restrict this to initializers
631 than can refer to local variables. */
632 if (DECL_INITIAL (var)
633 && DECL_CONTEXT (var) == current_function_decl)
634 walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
642 /* Remove VAR from the list. */
645 remove_referenced_var (tree var)
648 struct tree_decl_minimal in;
650 unsigned int uid = DECL_UID (var);
652 /* Preserve var_anns of globals. */
653 if (!is_global_var (var)
654 && (v_ann = var_ann (var)))
657 var->base.ann = NULL;
659 gcc_assert (DECL_P (var));
661 loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
663 htab_clear_slot (gimple_referenced_vars (cfun), loc);
667 /* Return the virtual variable associated to the non-scalar variable VAR. */
670 get_virtual_var (tree var)
674 if (TREE_CODE (var) == SSA_NAME)
675 var = SSA_NAME_VAR (var);
677 while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
678 || handled_component_p (var))
679 var = TREE_OPERAND (var, 0);
681 /* Treating GIMPLE registers as virtual variables makes no sense.
682 Also complain if we couldn't extract a _DECL out of the original
684 gcc_assert (SSA_VAR_P (var));
685 gcc_assert (!is_gimple_reg (var));
690 /* Mark all the naked symbols in STMT for SSA renaming. */
693 mark_symbols_for_renaming (gimple stmt)
700 /* Mark all the operands for renaming. */
701 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_OPERANDS)
703 mark_sym_for_renaming (op);
707 /* Find all variables within the gimplified statement that were not
708 previously visible to the function and add them to the referenced
712 find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
713 void *data ATTRIBUTE_UNUSED)
717 if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
719 add_referenced_var (t);
720 mark_sym_for_renaming (t);
723 if (IS_TYPE_OR_DECL_P (t))
730 /* Find any new referenced variables in STMT. */
733 find_new_referenced_vars (gimple stmt)
735 walk_gimple_op (stmt, find_new_referenced_vars_1, NULL);
739 /* If EXP is a handled component reference for a structure, return the
740 base variable. The access range is delimited by bit positions *POFFSET and
741 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
742 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
743 and *PMAX_SIZE are equal, the access is non-variable. */
746 get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
747 HOST_WIDE_INT *psize,
748 HOST_WIDE_INT *pmax_size)
750 HOST_WIDE_INT bitsize = -1;
751 HOST_WIDE_INT maxsize = -1;
752 tree size_tree = NULL_TREE;
753 HOST_WIDE_INT bit_offset = 0;
754 bool seen_variable_array_ref = false;
756 /* First get the final access size from just the outermost expression. */
757 if (TREE_CODE (exp) == COMPONENT_REF)
758 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
759 else if (TREE_CODE (exp) == BIT_FIELD_REF)
760 size_tree = TREE_OPERAND (exp, 1);
761 else if (!VOID_TYPE_P (TREE_TYPE (exp)))
763 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
765 size_tree = TYPE_SIZE (TREE_TYPE (exp));
767 bitsize = GET_MODE_BITSIZE (mode);
769 if (size_tree != NULL_TREE)
771 if (! host_integerp (size_tree, 1))
774 bitsize = TREE_INT_CST_LOW (size_tree);
777 /* Initially, maxsize is the same as the accessed element size.
778 In the following it will only grow (or become -1). */
781 /* Compute cumulative bit-offset for nested component-refs and array-refs,
782 and find the ultimate containing object. */
785 switch (TREE_CODE (exp))
788 bit_offset += TREE_INT_CST_LOW (TREE_OPERAND (exp, 2));
793 tree field = TREE_OPERAND (exp, 1);
794 tree this_offset = component_ref_field_offset (exp);
797 && TREE_CODE (this_offset) == INTEGER_CST
798 && host_integerp (this_offset, 0))
800 HOST_WIDE_INT hthis_offset = TREE_INT_CST_LOW (this_offset);
801 hthis_offset *= BITS_PER_UNIT;
802 bit_offset += hthis_offset;
803 bit_offset += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
807 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
808 /* We need to adjust maxsize to the whole structure bitsize.
809 But we can subtract any constant offset seen so far,
810 because that would get us out of the structure otherwise. */
811 if (maxsize != -1 && csize && host_integerp (csize, 1))
812 maxsize = TREE_INT_CST_LOW (csize) - bit_offset;
820 case ARRAY_RANGE_REF:
822 tree index = TREE_OPERAND (exp, 1);
823 tree low_bound, unit_size;
825 /* If the resulting bit-offset is constant, track it. */
826 if (TREE_CODE (index) == INTEGER_CST
827 && host_integerp (index, 0)
828 && (low_bound = array_ref_low_bound (exp),
829 host_integerp (low_bound, 0))
830 && (unit_size = array_ref_element_size (exp),
831 host_integerp (unit_size, 1)))
833 HOST_WIDE_INT hindex = TREE_INT_CST_LOW (index);
835 hindex -= TREE_INT_CST_LOW (low_bound);
836 hindex *= TREE_INT_CST_LOW (unit_size);
837 hindex *= BITS_PER_UNIT;
838 bit_offset += hindex;
840 /* An array ref with a constant index up in the structure
841 hierarchy will constrain the size of any variable array ref
842 lower in the access hierarchy. */
843 seen_variable_array_ref = false;
847 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
848 /* Get at the array size but include trailing padding if
849 the array is the last element of a struct or union. */
851 && TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF)
853 tree cref = TREE_OPERAND (exp, 0);
854 tree field = TREE_OPERAND (cref, 1);
855 tree stype = TREE_TYPE (TREE_OPERAND (cref, 0));
856 tree next = TREE_CHAIN (field);
857 while (next && TREE_CODE (next) != FIELD_DECL)
858 next = TREE_CHAIN (next);
860 || TREE_CODE (stype) != RECORD_TYPE)
862 /* The size including padding is the size of
863 the whole structure minus the offset of the
865 tree field_offset = component_ref_field_offset (cref);
867 && host_integerp (field_offset, 0)
868 && host_integerp (TYPE_SIZE_UNIT (stype), 0))
870 unsigned HOST_WIDE_INT as;
871 as = (((TREE_INT_CST_LOW (TYPE_SIZE_UNIT (stype))
872 - TREE_INT_CST_LOW (field_offset))
875 (DECL_FIELD_BIT_OFFSET (field)));
876 asize = build_int_cstu (sizetype, as);
882 /* We need to adjust maxsize to the whole array bitsize.
883 But we can subtract any constant offset seen so far,
884 because that would get us outside of the array otherwise. */
885 if (maxsize != -1 && asize && host_integerp (asize, 1))
886 maxsize = TREE_INT_CST_LOW (asize) - bit_offset;
890 /* Remember that we have seen an array ref with a variable
892 seen_variable_array_ref = true;
901 bit_offset += bitsize;
904 case VIEW_CONVERT_EXPR:
905 /* ??? We probably should give up here and bail out. */
912 exp = TREE_OPERAND (exp, 0);
916 /* We need to deal with variable arrays ending structures such as
917 struct { int length; int a[1]; } x; x.a[d]
918 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
919 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
920 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
921 where we do not know maxsize for variable index accesses to
922 the array. The simplest way to conservatively deal with this
923 is to punt in the case that offset + maxsize reaches the
924 base type boundary. This needs to include possible trailing padding
925 that is there for alignment purposes. */
927 if (seen_variable_array_ref
929 && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
930 && bit_offset + maxsize
931 == (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))))
934 /* ??? Due to negative offsets in ARRAY_REF we can end up with
935 negative bit_offset here. We might want to store a zero offset
937 *poffset = bit_offset;
939 *pmax_size = maxsize;
944 /* Returns true if STMT references an SSA_NAME that has
945 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
948 stmt_references_abnormal_ssa_name (gimple stmt)
953 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
955 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p)))