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_fn (fn, var, gimple_build_nop ());
 366       set_ssa_default_def (fn, 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
 390   /* First get the final access size from just the outermost expression.  */
 391   if (TREE_CODE (exp) == COMPONENT_REF)
 392     size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
 393   else if (TREE_CODE (exp) == BIT_FIELD_REF)
 394     size_tree = TREE_OPERAND (exp, 1);
 395   else if (!VOID_TYPE_P (TREE_TYPE (exp)))
 396     {
 397       enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 398       if (mode == BLKmode)
 399         size_tree = TYPE_SIZE (TREE_TYPE (exp));
 400       else
 401         bitsize = GET_MODE_BITSIZE (mode);
 402     }
 403   if (size_tree != NULL_TREE)
 404     {
 405       if (! host_integerp (size_tree, 1))
 406         bitsize = -1;
 407       else
 408         bitsize = TREE_INT_CST_LOW (size_tree);
 409     }
 410
 411   /* Initially, maxsize is the same as the accessed element size.
 412      In the following it will only grow (or become -1).  */
 413   maxsize = bitsize;
 414
 415   /* Compute cumulative bit-offset for nested component-refs and array-refs,
 416      and find the ultimate containing object.  */
 417   while (1)
 418     {
 419       switch (TREE_CODE (exp))
 420         {
 421         case BIT_FIELD_REF:
 422           bit_offset += tree_to_double_int (TREE_OPERAND (exp, 2));
 423           break;
 424
 425         case COMPONENT_REF:
 426           {
 427             tree field = TREE_OPERAND (exp, 1);
 428             tree this_offset = component_ref_field_offset (exp);
 429
 430             if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
 431               {
 432                 double_int doffset = tree_to_double_int (this_offset);
 433                 doffset = doffset.alshift (BITS_PER_UNIT == 8
 434                                            ? 3 : exact_log2 (BITS_PER_UNIT),
 435                                            HOST_BITS_PER_DOUBLE_INT);
 436                 doffset += tree_to_double_int (DECL_FIELD_BIT_OFFSET (field));
 437                 bit_offset = bit_offset + doffset;
 438
 439                 /* If we had seen a variable array ref already and we just
 440                    referenced the last field of a struct or a union member
 441                    then we have to adjust maxsize by the padding at the end
 442                    of our field.  */
 443                 if (seen_variable_array_ref && maxsize != -1)
 444                   {
 445                     tree stype = TREE_TYPE (TREE_OPERAND (exp, 0));
 446                     tree next = DECL_CHAIN (field);
 447                     while (next && TREE_CODE (next) != FIELD_DECL)
 448                       next = DECL_CHAIN (next);
 449                     if (!next
 450                         || TREE_CODE (stype) != RECORD_TYPE)
 451                       {
 452                         tree fsize = DECL_SIZE_UNIT (field);
 453                         tree ssize = TYPE_SIZE_UNIT (stype);
 454                         if (host_integerp (fsize, 0)
 455                             && host_integerp (ssize, 0)
 456                             && doffset.fits_shwi ())
 457                           maxsize += ((TREE_INT_CST_LOW (ssize)
 458                                        - TREE_INT_CST_LOW (fsize))
 459                                       * BITS_PER_UNIT
 460                                         - doffset.to_shwi ());
 461                         else
 462                           maxsize = -1;
 463                       }
 464                   }
 465               }
 466             else
 467               {
 468                 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 469                 /* We need to adjust maxsize to the whole structure bitsize.
 470                    But we can subtract any constant offset seen so far,
 471                    because that would get us out of the structure otherwise.  */
 472                 if (maxsize != -1
 473                     && csize
 474                     && host_integerp (csize, 1)
 475                     && bit_offset.fits_shwi ())
 476                   maxsize = TREE_INT_CST_LOW (csize)
 477                             - bit_offset.to_shwi ();
 478                 else
 479                   maxsize = -1;
 480               }
 481           }
 482           break;
 483
 484         case ARRAY_REF:
 485         case ARRAY_RANGE_REF:
 486           {
 487             tree index = TREE_OPERAND (exp, 1);
 488             tree low_bound, unit_size;
 489
 490             /* If the resulting bit-offset is constant, track it.  */
 491             if (TREE_CODE (index) == INTEGER_CST
 492                 && (low_bound = array_ref_low_bound (exp),
 493                     TREE_CODE (low_bound) == INTEGER_CST)
 494                 && (unit_size = array_ref_element_size (exp),
 495                     TREE_CODE (unit_size) == INTEGER_CST))
 496               {
 497                 double_int doffset
 498                   = (TREE_INT_CST (index) - TREE_INT_CST (low_bound))
 499                     .sext (TYPE_PRECISION (TREE_TYPE (index)));
 500                 doffset *= tree_to_double_int (unit_size);
 501                 doffset = doffset.alshift (BITS_PER_UNIT == 8
 502                                            ? 3 : exact_log2 (BITS_PER_UNIT),
 503                                            HOST_BITS_PER_DOUBLE_INT);
 504                 bit_offset = bit_offset + doffset;
 505
 506                 /* An array ref with a constant index up in the structure
 507                    hierarchy will constrain the size of any variable array ref
 508                    lower in the access hierarchy.  */
 509                 seen_variable_array_ref = false;
 510               }
 511             else
 512               {
 513                 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 514                 /* We need to adjust maxsize to the whole array bitsize.
 515                    But we can subtract any constant offset seen so far,
 516                    because that would get us outside of the array otherwise.  */
 517                 if (maxsize != -1
 518                     && asize
 519                     && host_integerp (asize, 1)
 520                     && bit_offset.fits_shwi ())
 521                   maxsize = TREE_INT_CST_LOW (asize)
 522                             - bit_offset.to_shwi ();
 523                 else
 524                   maxsize = -1;
 525
 526                 /* Remember that we have seen an array ref with a variable
 527                    index.  */
 528                 seen_variable_array_ref = true;
 529               }
 530           }
 531           break;
 532
 533         case REALPART_EXPR:
 534           break;
 535
 536         case IMAGPART_EXPR:
 537           bit_offset += double_int::from_uhwi (bitsize);
 538           break;
 539
 540         case VIEW_CONVERT_EXPR:
 541           break;
 542
 543         case TARGET_MEM_REF:
 544           /* Via the variable index or index2 we can reach the
 545              whole object.  Still hand back the decl here.  */
 546           if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
 547               && (TMR_INDEX (exp) || TMR_INDEX2 (exp)))
 548             {
 549               exp = TREE_OPERAND (TMR_BASE (exp), 0);
 550               bit_offset = double_int_zero;
 551               maxsize = -1;
 552               goto done;
 553             }
 554           /* Fallthru.  */
 555         case MEM_REF:
 556           /* We need to deal with variable arrays ending structures such as
 557              struct { int length; int a[1]; } x;           x.a[d]
 558              struct { struct { int a; int b; } a[1]; } x;  x.a[d].a
 559              struct { struct { int a[1]; } a[1]; } x;      x.a[0][d], x.a[d][0]
 560              struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
 561              where we do not know maxsize for variable index accesses to
 562              the array.  The simplest way to conservatively deal with this
 563              is to punt in the case that offset + maxsize reaches the
 564              base type boundary.  This needs to include possible trailing
 565              padding that is there for alignment purposes.  */
 566           if (seen_variable_array_ref
 567               && maxsize != -1
 568               && (!bit_offset.fits_shwi ()
 569                   || !host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
 570                   || (bit_offset.to_shwi () + maxsize
 571                       == (HOST_WIDE_INT) TREE_INT_CST_LOW
 572                             (TYPE_SIZE (TREE_TYPE (exp))))))
 573             maxsize = -1;
 574
 575           /* Hand back the decl for MEM[&decl, off].  */
 576           if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
 577             {
 578               if (integer_zerop (TREE_OPERAND (exp, 1)))
 579                 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 580               else
 581                 {
 582                   double_int off = mem_ref_offset (exp);
 583                   off = off.alshift (BITS_PER_UNIT == 8
 584                                      ? 3 : exact_log2 (BITS_PER_UNIT),
 585                                      HOST_BITS_PER_DOUBLE_INT);
 586                   off = off + bit_offset;
 587                   if (off.fits_shwi ())
 588                     {
 589                       bit_offset = off;
 590                       exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 591                     }
 592                 }
 593             }
 594           goto done;
 595
 596         default:
 597           goto done;
 598         }
 599
 600       exp = TREE_OPERAND (exp, 0);
 601     }
 602
 603   /* We need to deal with variable arrays ending structures.  */
 604   if (seen_variable_array_ref
 605       && maxsize != -1
 606       && (!bit_offset.fits_shwi ()
 607           || !host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
 608           || (bit_offset.to_shwi () + maxsize
 609               == (HOST_WIDE_INT)
 610                    TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))))))
 611     maxsize = -1;
 612
 613  done:
 614   if (!bit_offset.fits_shwi ())
 615     {
 616       *poffset = 0;
 617       *psize = bitsize;
 618       *pmax_size = -1;
 619
 620       return exp;
 621     }
 622
 623   hbit_offset = bit_offset.to_shwi ();
 624
 625   /* In case of a decl or constant base object we can do better.  */
 626
 627   if (DECL_P (exp))
 628     {
 629       /* If maxsize is unknown adjust it according to the size of the
 630          base decl.  */
 631       if (maxsize == -1
 632           && host_integerp (DECL_SIZE (exp), 1))
 633         maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - hbit_offset;
 634     }
 635   else if (CONSTANT_CLASS_P (exp))
 636     {
 637       /* If maxsize is unknown adjust it according to the size of the
 638          base type constant.  */
 639       if (maxsize == -1
 640           && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1))
 641         maxsize = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))) - hbit_offset;
 642     }
 643
 644   /* ???  Due to negative offsets in ARRAY_REF we can end up with
 645      negative bit_offset here.  We might want to store a zero offset
 646      in this case.  */
 647   *poffset = hbit_offset;
 648   *psize = bitsize;
 649   *pmax_size = maxsize;
 650
 651   return exp;
 652 }
 653
 654 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that
 655    denotes the starting address of the memory access EXP.
 656    Returns NULL_TREE if the offset is not constant or any component
 657    is not BITS_PER_UNIT-aligned.  */
 658
 659 tree
 660 get_addr_base_and_unit_offset (tree exp, HOST_WIDE_INT *poffset)
 661 {
 662   return get_addr_base_and_unit_offset_1 (exp, poffset, NULL);
 663 }
 664
 665 /* Returns true if STMT references an SSA_NAME that has
 666    SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false.  */
 667
 668 bool
 669 stmt_references_abnormal_ssa_name (gimple stmt)
 670 {
 671   ssa_op_iter oi;
 672   use_operand_p use_p;
 673
 674   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE)
 675     {
 676       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p)))
 677         return true;
 678     }
 679
 680   return false;
 681 }
 682
 683 /* Pair of tree and a sorting index, for dump_enumerated_decls.  */
 684 struct GTY(()) numbered_tree_d
 685 {
 686   tree t;
 687   int num;
 688 };
 689 typedef struct numbered_tree_d numbered_tree;
 690
 691
 692 /* Compare two declarations references by their DECL_UID / sequence number.
 693    Called via qsort.  */
 694
 695 static int
 696 compare_decls_by_uid (const void *pa, const void *pb)
 697 {
 698   const numbered_tree *nt_a = ((const numbered_tree *)pa);
 699   const numbered_tree *nt_b = ((const numbered_tree *)pb);
 700
 701   if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t))
 702     return  DECL_UID (nt_a->t) - DECL_UID (nt_b->t);
 703   return nt_a->num - nt_b->num;
 704 }
 705
 706 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls.  */
 707 static tree
 708 dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data)
 709 {
 710   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
 711   vec<numbered_tree> *list = (vec<numbered_tree> *) wi->info;
 712   numbered_tree nt;
 713
 714   if (!DECL_P (*tp))
 715     return NULL_TREE;
 716   nt.t = *tp;
 717   nt.num = list->length ();
 718   list->safe_push (nt);
 719   *walk_subtrees = 0;
 720   return NULL_TREE;
 721 }
 722
 723 /* Find all the declarations used by the current function, sort them by uid,
 724    and emit the sorted list.  Each declaration is tagged with a sequence
 725    number indicating when it was found during statement / tree walking,
 726    so that TDF_NOUID comparisons of anonymous declarations are still
 727    meaningful.  Where a declaration was encountered more than once, we
 728    emit only the sequence number of the first encounter.
 729    FILE is the dump file where to output the list and FLAGS is as in
 730    print_generic_expr.  */
 731 void
 732 dump_enumerated_decls (FILE *file, int flags)
 733 {
 734   basic_block bb;
 735   struct walk_stmt_info wi;
 736   vec<numbered_tree> decl_list;
 737   decl_list.create (40);
 738
 739   memset (&wi, '\0', sizeof (wi));
 740   wi.info = (void *) &decl_list;
 741   FOR_EACH_BB (bb)
 742     {
 743       gimple_stmt_iterator gsi;
 744
 745       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 746         if (!is_gimple_debug (gsi_stmt (gsi)))
 747           walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi);
 748     }
 749   decl_list.qsort (compare_decls_by_uid);
 750   if (decl_list.length ())
 751     {
 752       unsigned ix;
 753       numbered_tree *ntp;
 754       tree last = NULL_TREE;
 755
 756       fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n",
 757                current_function_name ());
 758       FOR_EACH_VEC_ELT (decl_list, ix, ntp)
 759         {
 760           if (ntp->t == last)
 761             continue;
 762           fprintf (file, "%d: ", ntp->num);
 763           print_generic_decl (file, ntp->t, flags);
 764           fprintf (file, "\n");
 765           last = ntp->t;
 766         }
 767     }
 768   decl_list.release ();
 769 }