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 "gimple-ssa.h"
  37 #include "tree-phinodes.h"
  38 #include "ssa-iterators.h"
  39 #include "tree-ssanames.h"
  40 #include "tree-dfa.h"
  41 #include "tree-inline.h"
  42 #include "tree-pass.h"
  43 #include "convert.h"
  44 #include "params.h"
  45
  46 /* Build and maintain data flow information for trees.  */
  47
  48 /* Counters used to display DFA and SSA statistics.  */
  49 struct dfa_stats_d
  50 {
  51   long num_defs;
  52   long num_uses;
  53   long num_phis;
  54   long num_phi_args;
  55   size_t max_num_phi_args;
  56   long num_vdefs;
  57   long num_vuses;
  58 };
  59
  60
  61 /* Local functions.  */
  62 static void collect_dfa_stats (struct dfa_stats_d *);
  63
  64
  65 /*---------------------------------------------------------------------------
  66                         Dataflow analysis (DFA) routines
  67 ---------------------------------------------------------------------------*/
  68
  69 /* Renumber all of the gimple stmt uids.  */
  70
  71 void
  72 renumber_gimple_stmt_uids (void)
  73 {
  74   basic_block bb;
  75
  76   set_gimple_stmt_max_uid (cfun, 0);
  77   FOR_ALL_BB (bb)
  78     {
  79       gimple_stmt_iterator bsi;
  80       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
  81         {
  82           gimple stmt = gsi_stmt (bsi);
  83           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
  84         }
  85       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
  86         {
  87           gimple stmt = gsi_stmt (bsi);
  88           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
  89         }
  90     }
  91 }
  92
  93 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks
  94    in BLOCKS, of which there are N_BLOCKS.  Also renumbers PHIs.  */
  95
  96 void
  97 renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks)
  98 {
  99   int i;
 100
 101   set_gimple_stmt_max_uid (cfun, 0);
 102   for (i = 0; i < n_blocks; i++)
 103     {
 104       basic_block bb = blocks[i];
 105       gimple_stmt_iterator bsi;
 106       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 107         {
 108           gimple stmt = gsi_stmt (bsi);
 109           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 110         }
 111       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 112         {
 113           gimple stmt = gsi_stmt (bsi);
 114           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
 115         }
 116     }
 117 }
 118
 119
 120
 121 /*---------------------------------------------------------------------------
 122                               Debugging functions
 123 ---------------------------------------------------------------------------*/
 124
 125 /* Dump variable VAR and its may-aliases to FILE.  */
 126
 127 void
 128 dump_variable (FILE *file, tree var)
 129 {
 130   if (TREE_CODE (var) == SSA_NAME)
 131     {
 132       if (POINTER_TYPE_P (TREE_TYPE (var)))
 133         dump_points_to_info_for (file, var);
 134       var = SSA_NAME_VAR (var);
 135     }
 136
 137   if (var == NULL_TREE)
 138     {
 139       fprintf (file, "<nil>");
 140       return;
 141     }
 142
 143   print_generic_expr (file, var, dump_flags);
 144
 145   fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var));
 146   if (DECL_PT_UID (var) != DECL_UID (var))
 147     fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var));
 148
 149   fprintf (file, ", ");
 150   print_generic_expr (file, TREE_TYPE (var), dump_flags);
 151
 152   if (TREE_ADDRESSABLE (var))
 153     fprintf (file, ", is addressable");
 154
 155   if (is_global_var (var))
 156     fprintf (file, ", is global");
 157
 158   if (TREE_THIS_VOLATILE (var))
 159     fprintf (file, ", is volatile");
 160
 161   if (cfun && ssa_default_def (cfun, var))
 162     {
 163       fprintf (file, ", default def: ");
 164       print_generic_expr (file, ssa_default_def (cfun, var), dump_flags);
 165     }
 166
 167   if (DECL_INITIAL (var))
 168     {
 169       fprintf (file, ", initial: ");
 170       print_generic_expr (file, DECL_INITIAL (var), dump_flags);
 171     }
 172
 173   fprintf (file, "\n");
 174 }
 175
 176
 177 /* Dump variable VAR and its may-aliases to stderr.  */
 178
 179 DEBUG_FUNCTION void
 180 debug_variable (tree var)
 181 {
 182   dump_variable (stderr, var);
 183 }
 184
 185
 186 /* Dump various DFA statistics to FILE.  */
 187
 188 void
 189 dump_dfa_stats (FILE *file)
 190 {
 191   struct dfa_stats_d dfa_stats;
 192
 193   unsigned long size, total = 0;
 194   const char * const fmt_str   = "%-30s%-13s%12s\n";
 195   const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n";
 196   const char * const fmt_str_3 = "%-43s%11lu%c\n";
 197   const char *funcname
 198     = lang_hooks.decl_printable_name (current_function_decl, 2);
 199
 200   collect_dfa_stats (&dfa_stats);
 201
 202   fprintf (file, "\nDFA Statistics for %s\n\n", funcname);
 203
 204   fprintf (file, "---------------------------------------------------------\n");
 205   fprintf (file, fmt_str, "", "  Number of  ", "Memory");
 206   fprintf (file, fmt_str, "", "  instances  ", "used ");
 207   fprintf (file, "---------------------------------------------------------\n");
 208
 209   size = dfa_stats.num_uses * sizeof (tree *);
 210   total += size;
 211   fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses,
 212            SCALE (size), LABEL (size));
 213
 214   size = dfa_stats.num_defs * sizeof (tree *);
 215   total += size;
 216   fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs,
 217            SCALE (size), LABEL (size));
 218
 219   size = dfa_stats.num_vuses * sizeof (tree *);
 220   total += size;
 221   fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses,
 222            SCALE (size), LABEL (size));
 223
 224   size = dfa_stats.num_vdefs * sizeof (tree *);
 225   total += size;
 226   fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
 227            SCALE (size), LABEL (size));
 228
 229   size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
 230   total += size;
 231   fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
 232            SCALE (size), LABEL (size));
 233
 234   size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d);
 235   total += size;
 236   fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args,
 237            SCALE (size), LABEL (size));
 238
 239   fprintf (file, "---------------------------------------------------------\n");
 240   fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total),
 241            LABEL (total));
 242   fprintf (file, "---------------------------------------------------------\n");
 243   fprintf (file, "\n");
 244
 245   if (dfa_stats.num_phis)
 246     fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n",
 247              (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis,
 248              (long) dfa_stats.max_num_phi_args);
 249
 250   fprintf (file, "\n");
 251 }
 252
 253
 254 /* Dump DFA statistics on stderr.  */
 255
 256 DEBUG_FUNCTION void
 257 debug_dfa_stats (void)
 258 {
 259   dump_dfa_stats (stderr);
 260 }
 261
 262
 263 /* Collect DFA statistics and store them in the structure pointed to by
 264    DFA_STATS_P.  */
 265
 266 static void
 267 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED)
 268 {
 269   basic_block bb;
 270
 271   gcc_assert (dfa_stats_p);
 272
 273   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 274
 275   /* Walk all the statements in the function counting references.  */
 276   FOR_EACH_BB (bb)
 277     {
 278       gimple_stmt_iterator si;
 279
 280       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 281         {
 282           gimple phi = gsi_stmt (si);
 283           dfa_stats_p->num_phis++;
 284           dfa_stats_p->num_phi_args += gimple_phi_num_args (phi);
 285           if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args)
 286             dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi);
 287         }
 288
 289       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 290         {
 291           gimple stmt = gsi_stmt (si);
 292           dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF);
 293           dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE);
 294           dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0;
 295           dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0;
 296         }
 297     }
 298 }
 299
 300
 301 /*---------------------------------------------------------------------------
 302                              Miscellaneous helpers
 303 ---------------------------------------------------------------------------*/
 304
 305 /* Lookup VAR UID in the default_defs hashtable and return the associated
 306    variable.  */
 307
 308 tree
 309 ssa_default_def (struct function *fn, tree var)
 310 {
 311   struct tree_decl_minimal ind;
 312   struct tree_ssa_name in;
 313   gcc_assert (TREE_CODE (var) == VAR_DECL
 314               || TREE_CODE (var) == PARM_DECL
 315               || TREE_CODE (var) == RESULT_DECL);
 316   in.var = (tree)&ind;
 317   ind.uid = DECL_UID (var);
 318   return (tree) htab_find_with_hash (DEFAULT_DEFS (fn), &in, DECL_UID (var));
 319 }
 320
 321 /* Insert the pair VAR's UID, DEF into the default_defs hashtable
 322    of function FN.  */
 323
 324 void
 325 set_ssa_default_def (struct function *fn, tree var, tree def)
 326 {
 327   struct tree_decl_minimal ind;
 328   struct tree_ssa_name in;
 329   void **loc;
 330
 331   gcc_assert (TREE_CODE (var) == VAR_DECL
 332               || TREE_CODE (var) == PARM_DECL
 333               || TREE_CODE (var) == RESULT_DECL);
 334   in.var = (tree)&ind;
 335   ind.uid = DECL_UID (var);
 336   if (!def)
 337     {
 338       loc = htab_find_slot_with_hash (DEFAULT_DEFS (fn), &in,
 339                                       DECL_UID (var), NO_INSERT);
 340       if (*loc)
 341         {
 342           SSA_NAME_IS_DEFAULT_DEF (*(tree *)loc) = false;
 343           htab_clear_slot (DEFAULT_DEFS (fn), loc);
 344         }
 345       return;
 346     }
 347   gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var);
 348   loc = htab_find_slot_with_hash (DEFAULT_DEFS (fn), &in,
 349                                   DECL_UID (var), INSERT);
 350
 351   /* Default definition might be changed by tail call optimization.  */
 352   if (*loc)
 353     SSA_NAME_IS_DEFAULT_DEF (*(tree *) loc) = false;
 354
 355    /* Mark DEF as the default definition for VAR.  */
 356   *(tree *) loc = def;
 357   SSA_NAME_IS_DEFAULT_DEF (def) = true;
 358 }
 359
 360 /* Retrieve or create a default definition for VAR.  */
 361
 362 tree
 363 get_or_create_ssa_default_def (struct function *fn, tree var)
 364 {
 365   tree ddef = ssa_default_def (fn, var);
 366   if (ddef == NULL_TREE)
 367     {
 368       ddef = make_ssa_name_fn (fn, var, gimple_build_nop ());
 369       set_ssa_default_def (fn, var, ddef);
 370     }
 371   return ddef;
 372 }
 373
 374
 375 /* If EXP is a handled component reference for a structure, return the
 376    base variable.  The access range is delimited by bit positions *POFFSET and
 377    *POFFSET + *PMAX_SIZE.  The access size is *PSIZE bits.  If either
 378    *PSIZE or *PMAX_SIZE is -1, they could not be determined.  If *PSIZE
 379    and *PMAX_SIZE are equal, the access is non-variable.  */
 380
 381 tree
 382 get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
 383                          HOST_WIDE_INT *psize,
 384                          HOST_WIDE_INT *pmax_size)
 385 {
 386   HOST_WIDE_INT bitsize = -1;
 387   HOST_WIDE_INT maxsize = -1;
 388   tree size_tree = NULL_TREE;
 389   double_int bit_offset = double_int_zero;
 390   HOST_WIDE_INT hbit_offset;
 391   bool seen_variable_array_ref = false;
 392
 393   /* First get the final access size from just the outermost expression.  */
 394   if (TREE_CODE (exp) == COMPONENT_REF)
 395     size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
 396   else if (TREE_CODE (exp) == BIT_FIELD_REF)
 397     size_tree = TREE_OPERAND (exp, 1);
 398   else if (!VOID_TYPE_P (TREE_TYPE (exp)))
 399     {
 400       enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
 401       if (mode == BLKmode)
 402         size_tree = TYPE_SIZE (TREE_TYPE (exp));
 403       else
 404         bitsize = GET_MODE_BITSIZE (mode);
 405     }
 406   if (size_tree != NULL_TREE)
 407     {
 408       if (! host_integerp (size_tree, 1))
 409         bitsize = -1;
 410       else
 411         bitsize = TREE_INT_CST_LOW (size_tree);
 412     }
 413
 414   /* Initially, maxsize is the same as the accessed element size.
 415      In the following it will only grow (or become -1).  */
 416   maxsize = bitsize;
 417
 418   /* Compute cumulative bit-offset for nested component-refs and array-refs,
 419      and find the ultimate containing object.  */
 420   while (1)
 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.lshift (BITS_PER_UNIT == 8
 437                                           ? 3 : exact_log2 (BITS_PER_UNIT));
 438                 doffset += tree_to_double_int (DECL_FIELD_BIT_OFFSET (field));
 439                 bit_offset = bit_offset + doffset;
 440
 441                 /* If we had seen a variable array ref already and we just
 442                    referenced the last field of a struct or a union member
 443                    then we have to adjust maxsize by the padding at the end
 444                    of our field.  */
 445                 if (seen_variable_array_ref && maxsize != -1)
 446                   {
 447                     tree stype = TREE_TYPE (TREE_OPERAND (exp, 0));
 448                     tree next = DECL_CHAIN (field);
 449                     while (next && TREE_CODE (next) != FIELD_DECL)
 450                       next = DECL_CHAIN (next);
 451                     if (!next
 452                         || TREE_CODE (stype) != RECORD_TYPE)
 453                       {
 454                         tree fsize = DECL_SIZE_UNIT (field);
 455                         tree ssize = TYPE_SIZE_UNIT (stype);
 456                         if (host_integerp (fsize, 0)
 457                             && host_integerp (ssize, 0)
 458                             && doffset.fits_shwi ())
 459                           maxsize += ((TREE_INT_CST_LOW (ssize)
 460                                        - TREE_INT_CST_LOW (fsize))
 461                                       * BITS_PER_UNIT
 462                                         - doffset.to_shwi ());
 463                         else
 464                           maxsize = -1;
 465                       }
 466                   }
 467               }
 468             else
 469               {
 470                 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 471                 /* We need to adjust maxsize to the whole structure bitsize.
 472                    But we can subtract any constant offset seen so far,
 473                    because that would get us out of the structure otherwise.  */
 474                 if (maxsize != -1
 475                     && csize
 476                     && host_integerp (csize, 1)
 477                     && bit_offset.fits_shwi ())
 478                   maxsize = TREE_INT_CST_LOW (csize)
 479                             - bit_offset.to_shwi ();
 480                 else
 481                   maxsize = -1;
 482               }
 483           }
 484           break;
 485
 486         case ARRAY_REF:
 487         case ARRAY_RANGE_REF:
 488           {
 489             tree index = TREE_OPERAND (exp, 1);
 490             tree low_bound, unit_size;
 491
 492             /* If the resulting bit-offset is constant, track it.  */
 493             if (TREE_CODE (index) == INTEGER_CST
 494                 && (low_bound = array_ref_low_bound (exp),
 495                     TREE_CODE (low_bound) == INTEGER_CST)
 496                 && (unit_size = array_ref_element_size (exp),
 497                     TREE_CODE (unit_size) == INTEGER_CST))
 498               {
 499                 double_int doffset
 500                   = (TREE_INT_CST (index) - TREE_INT_CST (low_bound))
 501                     .sext (TYPE_PRECISION (TREE_TYPE (index)));
 502                 doffset *= tree_to_double_int (unit_size);
 503                 doffset = doffset.lshift (BITS_PER_UNIT == 8
 504                                           ? 3 : exact_log2 (BITS_PER_UNIT));
 505                 bit_offset = bit_offset + doffset;
 506
 507                 /* An array ref with a constant index up in the structure
 508                    hierarchy will constrain the size of any variable array ref
 509                    lower in the access hierarchy.  */
 510                 seen_variable_array_ref = false;
 511               }
 512             else
 513               {
 514                 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 515                 /* We need to adjust maxsize to the whole array bitsize.
 516                    But we can subtract any constant offset seen so far,
 517                    because that would get us outside of the array otherwise.  */
 518                 if (maxsize != -1
 519                     && asize
 520                     && host_integerp (asize, 1)
 521                     && bit_offset.fits_shwi ())
 522                   maxsize = TREE_INT_CST_LOW (asize)
 523                             - bit_offset.to_shwi ();
 524                 else
 525                   maxsize = -1;
 526
 527                 /* Remember that we have seen an array ref with a variable
 528                    index.  */
 529                 seen_variable_array_ref = true;
 530               }
 531           }
 532           break;
 533
 534         case REALPART_EXPR:
 535           break;
 536
 537         case IMAGPART_EXPR:
 538           bit_offset += double_int::from_uhwi (bitsize);
 539           break;
 540
 541         case VIEW_CONVERT_EXPR:
 542           break;
 543
 544         case TARGET_MEM_REF:
 545           /* Via the variable index or index2 we can reach the
 546              whole object.  Still hand back the decl here.  */
 547           if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
 548               && (TMR_INDEX (exp) || TMR_INDEX2 (exp)))
 549             {
 550               exp = TREE_OPERAND (TMR_BASE (exp), 0);
 551               bit_offset = double_int_zero;
 552               maxsize = -1;
 553               goto done;
 554             }
 555           /* Fallthru.  */
 556         case MEM_REF:
 557           /* We need to deal with variable arrays ending structures such as
 558              struct { int length; int a[1]; } x;           x.a[d]
 559              struct { struct { int a; int b; } a[1]; } x;  x.a[d].a
 560              struct { struct { int a[1]; } a[1]; } x;      x.a[0][d], x.a[d][0]
 561              struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d]
 562              where we do not know maxsize for variable index accesses to
 563              the array.  The simplest way to conservatively deal with this
 564              is to punt in the case that offset + maxsize reaches the
 565              base type boundary.  This needs to include possible trailing
 566              padding that is there for alignment purposes.  */
 567           if (seen_variable_array_ref
 568               && maxsize != -1
 569               && (!bit_offset.fits_shwi ()
 570                   || !host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)
 571                   || (bit_offset.to_shwi () + maxsize
 572                       == (HOST_WIDE_INT) TREE_INT_CST_LOW
 573                             (TYPE_SIZE (TREE_TYPE (exp))))))
 574             maxsize = -1;
 575
 576           /* Hand back the decl for MEM[&decl, off].  */
 577           if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
 578             {
 579               if (integer_zerop (TREE_OPERAND (exp, 1)))
 580                 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 581               else
 582                 {
 583                   double_int off = mem_ref_offset (exp);
 584                   off = off.lshift (BITS_PER_UNIT == 8
 585                                     ? 3 : exact_log2 (BITS_PER_UNIT));
 586                   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) TREE_INT_CST_LOW
 610                    (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   stack_vec<numbered_tree, 40> decl_list;
 737
 738   memset (&wi, '\0', sizeof (wi));
 739   wi.info = (void *) &decl_list;
 740   FOR_EACH_BB (bb)
 741     {
 742       gimple_stmt_iterator gsi;
 743
 744       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 745         if (!is_gimple_debug (gsi_stmt (gsi)))
 746           walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi);
 747     }
 748   decl_list.qsort (compare_decls_by_uid);
 749   if (decl_list.length ())
 750     {
 751       unsigned ix;
 752       numbered_tree *ntp;
 753       tree last = NULL_TREE;
 754
 755       fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n",
 756                current_function_name ());
 757       FOR_EACH_VEC_ELT (decl_list, ix, ntp)
 758         {
 759           if (ntp->t == last)
 760             continue;
 761           fprintf (file, "%d: ", ntp->num);
 762           print_generic_decl (file, ntp->t, flags);
 763           fprintf (file, "\n");
 764           last = ntp->t;
 765         }
 766     }
 767 }