gcc/tree.c

   1 /* Language-independent node constructors for parse phase of GNU compiler.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* This file contains the low level primitives for operating on tree nodes,
  23    including allocation, list operations, interning of identifiers,
  24    construction of data type nodes and statement nodes,
  25    and construction of type conversion nodes.  It also contains
  26    tables index by tree code that describe how to take apart
  27    nodes of that code.
  28
  29    It is intended to be language-independent, but occasionally
  30    calls language-dependent routines defined (for C) in typecheck.c.  */
  31
  32 #include "config.h"
  33 #include "system.h"
  34 #include "coretypes.h"
  35 #include "tm.h"
  36 #include "flags.h"
  37 #include "tree.h"
  38 #include "real.h"
  39 #include "tm_p.h"
  40 #include "function.h"
  41 #include "obstack.h"
  42 #include "toplev.h"
  43 #include "ggc.h"
  44 #include "hashtab.h"
  45 #include "output.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "tree-inline.h"
  49 #include "tree-iterator.h"
  50 #include "basic-block.h"
  51 #include "tree-flow.h"
  52 #include "params.h"
  53 #include "pointer-set.h"
  54 #include "fixed-value.h"
  55 #include "tree-pass.h"
  56 #include "langhooks-def.h"
  57 #include "diagnostic.h"
  58 #include "cgraph.h"
  59 #include "timevar.h"
  60 #include "except.h"
  61 #include "debug.h"
  62 #include "intl.h"
  63
  64 /* Tree code classes.  */
  65
  66 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  67 #define END_OF_BASE_TREE_CODES tcc_exceptional,
  68
  69 const enum tree_code_class tree_code_type[] = {
  70 #include "all-tree.def"
  71 };
  72
  73 #undef DEFTREECODE
  74 #undef END_OF_BASE_TREE_CODES
  75
  76 /* Table indexed by tree code giving number of expression
  77    operands beyond the fixed part of the node structure.
  78    Not used for types or decls.  */
  79
  80 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  81 #define END_OF_BASE_TREE_CODES 0,
  82
  83 const unsigned char tree_code_length[] = {
  84 #include "all-tree.def"
  85 };
  86
  87 #undef DEFTREECODE
  88 #undef END_OF_BASE_TREE_CODES
  89
  90 /* Names of tree components.
  91    Used for printing out the tree and error messages.  */
  92 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
  93 #define END_OF_BASE_TREE_CODES "@dummy",
  94
  95 const char *const tree_code_name[] = {
  96 #include "all-tree.def"
  97 };
  98
  99 #undef DEFTREECODE
 100 #undef END_OF_BASE_TREE_CODES
 101
 102 /* Each tree code class has an associated string representation.
 103    These must correspond to the tree_code_class entries.  */
 104
 105 const char *const tree_code_class_strings[] =
 106 {
 107   "exceptional",
 108   "constant",
 109   "type",
 110   "declaration",
 111   "reference",
 112   "comparison",
 113   "unary",
 114   "binary",
 115   "statement",
 116   "vl_exp",
 117   "expression"
 118 };
 119
 120 /* obstack.[ch] explicitly declined to prototype this.  */
 121 extern int _obstack_allocated_p (struct obstack *h, void *obj);
 122
 123 #ifdef GATHER_STATISTICS
 124 /* Statistics-gathering stuff.  */
 125
 126 int tree_node_counts[(int) all_kinds];
 127 int tree_node_sizes[(int) all_kinds];
 128
 129 /* Keep in sync with tree.h:enum tree_node_kind.  */
 130 static const char * const tree_node_kind_names[] = {
 131   "decls",
 132   "types",
 133   "blocks",
 134   "stmts",
 135   "refs",
 136   "exprs",
 137   "constants",
 138   "identifiers",
 139   "perm_tree_lists",
 140   "temp_tree_lists",
 141   "vecs",
 142   "binfos",
 143   "ssa names",
 144   "constructors",
 145   "random kinds",
 146   "lang_decl kinds",
 147   "lang_type kinds",
 148   "omp clauses",
 149 };
 150 #endif /* GATHER_STATISTICS */
 151
 152 /* Unique id for next decl created.  */
 153 static GTY(()) int next_decl_uid;
 154 /* Unique id for next type created.  */
 155 static GTY(()) int next_type_uid = 1;
 156 /* Unique id for next debug decl created.  Use negative numbers,
 157    to catch erroneous uses.  */
 158 static GTY(()) int next_debug_decl_uid;
 159
 160 /* Since we cannot rehash a type after it is in the table, we have to
 161    keep the hash code.  */
 162
 163 struct GTY(()) type_hash {
 164   unsigned long hash;
 165   tree type;
 166 };
 167
 168 /* Initial size of the hash table (rounded to next prime).  */
 169 #define TYPE_HASH_INITIAL_SIZE 1000
 170
 171 /* Now here is the hash table.  When recording a type, it is added to
 172    the slot whose index is the hash code.  Note that the hash table is
 173    used for several kinds of types (function types, array types and
 174    array index range types, for now).  While all these live in the
 175    same table, they are completely independent, and the hash code is
 176    computed differently for each of these.  */
 177
 178 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
 179      htab_t type_hash_table;
 180
 181 /* Hash table and temporary node for larger integer const values.  */
 182 static GTY (()) tree int_cst_node;
 183 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
 184      htab_t int_cst_hash_table;
 185
 186 /* Hash table for optimization flags and target option flags.  Use the same
 187    hash table for both sets of options.  Nodes for building the current
 188    optimization and target option nodes.  The assumption is most of the time
 189    the options created will already be in the hash table, so we avoid
 190    allocating and freeing up a node repeatably.  */
 191 static GTY (()) tree cl_optimization_node;
 192 static GTY (()) tree cl_target_option_node;
 193 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
 194      htab_t cl_option_hash_table;
 195
 196 /* General tree->tree mapping  structure for use in hash tables.  */
 197
 198
 199 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 200      htab_t debug_expr_for_decl;
 201
 202 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 203      htab_t value_expr_for_decl;
 204
 205 static GTY ((if_marked ("tree_priority_map_marked_p"),
 206              param_is (struct tree_priority_map)))
 207   htab_t init_priority_for_decl;
 208
 209 static void set_type_quals (tree, int);
 210 static int type_hash_eq (const void *, const void *);
 211 static hashval_t type_hash_hash (const void *);
 212 static hashval_t int_cst_hash_hash (const void *);
 213 static int int_cst_hash_eq (const void *, const void *);
 214 static hashval_t cl_option_hash_hash (const void *);
 215 static int cl_option_hash_eq (const void *, const void *);
 216 static void print_type_hash_statistics (void);
 217 static void print_debug_expr_statistics (void);
 218 static void print_value_expr_statistics (void);
 219 static int type_hash_marked_p (const void *);
 220 static unsigned int type_hash_list (const_tree, hashval_t);
 221 static unsigned int attribute_hash_list (const_tree, hashval_t);
 222
 223 tree global_trees[TI_MAX];
 224 tree integer_types[itk_none];
 225
 226 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
 227
 228 /* Number of operands for each OpenMP clause.  */
 229 unsigned const char omp_clause_num_ops[] =
 230 {
 231   0, /* OMP_CLAUSE_ERROR  */
 232   1, /* OMP_CLAUSE_PRIVATE  */
 233   1, /* OMP_CLAUSE_SHARED  */
 234   1, /* OMP_CLAUSE_FIRSTPRIVATE  */
 235   2, /* OMP_CLAUSE_LASTPRIVATE  */
 236   4, /* OMP_CLAUSE_REDUCTION  */
 237   1, /* OMP_CLAUSE_COPYIN  */
 238   1, /* OMP_CLAUSE_COPYPRIVATE  */
 239   1, /* OMP_CLAUSE_IF  */
 240   1, /* OMP_CLAUSE_NUM_THREADS  */
 241   1, /* OMP_CLAUSE_SCHEDULE  */
 242   0, /* OMP_CLAUSE_NOWAIT  */
 243   0, /* OMP_CLAUSE_ORDERED  */
 244   0, /* OMP_CLAUSE_DEFAULT  */
 245   3, /* OMP_CLAUSE_COLLAPSE  */
 246   0  /* OMP_CLAUSE_UNTIED   */
 247 };
 248
 249 const char * const omp_clause_code_name[] =
 250 {
 251   "error_clause",
 252   "private",
 253   "shared",
 254   "firstprivate",
 255   "lastprivate",
 256   "reduction",
 257   "copyin",
 258   "copyprivate",
 259   "if",
 260   "num_threads",
 261   "schedule",
 262   "nowait",
 263   "ordered",
 264   "default",
 265   "collapse",
 266   "untied"
 267 };
 268
 269
 270 /* Return the tree node structure used by tree code CODE.  */
 271
 272 static inline enum tree_node_structure_enum
 273 tree_node_structure_for_code (enum tree_code code)
 274 {
 275   switch (TREE_CODE_CLASS (code))
 276     {
 277     case tcc_declaration:
 278       {
 279         switch (code)
 280           {
 281           case FIELD_DECL:
 282             return TS_FIELD_DECL;
 283           case PARM_DECL:
 284             return TS_PARM_DECL;
 285           case VAR_DECL:
 286             return TS_VAR_DECL;
 287           case LABEL_DECL:
 288             return TS_LABEL_DECL;
 289           case RESULT_DECL:
 290             return TS_RESULT_DECL;
 291           case DEBUG_EXPR_DECL:
 292             return TS_DECL_WRTL;
 293           case CONST_DECL:
 294             return TS_CONST_DECL;
 295           case TYPE_DECL:
 296             return TS_TYPE_DECL;
 297           case FUNCTION_DECL:
 298             return TS_FUNCTION_DECL;
 299           default:
 300             return TS_DECL_NON_COMMON;
 301           }
 302       }
 303     case tcc_type:
 304       return TS_TYPE;
 305     case tcc_reference:
 306     case tcc_comparison:
 307     case tcc_unary:
 308     case tcc_binary:
 309     case tcc_expression:
 310     case tcc_statement:
 311     case tcc_vl_exp:
 312       return TS_EXP;
 313     default:  /* tcc_constant and tcc_exceptional */
 314       break;
 315     }
 316   switch (code)
 317     {
 318       /* tcc_constant cases.  */
 319     case INTEGER_CST:           return TS_INT_CST;
 320     case REAL_CST:              return TS_REAL_CST;
 321     case FIXED_CST:             return TS_FIXED_CST;
 322     case COMPLEX_CST:           return TS_COMPLEX;
 323     case VECTOR_CST:            return TS_VECTOR;
 324     case STRING_CST:            return TS_STRING;
 325       /* tcc_exceptional cases.  */
 326     case ERROR_MARK:            return TS_COMMON;
 327     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
 328     case TREE_LIST:             return TS_LIST;
 329     case TREE_VEC:              return TS_VEC;
 330     case SSA_NAME:              return TS_SSA_NAME;
 331     case PLACEHOLDER_EXPR:      return TS_COMMON;
 332     case STATEMENT_LIST:        return TS_STATEMENT_LIST;
 333     case BLOCK:                 return TS_BLOCK;
 334     case CONSTRUCTOR:           return TS_CONSTRUCTOR;
 335     case TREE_BINFO:            return TS_BINFO;
 336     case OMP_CLAUSE:            return TS_OMP_CLAUSE;
 337     case OPTIMIZATION_NODE:     return TS_OPTIMIZATION;
 338     case TARGET_OPTION_NODE:    return TS_TARGET_OPTION;
 339
 340     default:
 341       gcc_unreachable ();
 342     }
 343 }
 344
 345
 346 /* Initialize tree_contains_struct to describe the hierarchy of tree
 347    nodes.  */
 348
 349 static void
 350 initialize_tree_contains_struct (void)
 351 {
 352   unsigned i;
 353
 354 #define MARK_TS_BASE(C)                                 \
 355   do {                                                  \
 356     tree_contains_struct[C][TS_BASE] = 1;               \
 357   } while (0)
 358
 359 #define MARK_TS_COMMON(C)                               \
 360   do {                                                  \
 361     MARK_TS_BASE (C);                                   \
 362     tree_contains_struct[C][TS_COMMON] = 1;             \
 363   } while (0)
 364
 365 #define MARK_TS_DECL_MINIMAL(C)                         \
 366   do {                                                  \
 367     MARK_TS_COMMON (C);                                 \
 368     tree_contains_struct[C][TS_DECL_MINIMAL] = 1;       \
 369   } while (0)
 370
 371 #define MARK_TS_DECL_COMMON(C)                          \
 372   do {                                                  \
 373     MARK_TS_DECL_MINIMAL (C);                           \
 374     tree_contains_struct[C][TS_DECL_COMMON] = 1;        \
 375   } while (0)
 376
 377 #define MARK_TS_DECL_WRTL(C)                            \
 378   do {                                                  \
 379     MARK_TS_DECL_COMMON (C);                            \
 380     tree_contains_struct[C][TS_DECL_WRTL] = 1;          \
 381   } while (0)
 382
 383 #define MARK_TS_DECL_WITH_VIS(C)                        \
 384   do {                                                  \
 385     MARK_TS_DECL_WRTL (C);                              \
 386     tree_contains_struct[C][TS_DECL_WITH_VIS] = 1;      \
 387   } while (0)
 388
 389 #define MARK_TS_DECL_NON_COMMON(C)                      \
 390   do {                                                  \
 391     MARK_TS_DECL_WITH_VIS (C);                          \
 392     tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;    \
 393   } while (0)
 394
 395   for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
 396     {
 397       enum tree_code code;
 398       enum tree_node_structure_enum ts_code;
 399
 400       code = (enum tree_code) i;
 401       ts_code = tree_node_structure_for_code (code);
 402
 403       /* Mark the TS structure itself.  */
 404       tree_contains_struct[code][ts_code] = 1;
 405
 406       /* Mark all the structures that TS is derived from.  */
 407       switch (ts_code)
 408         {
 409         case TS_COMMON:
 410           MARK_TS_BASE (code);
 411           break;
 412
 413         case TS_INT_CST:
 414         case TS_REAL_CST:
 415         case TS_FIXED_CST:
 416         case TS_VECTOR:
 417         case TS_STRING:
 418         case TS_COMPLEX:
 419         case TS_IDENTIFIER:
 420         case TS_DECL_MINIMAL:
 421         case TS_TYPE:
 422         case TS_LIST:
 423         case TS_VEC:
 424         case TS_EXP:
 425         case TS_SSA_NAME:
 426         case TS_BLOCK:
 427         case TS_BINFO:
 428         case TS_STATEMENT_LIST:
 429         case TS_CONSTRUCTOR:
 430         case TS_OMP_CLAUSE:
 431         case TS_OPTIMIZATION:
 432         case TS_TARGET_OPTION:
 433           MARK_TS_COMMON (code);
 434           break;
 435
 436         case TS_DECL_COMMON:
 437           MARK_TS_DECL_MINIMAL (code);
 438           break;
 439
 440         case TS_DECL_WRTL:
 441           MARK_TS_DECL_COMMON (code);
 442           break;
 443
 444         case TS_DECL_NON_COMMON:
 445           MARK_TS_DECL_WITH_VIS (code);
 446           break;
 447
 448         case TS_DECL_WITH_VIS:
 449         case TS_PARM_DECL:
 450         case TS_LABEL_DECL:
 451         case TS_RESULT_DECL:
 452         case TS_CONST_DECL:
 453           MARK_TS_DECL_WRTL (code);
 454           break;
 455
 456         case TS_FIELD_DECL:
 457           MARK_TS_DECL_COMMON (code);
 458           break;
 459
 460         case TS_VAR_DECL:
 461           MARK_TS_DECL_WITH_VIS (code);
 462           break;
 463
 464         case TS_TYPE_DECL:
 465         case TS_FUNCTION_DECL:
 466           MARK_TS_DECL_NON_COMMON (code);
 467           break;
 468
 469         default:
 470           gcc_unreachable ();
 471         }
 472     }
 473
 474   /* Basic consistency checks for attributes used in fold.  */
 475   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
 476   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON]);
 477   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
 478   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
 479   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
 480   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
 481   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
 482   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
 483   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
 484   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
 485   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
 486   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
 487   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]);
 488   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
 489   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
 490   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
 491   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
 492   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
 493   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
 494   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
 495   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
 496   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
 497   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
 498   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
 499   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
 500   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
 501   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
 502   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
 503   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
 504   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
 505   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS]);
 506   gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
 507   gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
 508   gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
 509   gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
 510   gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
 511   gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
 512   gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
 513   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
 514   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
 515   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
 516
 517 #undef MARK_TS_BASE
 518 #undef MARK_TS_COMMON
 519 #undef MARK_TS_DECL_MINIMAL
 520 #undef MARK_TS_DECL_COMMON
 521 #undef MARK_TS_DECL_WRTL
 522 #undef MARK_TS_DECL_WITH_VIS
 523 #undef MARK_TS_DECL_NON_COMMON
 524 }
 525
 526
 527 /* Init tree.c.  */
 528
 529 void
 530 init_ttree (void)
 531 {
 532   /* Initialize the hash table of types.  */
 533   type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
 534                                      type_hash_eq, 0);
 535
 536   debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
 537                                          tree_map_eq, 0);
 538
 539   value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
 540                                          tree_map_eq, 0);
 541   init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
 542                                             tree_priority_map_eq, 0);
 543
 544   int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
 545                                         int_cst_hash_eq, NULL);
 546
 547   int_cst_node = make_node (INTEGER_CST);
 548
 549   cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
 550                                           cl_option_hash_eq, NULL);
 551
 552   cl_optimization_node = make_node (OPTIMIZATION_NODE);
 553   cl_target_option_node = make_node (TARGET_OPTION_NODE);
 554
 555   /* Initialize the tree_contains_struct array.  */
 556   initialize_tree_contains_struct ();
 557   lang_hooks.init_ts ();
 558 }
 559
 560 \f
 561 /* The name of the object as the assembler will see it (but before any
 562    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
 563    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
 564 tree
 565 decl_assembler_name (tree decl)
 566 {
 567   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 568     lang_hooks.set_decl_assembler_name (decl);
 569   return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
 570 }
 571
 572 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
 573
 574 bool
 575 decl_assembler_name_equal (tree decl, const_tree asmname)
 576 {
 577   tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
 578   const char *decl_str;
 579   const char *asmname_str;
 580   bool test = false;
 581
 582   if (decl_asmname == asmname)
 583     return true;
 584
 585   decl_str = IDENTIFIER_POINTER (decl_asmname);
 586   asmname_str = IDENTIFIER_POINTER (asmname);
 587
 588
 589   /* If the target assembler name was set by the user, things are trickier.
 590      We have a leading '*' to begin with.  After that, it's arguable what
 591      is the correct thing to do with -fleading-underscore.  Arguably, we've
 592      historically been doing the wrong thing in assemble_alias by always
 593      printing the leading underscore.  Since we're not changing that, make
 594      sure user_label_prefix follows the '*' before matching.  */
 595   if (decl_str[0] == '*')
 596     {
 597       size_t ulp_len = strlen (user_label_prefix);
 598
 599       decl_str ++;
 600
 601       if (ulp_len == 0)
 602         test = true;
 603       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 604         decl_str += ulp_len, test=true;
 605       else
 606         decl_str --;
 607     }
 608   if (asmname_str[0] == '*')
 609     {
 610       size_t ulp_len = strlen (user_label_prefix);
 611
 612       asmname_str ++;
 613
 614       if (ulp_len == 0)
 615         test = true;
 616       else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
 617         asmname_str += ulp_len, test=true;
 618       else
 619         asmname_str --;
 620     }
 621
 622   if (!test)
 623     return false;
 624   return strcmp (decl_str, asmname_str) == 0;
 625 }
 626
 627 /* Hash asmnames ignoring the user specified marks.  */
 628
 629 hashval_t
 630 decl_assembler_name_hash (const_tree asmname)
 631 {
 632   if (IDENTIFIER_POINTER (asmname)[0] == '*')
 633     {
 634       const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
 635       size_t ulp_len = strlen (user_label_prefix);
 636
 637       if (ulp_len == 0)
 638         ;
 639       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 640         decl_str += ulp_len;
 641
 642       return htab_hash_string (decl_str);
 643     }
 644
 645   return htab_hash_string (IDENTIFIER_POINTER (asmname));
 646 }
 647
 648 /* Compute the number of bytes occupied by a tree with code CODE.
 649    This function cannot be used for nodes that have variable sizes,
 650    including TREE_VEC, STRING_CST, and CALL_EXPR.  */
 651 size_t
 652 tree_code_size (enum tree_code code)
 653 {
 654   switch (TREE_CODE_CLASS (code))
 655     {
 656     case tcc_declaration:  /* A decl node */
 657       {
 658         switch (code)
 659           {
 660           case FIELD_DECL:
 661             return sizeof (struct tree_field_decl);
 662           case PARM_DECL:
 663             return sizeof (struct tree_parm_decl);
 664           case VAR_DECL:
 665             return sizeof (struct tree_var_decl);
 666           case LABEL_DECL:
 667             return sizeof (struct tree_label_decl);
 668           case RESULT_DECL:
 669             return sizeof (struct tree_result_decl);
 670           case CONST_DECL:
 671             return sizeof (struct tree_const_decl);
 672           case TYPE_DECL:
 673             return sizeof (struct tree_type_decl);
 674           case FUNCTION_DECL:
 675             return sizeof (struct tree_function_decl);
 676           case DEBUG_EXPR_DECL:
 677             return sizeof (struct tree_decl_with_rtl);
 678           default:
 679             return sizeof (struct tree_decl_non_common);
 680           }
 681       }
 682
 683     case tcc_type:  /* a type node */
 684       return sizeof (struct tree_type);
 685
 686     case tcc_reference:   /* a reference */
 687     case tcc_expression:  /* an expression */
 688     case tcc_statement:   /* an expression with side effects */
 689     case tcc_comparison:  /* a comparison expression */
 690     case tcc_unary:       /* a unary arithmetic expression */
 691     case tcc_binary:      /* a binary arithmetic expression */
 692       return (sizeof (struct tree_exp)
 693               + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
 694
 695     case tcc_constant:  /* a constant */
 696       switch (code)
 697         {
 698         case INTEGER_CST:       return sizeof (struct tree_int_cst);
 699         case REAL_CST:          return sizeof (struct tree_real_cst);
 700         case FIXED_CST:         return sizeof (struct tree_fixed_cst);
 701         case COMPLEX_CST:       return sizeof (struct tree_complex);
 702         case VECTOR_CST:        return sizeof (struct tree_vector);
 703         case STRING_CST:        gcc_unreachable ();
 704         default:
 705           return lang_hooks.tree_size (code);
 706         }
 707
 708     case tcc_exceptional:  /* something random, like an identifier.  */
 709       switch (code)
 710         {
 711         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
 712         case TREE_LIST:         return sizeof (struct tree_list);
 713
 714         case ERROR_MARK:
 715         case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
 716
 717         case TREE_VEC:
 718         case OMP_CLAUSE:        gcc_unreachable ();
 719
 720         case SSA_NAME:          return sizeof (struct tree_ssa_name);
 721
 722         case STATEMENT_LIST:    return sizeof (struct tree_statement_list);
 723         case BLOCK:             return sizeof (struct tree_block);
 724         case CONSTRUCTOR:       return sizeof (struct tree_constructor);
 725         case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
 726         case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
 727
 728         default:
 729           return lang_hooks.tree_size (code);
 730         }
 731
 732     default:
 733       gcc_unreachable ();
 734     }
 735 }
 736
 737 /* Compute the number of bytes occupied by NODE.  This routine only
 738    looks at TREE_CODE, except for those nodes that have variable sizes.  */
 739 size_t
 740 tree_size (const_tree node)
 741 {
 742   const enum tree_code code = TREE_CODE (node);
 743   switch (code)
 744     {
 745     case TREE_BINFO:
 746       return (offsetof (struct tree_binfo, base_binfos)
 747               + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
 748
 749     case TREE_VEC:
 750       return (sizeof (struct tree_vec)
 751               + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
 752
 753     case STRING_CST:
 754       return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
 755
 756     case OMP_CLAUSE:
 757       return (sizeof (struct tree_omp_clause)
 758               + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
 759                 * sizeof (tree));
 760
 761     default:
 762       if (TREE_CODE_CLASS (code) == tcc_vl_exp)
 763         return (sizeof (struct tree_exp)
 764                 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
 765       else
 766         return tree_code_size (code);
 767     }
 768 }
 769
 770 /* Return a newly allocated node of code CODE.  For decl and type
 771    nodes, some other fields are initialized.  The rest of the node is
 772    initialized to zero.  This function cannot be used for TREE_VEC or
 773    OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
 774
 775    Achoo!  I got a code in the node.  */
 776
 777 tree
 778 make_node_stat (enum tree_code code MEM_STAT_DECL)
 779 {
 780   tree t;
 781   enum tree_code_class type = TREE_CODE_CLASS (code);
 782   size_t length = tree_code_size (code);
 783 #ifdef GATHER_STATISTICS
 784   tree_node_kind kind;
 785
 786   switch (type)
 787     {
 788     case tcc_declaration:  /* A decl node */
 789       kind = d_kind;
 790       break;
 791
 792     case tcc_type:  /* a type node */
 793       kind = t_kind;
 794       break;
 795
 796     case tcc_statement:  /* an expression with side effects */
 797       kind = s_kind;
 798       break;
 799
 800     case tcc_reference:  /* a reference */
 801       kind = r_kind;
 802       break;
 803
 804     case tcc_expression:  /* an expression */
 805     case tcc_comparison:  /* a comparison expression */
 806     case tcc_unary:  /* a unary arithmetic expression */
 807     case tcc_binary:  /* a binary arithmetic expression */
 808       kind = e_kind;
 809       break;
 810
 811     case tcc_constant:  /* a constant */
 812       kind = c_kind;
 813       break;
 814
 815     case tcc_exceptional:  /* something random, like an identifier.  */
 816       switch (code)
 817         {
 818         case IDENTIFIER_NODE:
 819           kind = id_kind;
 820           break;
 821
 822         case TREE_VEC:
 823           kind = vec_kind;
 824           break;
 825
 826         case TREE_BINFO:
 827           kind = binfo_kind;
 828           break;
 829
 830         case SSA_NAME:
 831           kind = ssa_name_kind;
 832           break;
 833
 834         case BLOCK:
 835           kind = b_kind;
 836           break;
 837
 838         case CONSTRUCTOR:
 839           kind = constr_kind;
 840           break;
 841
 842         default:
 843           kind = x_kind;
 844           break;
 845         }
 846       break;
 847
 848     default:
 849       gcc_unreachable ();
 850     }
 851
 852   tree_node_counts[(int) kind]++;
 853   tree_node_sizes[(int) kind] += length;
 854 #endif
 855
 856   if (code == IDENTIFIER_NODE)
 857     t = (tree) ggc_alloc_zone_pass_stat (length, &tree_id_zone);
 858   else
 859     t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
 860
 861   memset (t, 0, length);
 862
 863   TREE_SET_CODE (t, code);
 864
 865   switch (type)
 866     {
 867     case tcc_statement:
 868       TREE_SIDE_EFFECTS (t) = 1;
 869       break;
 870
 871     case tcc_declaration:
 872       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 873         {
 874           if (code == FUNCTION_DECL)
 875             {
 876               DECL_ALIGN (t) = FUNCTION_BOUNDARY;
 877               DECL_MODE (t) = FUNCTION_MODE;
 878             }
 879           else
 880             DECL_ALIGN (t) = 1;
 881         }
 882       DECL_SOURCE_LOCATION (t) = input_location;
 883       if (TREE_CODE (t) == DEBUG_EXPR_DECL)
 884         DECL_UID (t) = --next_debug_decl_uid;
 885       else
 886         {
 887           DECL_UID (t) = next_decl_uid++;
 888           SET_DECL_PT_UID (t, -1);
 889         }
 890       if (TREE_CODE (t) == LABEL_DECL)
 891         LABEL_DECL_UID (t) = -1;
 892
 893       break;
 894
 895     case tcc_type:
 896       TYPE_UID (t) = next_type_uid++;
 897       TYPE_ALIGN (t) = BITS_PER_UNIT;
 898       TYPE_USER_ALIGN (t) = 0;
 899       TYPE_MAIN_VARIANT (t) = t;
 900       TYPE_CANONICAL (t) = t;
 901
 902       /* Default to no attributes for type, but let target change that.  */
 903       TYPE_ATTRIBUTES (t) = NULL_TREE;
 904       targetm.set_default_type_attributes (t);
 905
 906       /* We have not yet computed the alias set for this type.  */
 907       TYPE_ALIAS_SET (t) = -1;
 908       break;
 909
 910     case tcc_constant:
 911       TREE_CONSTANT (t) = 1;
 912       break;
 913
 914     case tcc_expression:
 915       switch (code)
 916         {
 917         case INIT_EXPR:
 918         case MODIFY_EXPR:
 919         case VA_ARG_EXPR:
 920         case PREDECREMENT_EXPR:
 921         case PREINCREMENT_EXPR:
 922         case POSTDECREMENT_EXPR:
 923         case POSTINCREMENT_EXPR:
 924           /* All of these have side-effects, no matter what their
 925              operands are.  */
 926           TREE_SIDE_EFFECTS (t) = 1;
 927           break;
 928
 929         default:
 930           break;
 931         }
 932       break;
 933
 934     default:
 935       /* Other classes need no special treatment.  */
 936       break;
 937     }
 938
 939   return t;
 940 }
 941 \f
 942 /* Return a new node with the same contents as NODE except that its
 943    TREE_CHAIN is zero and it has a fresh uid.  */
 944
 945 tree
 946 copy_node_stat (tree node MEM_STAT_DECL)
 947 {
 948   tree t;
 949   enum tree_code code = TREE_CODE (node);
 950   size_t length;
 951
 952   gcc_assert (code != STATEMENT_LIST);
 953
 954   length = tree_size (node);
 955   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
 956   memcpy (t, node, length);
 957
 958   TREE_CHAIN (t) = 0;
 959   TREE_ASM_WRITTEN (t) = 0;
 960   TREE_VISITED (t) = 0;
 961   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
 962     *DECL_VAR_ANN_PTR (t) = 0;
 963
 964   if (TREE_CODE_CLASS (code) == tcc_declaration)
 965     {
 966       if (code == DEBUG_EXPR_DECL)
 967         DECL_UID (t) = --next_debug_decl_uid;
 968       else
 969         {
 970           DECL_UID (t) = next_decl_uid++;
 971           if (DECL_PT_UID_SET_P (node))
 972             SET_DECL_PT_UID (t, DECL_PT_UID (node));
 973         }
 974       if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
 975           && DECL_HAS_VALUE_EXPR_P (node))
 976         {
 977           SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
 978           DECL_HAS_VALUE_EXPR_P (t) = 1;
 979         }
 980       if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
 981         {
 982           SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
 983           DECL_HAS_INIT_PRIORITY_P (t) = 1;
 984         }
 985     }
 986   else if (TREE_CODE_CLASS (code) == tcc_type)
 987     {
 988       TYPE_UID (t) = next_type_uid++;
 989       /* The following is so that the debug code for
 990          the copy is different from the original type.
 991          The two statements usually duplicate each other
 992          (because they clear fields of the same union),
 993          but the optimizer should catch that.  */
 994       TYPE_SYMTAB_POINTER (t) = 0;
 995       TYPE_SYMTAB_ADDRESS (t) = 0;
 996
 997       /* Do not copy the values cache.  */
 998       if (TYPE_CACHED_VALUES_P(t))
 999         {
1000           TYPE_CACHED_VALUES_P (t) = 0;
1001           TYPE_CACHED_VALUES (t) = NULL_TREE;
1002         }
1003     }
1004
1005   return t;
1006 }
1007
1008 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1009    For example, this can copy a list made of TREE_LIST nodes.  */
1010
1011 tree
1012 copy_list (tree list)
1013 {
1014   tree head;
1015   tree prev, next;
1016
1017   if (list == 0)
1018     return 0;
1019
1020   head = prev = copy_node (list);
1021   next = TREE_CHAIN (list);
1022   while (next)
1023     {
1024       TREE_CHAIN (prev) = copy_node (next);
1025       prev = TREE_CHAIN (prev);
1026       next = TREE_CHAIN (next);
1027     }
1028   return head;
1029 }
1030
1031 \f
1032 /* Create an INT_CST node with a LOW value sign extended.  */
1033
1034 tree
1035 build_int_cst (tree type, HOST_WIDE_INT low)
1036 {
1037   /* Support legacy code.  */
1038   if (!type)
1039     type = integer_type_node;
1040
1041   return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
1042 }
1043
1044 /* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
1045    if it is negative.  This function is similar to build_int_cst, but
1046    the extra bits outside of the type precision are cleared.  Constants
1047    with these extra bits may confuse the fold so that it detects overflows
1048    even in cases when they do not occur, and in general should be avoided.
1049    We cannot however make this a default behavior of build_int_cst without
1050    more intrusive changes, since there are parts of gcc that rely on the extra
1051    precision of the integer constants.  */
1052
1053 tree
1054 build_int_cst_type (tree type, HOST_WIDE_INT low)
1055 {
1056   unsigned HOST_WIDE_INT low1;
1057   HOST_WIDE_INT hi;
1058
1059   gcc_assert (type);
1060
1061   fit_double_type (low, low < 0 ? -1 : 0, &low1, &hi, type);
1062
1063   return build_int_cst_wide (type, low1, hi);
1064 }
1065
1066 /* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
1067    and sign extended according to the value range of TYPE.  */
1068
1069 tree
1070 build_int_cst_wide_type (tree type,
1071                          unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
1072 {
1073   fit_double_type (low, high, &low, &high, type);
1074   return build_int_cst_wide (type, low, high);
1075 }
1076
1077 /* Constructs tree in type TYPE from with value given by CST.  Signedness
1078    of CST is assumed to be the same as the signedness of TYPE.  */
1079
1080 tree
1081 double_int_to_tree (tree type, double_int cst)
1082 {
1083   /* Size types *are* sign extended.  */
1084   bool sign_extended_type = (!TYPE_UNSIGNED (type)
1085                              || (TREE_CODE (type) == INTEGER_TYPE
1086                                  && TYPE_IS_SIZETYPE (type)));
1087
1088   cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1089
1090   return build_int_cst_wide (type, cst.low, cst.high);
1091 }
1092
1093 /* Returns true if CST fits into range of TYPE.  Signedness of CST is assumed
1094    to be the same as the signedness of TYPE.  */
1095
1096 bool
1097 double_int_fits_to_tree_p (const_tree type, double_int cst)
1098 {
1099   /* Size types *are* sign extended.  */
1100   bool sign_extended_type = (!TYPE_UNSIGNED (type)
1101                              || (TREE_CODE (type) == INTEGER_TYPE
1102                                  && TYPE_IS_SIZETYPE (type)));
1103
1104   double_int ext
1105     = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1106
1107   return double_int_equal_p (cst, ext);
1108 }
1109
1110 /* These are the hash table functions for the hash table of INTEGER_CST
1111    nodes of a sizetype.  */
1112
1113 /* Return the hash code code X, an INTEGER_CST.  */
1114
1115 static hashval_t
1116 int_cst_hash_hash (const void *x)
1117 {
1118   const_tree const t = (const_tree) x;
1119
1120   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1121           ^ htab_hash_pointer (TREE_TYPE (t)));
1122 }
1123
1124 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1125    is the same as that given by *Y, which is the same.  */
1126
1127 static int
1128 int_cst_hash_eq (const void *x, const void *y)
1129 {
1130   const_tree const xt = (const_tree) x;
1131   const_tree const yt = (const_tree) y;
1132
1133   return (TREE_TYPE (xt) == TREE_TYPE (yt)
1134           && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1135           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1136 }
1137
1138 /* Create an INT_CST node of TYPE and value HI:LOW.
1139    The returned node is always shared.  For small integers we use a
1140    per-type vector cache, for larger ones we use a single hash table.  */
1141
1142 tree
1143 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1144 {
1145   tree t;
1146   int ix = -1;
1147   int limit = 0;
1148
1149   gcc_assert (type);
1150
1151   switch (TREE_CODE (type))
1152     {
1153     case POINTER_TYPE:
1154     case REFERENCE_TYPE:
1155       /* Cache NULL pointer.  */
1156       if (!hi && !low)
1157         {
1158           limit = 1;
1159           ix = 0;
1160         }
1161       break;
1162
1163     case BOOLEAN_TYPE:
1164       /* Cache false or true.  */
1165       limit = 2;
1166       if (!hi && low < 2)
1167         ix = low;
1168       break;
1169
1170     case INTEGER_TYPE:
1171     case OFFSET_TYPE:
1172       if (TYPE_UNSIGNED (type))
1173         {
1174           /* Cache 0..N */
1175           limit = INTEGER_SHARE_LIMIT;
1176           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1177             ix = low;
1178         }
1179       else
1180         {
1181           /* Cache -1..N */
1182           limit = INTEGER_SHARE_LIMIT + 1;
1183           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1184             ix = low + 1;
1185           else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1186             ix = 0;
1187         }
1188       break;
1189
1190     case ENUMERAL_TYPE:
1191       break;
1192
1193     default:
1194       gcc_unreachable ();
1195     }
1196
1197   if (ix >= 0)
1198     {
1199       /* Look for it in the type's vector of small shared ints.  */
1200       if (!TYPE_CACHED_VALUES_P (type))
1201         {
1202           TYPE_CACHED_VALUES_P (type) = 1;
1203           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1204         }
1205
1206       t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1207       if (t)
1208         {
1209           /* Make sure no one is clobbering the shared constant.  */
1210           gcc_assert (TREE_TYPE (t) == type);
1211           gcc_assert (TREE_INT_CST_LOW (t) == low);
1212           gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1213         }
1214       else
1215         {
1216           /* Create a new shared int.  */
1217           t = make_node (INTEGER_CST);
1218
1219           TREE_INT_CST_LOW (t) = low;
1220           TREE_INT_CST_HIGH (t) = hi;
1221           TREE_TYPE (t) = type;
1222
1223           TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1224         }
1225     }
1226   else
1227     {
1228       /* Use the cache of larger shared ints.  */
1229       void **slot;
1230
1231       TREE_INT_CST_LOW (int_cst_node) = low;
1232       TREE_INT_CST_HIGH (int_cst_node) = hi;
1233       TREE_TYPE (int_cst_node) = type;
1234
1235       slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1236       t = (tree) *slot;
1237       if (!t)
1238         {
1239           /* Insert this one into the hash table.  */
1240           t = int_cst_node;
1241           *slot = t;
1242           /* Make a new node for next time round.  */
1243           int_cst_node = make_node (INTEGER_CST);
1244         }
1245     }
1246
1247   return t;
1248 }
1249
1250 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1251    and the rest are zeros.  */
1252
1253 tree
1254 build_low_bits_mask (tree type, unsigned bits)
1255 {
1256   double_int mask;
1257
1258   gcc_assert (bits <= TYPE_PRECISION (type));
1259
1260   if (bits == TYPE_PRECISION (type)
1261       && !TYPE_UNSIGNED (type))
1262     /* Sign extended all-ones mask.  */
1263     mask = double_int_minus_one;
1264   else
1265     mask = double_int_mask (bits);
1266
1267   return build_int_cst_wide (type, mask.low, mask.high);
1268 }
1269
1270 /* Checks that X is integer constant that can be expressed in (unsigned)
1271    HOST_WIDE_INT without loss of precision.  */
1272
1273 bool
1274 cst_and_fits_in_hwi (const_tree x)
1275 {
1276   if (TREE_CODE (x) != INTEGER_CST)
1277     return false;
1278
1279   if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1280     return false;
1281
1282   return (TREE_INT_CST_HIGH (x) == 0
1283           || TREE_INT_CST_HIGH (x) == -1);
1284 }
1285
1286 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1287    are in a list pointed to by VALS.  */
1288
1289 tree
1290 build_vector (tree type, tree vals)
1291 {
1292   tree v = make_node (VECTOR_CST);
1293   int over = 0;
1294   tree link;
1295
1296   TREE_VECTOR_CST_ELTS (v) = vals;
1297   TREE_TYPE (v) = type;
1298
1299   /* Iterate through elements and check for overflow.  */
1300   for (link = vals; link; link = TREE_CHAIN (link))
1301     {
1302       tree value = TREE_VALUE (link);
1303
1304       /* Don't crash if we get an address constant.  */
1305       if (!CONSTANT_CLASS_P (value))
1306         continue;
1307
1308       over |= TREE_OVERFLOW (value);
1309     }
1310
1311   TREE_OVERFLOW (v) = over;
1312   return v;
1313 }
1314
1315 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1316    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1317
1318 tree
1319 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1320 {
1321   tree list = NULL_TREE;
1322   unsigned HOST_WIDE_INT idx;
1323   tree value;
1324
1325   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1326     list = tree_cons (NULL_TREE, value, list);
1327   return build_vector (type, nreverse (list));
1328 }
1329
1330 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1331    are in the VEC pointed to by VALS.  */
1332 tree
1333 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1334 {
1335   tree c = make_node (CONSTRUCTOR);
1336   unsigned int i;
1337   constructor_elt *elt;
1338   bool constant_p = true;
1339
1340   TREE_TYPE (c) = type;
1341   CONSTRUCTOR_ELTS (c) = vals;
1342
1343   for (i = 0; VEC_iterate (constructor_elt, vals, i, elt); i++)
1344     if (!TREE_CONSTANT (elt->value))
1345       {
1346         constant_p = false;
1347         break;
1348       }
1349
1350   TREE_CONSTANT (c) = constant_p;
1351
1352   return c;
1353 }
1354
1355 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1356    INDEX and VALUE.  */
1357 tree
1358 build_constructor_single (tree type, tree index, tree value)
1359 {
1360   VEC(constructor_elt,gc) *v;
1361   constructor_elt *elt;
1362
1363   v = VEC_alloc (constructor_elt, gc, 1);
1364   elt = VEC_quick_push (constructor_elt, v, NULL);
1365   elt->index = index;
1366   elt->value = value;
1367
1368   return build_constructor (type, v);
1369 }
1370
1371
1372 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1373    are in a list pointed to by VALS.  */
1374 tree
1375 build_constructor_from_list (tree type, tree vals)
1376 {
1377   tree t;
1378   VEC(constructor_elt,gc) *v = NULL;
1379
1380   if (vals)
1381     {
1382       v = VEC_alloc (constructor_elt, gc, list_length (vals));
1383       for (t = vals; t; t = TREE_CHAIN (t))
1384         CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1385     }
1386
1387   return build_constructor (type, v);
1388 }
1389
1390 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1391
1392 tree
1393 build_fixed (tree type, FIXED_VALUE_TYPE f)
1394 {
1395   tree v;
1396   FIXED_VALUE_TYPE *fp;
1397
1398   v = make_node (FIXED_CST);
1399   fp = GGC_NEW (FIXED_VALUE_TYPE);
1400   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1401
1402   TREE_TYPE (v) = type;
1403   TREE_FIXED_CST_PTR (v) = fp;
1404   return v;
1405 }
1406
1407 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1408
1409 tree
1410 build_real (tree type, REAL_VALUE_TYPE d)
1411 {
1412   tree v;
1413   REAL_VALUE_TYPE *dp;
1414   int overflow = 0;
1415
1416   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1417      Consider doing it via real_convert now.  */
1418
1419   v = make_node (REAL_CST);
1420   dp = GGC_NEW (REAL_VALUE_TYPE);
1421   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1422
1423   TREE_TYPE (v) = type;
1424   TREE_REAL_CST_PTR (v) = dp;
1425   TREE_OVERFLOW (v) = overflow;
1426   return v;
1427 }
1428
1429 /* Return a new REAL_CST node whose type is TYPE
1430    and whose value is the integer value of the INTEGER_CST node I.  */
1431
1432 REAL_VALUE_TYPE
1433 real_value_from_int_cst (const_tree type, const_tree i)
1434 {
1435   REAL_VALUE_TYPE d;
1436
1437   /* Clear all bits of the real value type so that we can later do
1438      bitwise comparisons to see if two values are the same.  */
1439   memset (&d, 0, sizeof d);
1440
1441   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1442                      TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1443                      TYPE_UNSIGNED (TREE_TYPE (i)));
1444   return d;
1445 }
1446
1447 /* Given a tree representing an integer constant I, return a tree
1448    representing the same value as a floating-point constant of type TYPE.  */
1449
1450 tree
1451 build_real_from_int_cst (tree type, const_tree i)
1452 {
1453   tree v;
1454   int overflow = TREE_OVERFLOW (i);
1455
1456   v = build_real (type, real_value_from_int_cst (type, i));
1457
1458   TREE_OVERFLOW (v) |= overflow;
1459   return v;
1460 }
1461
1462 /* Return a newly constructed STRING_CST node whose value is
1463    the LEN characters at STR.
1464    The TREE_TYPE is not initialized.  */
1465
1466 tree
1467 build_string (int len, const char *str)
1468 {
1469   tree s;
1470   size_t length;
1471
1472   /* Do not waste bytes provided by padding of struct tree_string.  */
1473   length = len + offsetof (struct tree_string, str) + 1;
1474
1475 #ifdef GATHER_STATISTICS
1476   tree_node_counts[(int) c_kind]++;
1477   tree_node_sizes[(int) c_kind] += length;
1478 #endif
1479
1480   s = ggc_alloc_tree (length);
1481
1482   memset (s, 0, sizeof (struct tree_common));
1483   TREE_SET_CODE (s, STRING_CST);
1484   TREE_CONSTANT (s) = 1;
1485   TREE_STRING_LENGTH (s) = len;
1486   memcpy (s->string.str, str, len);
1487   s->string.str[len] = '\0';
1488
1489   return s;
1490 }
1491
1492 /* Return a newly constructed COMPLEX_CST node whose value is
1493    specified by the real and imaginary parts REAL and IMAG.
1494    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1495    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1496
1497 tree
1498 build_complex (tree type, tree real, tree imag)
1499 {
1500   tree t = make_node (COMPLEX_CST);
1501
1502   TREE_REALPART (t) = real;
1503   TREE_IMAGPART (t) = imag;
1504   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1505   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1506   return t;
1507 }
1508
1509 /* Return a constant of arithmetic type TYPE which is the
1510    multiplicative identity of the set TYPE.  */
1511
1512 tree
1513 build_one_cst (tree type)
1514 {
1515   switch (TREE_CODE (type))
1516     {
1517     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1518     case POINTER_TYPE: case REFERENCE_TYPE:
1519     case OFFSET_TYPE:
1520       return build_int_cst (type, 1);
1521
1522     case REAL_TYPE:
1523       return build_real (type, dconst1);
1524
1525     case FIXED_POINT_TYPE:
1526       /* We can only generate 1 for accum types.  */
1527       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1528       return build_fixed (type, FCONST1(TYPE_MODE (type)));
1529
1530     case VECTOR_TYPE:
1531       {
1532         tree scalar, cst;
1533         int i;
1534
1535         scalar = build_one_cst (TREE_TYPE (type));
1536
1537         /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
1538         cst = NULL_TREE;
1539         for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1540           cst = tree_cons (NULL_TREE, scalar, cst);
1541
1542         return build_vector (type, cst);
1543       }
1544
1545     case COMPLEX_TYPE:
1546       return build_complex (type,
1547                             build_one_cst (TREE_TYPE (type)),
1548                             fold_convert (TREE_TYPE (type), integer_zero_node));
1549
1550     default:
1551       gcc_unreachable ();
1552     }
1553 }
1554
1555 /* Build a BINFO with LEN language slots.  */
1556
1557 tree
1558 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1559 {
1560   tree t;
1561   size_t length = (offsetof (struct tree_binfo, base_binfos)
1562                    + VEC_embedded_size (tree, base_binfos));
1563
1564 #ifdef GATHER_STATISTICS
1565   tree_node_counts[(int) binfo_kind]++;
1566   tree_node_sizes[(int) binfo_kind] += length;
1567 #endif
1568
1569   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1570
1571   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1572
1573   TREE_SET_CODE (t, TREE_BINFO);
1574
1575   VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1576
1577   return t;
1578 }
1579
1580
1581 /* Build a newly constructed TREE_VEC node of length LEN.  */
1582
1583 tree
1584 make_tree_vec_stat (int len MEM_STAT_DECL)
1585 {
1586   tree t;
1587   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1588
1589 #ifdef GATHER_STATISTICS
1590   tree_node_counts[(int) vec_kind]++;
1591   tree_node_sizes[(int) vec_kind] += length;
1592 #endif
1593
1594   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1595
1596   memset (t, 0, length);
1597
1598   TREE_SET_CODE (t, TREE_VEC);
1599   TREE_VEC_LENGTH (t) = len;
1600
1601   return t;
1602 }
1603 \f
1604 /* Return 1 if EXPR is the integer constant zero or a complex constant
1605    of zero.  */
1606
1607 int
1608 integer_zerop (const_tree expr)
1609 {
1610   STRIP_NOPS (expr);
1611
1612   return ((TREE_CODE (expr) == INTEGER_CST
1613            && TREE_INT_CST_LOW (expr) == 0
1614            && TREE_INT_CST_HIGH (expr) == 0)
1615           || (TREE_CODE (expr) == COMPLEX_CST
1616               && integer_zerop (TREE_REALPART (expr))
1617               && integer_zerop (TREE_IMAGPART (expr))));
1618 }
1619
1620 /* Return 1 if EXPR is the integer constant one or the corresponding
1621    complex constant.  */
1622
1623 int
1624 integer_onep (const_tree expr)
1625 {
1626   STRIP_NOPS (expr);
1627
1628   return ((TREE_CODE (expr) == INTEGER_CST
1629            && TREE_INT_CST_LOW (expr) == 1
1630            && TREE_INT_CST_HIGH (expr) == 0)
1631           || (TREE_CODE (expr) == COMPLEX_CST
1632               && integer_onep (TREE_REALPART (expr))
1633               && integer_zerop (TREE_IMAGPART (expr))));
1634 }
1635
1636 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1637    it contains.  Likewise for the corresponding complex constant.  */
1638
1639 int
1640 integer_all_onesp (const_tree expr)
1641 {
1642   int prec;
1643   int uns;
1644
1645   STRIP_NOPS (expr);
1646
1647   if (TREE_CODE (expr) == COMPLEX_CST
1648       && integer_all_onesp (TREE_REALPART (expr))
1649       && integer_zerop (TREE_IMAGPART (expr)))
1650     return 1;
1651
1652   else if (TREE_CODE (expr) != INTEGER_CST)
1653     return 0;
1654
1655   uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1656   if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1657       && TREE_INT_CST_HIGH (expr) == -1)
1658     return 1;
1659   if (!uns)
1660     return 0;
1661
1662   /* Note that using TYPE_PRECISION here is wrong.  We care about the
1663      actual bits, not the (arbitrary) range of the type.  */
1664   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1665   if (prec >= HOST_BITS_PER_WIDE_INT)
1666     {
1667       HOST_WIDE_INT high_value;
1668       int shift_amount;
1669
1670       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1671
1672       /* Can not handle precisions greater than twice the host int size.  */
1673       gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1674       if (shift_amount == HOST_BITS_PER_WIDE_INT)
1675         /* Shifting by the host word size is undefined according to the ANSI
1676            standard, so we must handle this as a special case.  */
1677         high_value = -1;
1678       else
1679         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1680
1681       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1682               && TREE_INT_CST_HIGH (expr) == high_value);
1683     }
1684   else
1685     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1686 }
1687
1688 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1689    one bit on).  */
1690
1691 int
1692 integer_pow2p (const_tree expr)
1693 {
1694   int prec;
1695   HOST_WIDE_INT high, low;
1696
1697   STRIP_NOPS (expr);
1698
1699   if (TREE_CODE (expr) == COMPLEX_CST
1700       && integer_pow2p (TREE_REALPART (expr))
1701       && integer_zerop (TREE_IMAGPART (expr)))
1702     return 1;
1703
1704   if (TREE_CODE (expr) != INTEGER_CST)
1705     return 0;
1706
1707   prec = TYPE_PRECISION (TREE_TYPE (expr));
1708   high = TREE_INT_CST_HIGH (expr);
1709   low = TREE_INT_CST_LOW (expr);
1710
1711   /* First clear all bits that are beyond the type's precision in case
1712      we've been sign extended.  */
1713
1714   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1715     ;
1716   else if (prec > HOST_BITS_PER_WIDE_INT)
1717     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1718   else
1719     {
1720       high = 0;
1721       if (prec < HOST_BITS_PER_WIDE_INT)
1722         low &= ~((HOST_WIDE_INT) (-1) << prec);
1723     }
1724
1725   if (high == 0 && low == 0)
1726     return 0;
1727
1728   return ((high == 0 && (low & (low - 1)) == 0)
1729           || (low == 0 && (high & (high - 1)) == 0));
1730 }
1731
1732 /* Return 1 if EXPR is an integer constant other than zero or a
1733    complex constant other than zero.  */
1734
1735 int
1736 integer_nonzerop (const_tree expr)
1737 {
1738   STRIP_NOPS (expr);
1739
1740   return ((TREE_CODE (expr) == INTEGER_CST
1741            && (TREE_INT_CST_LOW (expr) != 0
1742                || TREE_INT_CST_HIGH (expr) != 0))
1743           || (TREE_CODE (expr) == COMPLEX_CST
1744               && (integer_nonzerop (TREE_REALPART (expr))
1745                   || integer_nonzerop (TREE_IMAGPART (expr)))));
1746 }
1747
1748 /* Return 1 if EXPR is the fixed-point constant zero.  */
1749
1750 int
1751 fixed_zerop (const_tree expr)
1752 {
1753   return (TREE_CODE (expr) == FIXED_CST
1754           && double_int_zero_p (TREE_FIXED_CST (expr).data));
1755 }
1756
1757 /* Return the power of two represented by a tree node known to be a
1758    power of two.  */
1759
1760 int
1761 tree_log2 (const_tree expr)
1762 {
1763   int prec;
1764   HOST_WIDE_INT high, low;
1765
1766   STRIP_NOPS (expr);
1767
1768   if (TREE_CODE (expr) == COMPLEX_CST)
1769     return tree_log2 (TREE_REALPART (expr));
1770
1771   prec = TYPE_PRECISION (TREE_TYPE (expr));
1772   high = TREE_INT_CST_HIGH (expr);
1773   low = TREE_INT_CST_LOW (expr);
1774
1775   /* First clear all bits that are beyond the type's precision in case
1776      we've been sign extended.  */
1777
1778   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1779     ;
1780   else if (prec > HOST_BITS_PER_WIDE_INT)
1781     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1782   else
1783     {
1784       high = 0;
1785       if (prec < HOST_BITS_PER_WIDE_INT)
1786         low &= ~((HOST_WIDE_INT) (-1) << prec);
1787     }
1788
1789   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1790           : exact_log2 (low));
1791 }
1792
1793 /* Similar, but return the largest integer Y such that 2 ** Y is less
1794    than or equal to EXPR.  */
1795
1796 int
1797 tree_floor_log2 (const_tree expr)
1798 {
1799   int prec;
1800   HOST_WIDE_INT high, low;
1801
1802   STRIP_NOPS (expr);
1803
1804   if (TREE_CODE (expr) == COMPLEX_CST)
1805     return tree_log2 (TREE_REALPART (expr));
1806
1807   prec = TYPE_PRECISION (TREE_TYPE (expr));
1808   high = TREE_INT_CST_HIGH (expr);
1809   low = TREE_INT_CST_LOW (expr);
1810
1811   /* First clear all bits that are beyond the type's precision in case
1812      we've been sign extended.  Ignore if type's precision hasn't been set
1813      since what we are doing is setting it.  */
1814
1815   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1816     ;
1817   else if (prec > HOST_BITS_PER_WIDE_INT)
1818     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1819   else
1820     {
1821       high = 0;
1822       if (prec < HOST_BITS_PER_WIDE_INT)
1823         low &= ~((HOST_WIDE_INT) (-1) << prec);
1824     }
1825
1826   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1827           : floor_log2 (low));
1828 }
1829
1830 /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
1831    decimal float constants, so don't return 1 for them.  */
1832
1833 int
1834 real_zerop (const_tree expr)
1835 {
1836   STRIP_NOPS (expr);
1837
1838   return ((TREE_CODE (expr) == REAL_CST
1839            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1840            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1841           || (TREE_CODE (expr) == COMPLEX_CST
1842               && real_zerop (TREE_REALPART (expr))
1843               && real_zerop (TREE_IMAGPART (expr))));
1844 }
1845
1846 /* Return 1 if EXPR is the real constant one in real or complex form.
1847    Trailing zeroes matter for decimal float constants, so don't return
1848    1 for them.  */
1849
1850 int
1851 real_onep (const_tree expr)
1852 {
1853   STRIP_NOPS (expr);
1854
1855   return ((TREE_CODE (expr) == REAL_CST
1856            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1857            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1858           || (TREE_CODE (expr) == COMPLEX_CST
1859               && real_onep (TREE_REALPART (expr))
1860               && real_zerop (TREE_IMAGPART (expr))));
1861 }
1862
1863 /* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
1864    for decimal float constants, so don't return 1 for them.  */
1865
1866 int
1867 real_twop (const_tree expr)
1868 {
1869   STRIP_NOPS (expr);
1870
1871   return ((TREE_CODE (expr) == REAL_CST
1872            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1873            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1874           || (TREE_CODE (expr) == COMPLEX_CST
1875               && real_twop (TREE_REALPART (expr))
1876               && real_zerop (TREE_IMAGPART (expr))));
1877 }
1878
1879 /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
1880    matter for decimal float constants, so don't return 1 for them.  */
1881
1882 int
1883 real_minus_onep (const_tree expr)
1884 {
1885   STRIP_NOPS (expr);
1886
1887   return ((TREE_CODE (expr) == REAL_CST
1888            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1889            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1890           || (TREE_CODE (expr) == COMPLEX_CST
1891               && real_minus_onep (TREE_REALPART (expr))
1892               && real_zerop (TREE_IMAGPART (expr))));
1893 }
1894
1895 /* Nonzero if EXP is a constant or a cast of a constant.  */
1896
1897 int
1898 really_constant_p (const_tree exp)
1899 {
1900   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1901   while (CONVERT_EXPR_P (exp)
1902          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1903     exp = TREE_OPERAND (exp, 0);
1904   return TREE_CONSTANT (exp);
1905 }
1906 \f
1907 /* Return first list element whose TREE_VALUE is ELEM.
1908    Return 0 if ELEM is not in LIST.  */
1909
1910 tree
1911 value_member (tree elem, tree list)
1912 {
1913   while (list)
1914     {
1915       if (elem == TREE_VALUE (list))
1916         return list;
1917       list = TREE_CHAIN (list);
1918     }
1919   return NULL_TREE;
1920 }
1921
1922 /* Return first list element whose TREE_PURPOSE is ELEM.
1923    Return 0 if ELEM is not in LIST.  */
1924
1925 tree
1926 purpose_member (const_tree elem, tree list)
1927 {
1928   while (list)
1929     {
1930       if (elem == TREE_PURPOSE (list))
1931         return list;
1932       list = TREE_CHAIN (list);
1933     }
1934   return NULL_TREE;
1935 }
1936
1937 /* Returns element number IDX (zero-origin) of chain CHAIN, or
1938    NULL_TREE.  */
1939
1940 tree
1941 chain_index (int idx, tree chain)
1942 {
1943   for (; chain && idx > 0; --idx)
1944     chain = TREE_CHAIN (chain);
1945   return chain;
1946 }
1947
1948 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1949
1950 int
1951 chain_member (const_tree elem, const_tree chain)
1952 {
1953   while (chain)
1954     {
1955       if (elem == chain)
1956         return 1;
1957       chain = TREE_CHAIN (chain);
1958     }
1959
1960   return 0;
1961 }
1962
1963 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1964    We expect a null pointer to mark the end of the chain.
1965    This is the Lisp primitive `length'.  */
1966
1967 int
1968 list_length (const_tree t)
1969 {
1970   const_tree p = t;
1971 #ifdef ENABLE_TREE_CHECKING
1972   const_tree q = t;
1973 #endif
1974   int len = 0;
1975
1976   while (p)
1977     {
1978       p = TREE_CHAIN (p);
1979 #ifdef ENABLE_TREE_CHECKING
1980       if (len % 2)
1981         q = TREE_CHAIN (q);
1982       gcc_assert (p != q);
1983 #endif
1984       len++;
1985     }
1986
1987   return len;
1988 }
1989
1990 /* Returns the number of FIELD_DECLs in TYPE.  */
1991
1992 int
1993 fields_length (const_tree type)
1994 {
1995   tree t = TYPE_FIELDS (type);
1996   int count = 0;
1997
1998   for (; t; t = TREE_CHAIN (t))
1999     if (TREE_CODE (t) == FIELD_DECL)
2000       ++count;
2001
2002   return count;
2003 }
2004
2005 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2006    UNION_TYPE TYPE, or NULL_TREE if none.  */
2007
2008 tree
2009 first_field (const_tree type)
2010 {
2011   tree t = TYPE_FIELDS (type);
2012   while (t && TREE_CODE (t) != FIELD_DECL)
2013     t = TREE_CHAIN (t);
2014   return t;
2015 }
2016
2017 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2018    by modifying the last node in chain 1 to point to chain 2.
2019    This is the Lisp primitive `nconc'.  */
2020
2021 tree
2022 chainon (tree op1, tree op2)
2023 {
2024   tree t1;
2025
2026   if (!op1)
2027     return op2;
2028   if (!op2)
2029     return op1;
2030
2031   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2032     continue;
2033   TREE_CHAIN (t1) = op2;
2034
2035 #ifdef ENABLE_TREE_CHECKING
2036   {
2037     tree t2;
2038     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2039       gcc_assert (t2 != t1);
2040   }
2041 #endif
2042
2043   return op1;
2044 }
2045
2046 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
2047
2048 tree
2049 tree_last (tree chain)
2050 {
2051   tree next;
2052   if (chain)
2053     while ((next = TREE_CHAIN (chain)))
2054       chain = next;
2055   return chain;
2056 }
2057
2058 /* Reverse the order of elements in the chain T,
2059    and return the new head of the chain (old last element).  */
2060
2061 tree
2062 nreverse (tree t)
2063 {
2064   tree prev = 0, decl, next;
2065   for (decl = t; decl; decl = next)
2066     {
2067       next = TREE_CHAIN (decl);
2068       TREE_CHAIN (decl) = prev;
2069       prev = decl;
2070     }
2071   return prev;
2072 }
2073 \f
2074 /* Return a newly created TREE_LIST node whose
2075    purpose and value fields are PARM and VALUE.  */
2076
2077 tree
2078 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2079 {
2080   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2081   TREE_PURPOSE (t) = parm;
2082   TREE_VALUE (t) = value;
2083   return t;
2084 }
2085
2086 /* Build a chain of TREE_LIST nodes from a vector.  */
2087
2088 tree
2089 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2090 {
2091   tree ret = NULL_TREE;
2092   tree *pp = &ret;
2093   unsigned int i;
2094   tree t;
2095   for (i = 0; VEC_iterate (tree, vec, i, t); ++i)
2096     {
2097       *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2098       pp = &TREE_CHAIN (*pp);
2099     }
2100   return ret;
2101 }
2102
2103 /* Return a newly created TREE_LIST node whose
2104    purpose and value fields are PURPOSE and VALUE
2105    and whose TREE_CHAIN is CHAIN.  */
2106
2107 tree
2108 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2109 {
2110   tree node;
2111
2112   node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
2113
2114   memset (node, 0, sizeof (struct tree_common));
2115
2116 #ifdef GATHER_STATISTICS
2117   tree_node_counts[(int) x_kind]++;
2118   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2119 #endif
2120
2121   TREE_SET_CODE (node, TREE_LIST);
2122   TREE_CHAIN (node) = chain;
2123   TREE_PURPOSE (node) = purpose;
2124   TREE_VALUE (node) = value;
2125   return node;
2126 }
2127
2128 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2129    trees.  */
2130
2131 VEC(tree,gc) *
2132 ctor_to_vec (tree ctor)
2133 {
2134   VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2135   unsigned int ix;
2136   tree val;
2137
2138   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2139     VEC_quick_push (tree, vec, val);
2140
2141   return vec;
2142 }
2143 \f
2144 /* Return the size nominally occupied by an object of type TYPE
2145    when it resides in memory.  The value is measured in units of bytes,
2146    and its data type is that normally used for type sizes
2147    (which is the first type created by make_signed_type or
2148    make_unsigned_type).  */
2149
2150 tree
2151 size_in_bytes (const_tree type)
2152 {
2153   tree t;
2154
2155   if (type == error_mark_node)
2156     return integer_zero_node;
2157
2158   type = TYPE_MAIN_VARIANT (type);
2159   t = TYPE_SIZE_UNIT (type);
2160
2161   if (t == 0)
2162     {
2163       lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2164       return size_zero_node;
2165     }
2166
2167   return t;
2168 }
2169
2170 /* Return the size of TYPE (in bytes) as a wide integer
2171    or return -1 if the size can vary or is larger than an integer.  */
2172
2173 HOST_WIDE_INT
2174 int_size_in_bytes (const_tree type)
2175 {
2176   tree t;
2177
2178   if (type == error_mark_node)
2179     return 0;
2180
2181   type = TYPE_MAIN_VARIANT (type);
2182   t = TYPE_SIZE_UNIT (type);
2183   if (t == 0
2184       || TREE_CODE (t) != INTEGER_CST
2185       || TREE_INT_CST_HIGH (t) != 0
2186       /* If the result would appear negative, it's too big to represent.  */
2187       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2188     return -1;
2189
2190   return TREE_INT_CST_LOW (t);
2191 }
2192
2193 /* Return the maximum size of TYPE (in bytes) as a wide integer
2194    or return -1 if the size can vary or is larger than an integer.  */
2195
2196 HOST_WIDE_INT
2197 max_int_size_in_bytes (const_tree type)
2198 {
2199   HOST_WIDE_INT size = -1;
2200   tree size_tree;
2201
2202   /* If this is an array type, check for a possible MAX_SIZE attached.  */
2203
2204   if (TREE_CODE (type) == ARRAY_TYPE)
2205     {
2206       size_tree = TYPE_ARRAY_MAX_SIZE (type);
2207
2208       if (size_tree && host_integerp (size_tree, 1))
2209         size = tree_low_cst (size_tree, 1);
2210     }
2211
2212   /* If we still haven't been able to get a size, see if the language
2213      can compute a maximum size.  */
2214
2215   if (size == -1)
2216     {
2217       size_tree = lang_hooks.types.max_size (type);
2218
2219       if (size_tree && host_integerp (size_tree, 1))
2220         size = tree_low_cst (size_tree, 1);
2221     }
2222
2223   return size;
2224 }
2225
2226 /* Returns a tree for the size of EXP in bytes.  */
2227
2228 tree
2229 tree_expr_size (const_tree exp)
2230 {
2231   if (DECL_P (exp)
2232       && DECL_SIZE_UNIT (exp) != 0)
2233     return DECL_SIZE_UNIT (exp);
2234   else
2235     return size_in_bytes (TREE_TYPE (exp));
2236 }
2237 \f
2238 /* Return the bit position of FIELD, in bits from the start of the record.
2239    This is a tree of type bitsizetype.  */
2240
2241 tree
2242 bit_position (const_tree field)
2243 {
2244   return bit_from_pos (DECL_FIELD_OFFSET (field),
2245                        DECL_FIELD_BIT_OFFSET (field));
2246 }
2247
2248 /* Likewise, but return as an integer.  It must be representable in
2249    that way (since it could be a signed value, we don't have the
2250    option of returning -1 like int_size_in_byte can.  */
2251
2252 HOST_WIDE_INT
2253 int_bit_position (const_tree field)
2254 {
2255   return tree_low_cst (bit_position (field), 0);
2256 }
2257 \f
2258 /* Return the byte position of FIELD, in bytes from the start of the record.
2259    This is a tree of type sizetype.  */
2260
2261 tree
2262 byte_position (const_tree field)
2263 {
2264   return byte_from_pos (DECL_FIELD_OFFSET (field),
2265                         DECL_FIELD_BIT_OFFSET (field));
2266 }
2267
2268 /* Likewise, but return as an integer.  It must be representable in
2269    that way (since it could be a signed value, we don't have the
2270    option of returning -1 like int_size_in_byte can.  */
2271
2272 HOST_WIDE_INT
2273 int_byte_position (const_tree field)
2274 {
2275   return tree_low_cst (byte_position (field), 0);
2276 }
2277 \f
2278 /* Return the strictest alignment, in bits, that T is known to have.  */
2279
2280 unsigned int
2281 expr_align (const_tree t)
2282 {
2283   unsigned int align0, align1;
2284
2285   switch (TREE_CODE (t))
2286     {
2287     CASE_CONVERT:  case NON_LVALUE_EXPR:
2288       /* If we have conversions, we know that the alignment of the
2289          object must meet each of the alignments of the types.  */
2290       align0 = expr_align (TREE_OPERAND (t, 0));
2291       align1 = TYPE_ALIGN (TREE_TYPE (t));
2292       return MAX (align0, align1);
2293
2294     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
2295     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
2296     case CLEANUP_POINT_EXPR:
2297       /* These don't change the alignment of an object.  */
2298       return expr_align (TREE_OPERAND (t, 0));
2299
2300     case COND_EXPR:
2301       /* The best we can do is say that the alignment is the least aligned
2302          of the two arms.  */
2303       align0 = expr_align (TREE_OPERAND (t, 1));
2304       align1 = expr_align (TREE_OPERAND (t, 2));
2305       return MIN (align0, align1);
2306
2307       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2308          meaningfully, it's always 1.  */
2309     case LABEL_DECL:     case CONST_DECL:
2310     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
2311     case FUNCTION_DECL:
2312       gcc_assert (DECL_ALIGN (t) != 0);
2313       return DECL_ALIGN (t);
2314
2315     default:
2316       break;
2317     }
2318
2319   /* Otherwise take the alignment from that of the type.  */
2320   return TYPE_ALIGN (TREE_TYPE (t));
2321 }
2322 \f
2323 /* Return, as a tree node, the number of elements for TYPE (which is an
2324    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
2325
2326 tree
2327 array_type_nelts (const_tree type)
2328 {
2329   tree index_type, min, max;
2330
2331   /* If they did it with unspecified bounds, then we should have already
2332      given an error about it before we got here.  */
2333   if (! TYPE_DOMAIN (type))
2334     return error_mark_node;
2335
2336   index_type = TYPE_DOMAIN (type);
2337   min = TYPE_MIN_VALUE (index_type);
2338   max = TYPE_MAX_VALUE (index_type);
2339
2340   return (integer_zerop (min)
2341           ? max
2342           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2343 }
2344 \f
2345 /* If arg is static -- a reference to an object in static storage -- then
2346    return the object.  This is not the same as the C meaning of `static'.
2347    If arg isn't static, return NULL.  */
2348
2349 tree
2350 staticp (tree arg)
2351 {
2352   switch (TREE_CODE (arg))
2353     {
2354     case FUNCTION_DECL:
2355       /* Nested functions are static, even though taking their address will
2356          involve a trampoline as we unnest the nested function and create
2357          the trampoline on the tree level.  */
2358       return arg;
2359
2360     case VAR_DECL:
2361       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2362               && ! DECL_THREAD_LOCAL_P (arg)
2363               && ! DECL_DLLIMPORT_P (arg)
2364               ? arg : NULL);
2365
2366     case CONST_DECL:
2367       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2368               ? arg : NULL);
2369
2370     case CONSTRUCTOR:
2371       return TREE_STATIC (arg) ? arg : NULL;
2372
2373     case LABEL_DECL:
2374     case STRING_CST:
2375       return arg;
2376
2377     case COMPONENT_REF:
2378       /* If the thing being referenced is not a field, then it is
2379          something language specific.  */
2380       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2381
2382       /* If we are referencing a bitfield, we can't evaluate an
2383          ADDR_EXPR at compile time and so it isn't a constant.  */
2384       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2385         return NULL;
2386
2387       return staticp (TREE_OPERAND (arg, 0));
2388
2389     case BIT_FIELD_REF:
2390       return NULL;
2391
2392     case MISALIGNED_INDIRECT_REF:
2393     case ALIGN_INDIRECT_REF:
2394     case INDIRECT_REF:
2395       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2396
2397     case ARRAY_REF:
2398     case ARRAY_RANGE_REF:
2399       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2400           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2401         return staticp (TREE_OPERAND (arg, 0));
2402       else
2403         return NULL;
2404
2405     case COMPOUND_LITERAL_EXPR:
2406       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2407
2408     default:
2409       return NULL;
2410     }
2411 }
2412
2413 \f
2414
2415
2416 /* Return whether OP is a DECL whose address is function-invariant.  */
2417
2418 bool
2419 decl_address_invariant_p (const_tree op)
2420 {
2421   /* The conditions below are slightly less strict than the one in
2422      staticp.  */
2423
2424   switch (TREE_CODE (op))
2425     {
2426     case PARM_DECL:
2427     case RESULT_DECL:
2428     case LABEL_DECL:
2429     case FUNCTION_DECL:
2430       return true;
2431
2432     case VAR_DECL:
2433       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2434            && !DECL_DLLIMPORT_P (op))
2435           || DECL_THREAD_LOCAL_P (op)
2436           || DECL_CONTEXT (op) == current_function_decl
2437           || decl_function_context (op) == current_function_decl)
2438         return true;
2439       break;
2440
2441     case CONST_DECL:
2442       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2443           || decl_function_context (op) == current_function_decl)
2444         return true;
2445       break;
2446
2447     default:
2448       break;
2449     }
2450
2451   return false;
2452 }
2453
2454 /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
2455
2456 bool
2457 decl_address_ip_invariant_p (const_tree op)
2458 {
2459   /* The conditions below are slightly less strict than the one in
2460      staticp.  */
2461
2462   switch (TREE_CODE (op))
2463     {
2464     case LABEL_DECL:
2465     case FUNCTION_DECL:
2466     case STRING_CST:
2467       return true;
2468
2469     case VAR_DECL:
2470       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2471            && !DECL_DLLIMPORT_P (op))
2472           || DECL_THREAD_LOCAL_P (op))
2473         return true;
2474       break;
2475
2476     case CONST_DECL:
2477       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2478         return true;
2479       break;
2480
2481     default:
2482       break;
2483     }
2484
2485   return false;
2486 }
2487
2488
2489 /* Return true if T is function-invariant (internal function, does
2490    not handle arithmetic; that's handled in skip_simple_arithmetic and
2491    tree_invariant_p).  */
2492
2493 static bool tree_invariant_p (tree t);
2494
2495 static bool
2496 tree_invariant_p_1 (tree t)
2497 {
2498   tree op;
2499
2500   if (TREE_CONSTANT (t)
2501       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2502     return true;
2503
2504   switch (TREE_CODE (t))
2505     {
2506     case SAVE_EXPR:
2507       return true;
2508
2509     case ADDR_EXPR:
2510       op = TREE_OPERAND (t, 0);
2511       while (handled_component_p (op))
2512         {
2513           switch (TREE_CODE (op))
2514             {
2515             case ARRAY_REF:
2516             case ARRAY_RANGE_REF:
2517               if (!tree_invariant_p (TREE_OPERAND (op, 1))
2518                   || TREE_OPERAND (op, 2) != NULL_TREE
2519                   || TREE_OPERAND (op, 3) != NULL_TREE)
2520                 return false;
2521               break;
2522
2523             case COMPONENT_REF:
2524               if (TREE_OPERAND (op, 2) != NULL_TREE)
2525                 return false;
2526               break;
2527
2528             default:;
2529             }
2530           op = TREE_OPERAND (op, 0);
2531         }
2532
2533       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2534
2535     default:
2536       break;
2537     }
2538
2539   return false;
2540 }
2541
2542 /* Return true if T is function-invariant.  */
2543
2544 static bool
2545 tree_invariant_p (tree t)
2546 {
2547   tree inner = skip_simple_arithmetic (t);
2548   return tree_invariant_p_1 (inner);
2549 }
2550
2551 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2552    Do this to any expression which may be used in more than one place,
2553    but must be evaluated only once.
2554
2555    Normally, expand_expr would reevaluate the expression each time.
2556    Calling save_expr produces something that is evaluated and recorded
2557    the first time expand_expr is called on it.  Subsequent calls to
2558    expand_expr just reuse the recorded value.
2559
2560    The call to expand_expr that generates code that actually computes
2561    the value is the first call *at compile time*.  Subsequent calls
2562    *at compile time* generate code to use the saved value.
2563    This produces correct result provided that *at run time* control
2564    always flows through the insns made by the first expand_expr
2565    before reaching the other places where the save_expr was evaluated.
2566    You, the caller of save_expr, must make sure this is so.
2567
2568    Constants, and certain read-only nodes, are returned with no
2569    SAVE_EXPR because that is safe.  Expressions containing placeholders
2570    are not touched; see tree.def for an explanation of what these
2571    are used for.  */
2572
2573 tree
2574 save_expr (tree expr)
2575 {
2576   tree t = fold (expr);
2577   tree inner;
2578
2579   /* If the tree evaluates to a constant, then we don't want to hide that
2580      fact (i.e. this allows further folding, and direct checks for constants).
2581      However, a read-only object that has side effects cannot be bypassed.
2582      Since it is no problem to reevaluate literals, we just return the
2583      literal node.  */
2584   inner = skip_simple_arithmetic (t);
2585   if (TREE_CODE (inner) == ERROR_MARK)
2586     return inner;
2587
2588   if (tree_invariant_p_1 (inner))
2589     return t;
2590
2591   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2592      it means that the size or offset of some field of an object depends on
2593      the value within another field.
2594
2595      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2596      and some variable since it would then need to be both evaluated once and
2597      evaluated more than once.  Front-ends must assure this case cannot
2598      happen by surrounding any such subexpressions in their own SAVE_EXPR
2599      and forcing evaluation at the proper time.  */
2600   if (contains_placeholder_p (inner))
2601     return t;
2602
2603   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2604   SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2605
2606   /* This expression might be placed ahead of a jump to ensure that the
2607      value was computed on both sides of the jump.  So make sure it isn't
2608      eliminated as dead.  */
2609   TREE_SIDE_EFFECTS (t) = 1;
2610   return t;
2611 }
2612
2613 /* Look inside EXPR and into any simple arithmetic operations.  Return
2614    the innermost non-arithmetic node.  */
2615
2616 tree
2617 skip_simple_arithmetic (tree expr)
2618 {
2619   tree inner;
2620
2621   /* We don't care about whether this can be used as an lvalue in this
2622      context.  */
2623   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2624     expr = TREE_OPERAND (expr, 0);
2625
2626   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2627      a constant, it will be more efficient to not make another SAVE_EXPR since
2628      it will allow better simplification and GCSE will be able to merge the
2629      computations if they actually occur.  */
2630   inner = expr;
2631   while (1)
2632     {
2633       if (UNARY_CLASS_P (inner))
2634         inner = TREE_OPERAND (inner, 0);
2635       else if (BINARY_CLASS_P (inner))
2636         {
2637           if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2638             inner = TREE_OPERAND (inner, 0);
2639           else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2640             inner = TREE_OPERAND (inner, 1);
2641           else
2642             break;
2643         }
2644       else
2645         break;
2646     }
2647
2648   return inner;
2649 }
2650
2651
2652 /* Return which tree structure is used by T.  */
2653
2654 enum tree_node_structure_enum
2655 tree_node_structure (const_tree t)
2656 {
2657   const enum tree_code code = TREE_CODE (t);
2658   return tree_node_structure_for_code (code);
2659 }
2660
2661 /* Set various status flags when building a CALL_EXPR object T.  */
2662
2663 static void
2664 process_call_operands (tree t)
2665 {
2666   bool side_effects = TREE_SIDE_EFFECTS (t);
2667   bool read_only = false;
2668   int i = call_expr_flags (t);
2669
2670   /* Calls have side-effects, except those to const or pure functions.  */
2671   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2672     side_effects = true;
2673   /* Propagate TREE_READONLY of arguments for const functions.  */
2674   if (i & ECF_CONST)
2675     read_only = true;
2676
2677   if (!side_effects || read_only)
2678     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2679       {
2680         tree op = TREE_OPERAND (t, i);
2681         if (op && TREE_SIDE_EFFECTS (op))
2682           side_effects = true;
2683         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2684           read_only = false;
2685       }
2686
2687   TREE_SIDE_EFFECTS (t) = side_effects;
2688   TREE_READONLY (t) = read_only;
2689 }
2690 \f
2691 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2692    or offset that depends on a field within a record.  */
2693
2694 bool
2695 contains_placeholder_p (const_tree exp)
2696 {
2697   enum tree_code code;
2698
2699   if (!exp)
2700     return 0;
2701
2702   code = TREE_CODE (exp);
2703   if (code == PLACEHOLDER_EXPR)
2704     return 1;
2705
2706   switch (TREE_CODE_CLASS (code))
2707     {
2708     case tcc_reference:
2709       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2710          position computations since they will be converted into a
2711          WITH_RECORD_EXPR involving the reference, which will assume
2712          here will be valid.  */
2713       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2714
2715     case tcc_exceptional:
2716       if (code == TREE_LIST)
2717         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2718                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2719       break;
2720
2721     case tcc_unary:
2722     case tcc_binary:
2723     case tcc_comparison:
2724     case tcc_expression:
2725       switch (code)
2726         {
2727         case COMPOUND_EXPR:
2728           /* Ignoring the first operand isn't quite right, but works best.  */
2729           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2730
2731         case COND_EXPR:
2732           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2733                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2734                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2735
2736         case SAVE_EXPR:
2737           /* The save_expr function never wraps anything containing
2738              a PLACEHOLDER_EXPR. */
2739           return 0;
2740
2741         default:
2742           break;
2743         }
2744
2745       switch (TREE_CODE_LENGTH (code))
2746         {
2747         case 1:
2748           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2749         case 2:
2750           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2751                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2752         default:
2753           return 0;
2754         }
2755
2756     case tcc_vl_exp:
2757       switch (code)
2758         {
2759         case CALL_EXPR:
2760           {
2761             const_tree arg;
2762             const_call_expr_arg_iterator iter;
2763             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2764               if (CONTAINS_PLACEHOLDER_P (arg))
2765                 return 1;
2766             return 0;
2767           }
2768         default:
2769           return 0;
2770         }
2771
2772     default:
2773       return 0;
2774     }
2775   return 0;
2776 }
2777
2778 /* Return true if any part of the computation of TYPE involves a
2779    PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2780    (for QUAL_UNION_TYPE) and field positions.  */
2781
2782 static bool
2783 type_contains_placeholder_1 (const_tree type)
2784 {
2785   /* If the size contains a placeholder or the parent type (component type in
2786      the case of arrays) type involves a placeholder, this type does.  */
2787   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2788       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2789       || (TREE_TYPE (type) != 0
2790           && type_contains_placeholder_p (TREE_TYPE (type))))
2791     return true;
2792
2793   /* Now do type-specific checks.  Note that the last part of the check above
2794      greatly limits what we have to do below.  */
2795   switch (TREE_CODE (type))
2796     {
2797     case VOID_TYPE:
2798     case COMPLEX_TYPE:
2799     case ENUMERAL_TYPE:
2800     case BOOLEAN_TYPE:
2801     case POINTER_TYPE:
2802     case OFFSET_TYPE:
2803     case REFERENCE_TYPE:
2804     case METHOD_TYPE:
2805     case FUNCTION_TYPE:
2806     case VECTOR_TYPE:
2807       return false;
2808
2809     case INTEGER_TYPE:
2810     case REAL_TYPE:
2811     case FIXED_POINT_TYPE:
2812       /* Here we just check the bounds.  */
2813       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2814               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2815
2816     case ARRAY_TYPE:
2817       /* We're already checked the component type (TREE_TYPE), so just check
2818          the index type.  */
2819       return type_contains_placeholder_p (TYPE_DOMAIN (type));
2820
2821     case RECORD_TYPE:
2822     case UNION_TYPE:
2823     case QUAL_UNION_TYPE:
2824       {
2825         tree field;
2826
2827         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2828           if (TREE_CODE (field) == FIELD_DECL
2829               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2830                   || (TREE_CODE (type) == QUAL_UNION_TYPE
2831                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2832                   || type_contains_placeholder_p (TREE_TYPE (field))))
2833             return true;
2834
2835         return false;
2836       }
2837
2838     default:
2839       gcc_unreachable ();
2840     }
2841 }
2842
2843 bool
2844 type_contains_placeholder_p (tree type)
2845 {
2846   bool result;
2847
2848   /* If the contains_placeholder_bits field has been initialized,
2849      then we know the answer.  */
2850   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2851     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2852
2853   /* Indicate that we've seen this type node, and the answer is false.
2854      This is what we want to return if we run into recursion via fields.  */
2855   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2856
2857   /* Compute the real value.  */
2858   result = type_contains_placeholder_1 (type);
2859
2860   /* Store the real value.  */
2861   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2862
2863   return result;
2864 }
2865 \f
2866 /* Push tree EXP onto vector QUEUE if it is not already present.  */
2867
2868 static void
2869 push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2870 {
2871   unsigned int i;
2872   tree iter;
2873
2874   for (i = 0; VEC_iterate (tree, *queue, i, iter); i++)
2875     if (simple_cst_equal (iter, exp) == 1)
2876       break;
2877
2878   if (!iter)
2879     VEC_safe_push (tree, heap, *queue, exp);
2880 }
2881
2882 /* Given a tree EXP, find all occurences of references to fields
2883    in a PLACEHOLDER_EXPR and place them in vector REFS without
2884    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
2885    we assume here that EXP contains only arithmetic expressions
2886    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2887    argument list.  */
2888
2889 void
2890 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2891 {
2892   enum tree_code code = TREE_CODE (exp);
2893   tree inner;
2894   int i;
2895
2896   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2897   if (code == TREE_LIST)
2898     {
2899       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2900       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2901     }
2902   else if (code == COMPONENT_REF)
2903     {
2904       for (inner = TREE_OPERAND (exp, 0);
2905            REFERENCE_CLASS_P (inner);
2906            inner = TREE_OPERAND (inner, 0))
2907         ;
2908
2909       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2910         push_without_duplicates (exp, refs);
2911       else
2912         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2913    }
2914   else
2915     switch (TREE_CODE_CLASS (code))
2916       {
2917       case tcc_constant:
2918         break;
2919
2920       case tcc_declaration:
2921         /* Variables allocated to static storage can stay.  */
2922         if (!TREE_STATIC (exp))
2923           push_without_duplicates (exp, refs);
2924         break;
2925
2926       case tcc_expression:
2927         /* This is the pattern built in ada/make_aligning_type.  */
2928         if (code == ADDR_EXPR
2929             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
2930           {
2931             push_without_duplicates (exp, refs);
2932             break;
2933           }
2934
2935         /* Fall through...  */
2936
2937       case tcc_exceptional:
2938       case tcc_unary:
2939       case tcc_binary:
2940       case tcc_comparison:
2941       case tcc_reference:
2942         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
2943           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2944         break;
2945
2946       case tcc_vl_exp:
2947         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
2948           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2949         break;
2950
2951       default:
2952         gcc_unreachable ();
2953       }
2954 }
2955
2956 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2957    return a tree with all occurrences of references to F in a
2958    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
2959    CONST_DECLs.  Note that we assume here that EXP contains only
2960    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
2961    occurring only in their argument list.  */
2962
2963 tree
2964 substitute_in_expr (tree exp, tree f, tree r)
2965 {
2966   enum tree_code code = TREE_CODE (exp);
2967   tree op0, op1, op2, op3;
2968   tree new_tree;
2969
2970   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2971   if (code == TREE_LIST)
2972     {
2973       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
2974       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
2975       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2976         return exp;
2977
2978       return tree_cons (TREE_PURPOSE (exp), op1, op0);
2979     }
2980   else if (code == COMPONENT_REF)
2981     {
2982       tree inner;
2983
2984       /* If this expression is getting a value from a PLACEHOLDER_EXPR
2985          and it is the right field, replace it with R.  */
2986       for (inner = TREE_OPERAND (exp, 0);
2987            REFERENCE_CLASS_P (inner);
2988            inner = TREE_OPERAND (inner, 0))
2989         ;
2990
2991       /* The field.  */
2992       op1 = TREE_OPERAND (exp, 1);
2993
2994       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
2995         return r;
2996
2997       /* If this expression hasn't been completed let, leave it alone.  */
2998       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
2999         return exp;
3000
3001       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3002       if (op0 == TREE_OPERAND (exp, 0))
3003         return exp;
3004
3005       new_tree
3006         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3007    }
3008   else
3009     switch (TREE_CODE_CLASS (code))
3010       {
3011       case tcc_constant:
3012         return exp;
3013
3014       case tcc_declaration:
3015         if (exp == f)
3016           return r;
3017         else
3018           return exp;
3019
3020       case tcc_expression:
3021         if (exp == f)
3022           return r;
3023
3024         /* Fall through...  */
3025
3026       case tcc_exceptional:
3027       case tcc_unary:
3028       case tcc_binary:
3029       case tcc_comparison:
3030       case tcc_reference:
3031         switch (TREE_CODE_LENGTH (code))
3032           {
3033           case 0:
3034             return exp;
3035
3036           case 1:
3037             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3038             if (op0 == TREE_OPERAND (exp, 0))
3039               return exp;
3040
3041             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3042             break;
3043
3044           case 2:
3045             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3046             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3047
3048             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3049               return exp;
3050
3051             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3052             break;
3053
3054           case 3:
3055             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3056             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3057             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3058
3059             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3060                 && op2 == TREE_OPERAND (exp, 2))
3061               return exp;
3062
3063             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3064             break;
3065
3066           case 4:
3067             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3068             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3069             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3070             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3071
3072             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3073                 && op2 == TREE_OPERAND (exp, 2)
3074                 && op3 == TREE_OPERAND (exp, 3))
3075               return exp;
3076
3077             new_tree
3078               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3079             break;
3080
3081           default:
3082             gcc_unreachable ();
3083           }
3084         break;
3085
3086       case tcc_vl_exp:
3087         {
3088           int i;
3089
3090           new_tree = NULL_TREE;
3091
3092           /* If we are trying to replace F with a constant, inline back
3093              functions which do nothing else than computing a value from
3094              the arguments they are passed.  This makes it possible to
3095              fold partially or entirely the replacement expression.  */
3096           if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3097             {
3098               tree t = maybe_inline_call_in_expr (exp);
3099               if (t)
3100                 return SUBSTITUTE_IN_EXPR (t, f, r);
3101             }
3102
3103           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3104             {
3105               tree op = TREE_OPERAND (exp, i);
3106               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3107               if (new_op != op)
3108                 {
3109                   if (!new_tree)
3110                     new_tree = copy_node (exp);
3111                   TREE_OPERAND (new_tree, i) = new_op;
3112                 }
3113             }
3114
3115           if (new_tree)
3116             {
3117               new_tree = fold (new_tree);
3118               if (TREE_CODE (new_tree) == CALL_EXPR)
3119                 process_call_operands (new_tree);
3120             }
3121           else
3122             return exp;
3123         }
3124         break;
3125
3126       default:
3127         gcc_unreachable ();
3128       }
3129
3130   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3131   return new_tree;
3132 }
3133
3134 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3135    for it within OBJ, a tree that is an object or a chain of references.  */
3136
3137 tree
3138 substitute_placeholder_in_expr (tree exp, tree obj)
3139 {
3140   enum tree_code code = TREE_CODE (exp);
3141   tree op0, op1, op2, op3;
3142   tree new_tree;
3143
3144   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3145      in the chain of OBJ.  */
3146   if (code == PLACEHOLDER_EXPR)
3147     {
3148       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3149       tree elt;
3150
3151       for (elt = obj; elt != 0;
3152            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3153                    || TREE_CODE (elt) == COND_EXPR)
3154                   ? TREE_OPERAND (elt, 1)
3155                   : (REFERENCE_CLASS_P (elt)
3156                      || UNARY_CLASS_P (elt)
3157                      || BINARY_CLASS_P (elt)
3158                      || VL_EXP_CLASS_P (elt)
3159                      || EXPRESSION_CLASS_P (elt))
3160                   ? TREE_OPERAND (elt, 0) : 0))
3161         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3162           return elt;
3163
3164       for (elt = obj; elt != 0;
3165            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3166                    || TREE_CODE (elt) == COND_EXPR)
3167                   ? TREE_OPERAND (elt, 1)
3168                   : (REFERENCE_CLASS_P (elt)
3169                      || UNARY_CLASS_P (elt)
3170                      || BINARY_CLASS_P (elt)
3171                      || VL_EXP_CLASS_P (elt)
3172                      || EXPRESSION_CLASS_P (elt))
3173                   ? TREE_OPERAND (elt, 0) : 0))
3174         if (POINTER_TYPE_P (TREE_TYPE (elt))
3175             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3176                 == need_type))
3177           return fold_build1 (INDIRECT_REF, need_type, elt);
3178
3179       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3180          survives until RTL generation, there will be an error.  */
3181       return exp;
3182     }
3183
3184   /* TREE_LIST is special because we need to look at TREE_VALUE
3185      and TREE_CHAIN, not TREE_OPERANDS.  */
3186   else if (code == TREE_LIST)
3187     {
3188       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3189       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3190       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3191         return exp;
3192
3193       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3194     }
3195   else
3196     switch (TREE_CODE_CLASS (code))
3197       {
3198       case tcc_constant:
3199       case tcc_declaration:
3200         return exp;
3201
3202       case tcc_exceptional:
3203       case tcc_unary:
3204       case tcc_binary:
3205       case tcc_comparison:
3206       case tcc_expression:
3207       case tcc_reference:
3208       case tcc_statement:
3209         switch (TREE_CODE_LENGTH (code))
3210           {
3211           case 0:
3212             return exp;
3213
3214           case 1:
3215             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3216             if (op0 == TREE_OPERAND (exp, 0))
3217               return exp;
3218
3219             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3220             break;
3221
3222           case 2:
3223             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3224             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3225
3226             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3227               return exp;
3228
3229             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3230             break;
3231
3232           case 3:
3233             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3234             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3235             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3236
3237             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3238                 && op2 == TREE_OPERAND (exp, 2))
3239               return exp;
3240
3241             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3242             break;
3243
3244           case 4:
3245             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3246             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3247             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3248             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3249
3250             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3251                 && op2 == TREE_OPERAND (exp, 2)
3252                 && op3 == TREE_OPERAND (exp, 3))
3253               return exp;
3254
3255             new_tree
3256               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3257             break;
3258
3259           default:
3260             gcc_unreachable ();
3261           }
3262         break;
3263
3264       case tcc_vl_exp:
3265         {
3266           int i;
3267
3268           new_tree = NULL_TREE;
3269
3270           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3271             {
3272               tree op = TREE_OPERAND (exp, i);
3273               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3274               if (new_op != op)
3275                 {
3276                   if (!new_tree)
3277                     new_tree = copy_node (exp);
3278                   TREE_OPERAND (new_tree, i) = new_op;
3279                 }
3280             }
3281
3282           if (new_tree)
3283             {
3284               new_tree = fold (new_tree);
3285               if (TREE_CODE (new_tree) == CALL_EXPR)
3286                 process_call_operands (new_tree);
3287             }
3288           else
3289             return exp;
3290         }
3291         break;
3292
3293       default:
3294         gcc_unreachable ();
3295       }
3296
3297   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3298   return new_tree;
3299 }
3300 \f
3301 /* Stabilize a reference so that we can use it any number of times
3302    without causing its operands to be evaluated more than once.
3303    Returns the stabilized reference.  This works by means of save_expr,
3304    so see the caveats in the comments about save_expr.
3305
3306    Also allows conversion expressions whose operands are references.
3307    Any other kind of expression is returned unchanged.  */
3308
3309 tree
3310 stabilize_reference (tree ref)
3311 {
3312   tree result;
3313   enum tree_code code = TREE_CODE (ref);
3314
3315   switch (code)
3316     {
3317     case VAR_DECL:
3318     case PARM_DECL:
3319     case RESULT_DECL:
3320       /* No action is needed in this case.  */
3321       return ref;
3322
3323     CASE_CONVERT:
3324     case FLOAT_EXPR:
3325     case FIX_TRUNC_EXPR:
3326       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3327       break;
3328
3329     case INDIRECT_REF:
3330       result = build_nt (INDIRECT_REF,
3331                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3332       break;
3333
3334     case COMPONENT_REF:
3335       result = build_nt (COMPONENT_REF,
3336                          stabilize_reference (TREE_OPERAND (ref, 0)),
3337                          TREE_OPERAND (ref, 1), NULL_TREE);
3338       break;
3339
3340     case BIT_FIELD_REF:
3341       result = build_nt (BIT_FIELD_REF,
3342                          stabilize_reference (TREE_OPERAND (ref, 0)),
3343                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3344                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3345       break;
3346
3347     case ARRAY_REF:
3348       result = build_nt (ARRAY_REF,
3349                          stabilize_reference (TREE_OPERAND (ref, 0)),
3350                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3351                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3352       break;
3353
3354     case ARRAY_RANGE_REF:
3355       result = build_nt (ARRAY_RANGE_REF,
3356                          stabilize_reference (TREE_OPERAND (ref, 0)),
3357                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3358                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3359       break;
3360
3361     case COMPOUND_EXPR:
3362       /* We cannot wrap the first expression in a SAVE_EXPR, as then
3363          it wouldn't be ignored.  This matters when dealing with
3364          volatiles.  */
3365       return stabilize_reference_1 (ref);
3366
3367       /* If arg isn't a kind of lvalue we recognize, make no change.
3368          Caller should recognize the error for an invalid lvalue.  */
3369     default:
3370       return ref;
3371
3372     case ERROR_MARK:
3373       return error_mark_node;
3374     }
3375
3376   TREE_TYPE (result) = TREE_TYPE (ref);
3377   TREE_READONLY (result) = TREE_READONLY (ref);
3378   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3379   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3380
3381   return result;
3382 }
3383
3384 /* Subroutine of stabilize_reference; this is called for subtrees of
3385    references.  Any expression with side-effects must be put in a SAVE_EXPR
3386    to ensure that it is only evaluated once.
3387
3388    We don't put SAVE_EXPR nodes around everything, because assigning very
3389    simple expressions to temporaries causes us to miss good opportunities
3390    for optimizations.  Among other things, the opportunity to fold in the
3391    addition of a constant into an addressing mode often gets lost, e.g.
3392    "y[i+1] += x;".  In general, we take the approach that we should not make
3393    an assignment unless we are forced into it - i.e., that any non-side effect
3394    operator should be allowed, and that cse should take care of coalescing
3395    multiple utterances of the same expression should that prove fruitful.  */
3396
3397 tree
3398 stabilize_reference_1 (tree e)
3399 {
3400   tree result;
3401   enum tree_code code = TREE_CODE (e);
3402
3403   /* We cannot ignore const expressions because it might be a reference
3404      to a const array but whose index contains side-effects.  But we can
3405      ignore things that are actual constant or that already have been
3406      handled by this function.  */
3407
3408   if (tree_invariant_p (e))
3409     return e;
3410
3411   switch (TREE_CODE_CLASS (code))
3412     {
3413     case tcc_exceptional:
3414     case tcc_type:
3415     case tcc_declaration:
3416     case tcc_comparison:
3417     case tcc_statement:
3418     case tcc_expression:
3419     case tcc_reference:
3420     case tcc_vl_exp:
3421       /* If the expression has side-effects, then encase it in a SAVE_EXPR
3422          so that it will only be evaluated once.  */
3423       /* The reference (r) and comparison (<) classes could be handled as
3424          below, but it is generally faster to only evaluate them once.  */
3425       if (TREE_SIDE_EFFECTS (e))
3426         return save_expr (e);
3427       return e;
3428
3429     case tcc_constant:
3430       /* Constants need no processing.  In fact, we should never reach
3431          here.  */
3432       return e;
3433
3434     case tcc_binary:
3435       /* Division is slow and tends to be compiled with jumps,
3436          especially the division by powers of 2 that is often
3437          found inside of an array reference.  So do it just once.  */
3438       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3439           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3440           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3441           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3442         return save_expr (e);
3443       /* Recursively stabilize each operand.  */
3444       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3445                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
3446       break;
3447
3448     case tcc_unary:
3449       /* Recursively stabilize each operand.  */
3450       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3451       break;
3452
3453     default:
3454       gcc_unreachable ();
3455     }
3456
3457   TREE_TYPE (result) = TREE_TYPE (e);
3458   TREE_READONLY (result) = TREE_READONLY (e);
3459   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3460   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3461
3462   return result;
3463 }
3464 \f
3465 /* Low-level constructors for expressions.  */
3466
3467 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
3468    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
3469
3470 void
3471 recompute_tree_invariant_for_addr_expr (tree t)
3472 {
3473   tree node;
3474   bool tc = true, se = false;
3475
3476   /* We started out assuming this address is both invariant and constant, but
3477      does not have side effects.  Now go down any handled components and see if
3478      any of them involve offsets that are either non-constant or non-invariant.
3479      Also check for side-effects.
3480
3481      ??? Note that this code makes no attempt to deal with the case where
3482      taking the address of something causes a copy due to misalignment.  */
3483
3484 #define UPDATE_FLAGS(NODE)  \
3485 do { tree _node = (NODE); \
3486      if (_node && !TREE_CONSTANT (_node)) tc = false; \
3487      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3488
3489   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3490        node = TREE_OPERAND (node, 0))
3491     {
3492       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3493          array reference (probably made temporarily by the G++ front end),
3494          so ignore all the operands.  */
3495       if ((TREE_CODE (node) == ARRAY_REF
3496            || TREE_CODE (node) == ARRAY_RANGE_REF)
3497           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3498         {
3499           UPDATE_FLAGS (TREE_OPERAND (node, 1));
3500           if (TREE_OPERAND (node, 2))
3501             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3502           if (TREE_OPERAND (node, 3))
3503             UPDATE_FLAGS (TREE_OPERAND (node, 3));
3504         }
3505       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3506          FIELD_DECL, apparently.  The G++ front end can put something else
3507          there, at least temporarily.  */
3508       else if (TREE_CODE (node) == COMPONENT_REF
3509                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3510         {
3511           if (TREE_OPERAND (node, 2))
3512             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3513         }
3514       else if (TREE_CODE (node) == BIT_FIELD_REF)
3515         UPDATE_FLAGS (TREE_OPERAND (node, 2));
3516     }
3517
3518   node = lang_hooks.expr_to_decl (node, &tc, &se);
3519
3520   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
3521      the address, since &(*a)->b is a form of addition.  If it's a constant, the
3522      address is constant too.  If it's a decl, its address is constant if the
3523      decl is static.  Everything else is not constant and, furthermore,
3524      taking the address of a volatile variable is not volatile.  */
3525   if (TREE_CODE (node) == INDIRECT_REF)
3526     UPDATE_FLAGS (TREE_OPERAND (node, 0));
3527   else if (CONSTANT_CLASS_P (node))
3528     ;
3529   else if (DECL_P (node))
3530     tc &= (staticp (node) != NULL_TREE);
3531   else
3532     {
3533       tc = false;
3534       se |= TREE_SIDE_EFFECTS (node);
3535     }
3536
3537
3538   TREE_CONSTANT (t) = tc;
3539   TREE_SIDE_EFFECTS (t) = se;
3540 #undef UPDATE_FLAGS
3541 }
3542
3543 /* Build an expression of code CODE, data type TYPE, and operands as
3544    specified.  Expressions and reference nodes can be created this way.
3545    Constants, decls, types and misc nodes cannot be.
3546
3547    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
3548    enough for all extant tree codes.  */
3549
3550 tree
3551 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3552 {
3553   tree t;
3554
3555   gcc_assert (TREE_CODE_LENGTH (code) == 0);
3556
3557   t = make_node_stat (code PASS_MEM_STAT);
3558   TREE_TYPE (t) = tt;
3559
3560   return t;
3561 }
3562
3563 tree
3564 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3565 {
3566   int length = sizeof (struct tree_exp);
3567 #ifdef GATHER_STATISTICS
3568   tree_node_kind kind;
3569 #endif
3570   tree t;
3571
3572 #ifdef GATHER_STATISTICS
3573   switch (TREE_CODE_CLASS (code))
3574     {
3575     case tcc_statement:  /* an expression with side effects */
3576       kind = s_kind;
3577       break;
3578     case tcc_reference:  /* a reference */
3579       kind = r_kind;
3580       break;
3581     default:
3582       kind = e_kind;
3583       break;
3584     }
3585
3586   tree_node_counts[(int) kind]++;
3587   tree_node_sizes[(int) kind] += length;
3588 #endif
3589
3590   gcc_assert (TREE_CODE_LENGTH (code) == 1);
3591
3592   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
3593
3594   memset (t, 0, sizeof (struct tree_common));
3595
3596   TREE_SET_CODE (t, code);
3597
3598   TREE_TYPE (t) = type;
3599   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3600   TREE_OPERAND (t, 0) = node;
3601   TREE_BLOCK (t) = NULL_TREE;
3602   if (node && !TYPE_P (node))
3603     {
3604       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3605       TREE_READONLY (t) = TREE_READONLY (node);
3606     }
3607
3608   if (TREE_CODE_CLASS (code) == tcc_statement)
3609     TREE_SIDE_EFFECTS (t) = 1;
3610   else switch (code)
3611     {
3612     case VA_ARG_EXPR:
3613       /* All of these have side-effects, no matter what their
3614          operands are.  */
3615       TREE_SIDE_EFFECTS (t) = 1;
3616       TREE_READONLY (t) = 0;
3617       break;
3618
3619     case MISALIGNED_INDIRECT_REF:
3620     case ALIGN_INDIRECT_REF:
3621     case INDIRECT_REF:
3622       /* Whether a dereference is readonly has nothing to do with whether
3623          its operand is readonly.  */
3624       TREE_READONLY (t) = 0;
3625       break;
3626
3627     case ADDR_EXPR:
3628       if (node)
3629         recompute_tree_invariant_for_addr_expr (t);
3630       break;
3631
3632     default:
3633       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3634           && node && !TYPE_P (node)
3635           && TREE_CONSTANT (node))
3636         TREE_CONSTANT (t) = 1;
3637       if (TREE_CODE_CLASS (code) == tcc_reference
3638           && node && TREE_THIS_VOLATILE (node))
3639         TREE_THIS_VOLATILE (t) = 1;
3640       break;
3641     }
3642
3643   return t;
3644 }
3645
3646 #define PROCESS_ARG(N)                          \
3647   do {                                          \
3648     TREE_OPERAND (t, N) = arg##N;               \
3649     if (arg##N &&!TYPE_P (arg##N))              \
3650       {                                         \
3651         if (TREE_SIDE_EFFECTS (arg##N))         \
3652           side_effects = 1;                     \
3653         if (!TREE_READONLY (arg##N)             \
3654             && !CONSTANT_CLASS_P (arg##N))      \
3655           (void) (read_only = 0);               \
3656         if (!TREE_CONSTANT (arg##N))            \
3657           (void) (constant = 0);                \
3658       }                                         \
3659   } while (0)
3660
3661 tree
3662 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3663 {
3664   bool constant, read_only, side_effects;
3665   tree t;
3666
3667   gcc_assert (TREE_CODE_LENGTH (code) == 2);
3668
3669   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3670       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3671       /* When sizetype precision doesn't match that of pointers
3672          we need to be able to build explicit extensions or truncations
3673          of the offset argument.  */
3674       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3675     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3676                 && TREE_CODE (arg1) == INTEGER_CST);
3677
3678   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3679     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3680                 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3681                 && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3682
3683   t = make_node_stat (code PASS_MEM_STAT);
3684   TREE_TYPE (t) = tt;
3685
3686   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3687      result based on those same flags for the arguments.  But if the
3688      arguments aren't really even `tree' expressions, we shouldn't be trying
3689      to do this.  */
3690
3691   /* Expressions without side effects may be constant if their
3692      arguments are as well.  */
3693   constant = (TREE_CODE_CLASS (code) == tcc_comparison
3694               || TREE_CODE_CLASS (code) == tcc_binary);
3695   read_only = 1;
3696   side_effects = TREE_SIDE_EFFECTS (t);
3697
3698   PROCESS_ARG(0);
3699   PROCESS_ARG(1);
3700
3701   TREE_READONLY (t) = read_only;
3702   TREE_CONSTANT (t) = constant;
3703   TREE_SIDE_EFFECTS (t) = side_effects;
3704   TREE_THIS_VOLATILE (t)
3705     = (TREE_CODE_CLASS (code) == tcc_reference
3706        && arg0 && TREE_THIS_VOLATILE (arg0));
3707
3708   return t;
3709 }
3710
3711
3712 tree
3713 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3714              tree arg2 MEM_STAT_DECL)
3715 {
3716   bool constant, read_only, side_effects;
3717   tree t;
3718
3719   gcc_assert (TREE_CODE_LENGTH (code) == 3);
3720   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3721
3722   t = make_node_stat (code PASS_MEM_STAT);
3723   TREE_TYPE (t) = tt;
3724
3725   read_only = 1;
3726
3727   /* As a special exception, if COND_EXPR has NULL branches, we
3728      assume that it is a gimple statement and always consider
3729      it to have side effects.  */
3730   if (code == COND_EXPR
3731       && tt == void_type_node
3732       && arg1 == NULL_TREE
3733       && arg2 == NULL_TREE)
3734     side_effects = true;
3735   else
3736     side_effects = TREE_SIDE_EFFECTS (t);
3737
3738   PROCESS_ARG(0);
3739   PROCESS_ARG(1);
3740   PROCESS_ARG(2);
3741
3742   if (code == COND_EXPR)
3743     TREE_READONLY (t) = read_only;
3744
3745   TREE_SIDE_EFFECTS (t) = side_effects;
3746   TREE_THIS_VOLATILE (t)
3747     = (TREE_CODE_CLASS (code) == tcc_reference
3748        && arg0 && TREE_THIS_VOLATILE (arg0));
3749
3750   return t;
3751 }
3752
3753 tree