gcc/tree-dfa.c

   1 /* Data flow functions for trees.
   2    Copyright (C) 2001-2013 Free Software Foundation, Inc.
   3    Contributed by Diego Novillo <dnovillo@redhat.com>
   4
   5 This file is part of GCC.
   6
   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 3, or (at your option)
  10 any later version.
  11
  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.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "hashtab.h"
  26 #include "pointer-set.h"
  27 #include "tree.h"
  28 #include "tm_p.h"
  29 #include "basic-block.h"
  30 #include "ggc.h"
  31 #include "langhooks.h"
  32 #include "flags.h"
  33 #include "function.h"
  34 #include "tree-pretty-print.h"
  35 #include "gimple.h"
  36 #include "tree-flow.h"
  37 #include "tree-inline.h"
  38 #include "tree-pass.h"
  39 #include "convert.h"
  40 #include "params.h"
  41 #include "cgraph.h"
  42
  43 /* Build and maintain data flow information for trees.  */
  44
  45 /* Counters used to display DFA and SSA statistics.  */
  46 struct dfa_stats_d
  47 {
  48   long num_defs;
  49   long num_uses;
  50   long num_phis;
  51   long num_phi_args;
  52   size_t max_num_phi_args;
  53   long num_vdefs;
  54   long num_vuses;
  55 };
  56
  57
  58 /* Local functions.  */
  59 static void collect_dfa_stats (struct dfa_stats_d *);
  60
  61
  62 /*---------------------------------------------------------------------------
  63                         Dataflow analysis (DFA) routines
  64 ---------------------------------------------------------------------------*/
  65
  66 /* Renumber all of the gimple stmt uids.  */
  67
  68 void
  69 renumber_gimple_stmt_uids (void)
  70 {
  71   basic_block bb;
  72
  73   set_gimple_stmt_max_uid (cfun, 0);
  74   FOR_ALL_BB (bb)
  75     {
  76       gimple_stmt_iterator bsi;
  77       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
  78         {
  79           gimple stmt = gsi_stmt (bsi);
  80           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
  81         }
  82       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
  83         {
  84           gimple stmt = gsi_stmt (bsi);
  85           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
  86         }
  87     }
  88 }
  89
  90 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
  91    in BLOCKS, of which there are N_BLOCKS.  Also renumbers PHIs.  */
  92
  93 void
  94 renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
  95 {
  96   int i;
  97
  98   set_gimple_stmt_max_uid (cfun, 0);
  99   for (i = 0; i < n_blocks; i++)
 100     {
 101       basic_block bb = blocks[i];
 102       gimple_stmt_iterator bsi;
 103       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 104         {
 105           gimple stmt = gsi_stmt (bsi);
 106           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 107         }
 108       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 109         {
 110           gimple stmt = gsi_stmt (bsi);
 111           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 112         }
 113     }
 114 }
 115
 116
 117
 118 /*---------------------------------------------------------------------------
 119                               Debugging functions
 120 ---------------------------------------------------------------------------*/
 121
 122 /* Dump variable VAR and its may-aliases to FILE.  */
 123
 124 void
 125 dump_variable (FILE *file, tree var)
 126 {
 127   if (TREE_CODE (var) == SSA_NAME)
 128     {
 129       if (POINTER_TYPE_P (TREE_TYPE (var)))
 130         dump_points_to_info_for (file, var);
 131       var = SSA_NAME_VAR (var);
 132     }
 133
 134   if (var == NULL_TREE)
 135     {
 136       fprintf (file, "<nil>");
 137       return;
 138     }
 139
 140   print_generic_expr (file, var, dump_flags);
 141
 142   fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
 143   if (DECL_PT_UID (var) != DECL_UID (var))
 144     fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var));
 145
 146   fprintf (file, ", ");
 147   print_generic_expr (file, TREE_TYPE (var), dump_flags);
 148
 149   if (TREE_ADDRESSABLE (var))
 150     fprintf (file, ", is addressable");
 151
 152   if (is_global_var (var))
 153     fprintf (file, ", is global");
 154
 155   if (TREE_THIS_VOLATILE (var))
 156     fprintf (file, ", is volatile");
 157
 158   if (cfun && ssa_default_def (cfun, var))
 159     {
 160       fprintf (file, ", default def: ");
 161       print_generic_expr (file, ssa_default_def (cfun, var), dump_flags);
 162     }
 163
 164   if (DECL_INITIAL (var))
 165     {
 166       fprintf (file, ", initial: ");
 167       print_generic_expr (file, DECL_INITIAL (var), dump_flags);
 168     }
 169
 170   fprintf (file, "\n");
 171 }
 172
 173
 174 /* Dump variable VAR and its may-aliases to stderr.  */
 175
 176 DEBUG_FUNCTION void
 177 debug_variable (tree var)
 178 {
 179   dump_variable (stderr, var);
 180 }
 181
 182
 183 /* Dump various DFA statistics to FILE.  */
 184
 185 void
 186 dump_dfa_stats (FILE *file)
 187 {
 188   struct dfa_stats_d dfa_stats;
 189
 190   unsigned long size, total = 0;
 191   const char * const fmt_str   = "%-30s%-13s%12s\n";
 192   const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
 193   const char * const fmt_str_3 = "%-43s%11lu%c\n";
 194   const char *funcname
 195     = lang_hooks.decl_printable_name (current_function_decl, 2);
 196
 197   collect_dfa_stats (&dfa_stats);
 198
 199   fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
 200
 201   fprintf (file, "---------------------------------------------------------\n");
 202   fprintf (file, fmt_str, "", "  Number of  ", "Memory");
 203   fprintf (file, fmt_str, "", "  instances  ", "used ");
 204   fprintf (file, "---------------------------------------------------------\n");
 205
 206   size = dfa_stats.num_uses * sizeof (tree *);
 207   total += size;
 208   fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
 209            SCALE (size), LABEL (size));
 210
 211   size = dfa_stats.num_defs * sizeof (tree *);
 212   total += size;
 213   fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
 214            SCALE (size), LABEL (size));
 215
 216   size = dfa_stats.num_vuses * sizeof (tree *);
 217   total += size;
 218   fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
 219            SCALE (size), LABEL (size));
 220
 221   size = dfa_stats.num_vdefs * sizeof (tree *);
 222   total += size;
 223   fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
 224            SCALE (size), LABEL (size));
 225
 226   size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
 227   total += size;
 228   fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
 229            SCALE (size), LABEL (size));
 230
 231   size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
 232   total += size;
 233   fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
 234            SCALE (size), LABEL (size));
 235
 236   fprintf (file, "---------------------------------------------------------\n");
 237   fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
 238            LABEL (total));
 239   fprintf (file, "---------------------------------------------------------\n");
 240   fprintf (file, "\n");
 241
 242   if (dfa_stats.num_phis)
 243     fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
 244              (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
 245              (long) dfa_stats.max_num_phi_args);
 246
 247   fprintf (file, "\n");
 248 }
 249
 250
 251 /* Dump DFA statistics on stderr.  */
 252
 253 DEBUG_FUNCTION void
 254 debug_dfa_stats (void)
 255 {
 256   dump_dfa_stats (stderr);
 257 }
 258
 259
 260 /* Collect DFA statistics and store them in the structure pointed to by
 261    DFA_STATS_P.  */
 262
 263 static void
 264 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
 265 {
 266   basic_block bb;
 267
 268   gcc_assert (dfa_stats_p);
 269
 270   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 271
 272   /* Walk all the statements in the function counting references.  */
 273   FOR_EACH_BB (bb)
 274     {
 275       gimple_stmt_iterator si;
 276
 277       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 278         {
 279           gimple phi = gsi_stmt (si);
 280           dfa_stats_p->num_phis++;
 281           dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
 282           if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
 283             dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi);
 284         }
 285
 286       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 287         {
 288           gimple stmt = gsi_stmt (si);
 289           dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
 290           dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
 291           dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
 292           dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0;
 293         }
 294     }
 295 }
 296
 297
 298 /*---------------------------------------------------------------------------
 299                              Miscellaneous helpers
 300 ---------------------------------------------------------------------------*/
 301
 302 /* Lookup VAR UID in the default_defs hashtable and return the associated
 303    variable.  */
 304
 305 tree
 306 ssa_default_def (struct function *fn, tree var)
 307 {
 308   struct tree_decl_minimal ind;
 309   struct tree_ssa_name in;
 310   gcc_assert (TREE_CODE (var) == VAR_DECL
 311               || TREE_CODE (var) == PARM_DECL
 312               || TREE_CODE (var) == RESULT_DECL);
 313   in.var = (tree)&ind;
 314   ind.uid = DECL_UID (var);
 315   return (tree) htab_find_with_hash (DEFAULT_DEFS (fn), &in, DECL_UID (var));
 316 }
 317
 318 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
 319    of function FN.  */
 320
 321 void
 322 set_ssa_default_def (struct function *fn, tree var, tree def)
 323 {
 324   struct tree_decl_minimal ind;
 325   struct tree_ssa_name in;
 326   void **loc;
 327
 328   gcc_assert (TREE_CODE (var) == VAR_DECL
 329               || TREE_CODE (var) == PARM_DECL
 330               || TREE_CODE (var) == RESULT_DECL);
 331   in.var = (tree)&ind;
 332   ind.uid = DECL_UID (var);
 333   if (!def)
 334     {
 335       loc = htab_find_slot_with_hash (DEFAULT_DEFS (fn), &in,
 336                                       DECL_UID (var), NO_INSERT);
 337       if (*loc)
 338         {
 339           SSA_NAME_IS_DEFAULT_DEF (*(tree *)loc) = false;
 340           htab_clear_slot (DEFAULT_DEFS (fn), loc);
 341         }
 342       return;
 343     }
 344   gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var);
 345   loc = htab_find_slot_with_hash (DEFAULT_DEFS (fn), &in,
 346                                   DECL_UID (var), INSERT);
 347
 348   /* Default definition might be changed by tail call optimization.  */
 349   if (*loc)
 350     SSA_NAME_IS_DEFAULT_DEF (*(tree *) loc) = false;
 351
 352    /* Mark DEF as the default definition for VAR.  */
 353   *(tree *) loc = def;
 354   SSA_NAME_IS_DEFAULT_DEF (def) = true;
 355 }
 356
 357 /* Retrieve or create a default definition for VAR.  */
 358
 359 tree
 360 get_or_create_ssa_default_def (struct function *fn, tree var)
 361 {
 362   tree ddef = ssa_default_def (fn, var);
 363   if (ddef == NULL_TREE)
 364     {
 365       ddef = make_ssa_name (var, gimple_build_nop ());
 366       set_ssa_default_def (cfun, var, ddef);
 367     }
 368   return ddef;
 369 }
 370
 371
 372 /* If EXP is a handled component reference for a structure, return the
 373    base variable.  The access range is delimited by bit positions *POFFSET and
 374    *POFFSET + *PMAX_SIZE.  The access size is *PSIZE bits.  If either
 375    *PSIZE or *PMAX_SIZE is -1, they could not be determined.  If *PSIZE
 376    and *PMAX_SIZE are equal, the access is non-variable.  */
 377
 378 tree
 379 get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
 380                          HOST_WIDE_INT *psize,
 381                          HOST_WIDE_INT *pmax_size)
 382 {
 383   HOST_WIDE_INT bitsize = -1;
 384   HOST_WIDE_INT maxsize = -1;
 385   tree size_tree = NULL_TREE;
 386   double_int bit_offset = double_int_zero;
 387   HOST_WIDE_INT hbit_offset;
 388   bool seen_variable_array_ref = false;
 389   tree base_type;
 390
 391   /* First get the final access size from just the outermost expression.  */
 392   if (TREE_CODE (exp) == COMPONENT_REF)
 393     size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
 394   else if (TREE_CODE (exp) == BIT_FIELD_REF)
 395     size_tree = TREE_OPERAND (exp, 1);
 396   else if (!VOID_TYPE_P (TREE_TYPE (exp)))
 397     {
 398       enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 399       if (mode == BLKmode)
 400         size_tree = TYPE_SIZE (TREE_TYPE (exp));
 401       else
 402         bitsize = GET_MODE_BITSIZE (mode);
 403     }
 404   if (size_tree != NULL_TREE)
 405     {
 406       if (! host_integerp (size_tree, 1))
 407         bitsize = -1;
 408       else
 409         bitsize = TREE_INT_CST_LOW (size_tree);
 410     }
 411
 412   /* Initially, maxsize is the same as the accessed element size.
 413      In the following it will only grow (or become -1).  */
 414   maxsize = bitsize;
 415
 416   /* Compute cumulative bit-offset for nested component-refs and array-refs,
 417      and find the ultimate containing object.  */
 418   while (1)
 419     {
 420       base_type = TREE_TYPE (exp);
 421
 422       switch (TREE_CODE (exp))
 423         {
 424         case BIT_FIELD_REF:
 425           bit_offset += tree_to_double_int (TREE_OPERAND (exp, 2));
 426           break;
 427
 428         case COMPONENT_REF:
 429           {
 430             tree field = TREE_OPERAND (exp, 1);
 431             tree this_offset = component_ref_field_offset (exp);
 432
 433             if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
 434               {
 435                 double_int doffset = tree_to_double_int (this_offset);
 436                 doffset = doffset.alshift (BITS_PER_UNIT == 8
 437                                            ? 3 : exact_log2 (BITS_PER_UNIT),
 438                                            HOST_BITS_PER_DOUBLE_INT);
 439                 doffset += tree_to_double_int (DECL_FIELD_BIT_OFFSET (field));
 440                 bit_offset = bit_offset + doffset;
 441
 442                 /* If we had seen a variable array ref already and we just
 443                    referenced the last field of a struct or a union member
 444                    then we have to adjust maxsize by the padding at the end
 445                    of our field.  */
 446                 if (seen_variable_array_ref && maxsize != -1)
 447                   {
 448                     tree stype = TREE_TYPE (TREE_OPERAND (exp, 0));
 449                     tree next = DECL_CHAIN (field);
 450                     while (next && TREE_CODE (next) != FIELD_DECL)
 451                       next = DECL_CHAIN (next);
 452                     if (!next
 453                         || TREE_CODE (stype) != RECORD_TYPE)
 454                       {
 455                         tree fsize = DECL_SIZE_UNIT (field);
 456                         tree ssize = TYPE_SIZE_UNIT (stype);
 457                         if (host_integerp (fsize, 0)
 458                             && host_integerp (ssize, 0)
 459                             && doffset.fits_shwi ())
 460                           maxsize += ((TREE_INT_CST_LOW (ssize)
 461                                        - TREE_INT_CST_LOW (fsize))
 462                                       * BITS_PER_UNIT
 463                                         - doffset.to_shwi ());
 464                         else
 465                           maxsize = -1;
 466                       }
 467                   }
 468               }
 469             else
 470               {
 471                 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 472                 /* We need to adjust maxsize to the whole structure bitsize.
 473                    But we can subtract any constant offset seen so far,
 474                    because that would get us out of the structure otherwise.  */
 475                 if (maxsize != -1
 476                     && csize
 477                     && host_integerp (csize, 1)
 478                     && bit_offset.fits_shwi ())
 479                   maxsize = TREE_INT_CST_LOW (csize)
 480                             - bit_offset.to_shwi ();
 481                 else
 482                   maxsize = -1;
 483               }
 484           }
 485           break;
 486
 487         case ARRAY_REF:
 488         case ARRAY_RANGE_REF:
 489           {
 490             tree index = TREE_OPERAND (exp, 1);
 491             tree low_bound, unit_size;
 492
 493             /* If the resulting bit-offset is constant, track it.  */
 494             if (TREE_CODE (index) == INTEGER_CST
 495                 && (low_bound = array_ref_low_bound (exp),
 496                     TREE_CODE (low_bound) == INTEGER_CST)
 497                 && (unit_size = array_ref_element_size (exp),
 498                     TREE_CODE (unit_size) == INTEGER_CST))
 499               {
 500                 double_int doffset
 501                   = (TREE_INT_CST (index) - TREE_INT_CST (low_bound))
 502                     .sext (TYPE_PRECISION (TREE_TYPE (index)));
 503                 doffset *= tree_to_double_int (unit_size);
 504                 doffset = doffset.alshift (BITS_PER_UNIT == 8
 505                                            ? 3 : exact_log2 (BITS_PER_UNIT),
 506                                            HOST_BITS_PER_DOUBLE_INT);
 507                 bit_offset = bit_offset + doffset;
 508
 509                 /* An array ref with a constant index up in the structure
 510                    hierarchy will constrain the size of any variable array ref
 511                    lower in the access hierarchy.  */
 512                 seen_variable_array_ref = false;
 513               }
 514             else
 515               {
 516                 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 517                 /* We need to adjust maxsize to the whole array bitsize.
 518                    But we can subtract any constant offset seen so far,
 519                    because that would get us outside of the array otherwise.  */
 520                 if (maxsize != -1
 521                     && asize
 522                     && host_integerp (asize, 1)
 523                     && bit_offset.fits_shwi ())
 524                   maxsize = TREE_INT_CST_LOW (asize)
 525                             - bit_offset.to_shwi ();
 526                 else
 527                   maxsize = -1;
 528
 529                 /* Remember that we have seen an array ref with a variable
 530                    index.  */
 531                 seen_variable_array_ref = true;
 532               }
 533           }
 534           break;
 535
 536         case REALPART_EXPR:
 537           break;
 538
 539         case IMAGPART_EXPR:
 540           bit_offset += double_int::from_uhwi (bitsize);
 541           break;
 542
 543         case VIEW_CONVERT_EXPR:
 544           break;
 545
 546         case MEM_REF:
 547           /* Hand back the decl for MEM[&decl, off].  */
 548           if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
 549             {
 550               if (integer_zerop (TREE_OPERAND (exp, 1)))
 551                 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 552               else
 553                 {
 554                   double_int off = mem_ref_offset (exp);
 555                   off = off.alshift (BITS_PER_UNIT == 8
 556                                      ? 3 : exact_log2 (BITS_PER_UNIT),
 557                                      HOST_BITS_PER_DOUBLE_INT);
 558                   off = off + bit_offset;
 559                   if (off.fits_shwi ())
 560                     {
 561                       bit_offset = off;
 562                       exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 563                     }
 564                 }
 565             }
 566           goto done;
 567
 568         case TARGET_MEM_REF:
 569           /* Hand back the decl for MEM[&decl, off].  */
 570           if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR)
 571             {
 572               /* Via the variable index or index2 we can reach the
 573                  whole object.  */
 574               if (TMR_INDEX (exp) || TMR_INDEX2 (exp))
 575                 {
 576                   exp = TREE_OPERAND (TMR_BASE (exp), 0);
 577                   bit_offset = double_int_zero;
 578                   maxsize = -1;
 579                   goto done;
 580                 }
 581               if (integer_zerop (TMR_OFFSET (exp)))
 582                 exp = TREE_OPERAND (TMR_BASE (exp), 0);
 583               else
 584                 {
 585                   double_int off = mem_ref_offset (exp);
 586                   off = off.alshift (BITS_PER_UNIT == 8
 587                                      ? 3 : exact_log2 (BITS_PER_UNIT),
 588                                      HOST_BITS_PER_DOUBLE_INT);
 589                   off += bit_offset;
 590                   if (off.fits_shwi ())
 591                     {
 592                       bit_offset = off;
 593                       exp = TREE_OPERAND (TMR_BASE (exp), 0);
 594                     }
 595                 }
 596             }
 597           goto done;
 598
 599         default:
 600           goto done;
 601         }
 602
 603       exp = TREE_OPERAND (exp, 0);
 604     }
 605  done:
 606
 607   if (!bit_offset.fits_shwi ())
 608     {
 609       *poffset = 0;
 610       *psize = bitsize;
 611       *pmax_size = -1;
 612
 613       return exp;
 614     }
 615
 616   hbit_offset = bit_offset.to_shwi ();
 617
 618   /* We need to deal with variable arrays ending structures such as
 619        struct { int length; int a[1]; } x;           x.a[d]
 620        struct { struct { int a; int b; } a[1]; } x;  x.a[d].a
 621        struct { struct { int a[1]; } a[1]; } x;      x.a[0][d], x.a[d][0]
 622        struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
 623      where we do not know maxsize for variable index accesses to
 624      the array.  The simplest way to conservatively deal with this
 625      is to punt in the case that offset + maxsize reaches the
 626      base type boundary.  This needs to include possible trailing padding
 627      that is there for alignment purposes.  */
 628
 629   if (seen_variable_array_ref
 630       && maxsize != -1
 631       && (!host_integerp (TYPE_SIZE (base_type), 1)
 632           || (hbit_offset + maxsize
 633               == (signed) TREE_INT_CST_LOW (TYPE_SIZE (base_type)))))
 634     maxsize = -1;
 635
 636   /* In case of a decl or constant base object we can do better.  */
 637
 638   if (DECL_P (exp))
 639     {
 640       /* If maxsize is unknown adjust it according to the size of the
 641          base decl.  */
 642       if (maxsize == -1
 643           && host_integerp (DECL_SIZE (exp), 1))
 644         maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - hbit_offset;
 645     }
 646   else if (CONSTANT_CLASS_P (exp))
 647     {
 648       /* If maxsize is unknown adjust it according to the size of the
 649          base type constant.  */
 650       if (maxsize == -1
 651           && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1))
 652         maxsize = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))) - hbit_offset;
 653     }
 654
 655   /* ???  Due to negative offsets in ARRAY_REF we can end up with
 656      negative bit_offset here.  We might want to store a zero offset
 657      in this case.  */
 658   *poffset = hbit_offset;
 659   *psize = bitsize;
 660   *pmax_size = maxsize;
 661
 662   return exp;
 663 }
 664
 665 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
 666    denotes the starting address of the memory access EXP.
 667    Returns NULL_TREE if the offset is not constant or any component
 668    is not BITS_PER_UNIT-aligned.  */
 669
 670 tree
 671 get_addr_base_and_unit_offset (tree exp, HOST_WIDE_INT *poffset)
 672 {
 673   return get_addr_base_and_unit_offset_1 (exp, poffset, NULL);
 674 }
 675
 676 /* Returns true if STMT references an SSA_NAME that has
 677    SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false.  */
 678
 679 bool
 680 stmt_references_abnormal_ssa_name (gimple stmt)
 681 {
 682   ssa_op_iter oi;
 683   use_operand_p use_p;
 684
 685   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
 686     {
 687       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p)))
 688         return true;
 689     }
 690
 691   return false;
 692 }
 693
 694 /* Pair of tree and a sorting index, for dump_enumerated_decls.  */
 695 struct GTY(()) numbered_tree_d
 696 {
 697   tree t;
 698   int num;
 699 };
 700 typedef struct numbered_tree_d numbered_tree;
 701
 702
 703 /* Compare two declarations references by their DECL_UID / sequence number.
 704    Called via qsort.  */
 705
 706 static int
 707 compare_decls_by_uid (const void *pa, const void *pb)
 708 {
 709   const numbered_tree *nt_a = ((const numbered_tree *)pa);
 710   const numbered_tree *nt_b = ((const numbered_tree *)pb);
 711
 712   if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t))
 713     return  DECL_UID (nt_a->t) - DECL_UID (nt_b->t);
 714   return nt_a->num - nt_b->num;
 715 }
 716
 717 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls.  */
 718 static tree
 719 dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data)
 720 {
 721   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
 722   vec<numbered_tree> *list = (vec<numbered_tree> *) wi->info;
 723   numbered_tree nt;
 724
 725   if (!DECL_P (*tp))
 726     return NULL_TREE;
 727   nt.t = *tp;
 728   nt.num = list->length ();
 729   list->safe_push (nt);
 730   *walk_subtrees = 0;
 731   return NULL_TREE;
 732 }
 733
 734 /* Find all the declarations used by the current function, sort them by uid,
 735    and emit the sorted list.  Each declaration is tagged with a sequence
 736    number indicating when it was found during statement / tree walking,
 737    so that TDF_NOUID comparisons of anonymous declarations are still
 738    meaningful.  Where a declaration was encountered more than once, we
 739    emit only the sequence number of the first encounter.
 740    FILE is the dump file where to output the list and FLAGS is as in
 741    print_generic_expr.  */
 742 void
 743 dump_enumerated_decls (FILE *file, int flags)
 744 {
 745   basic_block bb;
 746   struct walk_stmt_info wi;
 747   vec<numbered_tree> decl_list;
 748   decl_list.create (40);
 749
 750   memset (&wi, '\0', sizeof (wi));
 751   wi.info = (void *) &decl_list;
 752   FOR_EACH_BB (bb)
 753     {
 754       gimple_stmt_iterator gsi;
 755
 756       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 757         if (!is_gimple_debug (gsi_stmt (gsi)))
 758           walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi);
 759     }
 760   decl_list.qsort (compare_decls_by_uid);
 761   if (decl_list.length ())
 762     {
 763       unsigned ix;
 764       numbered_tree *ntp;
 765       tree last = NULL_TREE;
 766
 767       fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n",
 768                current_function_name ());
 769       FOR_EACH_VEC_ELT (decl_list, ix, ntp)
 770         {
 771           if (ntp->t == last)
 772             continue;
 773           fprintf (file, "%d: ", ntp->num);
 774           print_generic_decl (file, ntp->t, flags);
 775           fprintf (file, "\n");
 776           last = ntp->t;
 777         }
 778     }
 779   decl_list.release ();
 780 }