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"
35 #include "langhooks.h"
38 #include "diagnostic.h"
39 #include "tree-pretty-print.h"
40 #include "tree-dump.h"
42 #include "tree-flow.h"
43 #include "tree-inline.h"
44 #include "tree-pass.h"
49 /* Build and maintain data flow information for trees. */
51 /* Counters used to display DFA and SSA statistics. */
59 size_t max_num_phi_args;
65 /* Local functions. */
66 static void collect_dfa_stats (struct dfa_stats_d *);
67 static tree find_vars_r (tree *, int *, void *);
70 /*---------------------------------------------------------------------------
71 Dataflow analysis (DFA) routines
72 ---------------------------------------------------------------------------*/
73 /* Find all the variables referenced in the function. This function
74 builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
76 Note that this function does not look for statement operands, it simply
77 determines what variables are referenced in the program and detects
78 various attributes for each variable used by alias analysis and the
82 find_referenced_vars (void)
85 gimple_stmt_iterator si;
89 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
91 gimple stmt = gsi_stmt (si);
92 if (is_gimple_debug (stmt))
94 find_referenced_vars_in (gsi_stmt (si));
97 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
98 find_referenced_vars_in (gsi_stmt (si));
104 struct gimple_opt_pass pass_referenced_vars =
108 "*referenced_vars", /* name */
110 find_referenced_vars, /* execute */
113 0, /* static_pass_number */
114 TV_FIND_REFERENCED_VARS, /* tv_id */
115 PROP_gimple_leh | PROP_cfg, /* properties_required */
116 PROP_referenced_vars, /* properties_provided */
117 0, /* properties_destroyed */
118 TODO_dump_func, /* todo_flags_start */
119 TODO_dump_func /* todo_flags_finish */
124 /*---------------------------------------------------------------------------
126 ---------------------------------------------------------------------------*/
127 /* Create a new annotation for a _DECL node T. */
130 create_var_ann (tree t)
135 gcc_assert (TREE_CODE (t) == VAR_DECL
136 || TREE_CODE (t) == PARM_DECL
137 || TREE_CODE (t) == RESULT_DECL);
139 ann = GGC_CNEW (struct var_ann_d);
140 *DECL_VAR_ANN_PTR (t) = ann;
145 /* Renumber all of the gimple stmt uids. */
148 renumber_gimple_stmt_uids (void)
152 set_gimple_stmt_max_uid (cfun, 0);
155 gimple_stmt_iterator bsi;
156 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
158 gimple stmt = gsi_stmt (bsi);
159 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
164 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
165 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */
168 renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
172 set_gimple_stmt_max_uid (cfun, 0);
173 for (i = 0; i < n_blocks; i++)
175 basic_block bb = blocks[i];
176 gimple_stmt_iterator bsi;
177 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
179 gimple stmt = gsi_stmt (bsi);
180 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
182 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
184 gimple stmt = gsi_stmt (bsi);
185 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
190 /* Build a temporary. Make sure and register it to be renamed. */
193 make_rename_temp (tree type, const char *prefix)
195 tree t = create_tmp_reg (type, prefix);
197 if (gimple_referenced_vars (cfun))
199 add_referenced_var (t);
200 mark_sym_for_renaming (t);
208 /*---------------------------------------------------------------------------
210 ---------------------------------------------------------------------------*/
211 /* Dump the list of all the referenced variables in the current function to
215 dump_referenced_vars (FILE *file)
218 referenced_var_iterator rvi;
220 fprintf (file, "\nReferenced variables in %s: %u\n\n",
221 get_name (current_function_decl), (unsigned) num_referenced_vars);
223 FOR_EACH_REFERENCED_VAR (var, rvi)
225 fprintf (file, "Variable: ");
226 dump_variable (file, var);
229 fprintf (file, "\n");
233 /* Dump the list of all the referenced variables to stderr. */
236 debug_referenced_vars (void)
238 dump_referenced_vars (stderr);
242 /* Dump variable VAR and its may-aliases to FILE. */
245 dump_variable (FILE *file, tree var)
249 if (TREE_CODE (var) == SSA_NAME)
251 if (POINTER_TYPE_P (TREE_TYPE (var)))
252 dump_points_to_info_for (file, var);
253 var = SSA_NAME_VAR (var);
256 if (var == NULL_TREE)
258 fprintf (file, "<nil>");
262 print_generic_expr (file, var, dump_flags);
266 fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
267 if (DECL_PT_UID (var) != DECL_UID (var))
268 fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var));
270 fprintf (file, ", ");
271 print_generic_expr (file, TREE_TYPE (var), dump_flags);
273 if (TREE_ADDRESSABLE (var))
274 fprintf (file, ", is addressable");
276 if (is_global_var (var))
277 fprintf (file, ", is global");
279 if (TREE_THIS_VOLATILE (var))
280 fprintf (file, ", is volatile");
282 if (ann && ann->noalias_state == NO_ALIAS)
283 fprintf (file, ", NO_ALIAS (does not alias other NO_ALIAS symbols)");
284 else if (ann && ann->noalias_state == NO_ALIAS_GLOBAL)
285 fprintf (file, ", NO_ALIAS_GLOBAL (does not alias other NO_ALIAS symbols"
286 " and global vars)");
287 else if (ann && ann->noalias_state == NO_ALIAS_ANYTHING)
288 fprintf (file, ", NO_ALIAS_ANYTHING (does not alias any other symbols)");
290 if (cfun && gimple_default_def (cfun, var))
292 fprintf (file, ", default def: ");
293 print_generic_expr (file, gimple_default_def (cfun, var), dump_flags);
296 if (DECL_INITIAL (var))
298 fprintf (file, ", initial: ");
299 print_generic_expr (file, DECL_INITIAL (var), dump_flags);
302 fprintf (file, "\n");
306 /* Dump variable VAR and its may-aliases to stderr. */
309 debug_variable (tree var)
311 dump_variable (stderr, var);
315 /* Dump various DFA statistics to FILE. */
318 dump_dfa_stats (FILE *file)
320 struct dfa_stats_d dfa_stats;
322 unsigned long size, total = 0;
323 const char * const fmt_str = "%-30s%-13s%12s\n";
324 const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
325 const char * const fmt_str_3 = "%-43s%11lu%c\n";
327 = lang_hooks.decl_printable_name (current_function_decl, 2);
329 collect_dfa_stats (&dfa_stats);
331 fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
333 fprintf (file, "---------------------------------------------------------\n");
334 fprintf (file, fmt_str, "", " Number of ", "Memory");
335 fprintf (file, fmt_str, "", " instances ", "used ");
336 fprintf (file, "---------------------------------------------------------\n");
338 size = num_referenced_vars * sizeof (tree);
340 fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars,
341 SCALE (size), LABEL (size));
343 size = dfa_stats.num_var_anns * sizeof (struct var_ann_d);
345 fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns,
346 SCALE (size), LABEL (size));
348 size = dfa_stats.num_uses * sizeof (tree *);
350 fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
351 SCALE (size), LABEL (size));
353 size = dfa_stats.num_defs * sizeof (tree *);
355 fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
356 SCALE (size), LABEL (size));
358 size = dfa_stats.num_vuses * sizeof (tree *);
360 fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
361 SCALE (size), LABEL (size));
363 size = dfa_stats.num_vdefs * sizeof (tree *);
365 fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
366 SCALE (size), LABEL (size));
368 size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
370 fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
371 SCALE (size), LABEL (size));
373 size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
375 fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
376 SCALE (size), LABEL (size));
378 fprintf (file, "---------------------------------------------------------\n");
379 fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
381 fprintf (file, "---------------------------------------------------------\n");
382 fprintf (file, "\n");
384 if (dfa_stats.num_phis)
385 fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
386 (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
387 (long) dfa_stats.max_num_phi_args);
389 fprintf (file, "\n");
393 /* Dump DFA statistics on stderr. */
396 debug_dfa_stats (void)
398 dump_dfa_stats (stderr);
402 /* Collect DFA statistics and store them in the structure pointed to by
406 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
409 referenced_var_iterator vi;
412 gcc_assert (dfa_stats_p);
414 memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
416 /* Count all the variable annotations. */
417 FOR_EACH_REFERENCED_VAR (var, vi)
419 dfa_stats_p->num_var_anns++;
421 /* Walk all the statements in the function counting references. */
424 gimple_stmt_iterator si;
426 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
428 gimple phi = gsi_stmt (si);
429 dfa_stats_p->num_phis++;
430 dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
431 if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
432 dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi);
435 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
437 gimple stmt = gsi_stmt (si);
438 dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
439 dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
440 dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
441 dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0;
447 /*---------------------------------------------------------------------------
448 Miscellaneous helpers
449 ---------------------------------------------------------------------------*/
450 /* Callback for walk_tree. Used to collect variables referenced in
454 find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
456 /* If we are reading the lto info back in, we need to rescan the
458 if (TREE_CODE (*tp) == SSA_NAME)
459 add_referenced_var (SSA_NAME_VAR (*tp));
461 /* If T is a regular variable that the optimizers are interested
462 in, add it to the list of variables. */
463 else if (SSA_VAR_P (*tp))
464 add_referenced_var (*tp);
466 /* Type, _DECL and constant nodes have no interesting children.
468 else if (IS_TYPE_OR_DECL_P (*tp) || CONSTANT_CLASS_P (*tp))
474 /* Find referenced variables in STMT. In contrast with
475 find_new_referenced_vars, this function will not mark newly found
476 variables for renaming. */
479 find_referenced_vars_in (gimple stmt)
483 if (gimple_code (stmt) != GIMPLE_PHI)
485 for (i = 0; i < gimple_num_ops (stmt); i++)
486 walk_tree (gimple_op_ptr (stmt, i), find_vars_r, NULL, NULL);
490 walk_tree (gimple_phi_result_ptr (stmt), find_vars_r, NULL, NULL);
492 for (i = 0; i < gimple_phi_num_args (stmt); i++)
494 tree arg = gimple_phi_arg_def (stmt, i);
495 walk_tree (&arg, find_vars_r, NULL, NULL);
501 /* Lookup UID in the referenced_vars hashtable and return the associated
505 referenced_var_lookup (unsigned int uid)
508 struct tree_decl_minimal in;
510 h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
511 gcc_assert (h || uid == 0);
515 /* Check if TO is in the referenced_vars hash table and insert it if not.
516 Return true if it required insertion. */
519 referenced_var_check_and_insert (tree to)
522 struct tree_decl_minimal in;
523 unsigned int uid = DECL_UID (to);
526 h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
529 /* DECL_UID has already been entered in the table. Verify that it is
530 the same entry as TO. See PR 27793. */
531 gcc_assert (h == to);
535 loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (cfun),
541 /* Lookup VAR UID in the default_defs hashtable and return the associated
545 gimple_default_def (struct function *fn, tree var)
547 struct tree_decl_minimal ind;
548 struct tree_ssa_name in;
549 gcc_assert (SSA_VAR_P (var));
551 ind.uid = DECL_UID (var);
552 return (tree) htab_find_with_hash (DEFAULT_DEFS (fn), &in, DECL_UID (var));
555 /* Insert the pair VAR's UID, DEF into the default_defs hashtable. */
558 set_default_def (tree var, tree def)
560 struct tree_decl_minimal ind;
561 struct tree_ssa_name in;
564 gcc_assert (SSA_VAR_P (var));
566 ind.uid = DECL_UID (var);
569 loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
570 DECL_UID (var), INSERT);
572 htab_remove_elt (DEFAULT_DEFS (cfun), *loc);
575 gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var);
576 loc = htab_find_slot_with_hash (DEFAULT_DEFS (cfun), &in,
577 DECL_UID (var), INSERT);
579 /* Default definition might be changed by tail call optimization. */
581 SSA_NAME_IS_DEFAULT_DEF (*(tree *) loc) = false;
584 /* Mark DEF as the default definition for VAR. */
585 SSA_NAME_IS_DEFAULT_DEF (def) = true;
588 /* Add VAR to the list of referenced variables if it isn't already there. */
591 add_referenced_var (tree var)
594 gcc_assert (DECL_P (var));
596 /* Insert VAR into the referenced_vars has table if it isn't present. */
597 if (referenced_var_check_and_insert (var))
599 /* Scan DECL_INITIAL for pointer variables as they may contain
600 address arithmetic referencing the address of other
601 variables. As we are only interested in directly referenced
602 globals or referenced locals restrict this to initializers
603 than can refer to local variables. */
604 if (DECL_INITIAL (var)
605 && DECL_CONTEXT (var) == current_function_decl)
606 walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0);
614 /* Remove VAR from the list. */
617 remove_referenced_var (tree var)
620 struct tree_decl_minimal in;
622 unsigned int uid = DECL_UID (var);
624 /* Preserve var_anns of globals. */
625 if (!is_global_var (var)
626 && (v_ann = var_ann (var)))
629 *DECL_VAR_ANN_PTR (var) = NULL;
631 gcc_assert (DECL_P (var));
633 loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
635 htab_clear_slot (gimple_referenced_vars (cfun), loc);
639 /* Return the virtual variable associated to the non-scalar variable VAR. */
642 get_virtual_var (tree var)
646 if (TREE_CODE (var) == SSA_NAME)
647 var = SSA_NAME_VAR (var);
649 while (TREE_CODE (var) == REALPART_EXPR || TREE_CODE (var) == IMAGPART_EXPR
650 || handled_component_p (var))
651 var = TREE_OPERAND (var, 0);
653 /* Treating GIMPLE registers as virtual variables makes no sense.
654 Also complain if we couldn't extract a _DECL out of the original
656 gcc_assert (SSA_VAR_P (var));
657 gcc_assert (!is_gimple_reg (var));
662 /* Mark all the naked symbols in STMT for SSA renaming. */
665 mark_symbols_for_renaming (gimple stmt)
672 /* Mark all the operands for renaming. */
673 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_OPERANDS)
675 mark_sym_for_renaming (op);
679 /* Find all variables within the gimplified statement that were not
680 previously visible to the function and add them to the referenced
684 find_new_referenced_vars_1 (tree *tp, int *walk_subtrees,
685 void *data ATTRIBUTE_UNUSED)
689 if (TREE_CODE (t) == VAR_DECL && !var_ann (t))
691 add_referenced_var (t);
692 mark_sym_for_renaming (t);
695 if (IS_TYPE_OR_DECL_P (t))
702 /* Find any new referenced variables in STMT. */
705 find_new_referenced_vars (gimple stmt)
707 walk_gimple_op (stmt, find_new_referenced_vars_1, NULL);
711 /* If EXP is a handled component reference for a structure, return the
712 base variable. The access range is delimited by bit positions *POFFSET and
713 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either
714 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE
715 and *PMAX_SIZE are equal, the access is non-variable. */
718 get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
719 HOST_WIDE_INT *psize,
720 HOST_WIDE_INT *pmax_size)
722 HOST_WIDE_INT bitsize = -1;
723 HOST_WIDE_INT maxsize = -1;
724 tree size_tree = NULL_TREE;
725 HOST_WIDE_INT bit_offset = 0;
726 bool seen_variable_array_ref = false;
728 /* First get the final access size from just the outermost expression. */
729 if (TREE_CODE (exp) == COMPONENT_REF)
730 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
731 else if (TREE_CODE (exp) == BIT_FIELD_REF)
732 size_tree = TREE_OPERAND (exp, 1);
733 else if (!VOID_TYPE_P (TREE_TYPE (exp)))
735 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
737 size_tree = TYPE_SIZE (TREE_TYPE (exp));
739 bitsize = GET_MODE_BITSIZE (mode);
741 if (size_tree != NULL_TREE)
743 if (! host_integerp (size_tree, 1))
746 bitsize = TREE_INT_CST_LOW (size_tree);
749 /* Initially, maxsize is the same as the accessed element size.
750 In the following it will only grow (or become -1). */
753 /* Compute cumulative bit-offset for nested component-refs and array-refs,
754 and find the ultimate containing object. */
757 switch (TREE_CODE (exp))
760 bit_offset += TREE_INT_CST_LOW (TREE_OPERAND (exp, 2));
765 tree field = TREE_OPERAND (exp, 1);
766 tree this_offset = component_ref_field_offset (exp);
769 && TREE_CODE (this_offset) == INTEGER_CST
770 && host_integerp (this_offset, 0))
772 HOST_WIDE_INT hthis_offset = TREE_INT_CST_LOW (this_offset);
773 hthis_offset *= BITS_PER_UNIT;
775 += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
776 bit_offset += hthis_offset;
778 /* If we had seen a variable array ref already and we just
779 referenced the last field of a struct or a union member
780 then we have to adjust maxsize by the padding at the end
782 if (seen_variable_array_ref
785 tree stype = TREE_TYPE (TREE_OPERAND (exp, 0));
786 tree next = TREE_CHAIN (field);
787 while (next && TREE_CODE (next) != FIELD_DECL)
788 next = TREE_CHAIN (next);
790 || TREE_CODE (stype) != RECORD_TYPE)
792 tree fsize = DECL_SIZE_UNIT (field);
793 tree ssize = TYPE_SIZE_UNIT (stype);
794 if (host_integerp (fsize, 0)
795 && host_integerp (ssize, 0))
796 maxsize += ((TREE_INT_CST_LOW (ssize)
797 - TREE_INT_CST_LOW (fsize))
798 * BITS_PER_UNIT - hthis_offset);
806 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
807 /* We need to adjust maxsize to the whole structure bitsize.
808 But we can subtract any constant offset seen so far,
809 because that would get us out of the structure otherwise. */
810 if (maxsize != -1 && csize && host_integerp (csize, 1))
811 maxsize = TREE_INT_CST_LOW (csize) - bit_offset;
819 case ARRAY_RANGE_REF:
821 tree index = TREE_OPERAND (exp, 1);
822 tree low_bound, unit_size;
824 /* If the resulting bit-offset is constant, track it. */
825 if (TREE_CODE (index) == INTEGER_CST
826 && host_integerp (index, 0)
827 && (low_bound = array_ref_low_bound (exp),
828 host_integerp (low_bound, 0))
829 && (unit_size = array_ref_element_size (exp),
830 host_integerp (unit_size, 1)))
832 HOST_WIDE_INT hindex = TREE_INT_CST_LOW (index);
834 hindex -= TREE_INT_CST_LOW (low_bound);
835 hindex *= TREE_INT_CST_LOW (unit_size);
836 hindex *= BITS_PER_UNIT;
837 bit_offset += hindex;
839 /* An array ref with a constant index up in the structure
840 hierarchy will constrain the size of any variable array ref
841 lower in the access hierarchy. */
842 seen_variable_array_ref = false;
846 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
847 /* We need to adjust maxsize to the whole array bitsize.
848 But we can subtract any constant offset seen so far,
849 because that would get us outside of the array otherwise. */
850 if (maxsize != -1 && asize && host_integerp (asize, 1))
851 maxsize = TREE_INT_CST_LOW (asize) - bit_offset;
855 /* Remember that we have seen an array ref with a variable
857 seen_variable_array_ref = true;
866 bit_offset += bitsize;
869 case VIEW_CONVERT_EXPR:
876 exp = TREE_OPERAND (exp, 0);
880 /* We need to deal with variable arrays ending structures such as
881 struct { int length; int a[1]; } x; x.a[d]
882 struct { struct { int a; int b; } a[1]; } x; x.a[d].a
883 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0]
884 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
885 where we do not know maxsize for variable index accesses to
886 the array. The simplest way to conservatively deal with this
887 is to punt in the case that offset + maxsize reaches the
888 base type boundary. This needs to include possible trailing padding
889 that is there for alignment purposes.
891 That is of course only true if the base object is not a decl. */
895 /* If maxsize is unknown adjust it according to the size of the
898 && host_integerp (DECL_SIZE (exp), 1))
899 maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - bit_offset;
901 else if (seen_variable_array_ref
903 && (!host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
904 || (bit_offset + maxsize
905 == (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))))
908 /* ??? Due to negative offsets in ARRAY_REF we can end up with
909 negative bit_offset here. We might want to store a zero offset
911 *poffset = bit_offset;
913 *pmax_size = maxsize;
918 /* Returns true if STMT references an SSA_NAME that has
919 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */
922 stmt_references_abnormal_ssa_name (gimple stmt)
927 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
929 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p)))