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