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
3754 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3755              tree arg2, tree arg3 MEM_STAT_DECL)
3756 {
3757   bool constant, read_only, side_effects;
3758   tree t;
3759
3760   gcc_assert (TREE_CODE_LENGTH (code) == 4);
3761
3762   t = make_node_stat (code PASS_MEM_STAT);
3763   TREE_TYPE (t) = tt;
3764
3765   side_effects = TREE_SIDE_EFFECTS (t);
3766
3767   PROCESS_ARG(0);
3768   PROCESS_ARG(1);
3769   PROCESS_ARG(2);
3770   PROCESS_ARG(3);
3771
3772   TREE_SIDE_EFFECTS (t) = side_effects;
3773   TREE_THIS_VOLATILE (t)
3774     = (TREE_CODE_CLASS (code) == tcc_reference
3775        && arg0 && TREE_THIS_VOLATILE (arg0));
3776
3777   return t;
3778 }
3779
3780 tree
3781 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3782              tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
3783 {
3784   bool constant, read_only, side_effects;
3785   tree t;
3786
3787   gcc_assert (TREE_CODE_LENGTH (code) == 5);
3788
3789   t = make_node_stat (code PASS_MEM_STAT);
3790   TREE_TYPE (t) = tt;
3791
3792   side_effects = TREE_SIDE_EFFECTS (t);
3793
3794   PROCESS_ARG(0);
3795   PROCESS_ARG(1);
3796   PROCESS_ARG(2);
3797   PROCESS_ARG(3);
3798   PROCESS_ARG(4);
3799
3800   TREE_SIDE_EFFECTS (t) = side_effects;
3801   TREE_THIS_VOLATILE (t)
3802     = (TREE_CODE_CLASS (code) == tcc_reference
3803        && arg0 && TREE_THIS_VOLATILE (arg0));
3804
3805   return t;
3806 }
3807
3808 tree
3809 build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3810              tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL)
3811 {
3812   bool constant, read_only, side_effects;
3813   tree t;
3814
3815   gcc_assert (code == TARGET_MEM_REF);
3816
3817   t = make_node_stat (code PASS_MEM_STAT);
3818   TREE_TYPE (t) = tt;
3819
3820   side_effects = TREE_SIDE_EFFECTS (t);
3821
3822   PROCESS_ARG(0);
3823   PROCESS_ARG(1);
3824   PROCESS_ARG(2);
3825   PROCESS_ARG(3);
3826   PROCESS_ARG(4);
3827   if (code == TARGET_MEM_REF)
3828     side_effects = 0;
3829   PROCESS_ARG(5);
3830
3831   TREE_SIDE_EFFECTS (t) = side_effects;
3832   TREE_THIS_VOLATILE (t)
3833     = (code == TARGET_MEM_REF
3834        && arg5 && TREE_THIS_VOLATILE (arg5));
3835
3836   return t;
3837 }
3838
3839 /* Similar except don't specify the TREE_TYPE
3840    and leave the TREE_SIDE_EFFECTS as 0.
3841    It is permissible for arguments to be null,
3842    or even garbage if their values do not matter.  */
3843
3844 tree
3845 build_nt (enum tree_code code, ...)
3846 {
3847   tree t;
3848   int length;
3849   int i;
3850   va_list p;
3851
3852   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3853
3854   va_start (p, code);
3855
3856   t = make_node (code);
3857   length = TREE_CODE_LENGTH (code);
3858
3859   for (i = 0; i < length; i++)
3860     TREE_OPERAND (t, i) = va_arg (p, tree);
3861
3862   va_end (p);
3863   return t;
3864 }
3865
3866 /* Similar to build_nt, but for creating a CALL_EXPR object with
3867    ARGLIST passed as a list.  */
3868
3869 tree
3870 build_nt_call_list (tree fn, tree arglist)
3871 {
3872   tree t;
3873   int i;
3874
3875   t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
3876   CALL_EXPR_FN (t) = fn;
3877   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
3878   for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
3879     CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
3880   return t;
3881 }
3882
3883 /* Similar to build_nt, but for creating a CALL_EXPR object with a
3884    tree VEC.  */
3885
3886 tree
3887 build_nt_call_vec (tree fn, VEC(tree,gc) *args)
3888 {
3889   tree ret, t;
3890   unsigned int ix;
3891
3892   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
3893   CALL_EXPR_FN (ret) = fn;
3894   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3895   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
3896     CALL_EXPR_ARG (ret, ix) = t;
3897   return ret;
3898 }
3899 \f
3900 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3901    We do NOT enter this node in any sort of symbol table.
3902
3903    LOC is the location of the decl.
3904
3905    layout_decl is used to set up the decl's storage layout.
3906    Other slots are initialized to 0 or null pointers.  */
3907
3908 tree
3909 build_decl_stat (location_t loc, enum tree_code code, tree name,
3910                  tree type MEM_STAT_DECL)
3911 {
3912   tree t;
3913
3914   t = make_node_stat (code PASS_MEM_STAT);
3915   DECL_SOURCE_LOCATION (t) = loc;
3916
3917 /*  if (type == error_mark_node)
3918     type = integer_type_node; */
3919 /* That is not done, deliberately, so that having error_mark_node
3920    as the type can suppress useless errors in the use of this variable.  */
3921
3922   DECL_NAME (t) = name;
3923   TREE_TYPE (t) = type;
3924
3925   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
3926     layout_decl (t, 0);
3927
3928   return t;
3929 }
3930
3931 /* Builds and returns function declaration with NAME and TYPE.  */
3932
3933 tree
3934 build_fn_decl (const char *name, tree type)
3935 {
3936   tree id = get_identifier (name);
3937   tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
3938
3939   DECL_EXTERNAL (decl) = 1;
3940   TREE_PUBLIC (decl) = 1;
3941   DECL_ARTIFICIAL (decl) = 1;
3942   TREE_NOTHROW (decl) = 1;
3943
3944   return decl;
3945 }
3946
3947 \f
3948 /* BLOCK nodes are used to represent the structure of binding contours
3949    and declarations, once those contours have been exited and their contents
3950    compiled.  This information is used for outputting debugging info.  */
3951
3952 tree
3953 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
3954 {
3955   tree block = make_node (BLOCK);
3956
3957   BLOCK_VARS (block) = vars;
3958   BLOCK_SUBBLOCKS (block) = subblocks;
3959   BLOCK_SUPERCONTEXT (block) = supercontext;
3960   BLOCK_CHAIN (block) = chain;
3961   return block;
3962 }
3963
3964 expanded_location
3965 expand_location (source_location loc)
3966 {
3967   expanded_location xloc;
3968   if (loc <= BUILTINS_LOCATION)
3969     {
3970       xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>");
3971       xloc.line = 0;
3972       xloc.column = 0;
3973       xloc.sysp = 0;
3974     }
3975   else
3976     {
3977       const struct line_map *map = linemap_lookup (line_table, loc);
3978       xloc.file = map->to_file;
3979       xloc.line = SOURCE_LINE (map, loc);
3980       xloc.column = SOURCE_COLUMN (map, loc);
3981       xloc.sysp = map->sysp != 0;
3982     };
3983   return xloc;
3984 }
3985
3986 \f
3987 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
3988
3989    LOC is the location to use in tree T.  */
3990
3991 void
3992 protected_set_expr_location (tree t, location_t loc)
3993 {
3994   if (t && CAN_HAVE_LOCATION_P (t))
3995     SET_EXPR_LOCATION (t, loc);
3996 }
3997 \f
3998 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
3999    is ATTRIBUTE.  */
4000
4001 tree
4002 build_decl_attribute_variant (tree ddecl, tree attribute)
4003 {
4004   DECL_ATTRIBUTES (ddecl) = attribute;
4005   return ddecl;
4006 }
4007
4008 /* Borrowed from hashtab.c iterative_hash implementation.  */
4009 #define mix(a,b,c) \
4010 { \
4011   a -= b; a -= c; a ^= (c>>13); \
4012   b -= c; b -= a; b ^= (a<< 8); \
4013   c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4014   a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4015   b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4016   c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4017   a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4018   b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4019   c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4020 }
4021
4022
4023 /* Produce good hash value combining VAL and VAL2.  */
4024 hashval_t
4025 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
4026 {
4027   /* the golden ratio; an arbitrary value.  */
4028   hashval_t a = 0x9e3779b9;
4029
4030   mix (a, val, val2);
4031   return val2;
4032 }
4033
4034 /* Produce good hash value combining VAL and VAL2.  */
4035 hashval_t
4036 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4037 {
4038   if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4039     return iterative_hash_hashval_t (val, val2);
4040   else
4041     {
4042       hashval_t a = (hashval_t) val;
4043       /* Avoid warnings about shifting of more than the width of the type on
4044          hosts that won't execute this path.  */
4045       int zero = 0;
4046       hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4047       mix (a, b, val2);
4048       if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4049         {
4050           hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4051           hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4052           mix (a, b, val2);
4053         }
4054       return val2;
4055     }
4056 }
4057
4058 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4059    is ATTRIBUTE and its qualifiers are QUALS.
4060
4061    Record such modified types already made so we don't make duplicates.  */
4062
4063 tree
4064 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4065 {
4066   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4067     {
4068       hashval_t hashcode = 0;
4069       tree ntype;
4070       enum tree_code code = TREE_CODE (ttype);
4071
4072       /* Building a distinct copy of a tagged type is inappropriate; it
4073          causes breakage in code that expects there to be a one-to-one
4074          relationship between a struct and its fields.
4075          build_duplicate_type is another solution (as used in
4076          handle_transparent_union_attribute), but that doesn't play well
4077          with the stronger C++ type identity model.  */
4078       if (TREE_CODE (ttype) == RECORD_TYPE
4079           || TREE_CODE (ttype) == UNION_TYPE
4080           || TREE_CODE (ttype) == QUAL_UNION_TYPE
4081           || TREE_CODE (ttype) == ENUMERAL_TYPE)
4082         {
4083           warning (OPT_Wattributes,
4084                    "ignoring attributes applied to %qT after definition",
4085                    TYPE_MAIN_VARIANT (ttype));
4086           return build_qualified_type (ttype, quals);
4087         }
4088
4089       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4090       ntype = build_distinct_type_copy (ttype);
4091
4092       TYPE_ATTRIBUTES (ntype) = attribute;
4093
4094       hashcode = iterative_hash_object (code, hashcode);
4095       if (TREE_TYPE (ntype))
4096         hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4097                                           hashcode);
4098       hashcode = attribute_hash_list (attribute, hashcode);
4099
4100       switch (TREE_CODE (ntype))
4101         {
4102         case FUNCTION_TYPE:
4103           hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4104           break;
4105         case ARRAY_TYPE:
4106           if (TYPE_DOMAIN (ntype))
4107             hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4108                                               hashcode);
4109           break;
4110         case INTEGER_TYPE:
4111           hashcode = iterative_hash_object
4112             (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4113           hashcode = iterative_hash_object
4114             (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4115           break;
4116         case REAL_TYPE:
4117         case FIXED_POINT_TYPE:
4118           {
4119             unsigned int precision = TYPE_PRECISION (ntype);
4120             hashcode = iterative_hash_object (precision, hashcode);
4121           }
4122           break;
4123         default:
4124           break;
4125         }
4126
4127       ntype = type_hash_canon (hashcode, ntype);
4128
4129       /* If the target-dependent attributes make NTYPE different from
4130          its canonical type, we will need to use structural equality
4131          checks for this type. */
4132       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4133           || !targetm.comp_type_attributes (ntype, ttype))
4134         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4135       else if (TYPE_CANONICAL (ntype) == ntype)
4136         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4137
4138       ttype = build_qualified_type (ntype, quals);
4139     }
4140   else if (TYPE_QUALS (ttype) != quals)
4141     ttype = build_qualified_type (ttype, quals);
4142
4143   return ttype;
4144 }
4145
4146
4147 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4148    is ATTRIBUTE.
4149
4150    Record such modified types already made so we don't make duplicates.  */
4151
4152 tree
4153 build_type_attribute_variant (tree ttype, tree attribute)
4154 {
4155   return build_type_attribute_qual_variant (ttype, attribute,
4156                                             TYPE_QUALS (ttype));
4157 }
4158
4159
4160 /* Reset the expression *EXPR_P, a size or position.
4161
4162    ??? We could reset all non-constant sizes or positions.  But it's cheap
4163    enough to not do so and refrain from adding workarounds to dwarf2out.c.
4164
4165    We need to reset self-referential sizes or positions because they cannot
4166    be gimplified and thus can contain a CALL_EXPR after the gimplification
4167    is finished, which will run afoul of LTO streaming.  And they need to be
4168    reset to something essentially dummy but not constant, so as to preserve
4169    the properties of the object they are attached to.  */
4170
4171 static inline void
4172 free_lang_data_in_one_sizepos (tree *expr_p)
4173 {
4174   tree expr = *expr_p;
4175   if (CONTAINS_PLACEHOLDER_P (expr))
4176     *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4177 }
4178
4179
4180 /* Reset all the fields in a binfo node BINFO.  We only keep
4181    BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref.  */
4182
4183 static void
4184 free_lang_data_in_binfo (tree binfo)
4185 {
4186   unsigned i;
4187   tree t;
4188
4189   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4190
4191   BINFO_VTABLE (binfo) = NULL_TREE;
4192   BINFO_BASE_ACCESSES (binfo) = NULL;
4193   BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4194   BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4195
4196   for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (binfo), i, t); i++)
4197     free_lang_data_in_binfo (t);
4198 }
4199
4200
4201 /* Reset all language specific information still present in TYPE.  */
4202
4203 static void
4204 free_lang_data_in_type (tree type)
4205 {
4206   gcc_assert (TYPE_P (type));
4207
4208   /* Give the FE a chance to remove its own data first.  */
4209   lang_hooks.free_lang_data (type);
4210
4211   TREE_LANG_FLAG_0 (type) = 0;
4212   TREE_LANG_FLAG_1 (type) = 0;
4213   TREE_LANG_FLAG_2 (type) = 0;
4214   TREE_LANG_FLAG_3 (type) = 0;
4215   TREE_LANG_FLAG_4 (type) = 0;
4216   TREE_LANG_FLAG_5 (type) = 0;
4217   TREE_LANG_FLAG_6 (type) = 0;
4218
4219   if (TREE_CODE (type) == FUNCTION_TYPE)
4220     {
4221       /* Remove the const and volatile qualifiers from arguments.  The
4222          C++ front end removes them, but the C front end does not,
4223          leading to false ODR violation errors when merging two
4224          instances of the same function signature compiled by
4225          different front ends.  */
4226       tree p;
4227
4228       for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4229         {
4230           tree arg_type = TREE_VALUE (p);
4231
4232           if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4233             {
4234               int quals = TYPE_QUALS (arg_type)
4235                           & ~TYPE_QUAL_CONST
4236                           & ~TYPE_QUAL_VOLATILE;
4237               TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4238               free_lang_data_in_type (TREE_VALUE (p));
4239             }
4240         }
4241     }
4242
4243   /* Remove members that are not actually FIELD_DECLs from the field
4244      list of an aggregate.  These occur in C++.  */
4245   if (RECORD_OR_UNION_TYPE_P (type))
4246     {
4247       tree prev, member;
4248
4249       /* Note that TYPE_FIELDS can be shared across distinct
4250          TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
4251          to be removed, we cannot set its TREE_CHAIN to NULL.
4252          Otherwise, we would not be able to find all the other fields
4253          in the other instances of this TREE_TYPE.
4254
4255          This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
4256       prev = NULL_TREE;
4257       member = TYPE_FIELDS (type);
4258       while (member)
4259         {
4260           if (TREE_CODE (member) == FIELD_DECL)
4261             {
4262               if (prev)
4263                 TREE_CHAIN (prev) = member;
4264               else
4265                 TYPE_FIELDS (type) = member;
4266               prev = member;
4267             }
4268
4269           member = TREE_CHAIN (member);
4270         }
4271
4272       if (prev)
4273         TREE_CHAIN (prev) = NULL_TREE;
4274       else
4275         TYPE_FIELDS (type) = NULL_TREE;
4276
4277       TYPE_METHODS (type) = NULL_TREE;
4278       if (TYPE_BINFO (type))
4279         free_lang_data_in_binfo (TYPE_BINFO (type));
4280     }
4281   else
4282     {
4283       /* For non-aggregate types, clear out the language slot (which
4284          overloads TYPE_BINFO).  */
4285       TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4286
4287       if (INTEGRAL_TYPE_P (type)
4288           || SCALAR_FLOAT_TYPE_P (type)
4289           || FIXED_POINT_TYPE_P (type))
4290         {
4291           free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
4292           free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
4293         }
4294     }
4295
4296   free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
4297   free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
4298
4299   if (debug_info_level < DINFO_LEVEL_TERSE
4300       || (TYPE_CONTEXT (type)
4301           && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
4302           && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL))
4303     TYPE_CONTEXT (type) = NULL_TREE;
4304
4305   if (debug_info_level < DINFO_LEVEL_TERSE)
4306     TYPE_STUB_DECL (type) = NULL_TREE;
4307 }
4308
4309
4310 /* Return true if DECL may need an assembler name to be set.  */
4311
4312 static inline bool
4313 need_assembler_name_p (tree decl)
4314 {
4315   /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
4316   if (TREE_CODE (decl) != FUNCTION_DECL
4317       && TREE_CODE (decl) != VAR_DECL)
4318     return false;
4319
4320   /* If DECL already has its assembler name set, it does not need a
4321      new one.  */
4322   if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4323       || DECL_ASSEMBLER_NAME_SET_P (decl))
4324     return false;
4325
4326   /* Abstract decls do not need an assembler name.  */
4327   if (DECL_ABSTRACT (decl))
4328     return false;
4329
4330   /* For VAR_DECLs, only static, public and external symbols need an
4331      assembler name.  */
4332   if (TREE_CODE (decl) == VAR_DECL
4333       && !TREE_STATIC (decl)
4334       && !TREE_PUBLIC (decl)
4335       && !DECL_EXTERNAL (decl))
4336     return false;
4337
4338   if (TREE_CODE (decl) == FUNCTION_DECL)
4339     {
4340       /* Do not set assembler name on builtins.  Allow RTL expansion to
4341          decide whether to expand inline or via a regular call.  */
4342       if (DECL_BUILT_IN (decl)
4343           && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4344         return false;
4345
4346       /* Functions represented in the callgraph need an assembler name.  */
4347       if (cgraph_get_node (decl) != NULL)
4348         return true;
4349
4350       /* Unused and not public functions don't need an assembler name.  */
4351       if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
4352         return false;
4353     }
4354
4355   return true;
4356 }
4357
4358
4359 /* Remove all the non-variable decls from BLOCK.  LOCALS is the set of
4360    variables in DECL_STRUCT_FUNCTION (FN)->local_decls.  Every decl
4361    in BLOCK that is not in LOCALS is removed.  */
4362
4363 static void
4364 free_lang_data_in_block (tree fn, tree block, struct pointer_set_t *locals)
4365 {
4366   tree *tp, t;
4367
4368   tp = &BLOCK_VARS (block);
4369   while (*tp)
4370     {
4371       if (!pointer_set_contains (locals, *tp))
4372         *tp = TREE_CHAIN (*tp);
4373       else
4374         tp = &TREE_CHAIN (*tp);
4375     }
4376
4377   for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
4378     free_lang_data_in_block (fn, t, locals);
4379 }
4380
4381
4382 /* Reset all language specific information still present in symbol
4383    DECL.  */
4384
4385 static void
4386 free_lang_data_in_decl (tree decl)
4387 {
4388   gcc_assert (DECL_P (decl));
4389
4390   /* Give the FE a chance to remove its own data first.  */
4391   lang_hooks.free_lang_data (decl);
4392
4393   TREE_LANG_FLAG_0 (decl) = 0;
4394   TREE_LANG_FLAG_1 (decl) = 0;
4395   TREE_LANG_FLAG_2 (decl) = 0;
4396   TREE_LANG_FLAG_3 (decl) = 0;
4397   TREE_LANG_FLAG_4 (decl) = 0;
4398   TREE_LANG_FLAG_5 (decl) = 0;
4399   TREE_LANG_FLAG_6 (decl) = 0;
4400
4401   /* Identifiers need not have a type.  */
4402   if (DECL_NAME (decl))
4403     TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
4404
4405   /* Ignore any intervening types, because we are going to clear their
4406      TYPE_CONTEXT fields.  */
4407   if (TREE_CODE (decl) != FIELD_DECL
4408       && TREE_CODE (decl) != FUNCTION_DECL)
4409     DECL_CONTEXT (decl) = decl_function_context (decl);
4410
4411   if (DECL_CONTEXT (decl)
4412       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
4413     DECL_CONTEXT (decl) = NULL_TREE;
4414
4415  if (TREE_CODE (decl) == VAR_DECL)
4416    {
4417      tree context = DECL_CONTEXT (decl);
4418
4419      if (context)
4420        {
4421          enum tree_code code = TREE_CODE (context);
4422          if (code == FUNCTION_DECL && DECL_ABSTRACT (context))
4423            {
4424              /* Do not clear the decl context here, that will promote
4425                 all vars to global ones.  */
4426              DECL_INITIAL (decl) = NULL_TREE;
4427            }
4428
4429          if (TREE_STATIC (decl))
4430            DECL_CONTEXT (decl) = NULL_TREE;
4431        }
4432    }
4433
4434   free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
4435   free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
4436   if (TREE_CODE (decl) == FIELD_DECL)
4437     free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
4438
4439  /* DECL_FCONTEXT is only used for debug info generation.  */
4440  if (TREE_CODE (decl) == FIELD_DECL
4441      && debug_info_level < DINFO_LEVEL_TERSE)
4442    DECL_FCONTEXT (decl) = NULL_TREE;
4443
4444  if (TREE_CODE (decl) == FUNCTION_DECL)
4445     {
4446       if (gimple_has_body_p (decl))
4447         {
4448           tree t;
4449           struct pointer_set_t *locals;
4450
4451           /* If DECL has a gimple body, then the context for its
4452              arguments must be DECL.  Otherwise, it doesn't really
4453              matter, as we will not be emitting any code for DECL.  In
4454              general, there may be other instances of DECL created by
4455              the front end and since PARM_DECLs are generally shared,
4456              their DECL_CONTEXT changes as the replicas of DECL are
4457              created.  The only time where DECL_CONTEXT is important
4458              is for the FUNCTION_DECLs that have a gimple body (since
4459              the PARM_DECL will be used in the function's body).  */
4460           for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
4461             DECL_CONTEXT (t) = decl;
4462
4463           /* Collect all the symbols declared in DECL.  */
4464           locals = pointer_set_create ();
4465           t = DECL_STRUCT_FUNCTION (decl)->local_decls;
4466           for (; t; t = TREE_CHAIN (t))
4467             {
4468               pointer_set_insert (locals, TREE_VALUE (t));
4469
4470               /* All the local symbols should have DECL as their
4471                  context.  */
4472               DECL_CONTEXT (TREE_VALUE (t)) = decl;
4473             }
4474
4475           /* Get rid of any decl not in local_decls.  */
4476           free_lang_data_in_block (decl, DECL_INITIAL (decl), locals);
4477
4478           pointer_set_destroy (locals);
4479         }
4480
4481       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4482          At this point, it is not needed anymore.  */
4483       DECL_SAVED_TREE (decl) = NULL_TREE;
4484     }
4485   else if (TREE_CODE (decl) == VAR_DECL)
4486     {
4487       tree expr = DECL_DEBUG_EXPR (decl);
4488       if (expr
4489           && TREE_CODE (expr) == VAR_DECL
4490           && !TREE_STATIC (expr) && !DECL_EXTERNAL (expr))
4491         SET_DECL_DEBUG_EXPR (decl, NULL_TREE);
4492
4493       if (DECL_EXTERNAL (decl)
4494           && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
4495         DECL_INITIAL (decl) = NULL_TREE;
4496     }
4497   else if (TREE_CODE (decl) == TYPE_DECL)
4498     {
4499       DECL_INITIAL (decl) = NULL_TREE;
4500
4501       /* DECL_CONTEXT is overloaded as DECL_FIELD_CONTEXT for
4502          FIELD_DECLs, which should be preserved.  Otherwise,
4503          we shouldn't be concerned with source-level lexical
4504          nesting beyond this point. */
4505       DECL_CONTEXT (decl) = NULL_TREE;
4506     }
4507 }
4508
4509
4510 /* Data used when collecting DECLs and TYPEs for language data removal.  */
4511
4512 struct free_lang_data_d
4513 {
4514   /* Worklist to avoid excessive recursion.  */
4515   VEC(tree,heap) *worklist;
4516
4517   /* Set of traversed objects.  Used to avoid duplicate visits.  */
4518   struct pointer_set_t *pset;
4519
4520   /* Array of symbols to process with free_lang_data_in_decl.  */
4521   VEC(tree,heap) *decls;
4522
4523   /* Array of types to process with free_lang_data_in_type.  */
4524   VEC(tree,heap) *types;
4525 };
4526
4527
4528 /* Save all language fields needed to generate proper debug information
4529    for DECL.  This saves most fields cleared out by free_lang_data_in_decl.  */
4530
4531 static void
4532 save_debug_info_for_decl (tree t)
4533 {
4534   /*struct saved_debug_info_d *sdi;*/
4535
4536   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
4537
4538   /* FIXME.  Partial implementation for saving debug info removed.  */
4539 }
4540
4541
4542 /* Save all language fields needed to generate proper debug information
4543    for TYPE.  This saves most fields cleared out by free_lang_data_in_type.  */
4544
4545 static void
4546 save_debug_info_for_type (tree t)
4547 {
4548   /*struct saved_debug_info_d *sdi;*/
4549
4550   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
4551
4552   /* FIXME.  Partial implementation for saving debug info removed.  */
4553 }
4554
4555
4556 /* Add type or decl T to one of the list of tree nodes that need their
4557    language data removed.  The lists are held inside FLD.  */
4558
4559 static void
4560 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
4561 {
4562   if (DECL_P (t))
4563     {
4564       VEC_safe_push (tree, heap, fld->decls, t);
4565       if (debug_info_level > DINFO_LEVEL_TERSE)
4566         save_debug_info_for_decl (t);
4567     }
4568   else if (TYPE_P (t))
4569     {
4570       VEC_safe_push (tree, heap, fld->types, t);
4571       if (debug_info_level > DINFO_LEVEL_TERSE)
4572         save_debug_info_for_type (t);
4573     }
4574   else
4575     gcc_unreachable ();
4576 }
4577
4578 /* Push tree node T into FLD->WORKLIST.  */
4579
4580 static inline void
4581 fld_worklist_push (tree t, struct free_lang_data_d *fld)
4582 {
4583   if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t))
4584     VEC_safe_push (tree, heap, fld->worklist, (t));
4585 }
4586
4587
4588 /* Operand callback helper for free_lang_data_in_node.  *TP is the
4589    subtree operand being considered.  */
4590
4591 static tree
4592 find_decls_types_r (tree *tp, int *ws, void *data)
4593 {
4594   tree t = *tp;
4595   struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
4596
4597   if (TREE_CODE (t) == TREE_LIST)
4598     return NULL_TREE;
4599
4600   /* Language specific nodes will be removed, so there is no need
4601      to gather anything under them.  */
4602   if (is_lang_specific (t))
4603     {
4604       *ws = 0;
4605       return NULL_TREE;
4606     }
4607
4608   if (DECL_P (t))
4609     {
4610       /* Note that walk_tree does not traverse every possible field in
4611          decls, so we have to do our own traversals here.  */
4612       add_tree_to_fld_list (t, fld);
4613
4614       fld_worklist_push (DECL_NAME (t), fld);
4615       fld_worklist_push (DECL_CONTEXT (t), fld);
4616       fld_worklist_push (DECL_SIZE (t), fld);
4617       fld_worklist_push (DECL_SIZE_UNIT (t), fld);
4618
4619       /* We are going to remove everything under DECL_INITIAL for
4620          TYPE_DECLs.  No point walking them.  */
4621       if (TREE_CODE (t) != TYPE_DECL)
4622         fld_worklist_push (DECL_INITIAL (t), fld);
4623
4624       fld_worklist_push (DECL_ATTRIBUTES (t), fld);
4625       fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
4626
4627       if (TREE_CODE (t) == FUNCTION_DECL)
4628         {
4629           fld_worklist_push (DECL_ARGUMENTS (t), fld);
4630           fld_worklist_push (DECL_RESULT (t), fld);
4631         }
4632       else if (TREE_CODE (t) == TYPE_DECL)
4633         {
4634           fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
4635           fld_worklist_push (DECL_VINDEX (t), fld);
4636         }
4637       else if (TREE_CODE (t) == FIELD_DECL)
4638         {
4639           fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
4640           fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
4641           fld_worklist_push (DECL_QUALIFIER (t), fld);
4642           fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
4643           fld_worklist_push (DECL_FCONTEXT (t), fld);
4644         }
4645       else if (TREE_CODE (t) == VAR_DECL)
4646         {
4647           fld_worklist_push (DECL_SECTION_NAME (t), fld);
4648           fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
4649         }
4650
4651       if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
4652           && DECL_HAS_VALUE_EXPR_P (t))
4653         fld_worklist_push (DECL_VALUE_EXPR (t), fld);
4654
4655       if (TREE_CODE (t) != FIELD_DECL)
4656         fld_worklist_push (TREE_CHAIN (t), fld);
4657       *ws = 0;
4658     }
4659   else if (TYPE_P (t))
4660     {
4661       /* Note that walk_tree does not traverse every possible field in
4662          types, so we have to do our own traversals here.  */
4663       add_tree_to_fld_list (t, fld);
4664
4665       if (!RECORD_OR_UNION_TYPE_P (t))
4666         fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
4667       fld_worklist_push (TYPE_SIZE (t), fld);
4668       fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
4669       fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
4670       fld_worklist_push (TYPE_POINTER_TO (t), fld);
4671       fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
4672       fld_worklist_push (TYPE_NAME (t), fld);
4673       fld_worklist_push (TYPE_MINVAL (t), fld);
4674       if (!RECORD_OR_UNION_TYPE_P (t))
4675         fld_worklist_push (TYPE_MAXVAL (t), fld);
4676       fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
4677       fld_worklist_push (TYPE_NEXT_VARIANT (t), fld);
4678       fld_worklist_push (TYPE_CONTEXT (t), fld);
4679       fld_worklist_push (TYPE_CANONICAL (t), fld);
4680
4681       if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
4682         {
4683           unsigned i;
4684           tree tem;
4685           for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)),
4686                                    i, tem); ++i)
4687             fld_worklist_push (TREE_TYPE (tem), fld);
4688           tem = BINFO_VIRTUALS (TYPE_BINFO (t));
4689           if (tem
4690               /* The Java FE overloads BINFO_VIRTUALS for its own purpose.  */
4691               && TREE_CODE (tem) == TREE_LIST)
4692             do
4693               {
4694                 fld_worklist_push (TREE_VALUE (tem), fld);
4695                 tem = TREE_CHAIN (tem);
4696               }
4697             while (tem);
4698         }
4699       if (RECORD_OR_UNION_TYPE_P (t))
4700         {
4701           tree tem;
4702           /* Push all TYPE_FIELDS - there can be interleaving interesting
4703              and non-interesting things.  */
4704           tem = TYPE_FIELDS (t);
4705           while (tem)
4706             {
4707               if (TREE_CODE (tem) == FIELD_DECL)
4708                 fld_worklist_push (tem, fld);
4709               tem = TREE_CHAIN (tem);
4710             }
4711         }
4712
4713       fld_worklist_push (TREE_CHAIN (t), fld);
4714       *ws = 0;
4715     }
4716   else if (TREE_CODE (t) == BLOCK)
4717     {
4718       tree tem;
4719       for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
4720         fld_worklist_push (tem, fld);
4721       for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
4722         fld_worklist_push (tem, fld);
4723       fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
4724     }
4725
4726   fld_worklist_push (TREE_TYPE (t), fld);
4727
4728   return NULL_TREE;
4729 }
4730
4731
4732 /* Find decls and types in T.  */
4733
4734 static void
4735 find_decls_types (tree t, struct free_lang_data_d *fld)
4736 {
4737   while (1)
4738     {
4739       if (!pointer_set_contains (fld->pset, t))
4740         walk_tree (&t, find_decls_types_r, fld, fld->pset);
4741       if (VEC_empty (tree, fld->worklist))
4742         break;
4743       t = VEC_pop (tree, fld->worklist);
4744     }
4745 }
4746
4747 /* Translate all the types in LIST with the corresponding runtime
4748    types.  */
4749
4750 static tree
4751 get_eh_types_for_runtime (tree list)
4752 {
4753   tree head, prev;
4754
4755   if (list == NULL_TREE)
4756     return NULL_TREE;
4757
4758   head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4759   prev = head;
4760   list = TREE_CHAIN (list);
4761   while (list)
4762     {
4763       tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4764       TREE_CHAIN (prev) = n;
4765       prev = TREE_CHAIN (prev);
4766       list = TREE_CHAIN (list);
4767     }
4768
4769   return head;
4770 }
4771
4772
4773 /* Find decls and types referenced in EH region R and store them in
4774    FLD->DECLS and FLD->TYPES.  */
4775
4776 static void
4777 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
4778 {
4779   switch (r->type)
4780     {
4781     case ERT_CLEANUP:
4782       break;
4783
4784     case ERT_TRY:
4785       {
4786         eh_catch c;
4787
4788         /* The types referenced in each catch must first be changed to the
4789            EH types used at runtime.  This removes references to FE types
4790            in the region.  */
4791         for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
4792           {
4793             c->type_list = get_eh_types_for_runtime (c->type_list);
4794             walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
4795           }
4796       }
4797       break;
4798
4799     case ERT_ALLOWED_EXCEPTIONS:
4800       r->u.allowed.type_list
4801         = get_eh_types_for_runtime (r->u.allowed.type_list);
4802       walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
4803       break;
4804
4805     case ERT_MUST_NOT_THROW:
4806       walk_tree (&r->u.must_not_throw.failure_decl,
4807                  find_decls_types_r, fld, fld->pset);
4808       break;
4809     }
4810 }
4811
4812
4813 /* Find decls and types referenced in cgraph node N and store them in
4814    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4815    look for *every* kind of DECL and TYPE node reachable from N,
4816    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4817    NAMESPACE_DECLs, etc).  */
4818
4819 static void
4820 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
4821 {
4822   basic_block bb;
4823   struct function *fn;
4824   tree t;
4825
4826   find_decls_types (n->decl, fld);
4827
4828   if (!gimple_has_body_p (n->decl))
4829     return;
4830
4831   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
4832
4833   fn = DECL_STRUCT_FUNCTION (n->decl);
4834
4835   /* Traverse locals. */
4836   for (t = fn->local_decls; t; t = TREE_CHAIN (t))
4837     find_decls_types (TREE_VALUE (t), fld);
4838
4839   /* Traverse EH regions in FN.  */
4840   {
4841     eh_region r;
4842     FOR_ALL_EH_REGION_FN (r, fn)
4843       find_decls_types_in_eh_region (r, fld);
4844   }
4845
4846   /* Traverse every statement in FN.  */
4847   FOR_EACH_BB_FN (bb, fn)
4848     {
4849       gimple_stmt_iterator si;
4850       unsigned i;
4851
4852       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4853         {
4854           gimple phi = gsi_stmt (si);
4855
4856           for (i = 0; i < gimple_phi_num_args (phi); i++)
4857             {
4858               tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
4859               find_decls_types (*arg_p, fld);
4860             }
4861         }
4862
4863       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
4864         {
4865           gimple stmt = gsi_stmt (si);
4866
4867           for (i = 0; i < gimple_num_ops (stmt); i++)
4868             {
4869               tree arg = gimple_op (stmt, i);
4870               find_decls_types (arg, fld);
4871             }
4872         }
4873     }
4874 }
4875
4876
4877 /* Find decls and types referenced in varpool node N and store them in
4878    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4879    look for *every* kind of DECL and TYPE node reachable from N,
4880    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4881    NAMESPACE_DECLs, etc).  */
4882
4883 static void
4884 find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
4885 {
4886   find_decls_types (v->decl, fld);
4887 }
4888
4889 /* If T needs an assembler name, have one created for it.  */
4890
4891 void
4892 assign_assembler_name_if_neeeded (tree t)
4893 {
4894   if (need_assembler_name_p (t))
4895     {
4896       /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
4897          diagnostics that use input_location to show locus
4898          information.  The problem here is that, at this point,
4899          input_location is generally anchored to the end of the file
4900          (since the parser is long gone), so we don't have a good
4901          position to pin it to.
4902
4903          To alleviate this problem, this uses the location of T's
4904          declaration.  Examples of this are
4905          testsuite/g++.dg/template/cond2.C and
4906          testsuite/g++.dg/template/pr35240.C.  */
4907       location_t saved_location = input_location;
4908       input_location = DECL_SOURCE_LOCATION (t);
4909
4910       decl_assembler_name (t);
4911
4912       input_location = saved_location;
4913     }
4914 }
4915
4916
4917 /* Free language specific information for every operand and expression
4918    in every node of the call graph.  This process operates in three stages:
4919
4920    1- Every callgraph node and varpool node is traversed looking for
4921       decls and types embedded in them.  This is a more exhaustive
4922       search than that done by find_referenced_vars, because it will
4923       also collect individual fields, decls embedded in types, etc.
4924
4925    2- All the decls found are sent to free_lang_data_in_decl.
4926
4927    3- All the types found are sent to free_lang_data_in_type.
4928
4929    The ordering between decls and types is important because
4930    free_lang_data_in_decl sets assembler names, which includes
4931    mangling.  So types cannot be freed up until assembler names have
4932    been set up.  */
4933
4934 static void
4935 free_lang_data_in_cgraph (void)
4936 {
4937   struct cgraph_node *n;
4938   struct varpool_node *v;
4939   struct free_lang_data_d fld;
4940   tree t;
4941   unsigned i;
4942   alias_pair *p;
4943
4944   /* Initialize sets and arrays to store referenced decls and types.  */
4945   fld.pset = pointer_set_create ();
4946   fld.worklist = NULL;
4947   fld.decls = VEC_alloc (tree, heap, 100);
4948   fld.types = VEC_alloc (tree, heap, 100);
4949
4950   /* Find decls and types in the body of every function in the callgraph.  */
4951   for (n = cgraph_nodes; n; n = n->next)
4952     find_decls_types_in_node (n, &fld);
4953
4954   for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4955     find_decls_types (p->decl, &fld);
4956
4957   /* Find decls and types in every varpool symbol.  */
4958   for (v = varpool_nodes_queue; v; v = v->next_needed)
4959     find_decls_types_in_var (v, &fld);
4960
4961   /* Set the assembler name on every decl found.  We need to do this
4962      now because free_lang_data_in_decl will invalidate data needed
4963      for mangling.  This breaks mangling on interdependent decls.  */
4964   for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
4965     assign_assembler_name_if_neeeded (t);
4966
4967   /* Traverse every decl found freeing its language data.  */
4968   for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
4969     free_lang_data_in_decl (t);
4970
4971   /* Traverse every type found freeing its language data.  */
4972   for (i = 0; VEC_iterate (tree, fld.types, i, t); i++)
4973     free_lang_data_in_type (t);
4974
4975   pointer_set_destroy (fld.pset);
4976   VEC_free (tree, heap, fld.worklist);
4977   VEC_free (tree, heap, fld.decls);
4978   VEC_free (tree, heap, fld.types);
4979 }
4980
4981
4982 /* Free resources that are used by FE but are not needed once they are done. */
4983
4984 static unsigned
4985 free_lang_data (void)
4986 {
4987   unsigned i;
4988
4989   /* If we are the LTO frontend we have freed lang-specific data already.  */
4990   if (in_lto_p
4991       || !flag_generate_lto)
4992     return 0;
4993
4994   /* Allocate and assign alias sets to the standard integer types
4995      while the slots are still in the way the frontends generated them.  */
4996   for (i = 0; i < itk_none; ++i)
4997     if (integer_types[i])
4998       TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
4999
5000   /* Traverse the IL resetting language specific information for
5001      operands, expressions, etc.  */
5002   free_lang_data_in_cgraph ();
5003
5004   /* Create gimple variants for common types.  */
5005   ptrdiff_type_node = integer_type_node;
5006   fileptr_type_node = ptr_type_node;
5007   if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE
5008       || (TYPE_MODE (boolean_type_node)
5009           != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0))
5010       || TYPE_PRECISION (boolean_type_node) != 1
5011       || !TYPE_UNSIGNED (boolean_type_node))
5012     {
5013       boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
5014       TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
5015       TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
5016       TYPE_PRECISION (boolean_type_node) = 1;
5017       boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
5018       boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
5019     }
5020
5021   /* Unify char_type_node with its properly signed variant.  */
5022   if (TYPE_UNSIGNED (char_type_node))
5023     unsigned_char_type_node = char_type_node;
5024   else
5025     signed_char_type_node = char_type_node;
5026
5027   /* Reset some langhooks.  Do not reset types_compatible_p, it may
5028      still be used indirectly via the get_alias_set langhook.  */
5029   lang_hooks.callgraph.analyze_expr = NULL;
5030   lang_hooks.dwarf_name = lhd_dwarf_name;
5031   lang_hooks.decl_printable_name = gimple_decl_printable_name;
5032   lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
5033
5034   /* Reset diagnostic machinery.  */
5035   diagnostic_starter (global_dc) = default_diagnostic_starter;
5036   diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
5037   diagnostic_format_decoder (global_dc) = default_tree_printer;
5038
5039   return 0;
5040 }
5041
5042
5043 struct simple_ipa_opt_pass pass_ipa_free_lang_data =
5044 {
5045  {
5046   SIMPLE_IPA_PASS,
5047   "*free_lang_data",                    /* name */
5048   NULL,                                 /* gate */
5049   free_lang_data,                       /* execute */
5050   NULL,                                 /* sub */
5051   NULL,                                 /* next */
5052   0,                                    /* static_pass_number */
5053   TV_IPA_FREE_LANG_DATA,                /* tv_id */
5054   0,                                    /* properties_required */
5055   0,                                    /* properties_provided */
5056   0,                                    /* properties_destroyed */
5057   0,                                    /* todo_flags_start */
5058   TODO_ggc_collect                      /* todo_flags_finish */
5059  }
5060 };
5061
5062 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5063    or zero if not.
5064
5065    We try both `text' and `__text__', ATTR may be either one.  */
5066 /* ??? It might be a reasonable simplification to require ATTR to be only
5067    `text'.  One might then also require attribute lists to be stored in
5068    their canonicalized form.  */
5069
5070 static int
5071 is_attribute_with_length_p (const char *attr, int attr_len, const_tree ident)
5072 {
5073   int ident_len;
5074   const char *p;
5075
5076   if (TREE_CODE (ident) != IDENTIFIER_NODE)
5077     return 0;
5078
5079   p = IDENTIFIER_POINTER (ident);
5080   ident_len = IDENTIFIER_LENGTH (ident);
5081
5082   if (ident_len == attr_len
5083       && strcmp (attr, p) == 0)
5084     return 1;
5085
5086   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
5087   if (attr[0] == '_')
5088     {
5089       gcc_assert (attr[1] == '_');
5090       gcc_assert (attr[attr_len - 2] == '_');
5091       gcc_assert (attr[attr_len - 1] == '_');
5092       if (ident_len == attr_len - 4
5093           && strncmp (attr + 2, p, attr_len - 4) == 0)
5094         return 1;
5095     }
5096   else
5097     {
5098       if (ident_len == attr_len + 4
5099           && p[0] == '_' && p[1] == '_'
5100           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5101           && strncmp (attr, p + 2, attr_len) == 0)
5102         return 1;
5103     }
5104
5105   return 0;
5106 }
5107
5108 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5109    or zero if not.
5110
5111    We try both `text' and `__text__', ATTR may be either one.  */
5112
5113 int
5114 is_attribute_p (const char *attr, const_tree ident)
5115 {
5116   return is_attribute_with_length_p (attr, strlen (attr), ident);
5117 }
5118
5119 /* Given an attribute name and a list of attributes, return a pointer to the
5120    attribute's list element if the attribute is part of the list, or NULL_TREE
5121    if not found.  If the attribute appears more than once, this only
5122    returns the first occurrence; the TREE_CHAIN of the return value should
5123    be passed back in if further occurrences are wanted.  */
5124
5125 tree
5126 lookup_attribute (const char *attr_name, tree list)
5127 {
5128   tree l;
5129   size_t attr_len = strlen (attr_name);
5130
5131   for (l = list; l; l = TREE_CHAIN (l))
5132     {
5133       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5134       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5135         return l;
5136     }
5137   return NULL_TREE;
5138 }
5139
5140 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5141    modified list.  */
5142
5143 tree
5144 remove_attribute (const char *attr_name, tree list)
5145 {
5146   tree *p;
5147   size_t attr_len = strlen (attr_name);
5148
5149   for (p = &list; *p; )
5150     {
5151       tree l = *p;
5152       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5153       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5154         *p = TREE_CHAIN (l);
5155       else
5156         p = &TREE_CHAIN (l);
5157     }
5158
5159   return list;
5160 }
5161
5162 /* Return an attribute list that is the union of a1 and a2.  */
5163
5164 tree
5165 merge_attributes (tree a1, tree a2)
5166 {
5167   tree attributes;
5168
5169   /* Either one unset?  Take the set one.  */
5170
5171   if ((attributes = a1) == 0)
5172     attributes = a2;
5173
5174   /* One that completely contains the other?  Take it.  */
5175
5176   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5177     {
5178       if (attribute_list_contained (a2, a1))
5179         attributes = a2;
5180       else
5181         {
5182           /* Pick the longest list, and hang on the other list.  */
5183
5184           if (list_length (a1) < list_length (a2))
5185             attributes = a2, a2 = a1;
5186
5187           for (; a2 != 0; a2 = TREE_CHAIN (a2))
5188             {
5189               tree a;
5190               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5191                                          attributes);
5192                    a != NULL_TREE;
5193                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5194                                          TREE_CHAIN (a)))
5195                 {
5196                   if (TREE_VALUE (a) != NULL
5197                       && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
5198                       && TREE_VALUE (a2) != NULL
5199                       && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
5200                     {
5201                       if (simple_cst_list_equal (TREE_VALUE (a),
5202                                                  TREE_VALUE (a2)) == 1)
5203                         break;
5204                     }
5205                   else if (simple_cst_equal (TREE_VALUE (a),
5206                                              TREE_VALUE (a2)) == 1)
5207                     break;
5208                 }
5209               if (a == NULL_TREE)
5210                 {
5211                   a1 = copy_node (a2);
5212                   TREE_CHAIN (a1) = attributes;
5213                   attributes = a1;
5214                 }
5215             }
5216         }
5217     }
5218   return attributes;
5219 }
5220
5221 /* Given types T1 and T2, merge their attributes and return
5222   the result.  */
5223
5224 tree
5225 merge_type_attributes (tree t1, tree t2)
5226 {
5227   return merge_attributes (TYPE_ATTRIBUTES (t1),
5228                            TYPE_ATTRIBUTES (t2));
5229 }
5230
5231 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5232    the result.  */
5233
5234 tree
5235 merge_decl_attributes (tree olddecl, tree newdecl)
5236 {
5237   return merge_attributes (DECL_ATTRIBUTES (olddecl),
5238                            DECL_ATTRIBUTES (newdecl));
5239 }
5240
5241 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5242
5243 /* Specialization of merge_decl_attributes for various Windows targets.
5244
5245    This handles the following situation:
5246
5247      __declspec (dllimport) int foo;
5248      int foo;
5249
5250    The second instance of `foo' nullifies the dllimport.  */
5251
5252 tree
5253 merge_dllimport_decl_attributes (tree old, tree new_tree)
5254 {
5255   tree a;
5256   int delete_dllimport_p = 1;
5257
5258   /* What we need to do here is remove from `old' dllimport if it doesn't
5259      appear in `new'.  dllimport behaves like extern: if a declaration is
5260      marked dllimport and a definition appears later, then the object
5261      is not dllimport'd.  We also remove a `new' dllimport if the old list
5262      contains dllexport:  dllexport always overrides dllimport, regardless
5263      of the order of declaration.  */
5264   if (!VAR_OR_FUNCTION_DECL_P (new_tree))
5265     delete_dllimport_p = 0;
5266   else if (DECL_DLLIMPORT_P (new_tree)
5267            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
5268     {
5269       DECL_DLLIMPORT_P (new_tree) = 0;
5270       warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
5271               "dllimport ignored", new_tree);
5272     }
5273   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
5274     {
5275       /* Warn about overriding a symbol that has already been used, e.g.:
5276            extern int __attribute__ ((dllimport)) foo;
5277            int* bar () {return &foo;}
5278            int foo;
5279       */
5280       if (TREE_USED (old))
5281         {
5282           warning (0, "%q+D redeclared without dllimport attribute "
5283                    "after being referenced with dll linkage", new_tree);
5284           /* If we have used a variable's address with dllimport linkage,
5285               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5286               decl may already have had TREE_CONSTANT computed.
5287               We still remove the attribute so that assembler code refers
5288               to '&foo rather than '_imp__foo'.  */
5289           if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
5290             DECL_DLLIMPORT_P (new_tree) = 1;
5291         }
5292
5293       /* Let an inline definition silently override the external reference,
5294          but otherwise warn about attribute inconsistency.  */
5295       else if (TREE_CODE (new_tree) == VAR_DECL
5296                || !DECL_DECLARED_INLINE_P (new_tree))
5297         warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
5298                   "previous dllimport ignored", new_tree);
5299     }
5300   else
5301     delete_dllimport_p = 0;
5302
5303   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
5304
5305   if (delete_dllimport_p)
5306     {
5307       tree prev, t;
5308       const size_t attr_len = strlen ("dllimport");
5309
5310       /* Scan the list for dllimport and delete it.  */
5311       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
5312         {
5313           if (is_attribute_with_length_p ("dllimport", attr_len,
5314                                           TREE_PURPOSE (t)))
5315             {
5316               if (prev == NULL_TREE)
5317                 a = TREE_CHAIN (a);
5318               else
5319                 TREE_CHAIN (prev) = TREE_CHAIN (t);
5320               break;
5321             }
5322         }
5323     }
5324
5325   return a;
5326 }
5327
5328 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5329    struct attribute_spec.handler.  */
5330
5331 tree
5332 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
5333                       bool *no_add_attrs)
5334 {
5335   tree node = *pnode;
5336   bool is_dllimport;
5337
5338   /* These attributes may apply to structure and union types being created,
5339      but otherwise should pass to the declaration involved.  */
5340   if (!DECL_P (node))
5341     {
5342       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
5343                    | (int) ATTR_FLAG_ARRAY_NEXT))
5344         {
5345           *no_add_attrs = true;
5346           return tree_cons (name, args, NULL_TREE);
5347         }
5348       if (TREE_CODE (node) == RECORD_TYPE
5349           || TREE_CODE (node) == UNION_TYPE)
5350         {
5351           node = TYPE_NAME (node);
5352           if (!node)
5353             return NULL_TREE;
5354         }
5355       else
5356         {
5357           warning (OPT_Wattributes, "%qE attribute ignored",
5358                    name);
5359           *no_add_attrs = true;
5360           return NULL_TREE;
5361         }
5362     }
5363
5364   if (TREE_CODE (node) != FUNCTION_DECL
5365       && TREE_CODE (node) != VAR_DECL
5366       && TREE_CODE (node) != TYPE_DECL)
5367     {
5368       *no_add_attrs = true;
5369       warning (OPT_Wattributes, "%qE attribute ignored",
5370                name);
5371       return NULL_TREE;
5372     }
5373
5374   if (TREE_CODE (node) == TYPE_DECL
5375       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
5376       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
5377     {
5378       *no_add_attrs = true;
5379       warning (OPT_Wattributes, "%qE attribute ignored",
5380                name);
5381       return NULL_TREE;
5382     }
5383
5384   is_dllimport = is_attribute_p ("dllimport", name);
5385
5386   /* Report error on dllimport ambiguities seen now before they cause
5387      any damage.  */
5388   if (is_dllimport)
5389     {
5390       /* Honor any target-specific overrides. */
5391       if (!targetm.valid_dllimport_attribute_p (node))
5392         *no_add_attrs = true;
5393
5394      else if (TREE_CODE (node) == FUNCTION_DECL
5395                 && DECL_DECLARED_INLINE_P (node))
5396         {
5397           warning (OPT_Wattributes, "inline function %q+D declared as "
5398                   " dllimport: attribute ignored", node);
5399           *no_add_attrs = true;
5400         }
5401       /* Like MS, treat definition of dllimported variables and
5402          non-inlined functions on declaration as syntax errors. */
5403      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
5404         {
5405           error ("function %q+D definition is marked dllimport", node);
5406           *no_add_attrs = true;
5407         }
5408
5409      else if (TREE_CODE (node) == VAR_DECL)
5410         {
5411           if (DECL_INITIAL (node))
5412             {
5413               error ("variable %q+D definition is marked dllimport",
5414                      node);
5415               *no_add_attrs = true;
5416             }
5417
5418           /* `extern' needn't be specified with dllimport.
5419              Specify `extern' now and hope for the best.  Sigh.  */
5420           DECL_EXTERNAL (node) = 1;
5421           /* Also, implicitly give dllimport'd variables declared within
5422              a function global scope, unless declared static.  */
5423           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
5424             TREE_PUBLIC (node) = 1;
5425         }
5426
5427       if (*no_add_attrs == false)
5428         DECL_DLLIMPORT_P (node) = 1;
5429     }
5430   else if (TREE_CODE (node) == FUNCTION_DECL
5431            && DECL_DECLARED_INLINE_P (node))
5432     /* An exported function, even if inline, must be emitted.  */
5433     DECL_EXTERNAL (node) = 0;
5434
5435   /*  Report error if symbol is not accessible at global scope.  */
5436   if (!TREE_PUBLIC (node)
5437       && (TREE_CODE (node) == VAR_DECL
5438           || TREE_CODE (node) == FUNCTION_DECL))
5439     {
5440       error ("external linkage required for symbol %q+D because of "
5441              "%qE attribute", node, name);
5442       *no_add_attrs = true;
5443     }
5444
5445   /* A dllexport'd entity must have default visibility so that other
5446      program units (shared libraries or the main executable) can see
5447      it.  A dllimport'd entity must have default visibility so that
5448      the linker knows that undefined references within this program
5449      unit can be resolved by the dynamic linker.  */
5450   if (!*no_add_attrs)
5451     {
5452       if (DECL_VISIBILITY_SPECIFIED (node)
5453           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
5454         error ("%qE implies default visibility, but %qD has already "
5455                "been declared with a different visibility",
5456                name, node);
5457       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
5458       DECL_VISIBILITY_SPECIFIED (node) = 1;
5459     }
5460
5461   return NULL_TREE;
5462 }
5463
5464 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
5465 \f
5466 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5467    of the various TYPE_QUAL values.  */
5468
5469 static void
5470 set_type_quals (tree type, int type_quals)
5471 {
5472   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
5473   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
5474   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
5475   TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
5476 }
5477
5478 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
5479
5480 bool
5481 check_qualified_type (const_tree cand, const_tree base, int type_quals)
5482 {
5483   return (TYPE_QUALS (cand) == type_quals
5484           && TYPE_NAME (cand) == TYPE_NAME (base)
5485           /* Apparently this is needed for Objective-C.  */
5486           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5487           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5488                                    TYPE_ATTRIBUTES (base)));
5489 }
5490
5491 /* Return a version of the TYPE, qualified as indicated by the
5492    TYPE_QUALS, if one exists.  If no qualified version exists yet,
5493    return NULL_TREE.  */
5494
5495 tree
5496 get_qualified_type (tree type, int type_quals)
5497 {
5498   tree t;
5499
5500   if (TYPE_QUALS (type) == type_quals)
5501     return type;
5502
5503   /* Search the chain of variants to see if there is already one there just
5504      like the one we need to have.  If so, use that existing one.  We must
5505      preserve the TYPE_NAME, since there is code that depends on this.  */
5506   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5507     if (check_qualified_type (t, type, type_quals))
5508       return t;
5509
5510   return NULL_TREE;
5511 }
5512
5513 /* Like get_qualified_type, but creates the type if it does not
5514    exist.  This function never returns NULL_TREE.  */
5515
5516 tree
5517 build_qualified_type (tree type, int type_quals)
5518 {
5519   tree t;
5520
5521   /* See if we already have the appropriate qualified variant.  */
5522   t = get_qualified_type (type, type_quals);
5523
5524   /* If not, build it.  */
5525   if (!t)
5526     {
5527       t = build_variant_type_copy (type);
5528       set_type_quals (t, type_quals);
5529
5530       if (TYPE_STRUCTURAL_EQUALITY_P (type))
5531         /* Propagate structural equality. */
5532         SET_TYPE_STRUCTURAL_EQUALITY (t);
5533       else if (TYPE_CANONICAL (type) != type)
5534         /* Build the underlying canonical type, since it is different
5535            from TYPE. */
5536         TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
5537                                                    type_quals);
5538       else
5539         /* T is its own canonical type. */
5540         TYPE_CANONICAL (t) = t;
5541
5542     }
5543
5544   return t;
5545 }
5546
5547 /* Create a new distinct copy of TYPE.  The new type is made its own
5548    MAIN_VARIANT. If TYPE requires structural equality checks, the
5549    resulting type requires structural equality checks; otherwise, its
5550    TYPE_CANONICAL points to itself. */
5551
5552 tree
5553 build_distinct_type_copy (tree type)
5554 {
5555   tree t = copy_node (type);
5556
5557   TYPE_POINTER_TO (t) = 0;
5558   TYPE_REFERENCE_TO (t) = 0;
5559
5560   /* Set the canonical type either to a new equivalence class, or
5561      propagate the need for structural equality checks. */
5562   if (TYPE_STRUCTURAL_EQUALITY_P (type))
5563     SET_TYPE_STRUCTURAL_EQUALITY (t);
5564   else
5565     TYPE_CANONICAL (t) = t;
5566
5567   /* Make it its own variant.  */
5568   TYPE_MAIN_VARIANT (t) = t;
5569   TYPE_NEXT_VARIANT (t) = 0;
5570
5571   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5572      whose TREE_TYPE is not t.  This can also happen in the Ada
5573      frontend when using subtypes.  */
5574
5575   return t;
5576 }
5577
5578 /* Create a new variant of TYPE, equivalent but distinct.  This is so
5579    the caller can modify it. TYPE_CANONICAL for the return type will
5580    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5581    are considered equal by the language itself (or that both types
5582    require structural equality checks). */
5583
5584 tree
5585 build_variant_type_copy (tree type)
5586 {
5587   tree t, m = TYPE_MAIN_VARIANT (type);
5588
5589   t = build_distinct_type_copy (type);
5590
5591   /* Since we're building a variant, assume that it is a non-semantic
5592      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5593   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
5594
5595   /* Add the new type to the chain of variants of TYPE.  */
5596   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
5597   TYPE_NEXT_VARIANT (m) = t;
5598   TYPE_MAIN_VARIANT (t) = m;
5599
5600   return t;
5601 }
5602 \f
5603 /* Return true if the from tree in both tree maps are equal.  */
5604
5605 int
5606 tree_map_base_eq (const void *va, const void *vb)
5607 {
5608   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
5609     *const b = (const struct tree_map_base *) vb;
5610   return (a->from == b->from);
5611 }
5612
5613 /* Hash a from tree in a tree_map.  */
5614
5615 unsigned int
5616 tree_map_base_hash (const void *item)
5617 {
5618   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
5619 }
5620
5621 /* Return true if this tree map structure is marked for garbage collection
5622    purposes.  We simply return true if the from tree is marked, so that this
5623    structure goes away when the from tree goes away.  */
5624
5625 int
5626 tree_map_base_marked_p (const void *p)
5627 {
5628   return ggc_marked_p (((const struct tree_map_base *) p)->from);
5629 }
5630
5631 unsigned int
5632 tree_map_hash (const void *item)
5633 {
5634   return (((const struct tree_map *) item)->hash);
5635 }
5636
5637 /* Return the initialization priority for DECL.  */
5638
5639 priority_type
5640 decl_init_priority_lookup (tree decl)
5641 {
5642   struct tree_priority_map *h;
5643   struct tree_map_base in;
5644
5645   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5646   in.from = decl;
5647   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5648   return h ? h->init : DEFAULT_INIT_PRIORITY;
5649 }
5650
5651 /* Return the finalization priority for DECL.  */
5652
5653 priority_type
5654 decl_fini_priority_lookup (tree decl)
5655 {
5656   struct tree_priority_map *h;
5657   struct tree_map_base in;
5658
5659   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5660   in.from = decl;
5661   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5662   return h ? h->fini : DEFAULT_INIT_PRIORITY;
5663 }
5664
5665 /* Return the initialization and finalization priority information for
5666    DECL.  If there is no previous priority information, a freshly
5667    allocated structure is returned.  */
5668
5669 static struct tree_priority_map *
5670 decl_priority_info (tree decl)
5671 {
5672   struct tree_priority_map in;
5673   struct tree_priority_map *h;
5674   void **loc;
5675
5676   in.base.from = decl;
5677   loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
5678   h = (struct tree_priority_map *) *loc;
5679   if (!h)
5680     {
5681       h = GGC_CNEW (struct tree_priority_map);
5682       *loc = h;
5683       h->base.from = decl;
5684       h->init = DEFAULT_INIT_PRIORITY;
5685       h->fini = DEFAULT_INIT_PRIORITY;
5686     }
5687
5688   return h;
5689 }
5690
5691 /* Set the initialization priority for DECL to PRIORITY.  */
5692
5693 void
5694 decl_init_priority_insert (tree decl, priority_type priority)
5695 {
5696   struct tree_priority_map *h;
5697
5698   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5699   h = decl_priority_info (decl);
5700   h->init = priority;
5701 }
5702
5703 /* Set the finalization priority for DECL to PRIORITY.  */
5704
5705 void
5706 decl_fini_priority_insert (tree decl, priority_type priority)
5707 {
5708   struct tree_priority_map *h;
5709
5710   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5711   h = decl_priority_info (decl);
5712   h->fini = priority;
5713 }
5714
5715 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
5716
5717 static void
5718 print_debug_expr_statistics (void)
5719 {
5720   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5721            (long) htab_size (debug_expr_for_decl),
5722            (long) htab_elements (debug_expr_for_decl),
5723            htab_collisions (debug_expr_for_decl));
5724 }
5725
5726 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
5727
5728 static void
5729 print_value_expr_statistics (void)
5730 {
5731   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5732            (long) htab_size (value_expr_for_decl),
5733            (long) htab_elements (value_expr_for_decl),
5734            htab_collisions (value_expr_for_decl));
5735 }
5736
5737 /* Lookup a debug expression for FROM, and return it if we find one.  */
5738
5739 tree
5740 decl_debug_expr_lookup (tree from)
5741 {
5742   struct tree_map *h, in;
5743   in.base.from = from;
5744
5745   h = (struct tree_map *) htab_find_with_hash (debug_expr_for_decl, &in,
5746                                                htab_hash_pointer (from));
5747   if (h)
5748     return h->to;
5749   return NULL_TREE;
5750 }
5751
5752 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
5753
5754 void
5755 decl_debug_expr_insert (tree from, tree to)
5756 {
5757   struct tree_map *h;
5758   void **loc;
5759
5760   h = GGC_NEW (struct tree_map);
5761   h->hash = htab_hash_pointer (from);
5762   h->base.from = from;
5763   h->to = to;
5764   loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
5765   *(struct tree_map **) loc = h;
5766 }
5767
5768 /* Lookup a value expression for FROM, and return it if we find one.  */
5769
5770 tree
5771 decl_value_expr_lookup (tree from)
5772 {
5773   struct tree_map *h, in;
5774   in.base.from = from;
5775
5776   h = (struct tree_map *) htab_find_with_hash (value_expr_for_decl, &in,
5777                                                htab_hash_pointer (from));
5778   if (h)
5779     return h->to;
5780   return NULL_TREE;
5781 }
5782
5783 /* Insert a mapping FROM->TO in the value expression hashtable.  */
5784
5785 void
5786 decl_value_expr_insert (tree from, tree to)
5787 {
5788   struct tree_map *h;
5789   void **loc;
5790
5791   h = GGC_NEW (struct tree_map);
5792   h->hash = htab_hash_pointer (from);
5793   h->base.from = from;
5794   h->to = to;
5795   loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT);
5796   *(struct tree_map **) loc = h;
5797 }
5798
5799 /* Hashing of types so that we don't make duplicates.
5800    The entry point is `type_hash_canon'.  */
5801
5802 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
5803    with types in the TREE_VALUE slots), by adding the hash codes
5804    of the individual types.  */
5805
5806 static unsigned int
5807 type_hash_list (const_tree list, hashval_t hashcode)
5808 {
5809   const_tree tail;
5810
5811   for (tail = list; tail; tail = TREE_CHAIN (tail))
5812     if (TREE_VALUE (tail) != error_mark_node)
5813       hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
5814                                         hashcode);
5815
5816   return hashcode;
5817 }
5818
5819 /* These are the Hashtable callback functions.  */
5820
5821 /* Returns true iff the types are equivalent.  */
5822
5823 static int
5824 type_hash_eq (const void *va, const void *vb)
5825 {
5826   const struct type_hash *const a = (const struct type_hash *) va,
5827     *const b = (const struct type_hash *) vb;
5828
5829   /* First test the things that are the same for all types.  */
5830   if (a->hash != b->hash
5831       || TREE_CODE (a->type) != TREE_CODE (b->type)
5832       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
5833       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
5834                                  TYPE_ATTRIBUTES (b->type))
5835       || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
5836       || TYPE_MODE (a->type) != TYPE_MODE (b->type)
5837       || (TREE_CODE (a->type) != COMPLEX_TYPE
5838           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
5839     return 0;
5840
5841   switch (TREE_CODE (a->type))
5842     {
5843     case VOID_TYPE:
5844     case COMPLEX_TYPE:
5845     case POINTER_TYPE:
5846     case REFERENCE_TYPE:
5847       return 1;
5848
5849     case VECTOR_TYPE:
5850       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
5851
5852     case ENUMERAL_TYPE:
5853       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
5854           && !(TYPE_VALUES (a->type)
5855                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
5856                && TYPE_VALUES (b->type)
5857                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
5858                && type_list_equal (TYPE_VALUES (a->type),
5859                                    TYPE_VALUES (b->type))))
5860         return 0;
5861
5862       /* ... fall through ... */
5863
5864     case INTEGER_TYPE:
5865     case REAL_TYPE:
5866     case BOOLEAN_TYPE:
5867       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
5868                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
5869                                       TYPE_MAX_VALUE (b->type)))
5870               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
5871                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
5872                                          TYPE_MIN_VALUE (b->type))));
5873
5874     case FIXED_POINT_TYPE:
5875       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
5876
5877     case OFFSET_TYPE:
5878       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
5879
5880     case METHOD_TYPE:
5881       return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
5882               && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5883                   || (TYPE_ARG_TYPES (a->type)
5884                       && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5885                       && TYPE_ARG_TYPES (b->type)
5886                       && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5887                       && type_list_equal (TYPE_ARG_TYPES (a->type),
5888                                           TYPE_ARG_TYPES (b->type)))));
5889
5890     case ARRAY_TYPE:
5891       return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
5892
5893     case RECORD_TYPE:
5894     case UNION_TYPE:
5895     case QUAL_UNION_TYPE:
5896       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
5897               || (TYPE_FIELDS (a->type)
5898                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
5899                   && TYPE_FIELDS (b->type)
5900                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
5901                   && type_list_equal (TYPE_FIELDS (a->type),
5902                                       TYPE_FIELDS (b->type))));
5903
5904     case FUNCTION_TYPE:
5905       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5906           || (TYPE_ARG_TYPES (a->type)
5907               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5908               && TYPE_ARG_TYPES (b->type)
5909               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5910               && type_list_equal (TYPE_ARG_TYPES (a->type),
5911                                   TYPE_ARG_TYPES (b->type))))
5912         break;
5913       return 0;
5914
5915     default:
5916       return 0;
5917     }
5918
5919   if (lang_hooks.types.type_hash_eq != NULL)
5920     return lang_hooks.types.type_hash_eq (a->type, b->type);
5921
5922   return 1;
5923 }
5924
5925 /* Return the cached hash value.  */
5926
5927 static hashval_t
5928 type_hash_hash (const void *item)
5929 {
5930   return ((const struct type_hash *) item)->hash;
5931 }
5932
5933 /* Look in the type hash table for a type isomorphic to TYPE.
5934    If one is found, return it.  Otherwise return 0.  */
5935
5936 tree
5937 type_hash_lookup (hashval_t hashcode, tree type)
5938 {
5939   struct type_hash *h, in;
5940
5941   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
5942      must call that routine before comparing TYPE_ALIGNs.  */
5943   layout_type (type);
5944
5945   in.hash = hashcode;
5946   in.type = type;
5947
5948   h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
5949                                                 hashcode);
5950   if (h)
5951     return h->type;
5952   return NULL_TREE;
5953 }
5954
5955 /* Add an entry to the type-hash-table
5956    for a type TYPE whose hash code is HASHCODE.  */
5957
5958 void
5959 type_hash_add (hashval_t hashcode, tree type)
5960 {
5961   struct type_hash *h;
5962   void **loc;
5963
5964   h = GGC_NEW (struct type_hash);
5965   h->hash = hashcode;
5966   h->type = type;
5967   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
5968   *loc = (void *)h;
5969 }
5970
5971 /* Given TYPE, and HASHCODE its hash code, return the canonical
5972    object for an identical type if one already exists.
5973    Otherwise, return TYPE, and record it as the canonical object.
5974
5975    To use this function, first create a type of the sort you want.
5976    Then compute its hash code from the fields of the type that
5977    make it different from other similar types.
5978    Then call this function and use the value.  */
5979
5980 tree
5981 type_hash_canon (unsigned int hashcode, tree type)
5982 {
5983   tree t1;
5984
5985   /* The hash table only contains main variants, so ensure that's what we're
5986      being passed.  */
5987   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
5988
5989   if (!lang_hooks.types.hash_types)
5990     return type;
5991
5992   /* See if the type is in the hash table already.  If so, return it.
5993      Otherwise, add the type.  */
5994   t1 = type_hash_lookup (hashcode, type);
5995   if (t1 != 0)
5996     {
5997 #ifdef GATHER_STATISTICS
5998       tree_node_counts[(int) t_kind]--;
5999       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
6000 #endif
6001       return t1;
6002     }
6003   else
6004     {
6005       type_hash_add (hashcode, type);
6006       return type;
6007     }
6008 }
6009
6010 /* See if the data pointed to by the type hash table is marked.  We consider
6011    it marked if the type is marked or if a debug type number or symbol
6012    table entry has been made for the type.  This reduces the amount of
6013    debugging output and eliminates that dependency of the debug output on
6014    the number of garbage collections.  */
6015
6016 static int
6017 type_hash_marked_p (const void *p)
6018 {
6019   const_tree const type = ((const struct type_hash *) p)->type;
6020
6021   return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
6022 }
6023
6024 static void
6025 print_type_hash_statistics (void)
6026 {
6027   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6028            (long) htab_size (type_hash_table),
6029            (long) htab_elements (type_hash_table),
6030            htab_collisions (type_hash_table));
6031 }
6032
6033 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6034    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6035    by adding the hash codes of the individual attributes.  */
6036
6037 static unsigned int
6038 attribute_hash_list (const_tree list, hashval_t hashcode)
6039 {
6040   const_tree tail;
6041
6042   for (tail = list; tail; tail = TREE_CHAIN (tail))
6043     /* ??? Do we want to add in TREE_VALUE too? */
6044     hashcode = iterative_hash_object
6045       (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
6046   return hashcode;
6047 }
6048
6049 /* Given two lists of attributes, return true if list l2 is
6050    equivalent to l1.  */
6051
6052 int
6053 attribute_list_equal (const_tree l1, const_tree l2)
6054 {
6055   return attribute_list_contained (l1, l2)
6056          && attribute_list_contained (l2, l1);
6057 }
6058
6059 /* Given two lists of attributes, return true if list L2 is
6060    completely contained within L1.  */
6061 /* ??? This would be faster if attribute names were stored in a canonicalized
6062    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6063    must be used to show these elements are equivalent (which they are).  */
6064 /* ??? It's not clear that attributes with arguments will always be handled
6065    correctly.  */
6066
6067 int
6068 attribute_list_contained (const_tree l1, const_tree l2)
6069 {
6070   const_tree t1, t2;
6071
6072   /* First check the obvious, maybe the lists are identical.  */
6073   if (l1 == l2)
6074     return 1;
6075
6076   /* Maybe the lists are similar.  */
6077   for (t1 = l1, t2 = l2;
6078        t1 != 0 && t2 != 0
6079         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
6080         && TREE_VALUE (t1) == TREE_VALUE (t2);
6081        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
6082
6083   /* Maybe the lists are equal.  */
6084   if (t1 == 0 && t2 == 0)
6085     return 1;
6086
6087   for (; t2 != 0; t2 = TREE_CHAIN (t2))
6088     {
6089       const_tree attr;
6090       /* This CONST_CAST is okay because lookup_attribute does not
6091          modify its argument and the return value is assigned to a
6092          const_tree.  */
6093       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6094                                     CONST_CAST_TREE(l1));
6095            attr != NULL_TREE;
6096            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6097                                     TREE_CHAIN (attr)))
6098         {
6099           if (TREE_VALUE (t2) != NULL
6100               && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
6101               && TREE_VALUE (attr) != NULL
6102               && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
6103             {
6104               if (simple_cst_list_equal (TREE_VALUE (t2),
6105                                          TREE_VALUE (attr)) == 1)
6106                 break;
6107             }
6108           else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
6109             break;
6110         }
6111
6112       if (attr == 0)
6113         return 0;
6114     }
6115
6116   return 1;
6117 }
6118
6119 /* Given two lists of types
6120    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6121    return 1 if the lists contain the same types in the same order.
6122    Also, the TREE_PURPOSEs must match.  */
6123
6124 int
6125 type_list_equal (const_tree l1, const_tree l2)
6126 {
6127   const_tree t1, t2;
6128
6129   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6130     if (TREE_VALUE (t1) != TREE_VALUE (t2)
6131         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6132             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6133                   && (TREE_TYPE (TREE_PURPOSE (t1))
6134                       == TREE_TYPE (TREE_PURPOSE (t2))))))
6135       return 0;
6136
6137   return t1 == t2;
6138 }
6139
6140 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6141    given by TYPE.  If the argument list accepts variable arguments,
6142    then this function counts only the ordinary arguments.  */
6143
6144 int
6145 type_num_arguments (const_tree type)
6146 {
6147   int i = 0;
6148   tree t;
6149
6150   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6151     /* If the function does not take a variable number of arguments,
6152        the last element in the list will have type `void'.  */
6153     if (VOID_TYPE_P (TREE_VALUE (t)))
6154       break;
6155     else
6156       ++i;
6157
6158   return i;
6159 }
6160
6161 /* Nonzero if integer constants T1 and T2
6162    represent the same constant value.  */
6163
6164 int
6165 tree_int_cst_equal (const_tree t1, const_tree t2)
6166 {
6167   if (t1 == t2)
6168     return 1;
6169
6170   if (t1 == 0 || t2 == 0)
6171     return 0;
6172
6173   if (TREE_CODE (t1) == INTEGER_CST
6174       && TREE_CODE (t2) == INTEGER_CST
6175       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6176       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
6177     return 1;
6178
6179   return 0;
6180 }
6181
6182 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6183    The precise way of comparison depends on their data type.  */
6184
6185 int
6186 tree_int_cst_lt (const_tree t1, const_tree t2)
6187 {
6188   if (t1 == t2)
6189     return 0;
6190
6191   if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
6192     {
6193       int t1_sgn = tree_int_cst_sgn (t1);
6194       int t2_sgn = tree_int_cst_sgn (t2);
6195
6196       if (t1_sgn < t2_sgn)
6197         return 1;
6198       else if (t1_sgn > t2_sgn)
6199         return 0;
6200       /* Otherwise, both are non-negative, so we compare them as
6201          unsigned just in case one of them would overflow a signed
6202          type.  */
6203     }
6204   else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
6205     return INT_CST_LT (t1, t2);
6206
6207   return INT_CST_LT_UNSIGNED (t1, t2);
6208 }
6209
6210 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
6211
6212 int
6213 tree_int_cst_compare (const_tree t1, const_tree t2)
6214 {
6215   if (tree_int_cst_lt (t1, t2))
6216     return -1;
6217   else if (tree_int_cst_lt (t2, t1))
6218     return 1;
6219   else
6220     return 0;
6221 }
6222
6223 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6224    the host.  If POS is zero, the value can be represented in a single
6225    HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
6226    be represented in a single unsigned HOST_WIDE_INT.  */
6227
6228 int
6229 host_integerp (const_tree t, int pos)
6230 {
6231   if (t == NULL_TREE)
6232     return 0;
6233
6234   return (TREE_CODE (t) == INTEGER_CST
6235           && ((TREE_INT_CST_HIGH (t) == 0
6236                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
6237               || (! pos && TREE_INT_CST_HIGH (t) == -1
6238                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
6239                   && (!TYPE_UNSIGNED (TREE_TYPE (t))
6240                       || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6241                           && TYPE_IS_SIZETYPE (TREE_TYPE (t)))))
6242               || (pos && TREE_INT_CST_HIGH (t) == 0)));
6243 }
6244
6245 /* Return the HOST_WIDE_INT least significant bits of T if it is an
6246    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
6247    be non-negative.  We must be able to satisfy the above conditions.  */
6248
6249 HOST_WIDE_INT
6250 tree_low_cst (const_tree t, int pos)
6251 {
6252   gcc_assert (host_integerp (t, pos));
6253   return TREE_INT_CST_LOW (t);
6254 }
6255
6256 /* Return the most significant bit of the integer constant T.  */
6257
6258 int
6259 tree_int_cst_msb (const_tree t)
6260 {
6261   int prec;
6262   HOST_WIDE_INT h;
6263   unsigned HOST_WIDE_INT l;
6264
6265   /* Note that using TYPE_PRECISION here is wrong.  We care about the
6266      actual bits, not the (arbitrary) range of the type.  */
6267   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
6268   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
6269                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
6270   return (l & 1) == 1;
6271 }
6272
6273 /* Return an indication of the sign of the integer constant T.
6274    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6275    Note that -1 will never be returned if T's type is unsigned.  */
6276
6277 int
6278 tree_int_cst_sgn (const_tree t)
6279 {
6280   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
6281     return 0;
6282   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
6283     return 1;
6284   else if (TREE_INT_CST_HIGH (t) < 0)
6285     return -1;
6286   else
6287     return 1;
6288 }
6289
6290 /* Return the minimum number of bits needed to represent VALUE in a
6291    signed or unsigned type, UNSIGNEDP says which.  */
6292
6293 unsigned int
6294 tree_int_cst_min_precision (tree value, bool unsignedp)
6295 {
6296   int log;
6297
6298   /* If the value is negative, compute its negative minus 1.  The latter
6299      adjustment is because the absolute value of the largest negative value
6300      is one larger than the largest positive value.  This is equivalent to
6301      a bit-wise negation, so use that operation instead.  */
6302
6303   if (tree_int_cst_sgn (value) < 0)
6304     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
6305
6306   /* Return the number of bits needed, taking into account the fact
6307      that we need one more bit for a signed than unsigned type.  */
6308
6309   if (integer_zerop (value))
6310     log = 0;
6311   else
6312     log = tree_floor_log2 (value);
6313
6314   return log + 1 + !unsignedp;
6315 }
6316
6317 /* Compare two constructor-element-type constants.  Return 1 if the lists
6318    are known to be equal; otherwise return 0.  */
6319
6320 int
6321 simple_cst_list_equal (const_tree l1, const_tree l2)
6322 {
6323   while (l1 != NULL_TREE && l2 != NULL_TREE)
6324     {
6325       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
6326         return 0;
6327
6328       l1 = TREE_CHAIN (l1);
6329       l2 = TREE_CHAIN (l2);
6330     }
6331
6332   return l1 == l2;
6333 }
6334
6335 /* Return truthvalue of whether T1 is the same tree structure as T2.
6336    Return 1 if they are the same.
6337    Return 0 if they are understandably different.
6338    Return -1 if either contains tree structure not understood by
6339    this function.  */
6340
6341 int
6342 simple_cst_equal (const_tree t1, const_tree t2)
6343 {
6344   enum tree_code code1, code2;
6345   int cmp;
6346   int i;
6347
6348   if (t1 == t2)
6349     return 1;
6350   if (t1 == 0 || t2 == 0)
6351     return 0;
6352
6353   code1 = TREE_CODE (t1);
6354   code2 = TREE_CODE (t2);
6355
6356   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
6357     {
6358       if (CONVERT_EXPR_CODE_P (code2)
6359           || code2 == NON_LVALUE_EXPR)
6360         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6361       else
6362         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
6363     }
6364
6365   else if (CONVERT_EXPR_CODE_P (code2)
6366            || code2 == NON_LVALUE_EXPR)
6367     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
6368
6369   if (code1 != code2)
6370     return 0;
6371
6372   switch (code1)
6373     {
6374     case INTEGER_CST:
6375       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6376               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
6377
6378     case REAL_CST:
6379       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
6380
6381     case FIXED_CST:
6382       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
6383
6384     case STRING_CST:
6385       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
6386               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
6387                          TREE_STRING_LENGTH (t1)));
6388
6389     case CONSTRUCTOR:
6390       {
6391         unsigned HOST_WIDE_INT idx;
6392         VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
6393         VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
6394
6395         if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
6396           return false;
6397
6398         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
6399           /* ??? Should we handle also fields here? */
6400           if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
6401                                  VEC_index (constructor_elt, v2, idx)->value))
6402             return false;
6403         return true;
6404       }
6405
6406     case SAVE_EXPR:
6407       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6408
6409     case CALL_EXPR:
6410       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
6411       if (cmp <= 0)
6412         return cmp;
6413       if (call_expr_nargs (t1) != call_expr_nargs (t2))
6414         return 0;
6415       {
6416         const_tree arg1, arg2;
6417         const_call_expr_arg_iterator iter1, iter2;
6418         for (arg1 = first_const_call_expr_arg (t1, &iter1),
6419                arg2 = first_const_call_expr_arg (t2, &iter2);
6420              arg1 && arg2;
6421              arg1 = next_const_call_expr_arg (&iter1),
6422                arg2 = next_const_call_expr_arg (&iter2))
6423           {
6424             cmp = simple_cst_equal (arg1, arg2);
6425             if (cmp <= 0)
6426               return cmp;
6427           }
6428         return arg1 == arg2;
6429       }
6430
6431     case TARGET_EXPR:
6432       /* Special case: if either target is an unallocated VAR_DECL,
6433          it means that it's going to be unified with whatever the
6434          TARGET_EXPR is really supposed to initialize, so treat it
6435          as being equivalent to anything.  */
6436       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
6437            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
6438            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
6439           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
6440               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
6441               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
6442         cmp = 1;
6443       else
6444         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6445
6446       if (cmp <= 0)
6447         return cmp;
6448
6449       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
6450
6451     case WITH_CLEANUP_EXPR:
6452       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6453       if (cmp <= 0)
6454         return cmp;
6455
6456       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
6457
6458     case COMPONENT_REF:
6459       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
6460         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6461
6462       return 0;
6463
6464     case VAR_DECL:
6465     case PARM_DECL:
6466     case CONST_DECL:
6467     case FUNCTION_DECL:
6468       return 0;
6469
6470     default:
6471       break;
6472     }
6473
6474   /* This general rule works for most tree codes.  All exceptions should be
6475      handled above.  If this is a language-specific tree code, we can't
6476      trust what might be in the operand, so say we don't know
6477      the situation.  */
6478   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
6479     return -1;
6480
6481   switch (TREE_CODE_CLASS (code1))
6482     {
6483     case tcc_unary:
6484     case tcc_binary:
6485     case tcc_comparison:
6486     case tcc_expression:
6487     case tcc_reference:
6488     case tcc_statement:
6489       cmp = 1;
6490       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
6491         {
6492           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
6493           if (cmp <= 0)
6494             return cmp;
6495         }
6496
6497       return cmp;
6498
6499     default:
6500       return -1;
6501     }
6502 }
6503
6504 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6505    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6506    than U, respectively.  */
6507
6508 int
6509 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
6510 {
6511   if (tree_int_cst_sgn (t) < 0)
6512     return -1;
6513   else if (TREE_INT_CST_HIGH (t) != 0)
6514     return 1;
6515   else if (TREE_INT_CST_LOW (t) == u)
6516     return 0;
6517   else if (TREE_INT_CST_LOW (t) < u)
6518     return -1;
6519   else
6520     return 1;
6521 }
6522
6523 /* Return true if CODE represents an associative tree code.  Otherwise
6524    return false.  */
6525 bool
6526 associative_tree_code (enum tree_code code)
6527 {
6528   switch (code)
6529     {
6530     case BIT_IOR_EXPR:
6531     case BIT_AND_EXPR:
6532     case BIT_XOR_EXPR:
6533     case PLUS_EXPR:
6534     case MULT_EXPR:
6535     case MIN_EXPR:
6536     case MAX_EXPR:
6537       return true;
6538
6539     default:
6540       break;
6541     }
6542   return false;
6543 }
6544
6545 /* Return true if CODE represents a commutative tree code.  Otherwise
6546    return false.  */
6547 bool
6548 commutative_tree_code (enum tree_code code)
6549 {
6550   switch (code)
6551     {
6552     case PLUS_EXPR:
6553     case MULT_EXPR:
6554     case MIN_EXPR:
6555     case MAX_EXPR:
6556     case BIT_IOR_EXPR:
6557     case BIT_XOR_EXPR:
6558     case BIT_AND_EXPR:
6559     case NE_EXPR:
6560     case EQ_EXPR:
6561     case UNORDERED_EXPR:
6562     case ORDERED_EXPR:
6563     case UNEQ_EXPR:
6564     case LTGT_EXPR:
6565     case TRUTH_AND_EXPR:
6566     case TRUTH_XOR_EXPR:
6567     case TRUTH_OR_EXPR:
6568       return true;
6569
6570     default:
6571       break;
6572     }
6573   return false;
6574 }
6575
6576 /* Generate a hash value for an expression.  This can be used iteratively
6577    by passing a previous result as the VAL argument.
6578
6579    This function is intended to produce the same hash for expressions which
6580    would compare equal using operand_equal_p.  */
6581
6582 hashval_t
6583 iterative_hash_expr (const_tree t, hashval_t val)
6584 {
6585   int i;
6586   enum tree_code code;
6587   char tclass;
6588
6589   if (t == NULL_TREE)
6590     return iterative_hash_hashval_t (0, val);
6591
6592   code = TREE_CODE (t);
6593
6594   switch (code)
6595     {
6596     /* Alas, constants aren't shared, so we can't rely on pointer
6597        identity.  */
6598     case INTEGER_CST:
6599       val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
6600       return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
6601     case REAL_CST:
6602       {
6603         unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
6604
6605         return iterative_hash_hashval_t (val2, val);
6606       }
6607     case FIXED_CST:
6608       {
6609         unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
6610
6611         return iterative_hash_hashval_t (val2, val);
6612       }
6613     case STRING_CST:
6614       return iterative_hash (TREE_STRING_POINTER (t),
6615                              TREE_STRING_LENGTH (t), val);
6616     case COMPLEX_CST:
6617       val = iterative_hash_expr (TREE_REALPART (t), val);
6618       return iterative_hash_expr (TREE_IMAGPART (t), val);
6619     case VECTOR_CST:
6620       return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
6621     case SSA_NAME:
6622       /* We can just compare by pointer.  */
6623       return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
6624     case PLACEHOLDER_EXPR:
6625       /* The node itself doesn't matter.  */
6626       return val;
6627     case TREE_LIST:
6628       /* A list of expressions, for a CALL_EXPR or as the elements of a
6629          VECTOR_CST.  */
6630       for (; t; t = TREE_CHAIN (t))
6631         val = iterative_hash_expr (TREE_VALUE (t), val);
6632       return val;
6633     case CONSTRUCTOR:
6634       {
6635         unsigned HOST_WIDE_INT idx;
6636         tree field, value;
6637         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
6638           {
6639             val = iterative_hash_expr (field, val);
6640             val = iterative_hash_expr (value, val);
6641           }
6642         return val;
6643       }
6644     case FUNCTION_DECL:
6645       /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
6646          Otherwise nodes that compare equal according to operand_equal_p might
6647          get different hash codes.  However, don't do this for machine specific
6648          or front end builtins, since the function code is overloaded in those
6649          cases.  */
6650       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
6651           && built_in_decls[DECL_FUNCTION_CODE (t)])
6652         {
6653           t = built_in_decls[DECL_FUNCTION_CODE (t)];
6654           code = TREE_CODE (t);
6655         }
6656       /* FALL THROUGH */
6657     default:
6658       tclass = TREE_CODE_CLASS (code);
6659
6660       if (tclass == tcc_declaration)
6661         {
6662           /* DECL's have a unique ID */
6663           val = iterative_hash_host_wide_int (DECL_UID (t), val);
6664         }
6665       else
6666         {
6667           gcc_assert (IS_EXPR_CODE_CLASS (tclass));
6668
6669           val = iterative_hash_object (code, val);
6670
6671           /* Don't hash the type, that can lead to having nodes which
6672              compare equal according to operand_equal_p, but which
6673              have different hash codes.  */
6674           if (CONVERT_EXPR_CODE_P (code)
6675               || code == NON_LVALUE_EXPR)
6676             {
6677               /* Make sure to include signness in the hash computation.  */
6678               val += TYPE_UNSIGNED (TREE_TYPE (t));
6679               val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
6680             }
6681
6682           else if (commutative_tree_code (code))
6683             {
6684               /* It's a commutative expression.  We want to hash it the same
6685                  however it appears.  We do this by first hashing both operands
6686                  and then rehashing based on the order of their independent
6687                  hashes.  */
6688               hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
6689               hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
6690               hashval_t t;
6691
6692               if (one > two)
6693                 t = one, one = two, two = t;
6694
6695               val = iterative_hash_hashval_t (one, val);
6696               val = iterative_hash_hashval_t (two, val);
6697             }
6698           else
6699             for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
6700               val = iterative_hash_expr (TREE_OPERAND (t, i), val);
6701         }
6702       return val;
6703       break;
6704     }
6705 }
6706
6707 /* Generate a hash value for a pair of expressions.  This can be used
6708    iteratively by passing a previous result as the VAL argument.
6709
6710    The same hash value is always returned for a given pair of expressions,
6711    regardless of the order in which they are presented.  This is useful in
6712    hashing the operands of commutative functions.  */
6713
6714 hashval_t
6715 iterative_hash_exprs_commutative (const_tree t1,
6716                                   const_tree t2, hashval_t val)
6717 {
6718   hashval_t one = iterative_hash_expr (t1, 0);
6719   hashval_t two = iterative_hash_expr (t2, 0);
6720   hashval_t t;
6721
6722   if (one > two)
6723     t = one, one = two, two = t;
6724   val = iterative_hash_hashval_t (one, val);
6725   val = iterative_hash_hashval_t (two, val);
6726
6727   return val;
6728 }
6729 \f
6730 /* Constructors for pointer, array and function types.
6731    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
6732    constructed by language-dependent code, not here.)  */
6733
6734 /* Construct, lay out and return the type of pointers to TO_TYPE with
6735    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
6736    reference all of memory. If such a type has already been
6737    constructed, reuse it.  */
6738
6739 tree
6740 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
6741                              bool can_alias_all)
6742 {
6743   tree t;
6744
6745   if (to_type == error_mark_node)
6746     return error_mark_node;
6747
6748   /* If the pointed-to type has the may_alias attribute set, force
6749      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6750   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6751     can_alias_all = true;
6752
6753   /* In some cases, languages will have things that aren't a POINTER_TYPE
6754      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
6755      In that case, return that type without regard to the rest of our
6756      operands.
6757
6758      ??? This is a kludge, but consistent with the way this function has
6759      always operated and there doesn't seem to be a good way to avoid this
6760      at the moment.  */
6761   if (TYPE_POINTER_TO (to_type) != 0
6762       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
6763     return TYPE_POINTER_TO (to_type);
6764
6765   /* First, if we already have a type for pointers to TO_TYPE and it's
6766      the proper mode, use it.  */
6767   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
6768     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6769       return t;
6770
6771   t = make_node (POINTER_TYPE);
6772
6773   TREE_TYPE (t) = to_type;
6774   SET_TYPE_MODE (t, mode);
6775   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6776   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
6777   TYPE_POINTER_TO (to_type) = t;
6778
6779   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6780     SET_TYPE_STRUCTURAL_EQUALITY (t);
6781   else if (TYPE_CANONICAL (to_type) != to_type)
6782     TYPE_CANONICAL (t)
6783       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
6784                                      mode, can_alias_all);
6785
6786   /* Lay out the type.  This function has many callers that are concerned
6787      with expression-construction, and this simplifies them all.  */
6788   layout_type (t);
6789
6790   return t;
6791 }
6792
6793 /* By default build pointers in ptr_mode.  */
6794
6795 tree
6796 build_pointer_type (tree to_type)
6797 {
6798   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6799                                               : TYPE_ADDR_SPACE (to_type);
6800   enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6801   return build_pointer_type_for_mode (to_type, pointer_mode, false);
6802 }
6803
6804 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
6805
6806 tree
6807 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
6808                                bool can_alias_all)
6809 {
6810   tree t;
6811
6812   if (to_type == error_mark_node)
6813     return error_mark_node;
6814
6815   /* If the pointed-to type has the may_alias attribute set, force
6816      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6817   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6818     can_alias_all = true;
6819
6820   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
6821      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
6822      In that case, return that type without regard to the rest of our
6823      operands.
6824
6825      ??? This is a kludge, but consistent with the way this function has
6826      always operated and there doesn't seem to be a good way to avoid this
6827      at the moment.  */
6828   if (TYPE_REFERENCE_TO (to_type) != 0
6829       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
6830     return TYPE_REFERENCE_TO (to_type);
6831
6832   /* First, if we already have a type for pointers to TO_TYPE and it's
6833      the proper mode, use it.  */
6834   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
6835     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6836       return t;
6837
6838   t = make_node (REFERENCE_TYPE);
6839
6840   TREE_TYPE (t) = to_type;
6841   SET_TYPE_MODE (t, mode);
6842   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6843   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
6844   TYPE_REFERENCE_TO (to_type) = t;
6845
6846   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6847     SET_TYPE_STRUCTURAL_EQUALITY (t);
6848   else if (TYPE_CANONICAL (to_type) != to_type)
6849     TYPE_CANONICAL (t)
6850       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
6851                                        mode, can_alias_all);
6852
6853   layout_type (t);
6854
6855   return t;
6856 }
6857
6858
6859 /* Build the node for the type of references-to-TO_TYPE by default
6860    in ptr_mode.  */
6861
6862 tree
6863 build_reference_type (tree to_type)
6864 {
6865   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6866                                               : TYPE_ADDR_SPACE (to_type);
6867   enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6868   return build_reference_type_for_mode (to_type, pointer_mode, false);
6869 }
6870
6871 /* Build a type that is compatible with t but has no cv quals anywhere
6872    in its type, thus
6873
6874    const char *const *const *  ->  char ***.  */
6875
6876 tree
6877 build_type_no_quals (tree t)
6878 {
6879   switch (TREE_CODE (t))
6880     {
6881     case POINTER_TYPE:
6882       return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6883                                           TYPE_MODE (t),
6884                                           TYPE_REF_CAN_ALIAS_ALL (t));
6885     case REFERENCE_TYPE:
6886       return
6887         build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6888                                        TYPE_MODE (t),
6889                                        TYPE_REF_CAN_ALIAS_ALL (t));
6890     default:
6891       return TYPE_MAIN_VARIANT (t);
6892     }
6893 }
6894
6895 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
6896    MAXVAL should be the maximum value in the domain
6897    (one less than the length of the array).
6898
6899    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
6900    We don't enforce this limit, that is up to caller (e.g. language front end).
6901    The limit exists because the result is a signed type and we don't handle
6902    sizes that use more than one HOST_WIDE_INT.  */
6903
6904 tree
6905 build_index_type (tree maxval)
6906 {
6907   tree itype = make_node (INTEGER_TYPE);
6908
6909   TREE_TYPE (itype) = sizetype;
6910   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
6911   TYPE_MIN_VALUE (itype) = size_zero_node;
6912   TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
6913   SET_TYPE_MODE (itype, TYPE_MODE (sizetype));
6914   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
6915   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
6916   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
6917   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
6918
6919   if (host_integerp (maxval, 1))
6920     return type_hash_canon (tree_low_cst (maxval, 1), itype);
6921   else
6922     {
6923       /* Since we cannot hash this type, we need to compare it using
6924          structural equality checks. */
6925       SET_TYPE_STRUCTURAL_EQUALITY (itype);
6926       return itype;
6927     }
6928 }
6929
6930 #define MAX_INT_CACHED_PREC \
6931   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
6932 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
6933
6934 /* Builds a signed or unsigned integer type of precision PRECISION.
6935    Used for C bitfields whose precision does not match that of
6936    built-in target types.  */
6937 tree
6938 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
6939                                 int unsignedp)
6940 {
6941   tree itype, ret;
6942
6943   if (unsignedp)
6944     unsignedp = MAX_INT_CACHED_PREC + 1;
6945
6946   if (precision <= MAX_INT_CACHED_PREC)
6947     {
6948       itype = nonstandard_integer_type_cache[precision + unsignedp];
6949       if (itype)
6950         return itype;
6951     }
6952
6953   itype = make_node (INTEGER_TYPE);
6954   TYPE_PRECISION (itype) = precision;
6955
6956   if (unsignedp)
6957     fixup_unsigned_type (itype);
6958   else
6959     fixup_signed_type (itype);
6960
6961   ret = itype;
6962   if (host_integerp (TYPE_MAX_VALUE (itype), 1))
6963     ret = type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
6964   if (precision <= MAX_INT_CACHED_PREC && lang_hooks.types.hash_types)
6965     nonstandard_integer_type_cache[precision + unsignedp] = ret;
6966
6967   return ret;
6968 }
6969
6970 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
6971    ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
6972    high bound HIGHVAL.  If TYPE is NULL, sizetype is used.  */
6973
6974 tree
6975 build_range_type (tree type, tree lowval, tree highval)
6976 {
6977   tree itype = make_node (INTEGER_TYPE);
6978
6979   TREE_TYPE (itype) = type;
6980   if (type == NULL_TREE)
6981     type = sizetype;
6982
6983   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
6984   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
6985
6986   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
6987   SET_TYPE_MODE (itype, TYPE_MODE (type));
6988   TYPE_SIZE (itype) = TYPE_SIZE (type);
6989   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
6990   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
6991   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
6992
6993   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
6994     return type_hash_canon (tree_low_cst (highval, 0)
6995                             - tree_low_cst (lowval, 0),
6996                             itype);
6997   else
6998     return itype;
6999 }
7000
7001 /* Return true if the debug information for TYPE, a subtype, should be emitted
7002    as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
7003    high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
7004    debug info and doesn't reflect the source code.  */
7005
7006 bool
7007 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7008 {
7009   tree base_type = TREE_TYPE (type), low, high;
7010
7011   /* Subrange types have a base type which is an integral type.  */
7012   if (!INTEGRAL_TYPE_P (base_type))
7013     return false;
7014
7015   /* Get the real bounds of the subtype.  */
7016   if (lang_hooks.types.get_subrange_bounds)
7017     lang_hooks.types.get_subrange_bounds (type, &low, &high);
7018   else
7019     {
7020       low = TYPE_MIN_VALUE (type);
7021       high = TYPE_MAX_VALUE (type);
7022     }
7023
7024   /* If the type and its base type have the same representation and the same
7025      name, then the type is not a subrange but a copy of the base type.  */
7026   if ((TREE_CODE (base_type) == INTEGER_TYPE
7027        || TREE_CODE (base_type) == BOOLEAN_TYPE)
7028       && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7029       && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7030       && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
7031     {
7032       tree type_name = TYPE_NAME (type);
7033       tree base_type_name = TYPE_NAME (base_type);
7034
7035       if (type_name && TREE_CODE (type_name) == TYPE_DECL)
7036         type_name = DECL_NAME (type_name);
7037
7038       if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
7039         base_type_name = DECL_NAME (base_type_name);
7040
7041       if (type_name == base_type_name)
7042         return false;
7043     }
7044
7045   if (lowval)
7046     *lowval = low;
7047   if (highval)
7048     *highval = high;
7049   return true;
7050 }
7051
7052 /* Just like build_index_type, but takes lowval and highval instead
7053    of just highval (maxval).  */
7054
7055 tree
7056 build_index_2_type (tree lowval, tree highval)
7057 {
7058   return build_range_type (sizetype, lowval, highval);
7059 }
7060
7061 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7062    and number of elements specified by the range of values of INDEX_TYPE.
7063    If such a type has already been constructed, reuse it.  */
7064
7065 tree
7066 build_array_type (tree elt_type, tree index_type)
7067 {
7068   tree t;
7069   hashval_t hashcode = 0;
7070
7071   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7072     {
7073       error ("arrays of functions are not meaningful");
7074       elt_type = integer_type_node;
7075     }
7076
7077   t = make_node (ARRAY_TYPE);
7078   TREE_TYPE (t) = elt_type;
7079   TYPE_DOMAIN (t) = index_type;
7080   TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7081   layout_type (t);
7082
7083   /* If the element type is incomplete at this point we get marked for
7084      structural equality.  Do not record these types in the canonical
7085      type hashtable.  */
7086   if (TYPE_STRUCTURAL_EQUALITY_P (t))
7087     return t;
7088
7089   hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
7090   if (index_type)
7091     hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
7092   t = type_hash_canon (hashcode, t);
7093
7094   if (TYPE_CANONICAL (t) == t)
7095     {
7096       if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7097           || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7098         SET_TYPE_STRUCTURAL_EQUALITY (t);
7099       else if (TYPE_CANONICAL (elt_type) != elt_type
7100                || (index_type && TYPE_CANONICAL (index_type) != index_type))
7101         TYPE_CANONICAL (t)
7102           = build_array_type (TYPE_CANONICAL (elt_type),
7103                               index_type ? TYPE_CANONICAL (index_type) : NULL);
7104     }
7105
7106   return t;
7107 }
7108
7109 /* Recursively examines the array elements of TYPE, until a non-array
7110    element type is found.  */
7111
7112 tree
7113 strip_array_types (tree type)
7114 {
7115   while (TREE_CODE (type) == ARRAY_TYPE)
7116     type = TREE_TYPE (type);
7117
7118   return type;
7119 }
7120
7121 /* Computes the canonical argument types from the argument type list
7122    ARGTYPES.
7123
7124    Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7125    on entry to this function, or if any of the ARGTYPES are
7126    structural.
7127
7128    Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7129    true on entry to this function, or if any of the ARGTYPES are
7130    non-canonical.
7131
7132    Returns a canonical argument list, which may be ARGTYPES when the
7133    canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7134    true) or would not differ from ARGTYPES.  */
7135
7136 static tree
7137 maybe_canonicalize_argtypes(tree argtypes,
7138                             bool *any_structural_p,
7139                             bool *any_noncanonical_p)
7140 {
7141   tree arg;
7142   bool any_noncanonical_argtypes_p = false;
7143
7144   for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7145     {
7146       if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7147         /* Fail gracefully by stating that the type is structural.  */
7148         *any_structural_p = true;
7149       else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7150         *any_structural_p = true;
7151       else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7152                || TREE_PURPOSE (arg))
7153         /* If the argument has a default argument, we consider it
7154            non-canonical even though the type itself is canonical.
7155            That way, different variants of function and method types
7156            with default arguments will all point to the variant with
7157            no defaults as their canonical type.  */
7158         any_noncanonical_argtypes_p = true;
7159     }
7160
7161   if (*any_structural_p)
7162     return argtypes;
7163
7164   if (any_noncanonical_argtypes_p)
7165     {
7166       /* Build the canonical list of argument types.  */
7167       tree canon_argtypes = NULL_TREE;
7168       bool is_void = false;
7169
7170       for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7171         {
7172           if (arg == void_list_node)
7173             is_void = true;
7174           else
7175             canon_argtypes = tree_cons (NULL_TREE,
7176                                         TYPE_CANONICAL (TREE_VALUE (arg)),
7177                                         canon_argtypes);
7178         }
7179
7180       canon_argtypes = nreverse (canon_argtypes);
7181       if (is_void)
7182         canon_argtypes = chainon (canon_argtypes, void_list_node);
7183
7184       /* There is a non-canonical type.  */
7185       *any_noncanonical_p = true;
7186       return canon_argtypes;
7187     }
7188
7189   /* The canonical argument types are the same as ARGTYPES.  */
7190   return argtypes;
7191 }
7192
7193 /* Construct, lay out and return
7194    the type of functions returning type VALUE_TYPE
7195    given arguments of types ARG_TYPES.
7196    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7197    are data type nodes for the arguments of the function.
7198    If such a type has already been constructed, reuse it.  */
7199
7200 tree
7201 build_function_type (tree value_type, tree arg_types)
7202 {
7203   tree t;
7204   hashval_t hashcode = 0;
7205   bool any_structural_p, any_noncanonical_p;
7206   tree canon_argtypes;
7207
7208   if (TREE_CODE (value_type) == FUNCTION_TYPE)
7209     {
7210       error ("function return type cannot be function");
7211       value_type = integer_type_node;
7212     }
7213
7214   /* Make a node of the sort we want.  */
7215   t = make_node (FUNCTION_TYPE);
7216   TREE_TYPE (t) = value_type;
7217   TYPE_ARG_TYPES (t) = arg_types;
7218
7219   /* If we already have such a type, use the old one.  */
7220   hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
7221   hashcode = type_hash_list (arg_types, hashcode);
7222   t = type_hash_canon (hashcode, t);
7223
7224   /* Set up the canonical type. */
7225   any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
7226   any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
7227   canon_argtypes = maybe_canonicalize_argtypes (arg_types,
7228                                                 &any_structural_p,
7229                                                 &any_noncanonical_p);
7230   if (any_structural_p)
7231     SET_TYPE_STRUCTURAL_EQUALITY (t);
7232   else if (any_noncanonical_p)
7233     TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
7234                                               canon_argtypes);
7235
7236   if (!COMPLETE_TYPE_P (t))
7237     layout_type (t);
7238   return t;
7239 }
7240
7241 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.  */
7242
7243 tree
7244 build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
7245 {
7246   tree new_type = NULL;
7247   tree args, new_args = NULL, t;
7248   tree new_reversed;
7249   int i = 0;
7250
7251   for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
7252        args = TREE_CHAIN (args), i++)
7253     if (!bitmap_bit_p (args_to_skip, i))
7254       new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
7255
7256   new_reversed = nreverse (new_args);
7257   if (args)
7258     {
7259       if (new_reversed)
7260         TREE_CHAIN (new_args) = void_list_node;
7261       else
7262         new_reversed = void_list_node;
7263     }
7264
7265   /* Use copy_node to preserve as much as possible from original type
7266      (debug info, attribute lists etc.)
7267      Exception is METHOD_TYPEs must have THIS argument.
7268      When we are asked to remove it, we need to build new FUNCTION_TYPE
7269      instead.  */
7270   if (TREE_CODE (orig_type) != METHOD_TYPE
7271       || !bitmap_bit_p (args_to_skip, 0))
7272     {
7273       new_type = copy_node (orig_type);
7274       TYPE_ARG_TYPES (new_type) = new_reversed;
7275     }
7276   else
7277     {
7278       new_type
7279         = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
7280                                                          new_reversed));
7281       TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
7282     }
7283
7284   /* This is a new type, not a copy of an old type.  Need to reassociate
7285      variants.  We can handle everything except the main variant lazily.  */
7286   t = TYPE_MAIN_VARIANT (orig_type);
7287   if (orig_type != t)
7288     {
7289       TYPE_MAIN_VARIANT (new_type) = t;
7290       TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
7291       TYPE_NEXT_VARIANT (t) = new_type;
7292     }
7293   else
7294     {
7295       TYPE_MAIN_VARIANT (new_type) = new_type;
7296       TYPE_NEXT_VARIANT (new_type) = NULL;
7297     }
7298   return new_type;
7299 }
7300
7301 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
7302
7303    Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7304    linked by TREE_CHAIN directly.  It is caller responsibility to eliminate
7305    them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
7306
7307 tree
7308 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
7309 {
7310   tree new_decl = copy_node (orig_decl);
7311   tree new_type;
7312
7313   new_type = TREE_TYPE (orig_decl);
7314   if (prototype_p (new_type))
7315     new_type = build_function_type_skip_args (new_type, args_to_skip);
7316   TREE_TYPE (new_decl) = new_type;
7317
7318   /* For declarations setting DECL_VINDEX (i.e. methods)
7319      we expect first argument to be THIS pointer.   */
7320   if (bitmap_bit_p (args_to_skip, 0))
7321     DECL_VINDEX (new_decl) = NULL_TREE;
7322   return new_decl;
7323 }
7324
7325 /* Build a function type.  The RETURN_TYPE is the type returned by the
7326    function. If VAARGS is set, no void_type_node is appended to the
7327    the list. ARGP muse be alway be terminated be a NULL_TREE.  */
7328
7329 static tree
7330 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
7331 {
7332   tree t, args, last;
7333
7334   t = va_arg (argp, tree);
7335   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
7336     args = tree_cons (NULL_TREE, t, args);
7337
7338   if (vaargs)
7339     {
7340       last = args;
7341       if (args != NULL_TREE)
7342         args = nreverse (args);
7343       gcc_assert (last != void_list_node);
7344     }
7345   else if (args == NULL_TREE)
7346     args = void_list_node;
7347   else
7348     {
7349       last = args;
7350       args = nreverse (args);
7351       TREE_CHAIN (last) = void_list_node;
7352     }
7353   args = build_function_type (return_type, args);
7354
7355   return args;
7356 }
7357
7358 /* Build a function type.  The RETURN_TYPE is the type returned by the
7359    function.  If additional arguments are provided, they are
7360    additional argument types.  The list of argument types must always
7361    be terminated by NULL_TREE.  */
7362
7363 tree
7364 build_function_type_list (tree return_type, ...)
7365 {
7366   tree args;
7367   va_list p;
7368
7369   va_start (p, return_type);
7370   args = build_function_type_list_1 (false, return_type, p);
7371   va_end (p);
7372   return args;
7373 }
7374
7375 /* Build a variable argument function type.  The RETURN_TYPE is the
7376    type returned by the function.  If additional arguments are provided,
7377    they are additional argument types.  The list of argument types must
7378    always be terminated by NULL_TREE.  */
7379
7380 tree
7381 build_varargs_function_type_list (tree return_type, ...)
7382 {
7383   tree args;
7384   va_list p;
7385
7386   va_start (p, return_type);
7387   args = build_function_type_list_1 (true, return_type, p);
7388   va_end (p);
7389
7390   return args;
7391 }
7392
7393 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
7394    and ARGTYPES (a TREE_LIST) are the return type and arguments types
7395    for the method.  An implicit additional parameter (of type
7396    pointer-to-BASETYPE) is added to the ARGTYPES.  */
7397
7398 tree
7399 build_method_type_directly (tree basetype,
7400                             tree rettype,
7401                             tree argtypes)
7402 {
7403   tree t;
7404   tree ptype;
7405   int hashcode = 0;
7406   bool any_structural_p, any_noncanonical_p;
7407   tree canon_argtypes;
7408
7409   /* Make a node of the sort we want.  */
7410   t = make_node (METHOD_TYPE);
7411
7412   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7413   TREE_TYPE (t) = rettype;
7414   ptype = build_pointer_type (basetype);
7415
7416   /* The actual arglist for this function includes a "hidden" argument
7417      which is "this".  Put it into the list of argument types.  */
7418   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
7419   TYPE_ARG_TYPES (t) = argtypes;
7420
7421   /* If we already have such a type, use the old one.  */
7422   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7423   hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
7424   hashcode = type_hash_list (argtypes, hashcode);
7425   t = type_hash_canon (hashcode, t);
7426
7427   /* Set up the canonical type. */
7428   any_structural_p
7429     = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7430        || TYPE_STRUCTURAL_EQUALITY_P (rettype));
7431   any_noncanonical_p
7432     = (TYPE_CANONICAL (basetype) != basetype
7433        || TYPE_CANONICAL (rettype) != rettype);
7434   canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
7435                                                 &any_structural_p,
7436                                                 &any_noncanonical_p);
7437   if (any_structural_p)
7438     SET_TYPE_STRUCTURAL_EQUALITY (t);
7439   else if (any_noncanonical_p)
7440     TYPE_CANONICAL (t)
7441       = build_method_type_directly (TYPE_CANONICAL (basetype),
7442                                     TYPE_CANONICAL (rettype),
7443                                     canon_argtypes);
7444   if (!COMPLETE_TYPE_P (t))
7445     layout_type (t);
7446
7447   return t;
7448 }
7449
7450 /* Construct, lay out and return the type of methods belonging to class
7451    BASETYPE and whose arguments and values are described by TYPE.
7452    If that type exists already, reuse it.
7453    TYPE must be a FUNCTION_TYPE node.  */
7454
7455 tree
7456 build_method_type (tree basetype, tree type)
7457 {
7458   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
7459
7460   return build_method_type_directly (basetype,
7461                                      TREE_TYPE (type),
7462                                      TYPE_ARG_TYPES (type));
7463 }
7464
7465 /* Construct, lay out and return the type of offsets to a value
7466    of type TYPE, within an object of type BASETYPE.
7467    If a suitable offset type exists already, reuse it.  */
7468
7469 tree
7470 build_offset_type (tree basetype, tree type)
7471 {
7472   tree t;
7473   hashval_t hashcode = 0;
7474
7475   /* Make a node of the sort we want.  */
7476   t = make_node (OFFSET_TYPE);
7477
7478   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7479   TREE_TYPE (t) = type;
7480
7481   /* If we already have such a type, use the old one.  */
7482   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7483   hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
7484   t = type_hash_canon (hashcode, t);
7485
7486   if (!COMPLETE_TYPE_P (t))
7487     layout_type (t);
7488
7489   if (TYPE_CANONICAL (t) == t)
7490     {
7491       if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7492           || TYPE_STRUCTURAL_EQUALITY_P (type))
7493         SET_TYPE_STRUCTURAL_EQUALITY (t);
7494       else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
7495                || TYPE_CANONICAL (type) != type)
7496         TYPE_CANONICAL (t)
7497           = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
7498                                TYPE_CANONICAL (type));
7499     }
7500
7501   return t;
7502 }
7503
7504 /* Create a complex type whose components are COMPONENT_TYPE.  */
7505
7506 tree
7507 build_complex_type (tree component_type)
7508 {
7509   tree t;
7510   hashval_t hashcode;
7511
7512   gcc_assert (INTEGRAL_TYPE_P (component_type)
7513               || SCALAR_FLOAT_TYPE_P (component_type)
7514               || FIXED_POINT_TYPE_P (component_type));
7515
7516   /* Make a node of the sort we want.  */
7517   t = make_node (COMPLEX_TYPE);
7518
7519   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
7520
7521   /* If we already have such a type, use the old one.  */
7522   hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
7523   t = type_hash_canon (hashcode, t);
7524
7525   if (!COMPLETE_TYPE_P (t))
7526     layout_type (t);
7527
7528   if (TYPE_CANONICAL (t) == t)
7529     {
7530       if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
7531         SET_TYPE_STRUCTURAL_EQUALITY (t);
7532       else if (TYPE_CANONICAL (component_type) != component_type)
7533         TYPE_CANONICAL (t)
7534           = build_complex_type (TYPE_CANONICAL (component_type));
7535     }
7536
7537   /* We need to create a name, since complex is a fundamental type.  */
7538   if (! TYPE_NAME (t))
7539     {
7540       const char *name;
7541       if (component_type == char_type_node)
7542         name = "complex char";
7543       else if (component_type == signed_char_type_node)
7544         name = "complex signed char";
7545       else if (component_type == unsigned_char_type_node)
7546         name = "complex unsigned char";
7547       else if (component_type == short_integer_type_node)
7548         name = "complex short int";
7549       else if (component_type == short_unsigned_type_node)
7550         name = "complex short unsigned int";
7551       else if (component_type == integer_type_node)
7552         name = "complex int";
7553       else if (component_type == unsigned_type_node)
7554         name = "complex unsigned int";
7555       else if (component_type == long_integer_type_node)
7556         name = "complex long int";
7557       else if (component_type == long_unsigned_type_node)
7558         name = "complex long unsigned int";
7559       else if (component_type == long_long_integer_type_node)
7560         name = "complex long long int";
7561       else if (component_type == long_long_unsigned_type_node)
7562         name = "complex long long unsigned int";
7563       else
7564         name = 0;
7565
7566       if (name != 0)
7567         TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
7568                                     get_identifier (name), t);
7569     }
7570
7571   return build_qualified_type (t, TYPE_QUALS (component_type));
7572 }
7573
7574 /* If TYPE is a real or complex floating-point type and the target
7575    does not directly support arithmetic on TYPE then return the wider
7576    type to be used for arithmetic on TYPE.  Otherwise, return
7577    NULL_TREE.  */
7578
7579 tree
7580 excess_precision_type (tree type)
7581 {
7582   if (flag_excess_precision != EXCESS_PRECISION_FAST)
7583     {
7584       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
7585       switch (TREE_CODE (type))
7586         {
7587         case REAL_TYPE:
7588           switch (flt_eval_method)
7589             {
7590             case 1:
7591               if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
7592                 return double_type_node;
7593               break;
7594             case 2:
7595               if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
7596                   || TYPE_MODE (type) == TYPE_MODE (double_type_node))
7597                 return long_double_type_node;
7598               break;
7599             default:
7600               gcc_unreachable ();
7601             }
7602           break;
7603         case COMPLEX_TYPE:
7604           if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
7605             return NULL_TREE;
7606           switch (flt_eval_method)
7607             {
7608             case 1:
7609               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
7610                 return complex_double_type_node;
7611               break;
7612             case 2:
7613               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
7614                   || (TYPE_MODE (TREE_TYPE (type))
7615                       == TYPE_MODE (double_type_node)))
7616                 return complex_long_double_type_node;
7617               break;
7618             default:
7619               gcc_unreachable ();
7620             }
7621           break;
7622         default:
7623           break;
7624         }
7625     }
7626   return NULL_TREE;
7627 }
7628 \f
7629 /* Return OP, stripped of any conversions to wider types as much as is safe.
7630    Converting the value back to OP's type makes a value equivalent to OP.
7631
7632    If FOR_TYPE is nonzero, we return a value which, if converted to
7633    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
7634
7635    OP must have integer, real or enumeral type.  Pointers are not allowed!
7636
7637    There are some cases where the obvious value we could return
7638    would regenerate to OP if converted to OP's type,
7639    but would not extend like OP to wider types.
7640    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
7641    For example, if OP is (unsigned short)(signed char)-1,
7642    we avoid returning (signed char)-1 if FOR_TYPE is int,
7643    even though extending that to an unsigned short would regenerate OP,
7644    since the result of extending (signed char)-1 to (int)
7645    is different from (int) OP.  */
7646
7647 tree
7648 get_unwidened (tree op, tree for_type)
7649 {
7650   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
7651   tree type = TREE_TYPE (op);
7652   unsigned final_prec
7653     = TYPE_PRECISION (for_type != 0 ? for_type : type);
7654   int uns
7655     = (for_type != 0 && for_type != type
7656        && final_prec > TYPE_PRECISION (type)
7657        && TYPE_UNSIGNED (type));
7658   tree win = op;
7659
7660   while (CONVERT_EXPR_P (op))
7661     {
7662       int bitschange;
7663
7664       /* TYPE_PRECISION on vector types has different meaning
7665          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
7666          so avoid them here.  */
7667       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
7668         break;
7669
7670       bitschange = TYPE_PRECISION (TREE_TYPE (op))
7671                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
7672
7673       /* Truncations are many-one so cannot be removed.
7674          Unless we are later going to truncate down even farther.  */
7675       if (bitschange < 0
7676           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
7677         break;
7678
7679       /* See what's inside this conversion.  If we decide to strip it,
7680          we will set WIN.  */
7681       op = TREE_OPERAND (op, 0);
7682
7683       /* If we have not stripped any zero-extensions (uns is 0),
7684          we can strip any kind of extension.
7685          If we have previously stripped a zero-extension,
7686          only zero-extensions can safely be stripped.
7687          Any extension can be stripped if the bits it would produce
7688          are all going to be discarded later by truncating to FOR_TYPE.  */
7689
7690       if (bitschange > 0)
7691         {
7692           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
7693             win = op;
7694           /* TYPE_UNSIGNED says whether this is a zero-extension.
7695              Let's avoid computing it if it does not affect WIN
7696              and if UNS will not be needed again.  */
7697           if ((uns
7698                || CONVERT_EXPR_P (op))
7699               && TYPE_UNSIGNED (TREE_TYPE (op)))
7700             {
7701               uns = 1;
7702               win = op;
7703             }
7704         }
7705     }
7706
7707   /* If we finally reach a constant see if it fits in for_type and
7708      in that case convert it.  */
7709   if (for_type
7710       && TREE_CODE (win) == INTEGER_CST
7711       && TREE_TYPE (win) != for_type
7712       && int_fits_type_p (win, for_type))
7713     win = fold_convert (for_type, win);
7714
7715   return win;
7716 }
7717 \f
7718 /* Return OP or a simpler expression for a narrower value
7719    which can be sign-extended or zero-extended to give back OP.
7720    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
7721    or 0 if the value should be sign-extended.  */
7722
7723 tree
7724 get_narrower (tree op, int *unsignedp_ptr)
7725 {
7726   int uns = 0;
7727   int first = 1;
7728   tree win = op;
7729   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
7730
7731   while (TREE_CODE (op) == NOP_EXPR)
7732     {
7733       int bitschange
7734         = (TYPE_PRECISION (TREE_TYPE (op))
7735            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
7736
7737       /* Truncations are many-one so cannot be removed.  */
7738       if (bitschange < 0)
7739         break;
7740
7741       /* See what's inside this conversion.  If we decide to strip it,
7742          we will set WIN.  */
7743
7744       if (bitschange > 0)
7745         {
7746           op = TREE_OPERAND (op, 0);
7747           /* An extension: the outermost one can be stripped,
7748              but remember whether it is zero or sign extension.  */
7749           if (first)
7750             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7751           /* Otherwise, if a sign extension has been stripped,
7752              only sign extensions can now be stripped;
7753              if a zero extension has been stripped, only zero-extensions.  */
7754           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
7755             break;
7756           first = 0;
7757         }
7758       else /* bitschange == 0 */
7759         {
7760           /* A change in nominal type can always be stripped, but we must
7761              preserve the unsignedness.  */
7762           if (first)
7763             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7764           first = 0;
7765           op = TREE_OPERAND (op, 0);
7766           /* Keep trying to narrow, but don't assign op to win if it
7767              would turn an integral type into something else.  */
7768           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
7769             continue;
7770         }
7771
7772       win = op;
7773     }
7774
7775   if (TREE_CODE (op) == COMPONENT_REF
7776       /* Since type_for_size always gives an integer type.  */
7777       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
7778       && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
7779       /* Ensure field is laid out already.  */
7780       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
7781       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
7782     {
7783       unsigned HOST_WIDE_INT innerprec
7784         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
7785       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
7786                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
7787       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
7788
7789       /* We can get this structure field in a narrower type that fits it,
7790          but the resulting extension to its nominal type (a fullword type)
7791          must satisfy the same conditions as for other extensions.
7792
7793          Do this only for fields that are aligned (not bit-fields),
7794          because when bit-field insns will be used there is no
7795          advantage in doing this.  */
7796
7797       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
7798           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
7799           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
7800           && type != 0)
7801         {
7802           if (first)
7803             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
7804           win = fold_convert (type, op);
7805         }
7806     }
7807
7808   *unsignedp_ptr = uns;
7809   return win;
7810 }
7811 \f
7812 /* Nonzero if integer constant C has a value that is permissible
7813    for type TYPE (an INTEGER_TYPE).  */
7814
7815 int
7816 int_fits_type_p (const_tree c, const_tree type)
7817 {
7818   tree type_low_bound, type_high_bound;
7819   bool ok_for_low_bound, ok_for_high_bound, unsc;
7820   double_int dc, dd;
7821
7822   dc = tree_to_double_int (c);
7823   unsc = TYPE_UNSIGNED (TREE_TYPE (c));
7824
7825   if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE
7826       && TYPE_IS_SIZETYPE (TREE_TYPE (c))
7827       && unsc)
7828     /* So c is an unsigned integer whose type is sizetype and type is not.
7829        sizetype'd integers are sign extended even though they are
7830        unsigned. If the integer value fits in the lower end word of c,
7831        and if the higher end word has all its bits set to 1, that
7832        means the higher end bits are set to 1 only for sign extension.
7833        So let's convert c into an equivalent zero extended unsigned
7834        integer.  */
7835     dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c)));
7836
7837 retry:
7838   type_low_bound = TYPE_MIN_VALUE (type);
7839   type_high_bound = TYPE_MAX_VALUE (type);
7840
7841   /* If at least one bound of the type is a constant integer, we can check
7842      ourselves and maybe make a decision. If no such decision is possible, but
7843      this type is a subtype, try checking against that.  Otherwise, use
7844      fit_double_type, which checks against the precision.
7845
7846      Compute the status for each possibly constant bound, and return if we see
7847      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
7848      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
7849      for "constant known to fit".  */
7850
7851   /* Check if c >= type_low_bound.  */
7852   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
7853     {
7854       dd = tree_to_double_int (type_low_bound);
7855       if (TREE_CODE (type) == INTEGER_TYPE
7856           && TYPE_IS_SIZETYPE (type)
7857           && TYPE_UNSIGNED (type))
7858         dd = double_int_zext (dd, TYPE_PRECISION (type));
7859       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
7860         {
7861           int c_neg = (!unsc && double_int_negative_p (dc));
7862           int t_neg = (unsc && double_int_negative_p (dd));
7863
7864           if (c_neg && !t_neg)
7865             return 0;
7866           if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0)
7867             return 0;
7868         }
7869       else if (double_int_cmp (dc, dd, unsc) < 0)
7870         return 0;
7871       ok_for_low_bound = true;
7872     }
7873   else
7874     ok_for_low_bound = false;
7875
7876   /* Check if c <= type_high_bound.  */
7877   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
7878     {
7879       dd = tree_to_double_int (type_high_bound);
7880       if (TREE_CODE (type) == INTEGER_TYPE
7881           && TYPE_IS_SIZETYPE (type)
7882           && TYPE_UNSIGNED (type))
7883         dd = double_int_zext (dd, TYPE_PRECISION (type));
7884       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
7885         {
7886           int c_neg = (!unsc && double_int_negative_p (dc));
7887           int t_neg = (unsc && double_int_negative_p (dd));
7888
7889           if (t_neg && !c_neg)
7890             return 0;
7891           if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0)
7892             return 0;
7893         }
7894       else if (double_int_cmp (dc, dd, unsc) > 0)
7895         return 0;
7896       ok_for_high_bound = true;
7897     }
7898   else
7899     ok_for_high_bound = false;
7900
7901   /* If the constant fits both bounds, the result is known.  */
7902   if (ok_for_low_bound && ok_for_high_bound)
7903     return 1;
7904
7905   /* Perform some generic filtering which may allow making a decision
7906      even if the bounds are not constant.  First, negative integers
7907      never fit in unsigned types, */
7908   if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc))
7909     return 0;
7910
7911   /* Second, narrower types always fit in wider ones.  */
7912   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
7913     return 1;
7914
7915   /* Third, unsigned integers with top bit set never fit signed types.  */
7916   if (! TYPE_UNSIGNED (type) && unsc)
7917     {
7918       int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1;
7919       if (prec < HOST_BITS_PER_WIDE_INT)
7920         {
7921           if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
7922             return 0;
7923         }
7924       else if (((((unsigned HOST_WIDE_INT) 1)
7925                  << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
7926         return 0;
7927     }
7928
7929   /* If we haven't been able to decide at this point, there nothing more we
7930      can check ourselves here.  Look at the base type if we have one and it
7931      has the same precision.  */
7932   if (TREE_CODE (type) == INTEGER_TYPE
7933       && TREE_TYPE (type) != 0
7934       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
7935     {
7936       type = TREE_TYPE (type);
7937       goto retry;
7938     }
7939
7940   /* Or to fit_double_type, if nothing else.  */
7941   return !fit_double_type (dc.low, dc.high, &dc.low, &dc.high, type);
7942 }
7943
7944 /* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
7945    bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
7946    represented (assuming two's-complement arithmetic) within the bit
7947    precision of the type are returned instead.  */
7948
7949 void
7950 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
7951 {
7952   if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
7953       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
7954     mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
7955                         TYPE_UNSIGNED (type));
7956   else
7957     {
7958       if (TYPE_UNSIGNED (type))
7959         mpz_set_ui (min, 0);
7960       else
7961         {
7962           double_int mn;
7963           mn = double_int_mask (TYPE_PRECISION (type) - 1);
7964           mn = double_int_sext (double_int_add (mn, double_int_one),
7965                                 TYPE_PRECISION (type));
7966           mpz_set_double_int (min, mn, false);
7967         }
7968     }
7969
7970   if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
7971       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
7972     mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
7973                         TYPE_UNSIGNED (type));
7974   else
7975     {
7976       if (TYPE_UNSIGNED (type))
7977         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)),
7978                             true);
7979       else
7980         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1),
7981                             true);
7982     }
7983 }
7984
7985 /* Return true if VAR is an automatic variable defined in function FN.  */
7986
7987 bool
7988 auto_var_in_fn_p (const_tree var, const_tree fn)
7989 {
7990   return (DECL_P (var) && DECL_CONTEXT (var) == fn
7991           && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
7992                 || TREE_CODE (var) == PARM_DECL)
7993                && ! TREE_STATIC (var))
7994               || TREE_CODE (var) == LABEL_DECL
7995               || TREE_CODE (var) == RESULT_DECL));
7996 }
7997
7998 /* Subprogram of following function.  Called by walk_tree.
7999
8000    Return *TP if it is an automatic variable or parameter of the
8001    function passed in as DATA.  */
8002
8003 static tree
8004 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8005 {
8006   tree fn = (tree) data;
8007
8008   if (TYPE_P (*tp))
8009     *walk_subtrees = 0;
8010
8011   else if (DECL_P (*tp)
8012            && auto_var_in_fn_p (*tp, fn))
8013     return *tp;
8014
8015   return NULL_TREE;
8016 }
8017
8018 /* Returns true if T is, contains, or refers to a type with variable
8019    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8020    arguments, but not the return type.  If FN is nonzero, only return
8021    true if a modifier of the type or position of FN is a variable or
8022    parameter inside FN.
8023
8024    This concept is more general than that of C99 'variably modified types':
8025    in C99, a struct type is never variably modified because a VLA may not
8026    appear as a structure member.  However, in GNU C code like:
8027
8028      struct S { int i[f()]; };
8029
8030    is valid, and other languages may define similar constructs.  */
8031
8032 bool
8033 variably_modified_type_p (tree type, tree fn)
8034 {
8035   tree t;
8036
8037 /* Test if T is either variable (if FN is zero) or an expression containing
8038    a variable in FN.  */
8039 #define RETURN_TRUE_IF_VAR(T)                                           \
8040   do { tree _t = (T);                                                   \
8041     if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
8042         && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
8043       return true;  } while (0)
8044
8045   if (type == error_mark_node)
8046     return false;
8047
8048   /* If TYPE itself has variable size, it is variably modified.  */
8049   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8050   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8051
8052   switch (TREE_CODE (type))
8053     {
8054     case POINTER_TYPE:
8055     case REFERENCE_TYPE:
8056     case VECTOR_TYPE:
8057       if (variably_modified_type_p (TREE_TYPE (type), fn))
8058         return true;
8059       break;
8060
8061     case FUNCTION_TYPE:
8062     case METHOD_TYPE:
8063       /* If TYPE is a function type, it is variably modified if the
8064          return type is variably modified.  */
8065       if (variably_modified_type_p (TREE_TYPE (type), fn))
8066           return true;
8067       break;
8068
8069     case INTEGER_TYPE:
8070     case REAL_TYPE:
8071     case FIXED_POINT_TYPE:
8072     case ENUMERAL_TYPE:
8073     case BOOLEAN_TYPE:
8074       /* Scalar types are variably modified if their end points
8075          aren't constant.  */
8076       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8077       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8078       break;
8079
8080     case RECORD_TYPE:
8081     case UNION_TYPE:
8082     case QUAL_UNION_TYPE:
8083       /* We can't see if any of the fields are variably-modified by the
8084          definition we normally use, since that would produce infinite
8085          recursion via pointers.  */
8086       /* This is variably modified if some field's type is.  */
8087       for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
8088         if (TREE_CODE (t) == FIELD_DECL)
8089           {
8090             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8091             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8092             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8093
8094             if (TREE_CODE (type) == QUAL_UNION_TYPE)
8095               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8096           }
8097         break;
8098
8099     case ARRAY_TYPE:
8100       /* Do not call ourselves to avoid infinite recursion.  This is
8101          variably modified if the element type is.  */
8102       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8103       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8104       break;
8105
8106     default:
8107       break;
8108     }
8109
8110   /* The current language may have other cases to check, but in general,
8111      all other types are not variably modified.  */
8112   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8113
8114 #undef RETURN_TRUE_IF_VAR
8115 }
8116
8117 /* Given a DECL or TYPE, return the scope in which it was declared, or
8118    NULL_TREE if there is no containing scope.  */
8119
8120 tree
8121 get_containing_scope (const_tree t)
8122 {
8123   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8124 }
8125
8126 /* Return the innermost context enclosing DECL that is
8127    a FUNCTION_DECL, or zero if none.  */
8128
8129 tree
8130 decl_function_context (const_tree decl)
8131 {
8132   tree context;
8133
8134   if (TREE_CODE (decl) == ERROR_MARK)
8135     return 0;
8136
8137   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8138      where we look up the function at runtime.  Such functions always take
8139      a first argument of type 'pointer to real context'.
8140
8141      C++ should really be fixed to use DECL_CONTEXT for the real context,
8142      and use something else for the "virtual context".  */
8143   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8144     context
8145       = TYPE_MAIN_VARIANT
8146         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8147   else
8148     context = DECL_CONTEXT (decl);
8149
8150   while (context && TREE_CODE (context) != FUNCTION_DECL)
8151     {
8152       if (TREE_CODE (context) == BLOCK)
8153         context = BLOCK_SUPERCONTEXT (context);
8154       else
8155         context = get_containing_scope (context);
8156     }
8157
8158   return context;
8159 }
8160
8161 /* Return the innermost context enclosing DECL that is
8162    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8163    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
8164
8165 tree
8166 decl_type_context (const_tree decl)
8167 {
8168   tree context = DECL_CONTEXT (decl);
8169
8170   while (context)
8171     switch (TREE_CODE (context))
8172       {
8173       case NAMESPACE_DECL:
8174       case TRANSLATION_UNIT_DECL:
8175         return NULL_TREE;
8176
8177       case RECORD_TYPE:
8178       case UNION_TYPE:
8179       case QUAL_UNION_TYPE:
8180         return context;
8181
8182       case TYPE_DECL:
8183       case FUNCTION_DECL:
8184         context = DECL_CONTEXT (context);
8185         break;
8186
8187       case BLOCK:
8188         context = BLOCK_SUPERCONTEXT (context);
8189         break;
8190
8191       default:
8192         gcc_unreachable ();
8193       }
8194
8195   return NULL_TREE;
8196 }
8197
8198 /* CALL is a CALL_EXPR.  Return the declaration for the function
8199    called, or NULL_TREE if the called function cannot be
8200    determined.  */
8201
8202 tree
8203 get_callee_fndecl (const_tree call)
8204 {
8205   tree addr;
8206
8207   if (call == error_mark_node)
8208     return error_mark_node;
8209
8210   /* It's invalid to call this function with anything but a
8211      CALL_EXPR.  */
8212   gcc_assert (TREE_CODE (call) == CALL_EXPR);
8213
8214   /* The first operand to the CALL is the address of the function
8215      called.  */
8216   addr = CALL_EXPR_FN (call);
8217
8218   STRIP_NOPS (addr);
8219
8220   /* If this is a readonly function pointer, extract its initial value.  */
8221   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8222       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8223       && DECL_INITIAL (addr))
8224     addr = DECL_INITIAL (addr);
8225
8226   /* If the address is just `&f' for some function `f', then we know
8227      that `f' is being called.  */
8228   if (TREE_CODE (addr) == ADDR_EXPR
8229       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8230     return TREE_OPERAND (addr, 0);
8231
8232   /* We couldn't figure out what was being called.  */
8233   return NULL_TREE;
8234 }
8235
8236 /* Print debugging information about tree nodes generated during the compile,
8237    and any language-specific information.  */
8238
8239 void
8240 dump_tree_statistics (void)
8241 {
8242 #ifdef GATHER_STATISTICS
8243   int i;
8244   int total_nodes, total_bytes;
8245 #endif
8246
8247   fprintf (stderr, "\n??? tree nodes created\n\n");
8248 #ifdef GATHER_STATISTICS
8249   fprintf (stderr, "Kind                   Nodes      Bytes\n");
8250   fprintf (stderr, "---------------------------------------\n");
8251   total_nodes = total_bytes = 0;
8252   for (i = 0; i < (int) all_kinds; i++)
8253     {
8254       fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8255                tree_node_counts[i], tree_node_sizes[i]);
8256       total_nodes += tree_node_counts[i];
8257       total_bytes += tree_node_sizes[i];
8258     }
8259   fprintf (stderr, "---------------------------------------\n");
8260   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8261   fprintf (stderr, "---------------------------------------\n");
8262   ssanames_print_statistics ();
8263   phinodes_print_statistics ();
8264 #else
8265   fprintf (stderr, "(No per-node statistics)\n");
8266 #endif
8267   print_type_hash_statistics ();
8268   print_debug_expr_statistics ();
8269   print_value_expr_statistics ();
8270   lang_hooks.print_statistics ();
8271 }
8272 \f
8273 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8274
8275 /* Generate a crc32 of a string.  */
8276
8277 unsigned
8278 crc32_string (unsigned chksum, const char *string)
8279 {
8280   do
8281     {
8282       unsigned value = *string << 24;
8283       unsigned ix;
8284
8285       for (ix = 8; ix--; value <<= 1)
8286         {
8287           unsigned feedback;
8288
8289           feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
8290           chksum <<= 1;
8291           chksum ^= feedback;
8292         }
8293     }
8294   while (*string++);
8295   return chksum;
8296 }
8297
8298 /* P is a string that will be used in a symbol.  Mask out any characters
8299    that are not valid in that context.  */
8300
8301 void
8302 clean_symbol_name (char *p)
8303 {
8304   for (; *p; p++)
8305     if (! (ISALNUM (*p)
8306 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
8307             || *p == '$'
8308 #endif
8309 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
8310             || *p == '.'
8311 #endif
8312            ))
8313       *p = '_';
8314 }
8315
8316 /* Generate a name for a special-purpose function function.
8317    The generated name may need to be unique across the whole link.
8318    TYPE is some string to identify the purpose of this function to the
8319    linker or collect2; it must start with an uppercase letter,
8320    one of:
8321    I - for constructors
8322    D - for destructors
8323    N - for C++ anonymous namespaces
8324    F - for DWARF unwind frame information.  */
8325
8326 tree
8327 get_file_function_name (const char *type)
8328 {
8329   char *buf;
8330   const char *p;
8331   char *q;
8332
8333   /* If we already have a name we know to be unique, just use that.  */
8334   if (first_global_object_name)
8335     p = q = ASTRDUP (first_global_object_name);
8336   /* If the target is handling the constructors/destructors, they
8337      will be local to this file and the name is only necessary for
8338      debugging purposes.  */
8339   else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
8340     {
8341       const char *file = main_input_filename;
8342       if (! file)
8343         file = input_filename;
8344       /* Just use the file's basename, because the full pathname
8345          might be quite long.  */
8346       p = strrchr (file, '/');
8347       if (p)
8348         p++;
8349       else
8350         p = file;
8351       p = q = ASTRDUP (p);
8352     }
8353   else
8354     {
8355       /* Otherwise, the name must be unique across the entire link.
8356          We don't have anything that we know to be unique to this translation
8357          unit, so use what we do have and throw in some randomness.  */
8358       unsigned len;
8359       const char *name = weak_global_object_name;
8360       const char *file = main_input_filename;
8361
8362       if (! name)
8363         name = "";
8364       if (! file)
8365         file = input_filename;
8366
8367       len = strlen (file);
8368       q = (char *) alloca (9 * 2 + len + 1);
8369       memcpy (q, file, len + 1);
8370
8371       sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
8372                crc32_string (0, get_random_seed (false)));
8373
8374       p = q;
8375     }
8376
8377   clean_symbol_name (q);
8378   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
8379                          + strlen (type));
8380
8381   /* Set up the name of the file-level functions we may need.
8382      Use a global object (which is already required to be unique over
8383      the program) rather than the file name (which imposes extra
8384      constraints).  */
8385   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
8386
8387   return get_identifier (buf);
8388 }
8389 \f
8390 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8391
8392 /* Complain that the tree code of NODE does not match the expected 0
8393    terminated list of trailing codes. The trailing code list can be
8394    empty, for a more vague error message.  FILE, LINE, and FUNCTION
8395    are of the caller.  */
8396
8397 void
8398 tree_check_failed (const_tree node, const char *file,
8399                    int line, const char *function, ...)
8400 {
8401   va_list args;
8402   const char *buffer;
8403   unsigned length = 0;
8404   int code;
8405
8406   va_start (args, function);
8407   while ((code = va_arg (args, int)))
8408     length += 4 + strlen (tree_code_name[code]);
8409   va_end (args);
8410   if (length)
8411     {
8412       char *tmp;
8413       va_start (args, function);
8414       length += strlen ("expected ");
8415       buffer = tmp = (char *) alloca (length);
8416       length = 0;
8417       while ((code = va_arg (args, int)))
8418         {
8419           const char *prefix = length ? " or " : "expected ";
8420
8421           strcpy (tmp + length, prefix);
8422           length += strlen (prefix);
8423           strcpy (tmp + length, tree_code_name[code]);
8424           length += strlen (tree_code_name[code]);
8425         }
8426       va_end (args);
8427     }
8428   else
8429     buffer = "unexpected node";
8430
8431   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8432                   buffer, tree_code_name[TREE_CODE (node)],
8433                   function, trim_filename (file), line);
8434 }
8435
8436 /* Complain that the tree code of NODE does match the expected 0
8437    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8438    the caller.  */
8439
8440 void
8441 tree_not_check_failed (const_tree node, const char *file,
8442                        int line, const char *function, ...)
8443 {
8444   va_list args;
8445   char *buffer;
8446   unsigned length = 0;
8447   int code;
8448
8449   va_start (args, function);
8450   while ((code = va_arg (args, int)))
8451     length += 4 + strlen (tree_code_name[code]);
8452   va_end (args);
8453   va_start (args, function);
8454   buffer = (char *) alloca (length);
8455   length = 0;
8456   while ((code = va_arg (args, int)))
8457     {
8458       if (length)
8459         {
8460           strcpy (buffer + length, " or ");
8461           length += 4;
8462         }
8463       strcpy (buffer + length, tree_code_name[code]);
8464       length += strlen (tree_code_name[code]);
8465     }
8466   va_end (args);
8467
8468   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8469                   buffer, tree_code_name[TREE_CODE (node)],
8470                   function, trim_filename (file), line);
8471 }
8472
8473 /* Similar to tree_check_failed, except that we check for a class of tree
8474    code, given in CL.  */
8475
8476 void
8477 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
8478                          const char *file, int line, const char *function)
8479 {
8480   internal_error
8481     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8482      TREE_CODE_CLASS_STRING (cl),
8483      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8484      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8485 }
8486
8487 /* Similar to tree_check_failed, except that instead of specifying a
8488    dozen codes, use the knowledge that they're all sequential.  */
8489
8490 void
8491 tree_range_check_failed (const_tree node, const char *file, int line,
8492                          const char *function, enum tree_code c1,
8493                          enum tree_code c2)
8494 {
8495   char *buffer;
8496   unsigned length = 0;
8497   unsigned int c;
8498
8499   for (c = c1; c <= c2; ++c)
8500     length += 4 + strlen (tree_code_name[c]);
8501
8502   length += strlen ("expected ");
8503   buffer = (char *) alloca (length);
8504   length = 0;
8505
8506   for (c = c1; c <= c2; ++c)
8507     {
8508       const char *prefix = length ? " or " : "expected ";
8509
8510       strcpy (buffer + length, prefix);
8511       length += strlen (prefix);
8512       strcpy (buffer + length, tree_code_name[c]);
8513       length += strlen (tree_code_name[c]);
8514     }
8515
8516   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8517                   buffer, tree_code_name[TREE_CODE (node)],
8518                   function, trim_filename (file), line);
8519 }
8520
8521
8522 /* Similar to tree_check_failed, except that we check that a tree does
8523    not have the specified code, given in CL.  */
8524
8525 void
8526 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
8527                              const char *file, int line, const char *function)
8528 {
8529   internal_error
8530     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8531      TREE_CODE_CLASS_STRING (cl),
8532      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8533      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8534 }
8535
8536
8537 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
8538
8539 void
8540 omp_clause_check_failed (const_tree node, const char *file, int line,
8541                          const char *function, enum omp_clause_code code)
8542 {
8543   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8544                   omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
8545                   function, trim_filename (file), line);
8546 }
8547
8548
8549 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
8550
8551 void
8552 omp_clause_range_check_failed (const_tree node, const char *file, int line,
8553                                const char *function, enum omp_clause_code c1,
8554                                enum omp_clause_code c2)
8555 {
8556   char *buffer;
8557   unsigned length = 0;
8558   unsigned int c;
8559
8560   for (c = c1; c <= c2; ++c)
8561     length += 4 + strlen (omp_clause_code_name[c]);
8562
8563   length += strlen ("expected ");
8564   buffer = (char *) alloca (length);
8565   length = 0;
8566
8567   for (c = c1; c <= c2; ++c)
8568     {
8569       const char *prefix = length ? " or " : "expected ";
8570
8571       strcpy (buffer + length, prefix);
8572       length += strlen (prefix);
8573       strcpy (buffer + length, omp_clause_code_name[c]);
8574       length += strlen (omp_clause_code_name[c]);
8575     }
8576
8577   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8578                   buffer, omp_clause_code_name[TREE_CODE (node)],
8579                   function, trim_filename (file), line);
8580 }
8581
8582
8583 #undef DEFTREESTRUCT
8584 #define DEFTREESTRUCT(VAL, NAME) NAME,
8585
8586 static const char *ts_enum_names[] = {
8587 #include "treestruct.def"
8588 };
8589 #undef DEFTREESTRUCT
8590
8591 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8592
8593 /* Similar to tree_class_check_failed, except that we check for
8594    whether CODE contains the tree structure identified by EN.  */
8595
8596 void
8597 tree_contains_struct_check_failed (const_tree node,
8598                                    const enum tree_node_structure_enum en,
8599                                    const char *file, int line,
8600                                    const char *function)
8601 {
8602   internal_error
8603     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8604      TS_ENUM_NAME(en),
8605      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8606 }
8607
8608
8609 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
8610    (dynamically sized) vector.  */
8611
8612 void
8613 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
8614                            const char *function)
8615 {
8616   internal_error
8617     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8618      idx + 1, len, function, trim_filename (file), line);
8619 }
8620
8621 /* Similar to above, except that the check is for the bounds of the operand
8622    vector of an expression node EXP.  */
8623
8624 void
8625 tree_operand_check_failed (int idx, const_tree exp, const char *file,
8626                            int line, const char *function)
8627 {
8628   int code = TREE_CODE (exp);
8629   internal_error
8630     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8631      idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
8632      function, trim_filename (file), line);
8633 }
8634
8635 /* Similar to above, except that the check is for the number of
8636    operands of an OMP_CLAUSE node.  */
8637
8638 void
8639 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
8640                                  int line, const char *function)
8641 {
8642   internal_error
8643     ("tree check: accessed operand %d of omp_clause %s with %d operands "
8644      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
8645      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
8646      trim_filename (file), line);
8647 }
8648 #endif /* ENABLE_TREE_CHECKING */
8649 \f
8650 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8651    and mapped to the machine mode MODE.  Initialize its fields and build
8652    the information necessary for debugging output.  */
8653
8654 static tree
8655 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
8656 {
8657   tree t;
8658   hashval_t hashcode = 0;
8659
8660   t = make_node (VECTOR_TYPE);
8661   TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
8662   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
8663   SET_TYPE_MODE (t, mode);
8664
8665   if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
8666     SET_TYPE_STRUCTURAL_EQUALITY (t);
8667   else if (TYPE_CANONICAL (innertype) != innertype
8668            || mode != VOIDmode)
8669     TYPE_CANONICAL (t)
8670       = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
8671
8672   layout_type (t);
8673
8674   {
8675     tree index = build_int_cst (NULL_TREE, nunits - 1);
8676     tree array = build_array_type (TYPE_MAIN_VARIANT (innertype),
8677                                    build_index_type (index));
8678     tree rt = make_node (RECORD_TYPE);
8679
8680     TYPE_FIELDS (rt) = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
8681                                    get_identifier ("f"), array);
8682     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
8683     layout_type (rt);
8684     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
8685     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
8686        the representation type, and we want to find that die when looking up
8687        the vector type.  This is most easily achieved by making the TYPE_UID
8688        numbers equal.  */
8689     TYPE_UID (rt) = TYPE_UID (t);
8690   }
8691
8692   hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
8693   hashcode = iterative_hash_host_wide_int (nunits, hashcode);
8694   hashcode = iterative_hash_host_wide_int (mode, hashcode);
8695   hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
8696   t = type_hash_canon (hashcode, t);
8697
8698   /* We have built a main variant, based on the main variant of the
8699      inner type. Use it to build the variant we return.  */
8700   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
8701       && TREE_TYPE (t) != innertype)
8702     return build_type_attribute_qual_variant (t,
8703                                               TYPE_ATTRIBUTES (innertype),
8704                                               TYPE_QUALS (innertype));
8705
8706   return t;
8707 }
8708
8709 static tree
8710 make_or_reuse_type (unsigned size, int unsignedp)
8711 {
8712   if (size == INT_TYPE_SIZE)
8713     return unsignedp ? unsigned_type_node : integer_type_node;
8714   if (size == CHAR_TYPE_SIZE)
8715     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
8716   if (size == SHORT_TYPE_SIZE)
8717     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
8718   if (size == LONG_TYPE_SIZE)
8719     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
8720   if (size == LONG_LONG_TYPE_SIZE)
8721     return (unsignedp ? long_long_unsigned_type_node
8722             : long_long_integer_type_node);
8723
8724   if (unsignedp)
8725     return make_unsigned_type (size);
8726   else
8727     return make_signed_type (size);
8728 }
8729
8730 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
8731
8732 static tree
8733 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
8734 {
8735   if (satp)
8736     {
8737       if (size == SHORT_FRACT_TYPE_SIZE)
8738         return unsignedp ? sat_unsigned_short_fract_type_node
8739                          : sat_short_fract_type_node;
8740       if (size == FRACT_TYPE_SIZE)
8741         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
8742       if (size == LONG_FRACT_TYPE_SIZE)
8743         return unsignedp ? sat_unsigned_long_fract_type_node
8744                          : sat_long_fract_type_node;
8745       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8746         return unsignedp ? sat_unsigned_long_long_fract_type_node
8747                          : sat_long_long_fract_type_node;
8748     }
8749   else
8750     {
8751       if (size == SHORT_FRACT_TYPE_SIZE)
8752         return unsignedp ? unsigned_short_fract_type_node
8753                          : short_fract_type_node;
8754       if (size == FRACT_TYPE_SIZE)
8755         return unsignedp ? unsigned_fract_type_node : fract_type_node;
8756       if (size == LONG_FRACT_TYPE_SIZE)
8757         return unsignedp ? unsigned_long_fract_type_node
8758                          : long_fract_type_node;
8759       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8760         return unsignedp ? unsigned_long_long_fract_type_node
8761                          : long_long_fract_type_node;
8762     }
8763
8764   return make_fract_type (size, unsignedp, satp);
8765 }
8766
8767 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
8768
8769 static tree
8770 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
8771 {
8772   if (satp)
8773     {
8774       if (size == SHORT_ACCUM_TYPE_SIZE)
8775         return unsignedp ? sat_unsigned_short_accum_type_node
8776                          : sat_short_accum_type_node;
8777       if (size == ACCUM_TYPE_SIZE)
8778         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
8779       if (size == LONG_ACCUM_TYPE_SIZE)
8780         return unsignedp ? sat_unsigned_long_accum_type_node
8781                          : sat_long_accum_type_node;
8782       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8783         return unsignedp ? sat_unsigned_long_long_accum_type_node
8784                          : sat_long_long_accum_type_node;
8785     }
8786   else
8787     {
8788       if (size == SHORT_ACCUM_TYPE_SIZE)
8789         return unsignedp ? unsigned_short_accum_type_node
8790                          : short_accum_type_node;
8791       if (size == ACCUM_TYPE_SIZE)
8792         return unsignedp ? unsigned_accum_type_node : accum_type_node;
8793       if (size == LONG_ACCUM_TYPE_SIZE)
8794         return unsignedp ? unsigned_long_accum_type_node
8795                          : long_accum_type_node;
8796       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8797         return unsignedp ? unsigned_long_long_accum_type_node
8798                          : long_long_accum_type_node;
8799     }
8800
8801   return make_accum_type (size, unsignedp, satp);
8802 }
8803
8804 /* Create nodes for all integer types (and error_mark_node) using the sizes
8805    of C datatypes.  The caller should call set_sizetype soon after calling
8806    this function to select one of the types as sizetype.  */
8807
8808 void
8809 build_common_tree_nodes (bool signed_char)
8810 {
8811   error_mark_node = make_node (ERROR_MARK);
8812   TREE_TYPE (error_mark_node) = error_mark_node;
8813
8814   initialize_sizetypes ();
8815
8816   /* Define both `signed char' and `unsigned char'.  */
8817   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
8818   TYPE_STRING_FLAG (signed_char_type_node) = 1;
8819   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
8820   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
8821
8822   /* Define `char', which is like either `signed char' or `unsigned char'
8823      but not the same as either.  */
8824   char_type_node
8825     = (signed_char
8826        ? make_signed_type (CHAR_TYPE_SIZE)
8827        : make_unsigned_type (CHAR_TYPE_SIZE));
8828   TYPE_STRING_FLAG (char_type_node) = 1;
8829
8830   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
8831   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
8832   integer_type_node = make_signed_type (INT_TYPE_SIZE);
8833   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
8834   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
8835   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
8836   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
8837   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
8838
8839   /* Define a boolean type.  This type only represents boolean values but
8840      may be larger than char depending on the value of BOOL_TYPE_SIZE.
8841      Front ends which want to override this size (i.e. Java) can redefine
8842      boolean_type_node before calling build_common_tree_nodes_2.  */
8843   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
8844   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
8845   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
8846   TYPE_PRECISION (boolean_type_node) = 1;
8847
8848   /* Fill in the rest of the sized types.  Reuse existing type nodes
8849      when possible.  */
8850   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
8851   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
8852   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
8853   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
8854   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
8855
8856   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
8857   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
8858   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
8859   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
8860   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
8861
8862   access_public_node = get_identifier ("public");
8863   access_protected_node = get_identifier ("protected");
8864   access_private_node = get_identifier ("private");
8865 }
8866
8867 /* Call this function after calling build_common_tree_nodes and set_sizetype.
8868    It will create several other common tree nodes.  */
8869
8870 void
8871 build_common_tree_nodes_2 (int short_double)
8872 {
8873   /* Define these next since types below may used them.  */
8874   integer_zero_node = build_int_cst (NULL_TREE, 0);
8875   integer_one_node = build_int_cst (NULL_TREE, 1);
8876   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
8877
8878   size_zero_node = size_int (0);
8879   size_one_node = size_int (1);
8880   bitsize_zero_node = bitsize_int (0);
8881   bitsize_one_node = bitsize_int (1);
8882   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
8883
8884   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
8885   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
8886
8887   void_type_node = make_node (VOID_TYPE);
8888   layout_type (void_type_node);
8889
8890   /* We are not going to have real types in C with less than byte alignment,
8891      so we might as well not have any types that claim to have it.  */
8892   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
8893   TYPE_USER_ALIGN (void_type_node) = 0;
8894
8895   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
8896   layout_type (TREE_TYPE (null_pointer_node));
8897
8898   ptr_type_node = build_pointer_type (void_type_node);
8899   const_ptr_type_node
8900     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
8901   fileptr_type_node = ptr_type_node;
8902
8903   float_type_node = make_node (REAL_TYPE);
8904   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
8905   layout_type (float_type_node);
8906
8907   double_type_node = make_node (REAL_TYPE);
8908   if (short_double)
8909     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
8910   else
8911     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
8912   layout_type (double_type_node);
8913
8914   long_double_type_node = make_node (REAL_TYPE);
8915   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
8916   layout_type (long_double_type_node);
8917
8918   float_ptr_type_node = build_pointer_type (float_type_node);
8919   double_ptr_type_node = build_pointer_type (double_type_node);
8920   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
8921   integer_ptr_type_node = build_pointer_type (integer_type_node);
8922
8923   /* Fixed size integer types.  */
8924   uint32_type_node = build_nonstandard_integer_type (32, true);
8925   uint64_type_node = build_nonstandard_integer_type (64, true);
8926
8927   /* Decimal float types. */
8928   dfloat32_type_node = make_node (REAL_TYPE);
8929   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
8930   layout_type (dfloat32_type_node);
8931   SET_TYPE_MODE (dfloat32_type_node, SDmode);
8932   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
8933
8934   dfloat64_type_node = make_node (REAL_TYPE);
8935   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
8936   layout_type (dfloat64_type_node);
8937   SET_TYPE_MODE (dfloat64_type_node, DDmode);
8938   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
8939
8940   dfloat128_type_node = make_node (REAL_TYPE);
8941   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
8942   layout_type (dfloat128_type_node);
8943   SET_TYPE_MODE (dfloat128_type_node, TDmode);
8944   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
8945
8946   complex_integer_type_node = build_complex_type (integer_type_node);
8947   complex_float_type_node = build_complex_type (float_type_node);
8948   complex_double_type_node = build_complex_type (double_type_node);
8949   complex_long_double_type_node = build_complex_type (long_double_type_node);
8950
8951 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
8952 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
8953   sat_ ## KIND ## _type_node = \
8954     make_sat_signed_ ## KIND ## _type (SIZE); \
8955   sat_unsigned_ ## KIND ## _type_node = \
8956     make_sat_unsigned_ ## KIND ## _type (SIZE); \
8957   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8958   unsigned_ ## KIND ## _type_node = \
8959     make_unsigned_ ## KIND ## _type (SIZE);
8960
8961 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
8962   sat_ ## WIDTH ## KIND ## _type_node = \
8963     make_sat_signed_ ## KIND ## _type (SIZE); \
8964   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
8965     make_sat_unsigned_ ## KIND ## _type (SIZE); \
8966   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8967   unsigned_ ## WIDTH ## KIND ## _type_node = \
8968     make_unsigned_ ## KIND ## _type (SIZE);
8969
8970 /* Make fixed-point type nodes based on four different widths.  */
8971 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
8972   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
8973   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
8974   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
8975   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
8976
8977 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
8978 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
8979   NAME ## _type_node = \
8980     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
8981   u ## NAME ## _type_node = \
8982     make_or_reuse_unsigned_ ## KIND ## _type \
8983       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
8984   sat_ ## NAME ## _type_node = \
8985     make_or_reuse_sat_signed_ ## KIND ## _type \
8986       (GET_MODE_BITSIZE (MODE ## mode)); \
8987   sat_u ## NAME ## _type_node = \
8988     make_or_reuse_sat_unsigned_ ## KIND ## _type \
8989       (GET_MODE_BITSIZE (U ## MODE ## mode));
8990
8991   /* Fixed-point type and mode nodes.  */
8992   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
8993   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
8994   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
8995   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
8996   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
8997   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
8998   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
8999   MAKE_FIXED_MODE_NODE (accum, ha, HA)
9000   MAKE_FIXED_MODE_NODE (accum, sa, SA)
9001   MAKE_FIXED_MODE_NODE (accum, da, DA)
9002   MAKE_FIXED_MODE_NODE (accum, ta, TA)
9003
9004   {
9005     tree t = targetm.build_builtin_va_list ();
9006
9007     /* Many back-ends define record types without setting TYPE_NAME.
9008        If we copied the record type here, we'd keep the original
9009        record type without a name.  This breaks name mangling.  So,
9010        don't copy record types and let c_common_nodes_and_builtins()
9011        declare the type to be __builtin_va_list.  */
9012     if (TREE_CODE (t) != RECORD_TYPE)
9013       t = build_variant_type_copy (t);
9014
9015     va_list_type_node = t;
9016   }
9017 }
9018
9019 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
9020
9021 static void
9022 local_define_builtin (const char *name, tree type, enum built_in_function code,
9023                       const char *library_name, int ecf_flags)
9024 {
9025   tree decl;
9026
9027   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
9028                                library_name, NULL_TREE);
9029   if (ecf_flags & ECF_CONST)
9030     TREE_READONLY (decl) = 1;
9031   if (ecf_flags & ECF_PURE)
9032     DECL_PURE_P (decl) = 1;
9033   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
9034     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
9035   if (ecf_flags & ECF_NORETURN)
9036     TREE_THIS_VOLATILE (decl) = 1;
9037   if (ecf_flags & ECF_NOTHROW)
9038     TREE_NOTHROW (decl) = 1;
9039   if (ecf_flags & ECF_MALLOC)
9040     DECL_IS_MALLOC (decl) = 1;
9041
9042   built_in_decls[code] = decl;
9043   implicit_built_in_decls[code] = decl;
9044 }
9045
9046 /* Call this function after instantiating all builtins that the language
9047    front end cares about.  This will build the rest of the builtins that
9048    are relied upon by the tree optimizers and the middle-end.  */
9049
9050 void
9051 build_common_builtin_nodes (void)
9052 {
9053   tree tmp, tmp2, ftype;
9054
9055   if (built_in_decls[BUILT_IN_MEMCPY] == NULL
9056       || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9057     {
9058       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9059       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9060       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9061       ftype = build_function_type (ptr_type_node, tmp);
9062
9063       if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
9064         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9065                               "memcpy", ECF_NOTHROW);
9066       if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9067         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9068                               "memmove", ECF_NOTHROW);
9069     }
9070
9071   if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
9072     {
9073       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9074       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9075       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9076       ftype = build_function_type (integer_type_node, tmp);
9077       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9078                             "memcmp", ECF_PURE | ECF_NOTHROW);
9079     }
9080
9081   if (built_in_decls[BUILT_IN_MEMSET] == NULL)
9082     {
9083       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9084       tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9085       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9086       ftype = build_function_type (ptr_type_node, tmp);
9087       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9088                             "memset", ECF_NOTHROW);
9089     }
9090
9091   if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
9092     {
9093       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9094       ftype = build_function_type (ptr_type_node, tmp);
9095       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
9096                             "alloca", ECF_MALLOC | ECF_NOTHROW);
9097     }
9098
9099   /* If we're checking the stack, `alloca' can throw.  */
9100   if (flag_stack_check)
9101     TREE_NOTHROW (built_in_decls[BUILT_IN_ALLOCA]) = 0;
9102
9103   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9104   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9105   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9106   ftype = build_function_type (void_type_node, tmp);
9107   local_define_builtin ("__builtin_init_trampoline", ftype,
9108                         BUILT_IN_INIT_TRAMPOLINE,
9109                         "__builtin_init_trampoline", ECF_NOTHROW);
9110
9111   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9112   ftype = build_function_type (ptr_type_node, tmp);
9113   local_define_builtin ("__builtin_adjust_trampoline", ftype,
9114                         BUILT_IN_ADJUST_TRAMPOLINE,
9115                         "__builtin_adjust_trampoline",
9116                         ECF_CONST | ECF_NOTHROW);
9117
9118   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9119   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9120   ftype = build_function_type (void_type_node, tmp);
9121   local_define_builtin ("__builtin_nonlocal_goto", ftype,
9122                         BUILT_IN_NONLOCAL_GOTO,
9123                         "__builtin_nonlocal_goto",
9124                         ECF_NORETURN | ECF_NOTHROW);
9125
9126   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9127   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9128   ftype = build_function_type (void_type_node, tmp);
9129   local_define_builtin ("__builtin_setjmp_setup", ftype,
9130                         BUILT_IN_SETJMP_SETUP,
9131                         "__builtin_setjmp_setup", ECF_NOTHROW);
9132
9133   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9134   ftype = build_function_type (ptr_type_node, tmp);
9135   local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
9136                         BUILT_IN_SETJMP_DISPATCHER,
9137                         "__builtin_setjmp_dispatcher",
9138                         ECF_PURE | ECF_NOTHROW);
9139
9140   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9141   ftype = build_function_type (void_type_node, tmp);
9142   local_define_builtin ("__builtin_setjmp_receiver", ftype,
9143                         BUILT_IN_SETJMP_RECEIVER,
9144                         "__builtin_setjmp_receiver", ECF_NOTHROW);
9145
9146   ftype = build_function_type (ptr_type_node, void_list_node);
9147   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
9148                         "__builtin_stack_save", ECF_NOTHROW);
9149
9150   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9151   ftype = build_function_type (void_type_node, tmp);
9152   local_define_builtin ("__builtin_stack_restore", ftype,
9153                         BUILT_IN_STACK_RESTORE,
9154                         "__builtin_stack_restore", ECF_NOTHROW);
9155
9156   ftype = build_function_type (void_type_node, void_list_node);
9157   local_define_builtin ("__builtin_profile_func_enter", ftype,
9158                         BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
9159   local_define_builtin ("__builtin_profile_func_exit", ftype,
9160                         BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
9161
9162   /* If there's a possibility that we might use the ARM EABI, build the
9163     alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
9164   if (targetm.arm_eabi_unwinder)
9165     {
9166       ftype = build_function_type (void_type_node, void_list_node);
9167       local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
9168                             BUILT_IN_CXA_END_CLEANUP,
9169                             "__cxa_end_cleanup", ECF_NORETURN);
9170     }
9171
9172   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9173   ftype = build_function_type (void_type_node, tmp);
9174   local_define_builtin ("__builtin_unwind_resume", ftype,
9175                         BUILT_IN_UNWIND_RESUME,
9176                         (USING_SJLJ_EXCEPTIONS
9177                          ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9178                         ECF_NORETURN);
9179
9180   /* The exception object and filter values from the runtime.  The argument
9181      must be zero before exception lowering, i.e. from the front end.  After
9182      exception lowering, it will be the region number for the exception
9183      landing pad.  These functions are PURE instead of CONST to prevent
9184      them from being hoisted past the exception edge that will initialize
9185      its value in the landing pad.  */
9186   tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9187   ftype = build_function_type (ptr_type_node, tmp);
9188   local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
9189                         "__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW);
9190
9191   tmp2 = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
9192   ftype = build_function_type (tmp2, tmp);
9193   local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
9194                         "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW);
9195
9196   tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9197   tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9198   ftype = build_function_type (void_type_node, tmp);
9199   local_define_builtin ("__builtin_eh_copy_values", ftype,
9200                         BUILT_IN_EH_COPY_VALUES,
9201                         "__builtin_eh_copy_values", ECF_NOTHROW);
9202
9203   /* Complex multiplication and division.  These are handled as builtins
9204      rather than optabs because emit_library_call_value doesn't support
9205      complex.  Further, we can do slightly better with folding these
9206      beasties if the real and complex parts of the arguments are separate.  */
9207   {
9208     int mode;
9209
9210     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
9211       {
9212         char mode_name_buf[4], *q;
9213         const char *p;
9214         enum built_in_function mcode, dcode;
9215         tree type, inner_type;
9216
9217         type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
9218         if (type == NULL)
9219           continue;
9220         inner_type = TREE_TYPE (type);
9221
9222         tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
9223         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9224         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9225         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9226         ftype = build_function_type (type, tmp);
9227
9228         mcode = ((enum built_in_function)
9229                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9230         dcode = ((enum built_in_function)
9231                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9232
9233         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
9234           *q = TOLOWER (*p);
9235         *q = '\0';
9236
9237         built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
9238         local_define_builtin (built_in_names[mcode], ftype, mcode,
9239                               built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
9240
9241         built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
9242         local_define_builtin (built_in_names[dcode], ftype, dcode,
9243                               built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
9244       }
9245   }
9246 }
9247
9248 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
9249    better way.
9250
9251    If we requested a pointer to a vector, build up the pointers that
9252    we stripped off while looking for the inner type.  Similarly for
9253    return values from functions.
9254
9255    The argument TYPE is the top of the chain, and BOTTOM is the
9256    new type which we will point to.  */
9257
9258 tree
9259 reconstruct_complex_type (tree type, tree bottom)
9260 {
9261   tree inner, outer;
9262
9263   if (TREE_CODE (type) == POINTER_TYPE)
9264     {
9265       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9266       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
9267                                            TYPE_REF_CAN_ALIAS_ALL (type));
9268     }
9269   else if (TREE_CODE (type) == REFERENCE_TYPE)
9270     {
9271       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9272       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
9273                                              TYPE_REF_CAN_ALIAS_ALL (type));
9274     }
9275   else if (TREE_CODE (type) == ARRAY_TYPE)
9276     {
9277       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9278       outer = build_array_type (inner, TYPE_DOMAIN (type));
9279     }
9280   else if (TREE_CODE (type) == FUNCTION_TYPE)
9281     {
9282       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9283       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
9284     }
9285   else if (TREE_CODE (type) == METHOD_TYPE)
9286     {
9287       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9288       /* The build_method_type_directly() routine prepends 'this' to argument list,
9289          so we must compensate by getting rid of it.  */
9290       outer
9291         = build_method_type_directly
9292             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
9293              inner,
9294              TREE_CHAIN (TYPE_ARG_TYPES (type)));
9295     }
9296   else if (TREE_CODE (type) == OFFSET_TYPE)
9297     {
9298       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9299       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
9300     }
9301   else
9302     return bottom;
9303
9304   return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
9305                                             TYPE_QUALS (type));
9306 }
9307
9308 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9309    the inner type.  */
9310 tree
9311 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
9312 {
9313   int nunits;
9314
9315   switch (GET_MODE_CLASS (mode))
9316     {
9317     case MODE_VECTOR_INT:
9318     case MODE_VECTOR_FLOAT:
9319     case MODE_VECTOR_FRACT:
9320     case MODE_VECTOR_UFRACT:
9321     case MODE_VECTOR_ACCUM:
9322     case MODE_VECTOR_UACCUM:
9323       nunits = GET_MODE_NUNITS (mode);
9324       break;
9325
9326     case MODE_INT:
9327       /* Check that there are no leftover bits.  */
9328       gcc_assert (GET_MODE_BITSIZE (mode)
9329                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
9330
9331       nunits = GET_MODE_BITSIZE (mode)
9332                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
9333       break;
9334
9335     default:
9336       gcc_unreachable ();
9337     }
9338
9339   return make_vector_type (innertype, nunits, mode);
9340 }
9341
9342 /* Similarly, but takes the inner type and number of units, which must be
9343    a power of two.  */
9344
9345 tree
9346 build_vector_type (tree innertype, int nunits)
9347 {
9348   return make_vector_type (innertype, nunits, VOIDmode);
9349 }
9350
9351 /* Similarly, but takes the inner type and number of units, which must be
9352    a power of two.  */
9353
9354 tree
9355 build_opaque_vector_type (tree innertype, int nunits)
9356 {
9357   tree t;
9358   innertype = build_distinct_type_copy (innertype);
9359   t = make_vector_type (innertype, nunits, VOIDmode);
9360   TYPE_VECTOR_OPAQUE (t) = true;
9361   return t;
9362 }
9363
9364
9365 /* Given an initializer INIT, return TRUE if INIT is zero or some
9366    aggregate of zeros.  Otherwise return FALSE.  */
9367 bool
9368 initializer_zerop (const_tree init)
9369 {
9370   tree elt;
9371
9372   STRIP_NOPS (init);
9373
9374   switch (TREE_CODE (init))
9375     {
9376     case INTEGER_CST:
9377       return integer_zerop (init);
9378
9379     case REAL_CST:
9380       /* ??? Note that this is not correct for C4X float formats.  There,
9381          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9382          negative exponent.  */
9383       return real_zerop (init)
9384         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
9385
9386     case FIXED_CST:
9387       return fixed_zerop (init);
9388
9389     case COMPLEX_CST:
9390       return integer_zerop (init)
9391         || (real_zerop (init)
9392             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
9393             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
9394
9395     case VECTOR_CST:
9396       for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
9397         if (!initializer_zerop (TREE_VALUE (elt)))
9398           return false;
9399       return true;
9400
9401     case CONSTRUCTOR:
9402       {
9403         unsigned HOST_WIDE_INT idx;
9404
9405         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
9406           if (!initializer_zerop (elt))
9407             return false;
9408         return true;
9409       }
9410
9411     case STRING_CST:
9412       {
9413         int i;
9414
9415         /* We need to loop through all elements to handle cases like
9416            "\0" and "\0foobar".  */
9417         for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
9418           if (TREE_STRING_POINTER (init)[i] != '\0')
9419             return false;
9420
9421         return true;
9422       }
9423
9424     default:
9425       return false;
9426     }
9427 }
9428
9429 /* Build an empty statement at location LOC.  */
9430
9431 tree
9432 build_empty_stmt (location_t loc)
9433 {
9434   tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
9435   SET_EXPR_LOCATION (t, loc);
9436   return t;
9437 }
9438
9439
9440 /* Build an OpenMP clause with code CODE.  LOC is the location of the
9441    clause.  */
9442
9443 tree
9444 build_omp_clause (location_t loc, enum omp_clause_code code)
9445 {
9446   tree t;
9447   int size, length;
9448
9449   length = omp_clause_num_ops[code];
9450   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
9451
9452   t = GGC_NEWVAR (union tree_node, size);
9453   memset (t, 0, size);
9454   TREE_SET_CODE (t, OMP_CLAUSE);
9455   OMP_CLAUSE_SET_CODE (t, code);
9456   OMP_CLAUSE_LOCATION (t) = loc;
9457
9458 #ifdef GATHER_STATISTICS
9459   tree_node_counts[(int) omp_clause_kind]++;
9460   tree_node_sizes[(int) omp_clause_kind] += size;
9461 #endif
9462
9463   return t;
9464 }
9465
9466 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
9467    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9468    Except for the CODE and operand count field, other storage for the
9469    object is initialized to zeros.  */
9470
9471 tree
9472 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
9473 {
9474   tree t;
9475   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
9476
9477   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
9478   gcc_assert (len >= 1);
9479
9480 #ifdef GATHER_STATISTICS
9481   tree_node_counts[(int) e_kind]++;
9482   tree_node_sizes[(int) e_kind] += length;
9483 #endif
9484
9485   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
9486
9487   memset (t, 0, length);
9488
9489   TREE_SET_CODE (t, code);
9490
9491   /* Can't use TREE_OPERAND to store the length because if checking is
9492      enabled, it will try to check the length before we store it.  :-P  */
9493   t->exp.operands[0] = build_int_cst (sizetype, len);
9494
9495   return t;
9496 }
9497
9498
9499 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE
9500    and FN and a null static chain slot.  ARGLIST is a TREE_LIST of the
9501    arguments.  */
9502
9503 tree
9504 build_call_list (tree return_type, tree fn, tree arglist)
9505 {
9506   tree t;
9507   int i;
9508
9509   t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
9510   TREE_TYPE (t) = return_type;
9511   CALL_EXPR_FN (t) = fn;
9512   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9513   for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
9514     CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
9515   process_call_operands (t);
9516   return t;
9517 }
9518
9519 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9520    FN and a null static chain slot.  NARGS is the number of call arguments
9521    which are specified as "..." arguments.  */
9522
9523 tree
9524 build_call_nary (tree return_type, tree fn, int nargs, ...)
9525 {
9526   tree ret;
9527   va_list args;
9528   va_start (args, nargs);
9529   ret = build_call_valist (return_type, fn, nargs, args);
9530   va_end (args);
9531   return ret;
9532 }
9533
9534 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9535    FN and a null static chain slot.  NARGS is the number of call arguments
9536    which are specified as a va_list ARGS.  */
9537
9538 tree
9539 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
9540 {
9541   tree t;
9542   int i;
9543
9544   t = build_vl_exp (CALL_EXPR, nargs + 3);
9545   TREE_TYPE (t) = return_type;
9546   CALL_EXPR_FN (t) = fn;
9547   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9548   for (i = 0; i < nargs; i++)
9549     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
9550   process_call_operands (t);
9551   return t;
9552 }
9553
9554 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9555    FN and a null static chain slot.  NARGS is the number of call arguments
9556    which are specified as a tree array ARGS.  */
9557
9558 tree
9559 build_call_array_loc (location_t loc, tree return_type, tree fn,
9560                       int nargs, const tree *args)
9561 {
9562   tree t;
9563   int i;
9564
9565   t = build_vl_exp (CALL_EXPR, nargs + 3);
9566   TREE_TYPE (t) = return_type;
9567   CALL_EXPR_FN (t) = fn;
9568   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9569   for (i = 0; i < nargs; i++)
9570     CALL_EXPR_ARG (t, i) = args[i];
9571   process_call_operands (t);
9572   SET_EXPR_LOCATION (t, loc);
9573   return t;
9574 }
9575
9576 /* Like build_call_array, but takes a VEC.  */
9577
9578 tree
9579 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
9580 {
9581   tree ret, t;
9582   unsigned int ix;
9583
9584   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
9585   TREE_TYPE (ret) = return_type;
9586   CALL_EXPR_FN (ret) = fn;
9587   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
9588   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
9589     CALL_EXPR_ARG (ret, ix) = t;
9590   process_call_operands (ret);
9591   return ret;
9592 }
9593
9594
9595 /* Returns true if it is possible to prove that the index of
9596    an array access REF (an ARRAY_REF expression) falls into the
9597    array bounds.  */
9598
9599 bool
9600 in_array_bounds_p (tree ref)
9601 {
9602   tree idx = TREE_OPERAND (ref, 1);
9603   tree min, max;
9604
9605   if (TREE_CODE (idx) != INTEGER_CST)
9606     return false;
9607
9608   min = array_ref_low_bound (ref);
9609   max = array_ref_up_bound (ref);
9610   if (!min
9611       || !max
9612       || TREE_CODE (min) != INTEGER_CST
9613       || TREE_CODE (max) != INTEGER_CST)
9614     return false;
9615
9616   if (tree_int_cst_lt (idx, min)
9617       || tree_int_cst_lt (max, idx))
9618     return false;
9619
9620   return true;
9621 }
9622
9623 /* Returns true if it is possible to prove that the range of
9624    an array access REF (an ARRAY_RANGE_REF expression) falls
9625    into the array bounds.  */
9626
9627 bool
9628 range_in_array_bounds_p (tree ref)
9629 {
9630   tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
9631   tree range_min, range_max, min, max;
9632
9633   range_min = TYPE_MIN_VALUE (domain_type);
9634   range_max = TYPE_MAX_VALUE (domain_type);
9635   if (!range_min
9636       || !range_max
9637       || TREE_CODE (range_min) != INTEGER_CST
9638       || TREE_CODE (range_max) != INTEGER_CST)
9639     return false;
9640
9641   min = array_ref_low_bound (ref);
9642   max = array_ref_up_bound (ref);
9643   if (!min
9644       || !max
9645       || TREE_CODE (min) != INTEGER_CST
9646       || TREE_CODE (max) != INTEGER_CST)
9647     return false;
9648
9649   if (tree_int_cst_lt (range_min, min)
9650       || tree_int_cst_lt (max, range_max))
9651     return false;
9652
9653   return true;
9654 }
9655
9656 /* Return true if T (assumed to be a DECL) must be assigned a memory
9657    location.  */
9658
9659 bool
9660 needs_to_live_in_memory (const_tree t)
9661 {
9662   if (TREE_CODE (t) == SSA_NAME)
9663     t = SSA_NAME_VAR (t);
9664
9665   return (TREE_ADDRESSABLE (t)
9666           || is_global_var (t)
9667           || (TREE_CODE (t) == RESULT_DECL
9668               && aggregate_value_p (t, current_function_decl)));
9669 }
9670
9671 /* There are situations in which a language considers record types
9672    compatible which have different field lists.  Decide if two fields
9673    are compatible.  It is assumed that the parent records are compatible.  */
9674
9675 bool
9676 fields_compatible_p (const_tree f1, const_tree f2)
9677 {
9678   if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
9679                         DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
9680     return false;
9681
9682   if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
9683                         DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
9684     return false;
9685
9686   if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
9687     return false;
9688
9689   return true;
9690 }
9691
9692 /* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
9693
9694 tree
9695 find_compatible_field (tree record, tree orig_field)
9696 {
9697   tree f;
9698
9699   for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
9700     if (TREE_CODE (f) == FIELD_DECL
9701         && fields_compatible_p (f, orig_field))
9702       return f;
9703
9704   /* ??? Why isn't this on the main fields list?  */
9705   f = TYPE_VFIELD (record);
9706   if (f && TREE_CODE (f) == FIELD_DECL
9707       && fields_compatible_p (f, orig_field))
9708     return f;
9709
9710   /* ??? We should abort here, but Java appears to do Bad Things
9711      with inherited fields.  */
9712   return orig_field;
9713 }
9714
9715 /* Return value of a constant X and sign-extend it.  */
9716
9717 HOST_WIDE_INT
9718 int_cst_value (const_tree x)
9719 {
9720   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9721   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
9722
9723   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9724   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9725               || TREE_INT_CST_HIGH (x) == -1);
9726
9727   if (bits < HOST_BITS_PER_WIDE_INT)
9728     {
9729       bool negative = ((val >> (bits - 1)) & 1) != 0;
9730       if (negative)
9731         val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
9732       else
9733         val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
9734     }
9735
9736   return val;
9737 }
9738
9739 /* Return value of a constant X and sign-extend it.  */
9740
9741 HOST_WIDEST_INT
9742 widest_int_cst_value (const_tree x)
9743 {
9744   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9745   unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
9746
9747 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9748   gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
9749   val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
9750           << HOST_BITS_PER_WIDE_INT);
9751 #else
9752   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9753   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9754               || TREE_INT_CST_HIGH (x) == -1);
9755 #endif
9756
9757   if (bits < HOST_BITS_PER_WIDEST_INT)
9758     {
9759       bool negative = ((val >> (bits - 1)) & 1) != 0;
9760       if (negative)
9761         val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
9762       else
9763         val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
9764     }
9765
9766   return val;
9767 }
9768
9769 /* If TYPE is an integral type, return an equivalent type which is
9770     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
9771     return TYPE itself.  */
9772
9773 tree
9774 signed_or_unsigned_type_for (int unsignedp, tree type)
9775 {
9776   tree t = type;
9777   if (POINTER_TYPE_P (type))
9778     {
9779       /* If the pointer points to the normal address space, use the
9780          size_type_node.  Otherwise use an appropriate size for the pointer
9781          based on the named address space it points to.  */
9782       if (!TYPE_ADDR_SPACE (TREE_TYPE (t)))
9783         t = size_type_node;
9784       else
9785         return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9786     }
9787
9788   if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
9789     return t;
9790
9791   return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9792 }
9793
9794 /* Returns unsigned variant of TYPE.  */
9795
9796 tree
9797 unsigned_type_for (tree type)
9798 {
9799   return signed_or_unsigned_type_for (1, type);
9800 }
9801
9802 /* Returns signed variant of TYPE.  */
9803
9804 tree
9805 signed_type_for (tree type)
9806 {
9807   return signed_or_unsigned_type_for (0, type);
9808 }
9809
9810 /* Returns the largest value obtainable by casting something in INNER type to
9811    OUTER type.  */
9812
9813 tree
9814 upper_bound_in_type (tree outer, tree inner)
9815 {
9816   unsigned HOST_WIDE_INT lo, hi;
9817   unsigned int det = 0;
9818   unsigned oprec = TYPE_PRECISION (outer);
9819   unsigned iprec = TYPE_PRECISION (inner);
9820   unsigned prec;
9821
9822   /* Compute a unique number for every combination.  */
9823   det |= (oprec > iprec) ? 4 : 0;
9824   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
9825   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
9826
9827   /* Determine the exponent to use.  */
9828   switch (det)
9829     {
9830     case 0:
9831     case 1:
9832       /* oprec <= iprec, outer: signed, inner: don't care.  */
9833       prec = oprec - 1;
9834       break;
9835     case 2:
9836     case 3:
9837       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
9838       prec = oprec;
9839       break;
9840     case 4:
9841       /* oprec > iprec, outer: signed, inner: signed.  */
9842       prec = iprec - 1;
9843       break;
9844     case 5:
9845       /* oprec > iprec, outer: signed, inner: unsigned.  */
9846       prec = iprec;
9847       break;
9848     case 6:
9849       /* oprec > iprec, outer: unsigned, inner: signed.  */
9850       prec = oprec;
9851       break;
9852     case 7:
9853       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
9854       prec = iprec;
9855       break;
9856     default:
9857       gcc_unreachable ();
9858     }
9859
9860   /* Compute 2^^prec - 1.  */
9861   if (prec <= HOST_BITS_PER_WIDE_INT)
9862     {
9863       hi = 0;
9864       lo = ((~(unsigned HOST_WIDE_INT) 0)
9865             >> (HOST_BITS_PER_WIDE_INT - prec));
9866     }
9867   else
9868     {
9869       hi = ((~(unsigned HOST_WIDE_INT) 0)
9870             >> (2 * HOST_BITS_PER_WIDE_INT - prec));
9871       lo = ~(unsigned HOST_WIDE_INT) 0;
9872     }
9873
9874   return build_int_cst_wide (outer, lo, hi);
9875 }
9876
9877 /* Returns the smallest value obtainable by casting something in INNER type to
9878    OUTER type.  */
9879
9880 tree
9881 lower_bound_in_type (tree outer, tree inner)
9882 {
9883   unsigned HOST_WIDE_INT lo, hi;
9884   unsigned oprec = TYPE_PRECISION (outer);
9885   unsigned iprec = TYPE_PRECISION (inner);
9886
9887   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
9888      and obtain 0.  */
9889   if (TYPE_UNSIGNED (outer)
9890       /* If we are widening something of an unsigned type, OUTER type
9891          contains all values of INNER type.  In particular, both INNER
9892          and OUTER types have zero in common.  */
9893       || (oprec > iprec && TYPE_UNSIGNED (inner)))
9894     lo = hi = 0;
9895   else
9896     {
9897       /* If we are widening a signed type to another signed type, we
9898          want to obtain -2^^(iprec-1).  If we are keeping the
9899          precision or narrowing to a signed type, we want to obtain
9900          -2^(oprec-1).  */
9901       unsigned prec = oprec > iprec ? iprec : oprec;
9902
9903       if (prec <= HOST_BITS_PER_WIDE_INT)
9904         {
9905           hi = ~(unsigned HOST_WIDE_INT) 0;
9906           lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
9907         }
9908       else
9909         {
9910           hi = ((~(unsigned HOST_WIDE_INT) 0)
9911                 << (prec - HOST_BITS_PER_WIDE_INT - 1));
9912           lo = 0;
9913         }
9914     }
9915
9916   return build_int_cst_wide (outer, lo, hi);
9917 }
9918
9919 /* Return nonzero if two operands that are suitable for PHI nodes are
9920    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
9921    SSA_NAME or invariant.  Note that this is strictly an optimization.
9922    That is, callers of this function can directly call operand_equal_p
9923    and get the same result, only slower.  */
9924
9925 int
9926 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
9927 {
9928   if (arg0 == arg1)
9929     return 1;
9930   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
9931     return 0;
9932   return operand_equal_p (arg0, arg1, 0);
9933 }
9934
9935 /* Returns number of zeros at the end of binary representation of X.
9936
9937    ??? Use ffs if available?  */
9938
9939 tree
9940 num_ending_zeros (const_tree x)
9941 {
9942   unsigned HOST_WIDE_INT fr, nfr;
9943   unsigned num, abits;
9944   tree type = TREE_TYPE (x);
9945
9946   if (TREE_INT_CST_LOW (x) == 0)
9947     {
9948       num = HOST_BITS_PER_WIDE_INT;
9949       fr = TREE_INT_CST_HIGH (x);
9950     }
9951   else
9952     {
9953       num = 0;
9954       fr = TREE_INT_CST_LOW (x);
9955     }
9956
9957   for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
9958     {
9959       nfr = fr >> abits;
9960       if (nfr << abits == fr)
9961         {
9962           num += abits;
9963           fr = nfr;
9964         }
9965     }
9966
9967   if (num > TYPE_PRECISION (type))
9968     num = TYPE_PRECISION (type);
9969
9970   return build_int_cst_type (type, num);
9971 }
9972
9973
9974 #define WALK_SUBTREE(NODE)                              \
9975   do                                                    \
9976     {                                                   \
9977       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
9978       if (result)                                       \
9979         return result;                                  \
9980     }                                                   \
9981   while (0)
9982
9983 /* This is a subroutine of walk_tree that walks field of TYPE that are to
9984    be walked whenever a type is seen in the tree.  Rest of operands and return
9985    value are as for walk_tree.  */
9986
9987 static tree
9988 walk_type_fields (tree type, walk_tree_fn func, void *data,
9989                   struct pointer_set_t *pset, walk_tree_lh lh)
9990 {
9991   tree result = NULL_TREE;
9992
9993   switch (TREE_CODE (type))
9994     {
9995     case POINTER_TYPE:
9996     case REFERENCE_TYPE:
9997       /* We have to worry about mutually recursive pointers.  These can't
9998          be written in C.  They can in Ada.  It's pathological, but
9999          there's an ACATS test (c38102a) that checks it.  Deal with this
10000          by checking if we're pointing to another pointer, that one
10001          points to another pointer, that one does too, and we have no htab.
10002          If so, get a hash table.  We check three levels deep to avoid
10003          the cost of the hash table if we don't need one.  */
10004       if (POINTER_TYPE_P (TREE_TYPE (type))
10005           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
10006           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
10007           && !pset)
10008         {
10009           result = walk_tree_without_duplicates (&TREE_TYPE (type),
10010                                                  func, data);
10011           if (result)
10012             return result;
10013
10014           break;
10015         }
10016
10017       /* ... fall through ... */
10018
10019     case COMPLEX_TYPE:
10020       WALK_SUBTREE (TREE_TYPE (type));
10021       break;
10022
10023     case METHOD_TYPE:
10024       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
10025
10026       /* Fall through.  */
10027
10028     case FUNCTION_TYPE:
10029       WALK_SUBTREE (TREE_TYPE (type));
10030       {
10031         tree arg;
10032
10033         /* We never want to walk into default arguments.  */
10034         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
10035           WALK_SUBTREE (TREE_VALUE (arg));
10036       }
10037       break;
10038
10039     case ARRAY_TYPE:
10040       /* Don't follow this nodes's type if a pointer for fear that
10041          we'll have infinite recursion.  If we have a PSET, then we
10042          need not fear.  */
10043       if (pset
10044           || (!POINTER_TYPE_P (TREE_TYPE (type))
10045               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
10046         WALK_SUBTREE (TREE_TYPE (type));
10047       WALK_SUBTREE (TYPE_DOMAIN (type));
10048       break;
10049
10050     case OFFSET_TYPE:
10051       WALK_SUBTREE (TREE_TYPE (type));
10052       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
10053       break;
10054
10055     default:
10056       break;
10057     }
10058
10059   return NULL_TREE;
10060 }
10061
10062 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
10063    called with the DATA and the address of each sub-tree.  If FUNC returns a
10064    non-NULL value, the traversal is stopped, and the value returned by FUNC
10065    is returned.  If PSET is non-NULL it is used to record the nodes visited,
10066    and to avoid visiting a node more than once.  */
10067
10068 tree
10069 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10070              struct pointer_set_t *pset, walk_tree_lh lh)
10071 {
10072   enum tree_code code;
10073   int walk_subtrees;
10074   tree result;
10075
10076 #define WALK_SUBTREE_TAIL(NODE)                         \
10077   do                                                    \
10078     {                                                   \
10079        tp = & (NODE);                                   \
10080        goto tail_recurse;                               \
10081     }                                                   \
10082   while (0)
10083
10084  tail_recurse:
10085   /* Skip empty subtrees.  */
10086   if (!*tp)
10087     return NULL_TREE;
10088
10089   /* Don't walk the same tree twice, if the user has requested
10090      that we avoid doing so.  */
10091   if (pset && pointer_set_insert (pset, *tp))
10092     return NULL_TREE;
10093
10094   /* Call the function.  */
10095   walk_subtrees = 1;
10096   result = (*func) (tp, &walk_subtrees, data);
10097
10098   /* If we found something, return it.  */
10099   if (result)
10100     return result;
10101
10102   code = TREE_CODE (*tp);
10103
10104   /* Even if we didn't, FUNC may have decided that there was nothing
10105      interesting below this point in the tree.  */
10106   if (!walk_subtrees)
10107     {
10108       /* But we still need to check our siblings.  */
10109       if (code == TREE_LIST)
10110         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10111       else if (code == OMP_CLAUSE)
10112         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10113       else
10114         return NULL_TREE;
10115     }
10116
10117   if (lh)
10118     {
10119       result = (*lh) (tp, &walk_subtrees, func, data, pset);
10120       if (result || !walk_subtrees)
10121         return result;
10122     }
10123
10124   switch (code)
10125     {
10126     case ERROR_MARK:
10127     case IDENTIFIER_NODE:
10128     case INTEGER_CST:
10129     case REAL_CST:
10130     case FIXED_CST:
10131     case VECTOR_CST:
10132     case STRING_CST:
10133     case BLOCK:
10134     case PLACEHOLDER_EXPR:
10135     case SSA_NAME:
10136     case FIELD_DECL:
10137     case RESULT_DECL:
10138       /* None of these have subtrees other than those already walked
10139          above.  */
10140       break;
10141
10142     case TREE_LIST:
10143       WALK_SUBTREE (TREE_VALUE (*tp));
10144       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10145       break;
10146
10147     case TREE_VEC:
10148       {
10149         int len = TREE_VEC_LENGTH (*tp);
10150
10151         if (len == 0)
10152           break;
10153
10154         /* Walk all elements but the first.  */
10155         while (--len)
10156           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
10157
10158         /* Now walk the first one as a tail call.  */
10159         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
10160       }
10161
10162     case COMPLEX_CST:
10163       WALK_SUBTREE (TREE_REALPART (*tp));
10164       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
10165
10166     case CONSTRUCTOR:
10167       {
10168         unsigned HOST_WIDE_INT idx;
10169         constructor_elt *ce;
10170
10171         for (idx = 0;
10172              VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
10173              idx++)
10174           WALK_SUBTREE (ce->value);
10175       }
10176       break;
10177
10178     case SAVE_EXPR:
10179       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
10180
10181     case BIND_EXPR:
10182       {
10183         tree decl;
10184         for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
10185           {
10186             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
10187                into declarations that are just mentioned, rather than
10188                declared; they don't really belong to this part of the tree.
10189                And, we can see cycles: the initializer for a declaration
10190                can refer to the declaration itself.  */
10191             WALK_SUBTREE (DECL_INITIAL (decl));
10192             WALK_SUBTREE (DECL_SIZE (decl));
10193             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
10194           }
10195         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
10196       }
10197
10198     case STATEMENT_LIST:
10199       {
10200         tree_stmt_iterator i;
10201         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
10202           WALK_SUBTREE (*tsi_stmt_ptr (i));
10203       }
10204       break;
10205
10206     case OMP_CLAUSE:
10207       switch (OMP_CLAUSE_CODE (*tp))
10208         {
10209         case OMP_CLAUSE_PRIVATE:
10210         case OMP_CLAUSE_SHARED:
10211         case OMP_CLAUSE_FIRSTPRIVATE:
10212         case OMP_CLAUSE_COPYIN:
10213         case OMP_CLAUSE_COPYPRIVATE:
10214         case OMP_CLAUSE_IF:
10215         case OMP_CLAUSE_NUM_THREADS:
10216         case OMP_CLAUSE_SCHEDULE:
10217           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
10218           /* FALLTHRU */
10219
10220         case OMP_CLAUSE_NOWAIT:
10221         case OMP_CLAUSE_ORDERED:
10222         case OMP_CLAUSE_DEFAULT:
10223         case OMP_CLAUSE_UNTIED:
10224           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10225
10226         case OMP_CLAUSE_LASTPRIVATE:
10227           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
10228           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
10229           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10230
10231         case OMP_CLAUSE_COLLAPSE:
10232           {
10233             int i;
10234             for (i = 0; i < 3; i++)
10235               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10236             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10237           }
10238
10239         case OMP_CLAUSE_REDUCTION:
10240           {
10241             int i;
10242             for (i = 0; i < 4; i++)
10243               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10244             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10245           }
10246
10247         default:
10248           gcc_unreachable ();
10249         }
10250       break;
10251
10252     case TARGET_EXPR:
10253       {
10254         int i, len;
10255
10256         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10257            But, we only want to walk once.  */
10258         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
10259         for (i = 0; i < len; ++i)
10260           WALK_SUBTREE (TREE_OPERAND (*tp, i));
10261         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
10262       }
10263
10264     case DECL_EXPR:
10265       /* If this is a TYPE_DECL, walk into the fields of the type that it's
10266          defining.  We only want to walk into these fields of a type in this
10267          case and not in the general case of a mere reference to the type.
10268
10269          The criterion is as follows: if the field can be an expression, it
10270          must be walked only here.  This should be in keeping with the fields
10271          that are directly gimplified in gimplify_type_sizes in order for the
10272          mark/copy-if-shared/unmark machinery of the gimplifier to work with
10273          variable-sized types.
10274
10275          Note that DECLs get walked as part of processing the BIND_EXPR.  */
10276       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
10277         {
10278           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
10279           if (TREE_CODE (*type_p) == ERROR_MARK)
10280             return NULL_TREE;
10281
10282           /* Call the function for the type.  See if it returns anything or
10283              doesn't want us to continue.  If we are to continue, walk both
10284              the normal fields and those for the declaration case.  */
10285           result = (*func) (type_p, &walk_subtrees, data);
10286           if (result || !walk_subtrees)
10287             return result;
10288
10289           result = walk_type_fields (*type_p, func, data, pset, lh);
10290           if (result)
10291             return result;
10292
10293           /* If this is a record type, also walk the fields.  */
10294           if (RECORD_OR_UNION_TYPE_P (*type_p))
10295             {
10296               tree field;
10297
10298               for (field = TYPE_FIELDS (*type_p); field;
10299                    field = TREE_CHAIN (field))
10300                 {
10301                   /* We'd like to look at the type of the field, but we can
10302                      easily get infinite recursion.  So assume it's pointed
10303                      to elsewhere in the tree.  Also, ignore things that
10304                      aren't fields.  */
10305                   if (TREE_CODE (field) != FIELD_DECL)
10306                     continue;
10307
10308                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
10309                   WALK_SUBTREE (DECL_SIZE (field));
10310                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
10311                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10312                     WALK_SUBTREE (DECL_QUALIFIER (field));
10313                 }
10314             }
10315
10316           /* Same for scalar types.  */
10317           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
10318                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
10319                    || TREE_CODE (*type_p) == INTEGER_TYPE
10320                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
10321                    || TREE_CODE (*type_p) == REAL_TYPE)
10322             {
10323               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
10324               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
10325             }
10326
10327           WALK_SUBTREE (TYPE_SIZE (*type_p));
10328           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
10329         }
10330       /* FALLTHRU */
10331
10332     default:
10333       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
10334         {
10335           int i, len;
10336
10337           /* Walk over all the sub-trees of this operand.  */
10338           len = TREE_OPERAND_LENGTH (*tp);
10339
10340           /* Go through the subtrees.  We need to do this in forward order so
10341              that the scope of a FOR_EXPR is handled properly.  */
10342           if (len)
10343             {
10344               for (i = 0; i < len - 1; ++i)
10345                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
10346               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
10347             }
10348         }
10349       /* If this is a type, walk the needed fields in the type.  */
10350       else if (TYPE_P (*tp))
10351         return walk_type_fields (*tp, func, data, pset, lh);
10352       break;
10353     }
10354
10355   /* We didn't find what we were looking for.  */
10356   return NULL_TREE;
10357
10358 #undef WALK_SUBTREE_TAIL
10359 }
10360 #undef WALK_SUBTREE
10361
10362 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
10363
10364 tree
10365 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
10366                                 walk_tree_lh lh)
10367 {
10368   tree result;
10369   struct pointer_set_t *pset;
10370
10371   pset = pointer_set_create ();
10372   result = walk_tree_1 (tp, func, data, pset, lh);
10373   pointer_set_destroy (pset);
10374   return result;
10375 }
10376
10377
10378 tree *
10379 tree_block (tree t)
10380 {
10381   char const c = TREE_CODE_CLASS (TREE_CODE (t));
10382
10383   if (IS_EXPR_CODE_CLASS (c))
10384     return &t->exp.block;
10385   gcc_unreachable ();
10386   return NULL;
10387 }
10388
10389 /* Create a nameless artificial label and put it in the current
10390    function context.  The label has a location of LOC.  Returns the
10391    newly created label.  */
10392
10393 tree
10394 create_artificial_label (location_t loc)
10395 {
10396   tree lab = build_decl (loc,
10397                          LABEL_DECL, NULL_TREE, void_type_node);
10398
10399   DECL_ARTIFICIAL (lab) = 1;
10400   DECL_IGNORED_P (lab) = 1;
10401   DECL_CONTEXT (lab) = current_function_decl;
10402   return lab;
10403 }
10404
10405 /*  Given a tree, try to return a useful variable name that we can use
10406     to prefix a temporary that is being assigned the value of the tree.
10407     I.E. given  <temp> = &A, return A.  */
10408
10409 const char *
10410 get_name (tree t)
10411 {
10412   tree stripped_decl;
10413
10414   stripped_decl = t;
10415   STRIP_NOPS (stripped_decl);
10416   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
10417     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
10418   else
10419     {
10420       switch (TREE_CODE (stripped_decl))
10421         {
10422         case ADDR_EXPR:
10423           return get_name (TREE_OPERAND (stripped_decl, 0));
10424         default:
10425           return NULL;
10426         }
10427     }
10428 }
10429
10430 /* Return true if TYPE has a variable argument list.  */
10431
10432 bool
10433 stdarg_p (tree fntype)
10434 {
10435   function_args_iterator args_iter;
10436   tree n = NULL_TREE, t;
10437
10438   if (!fntype)
10439     return false;
10440
10441   FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
10442     {
10443       n = t;
10444     }
10445
10446   return n != NULL_TREE && n != void_type_node;
10447 }
10448
10449 /* Return true if TYPE has a prototype.  */
10450
10451 bool
10452 prototype_p (tree fntype)
10453 {
10454   tree t;
10455
10456   gcc_assert (fntype != NULL_TREE);
10457
10458   t = TYPE_ARG_TYPES (fntype);
10459   return (t != NULL_TREE);
10460 }
10461
10462 /* If BLOCK is inlined from an __attribute__((__artificial__))
10463    routine, return pointer to location from where it has been
10464    called.  */
10465 location_t *
10466 block_nonartificial_location (tree block)
10467 {
10468   location_t *ret = NULL;
10469
10470   while (block && TREE_CODE (block) == BLOCK
10471          && BLOCK_ABSTRACT_ORIGIN (block))
10472     {
10473       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
10474
10475       while (TREE_CODE (ao) == BLOCK
10476              && BLOCK_ABSTRACT_ORIGIN (ao)
10477              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
10478         ao = BLOCK_ABSTRACT_ORIGIN (ao);
10479
10480       if (TREE_CODE (ao) == FUNCTION_DECL)
10481         {
10482           /* If AO is an artificial inline, point RET to the
10483              call site locus at which it has been inlined and continue
10484              the loop, in case AO's caller is also an artificial
10485              inline.  */
10486           if (DECL_DECLARED_INLINE_P (ao)
10487               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
10488             ret = &BLOCK_SOURCE_LOCATION (block);
10489           else
10490             break;
10491         }
10492       else if (TREE_CODE (ao) != BLOCK)
10493         break;
10494
10495       block = BLOCK_SUPERCONTEXT (block);
10496     }
10497   return ret;
10498 }
10499
10500
10501 /* If EXP is inlined from an __attribute__((__artificial__))
10502    function, return the location of the original call expression.  */
10503
10504 location_t
10505 tree_nonartificial_location (tree exp)
10506 {
10507   location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
10508
10509   if (loc)
10510     return *loc;
10511   else
10512     return EXPR_LOCATION (exp);
10513 }
10514
10515
10516 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10517    nodes.  */
10518
10519 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
10520
10521 static hashval_t
10522 cl_option_hash_hash (const void *x)
10523 {
10524   const_tree const t = (const_tree) x;
10525   const char *p;
10526   size_t i;
10527   size_t len = 0;
10528   hashval_t hash = 0;
10529
10530   if (TREE_CODE (t) == OPTIMIZATION_NODE)
10531     {
10532       p = (const char *)TREE_OPTIMIZATION (t);
10533       len = sizeof (struct cl_optimization);
10534     }
10535
10536   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
10537     {
10538       p = (const char *)TREE_TARGET_OPTION (t);
10539       len = sizeof (struct cl_target_option);
10540     }
10541
10542   else
10543     gcc_unreachable ();
10544
10545   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10546      something else.  */
10547   for (i = 0; i < len; i++)
10548     if (p[i])
10549       hash = (hash << 4) ^ ((i << 2) | p[i]);
10550
10551   return hash;
10552 }
10553
10554 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
10555    TARGET_OPTION tree node) is the same as that given by *Y, which is the
10556    same.  */
10557
10558 static int
10559 cl_option_hash_eq (const void *x, const void *y)
10560 {
10561   const_tree const xt = (const_tree) x;
10562   const_tree const yt = (const_tree) y;
10563   const char *xp;
10564   const char *yp;
10565   size_t len;
10566
10567   if (TREE_CODE (xt) != TREE_CODE (yt))
10568     return 0;
10569
10570   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
10571     {
10572       xp = (const char *)TREE_OPTIMIZATION (xt);
10573       yp = (const char *)TREE_OPTIMIZATION (yt);
10574       len = sizeof (struct cl_optimization);
10575     }
10576
10577   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
10578     {
10579       xp = (const char *)TREE_TARGET_OPTION (xt);
10580       yp = (const char *)TREE_TARGET_OPTION (yt);
10581       len = sizeof (struct cl_target_option);
10582     }
10583
10584   else
10585     gcc_unreachable ();
10586
10587   return (memcmp (xp, yp, len) == 0);
10588 }
10589
10590 /* Build an OPTIMIZATION_NODE based on the current options.  */
10591
10592 tree
10593 build_optimization_node (void)
10594 {
10595   tree t;
10596   void **slot;
10597
10598   /* Use the cache of optimization nodes.  */
10599
10600   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node));
10601
10602   slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
10603   t = (tree) *slot;
10604   if (!t)
10605     {
10606       /* Insert this one into the hash table.  */
10607       t = cl_optimization_node;
10608       *slot = t;
10609
10610       /* Make a new node for next time round.  */
10611       cl_optimization_node = make_node (OPTIMIZATION_NODE);
10612     }
10613
10614   return t;
10615 }
10616
10617 /* Build a TARGET_OPTION_NODE based on the current options.  */
10618
10619 tree
10620 build_target_option_node (void)
10621 {
10622   tree t;
10623   void **slot;
10624
10625   /* Use the cache of optimization nodes.  */
10626
10627   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node));
10628
10629   slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
10630   t = (tree) *slot;
10631   if (!t)
10632     {
10633       /* Insert this one into the hash table.  */
10634       t = cl_target_option_node;
10635       *slot = t;
10636
10637       /* Make a new node for next time round.  */
10638       cl_target_option_node = make_node (TARGET_OPTION_NODE);
10639     }
10640
10641   return t;
10642 }
10643
10644 /* Determine the "ultimate origin" of a block.  The block may be an inlined
10645    instance of an inlined instance of a block which is local to an inline
10646    function, so we have to trace all of the way back through the origin chain
10647    to find out what sort of node actually served as the original seed for the
10648    given block.  */
10649
10650 tree
10651 block_ultimate_origin (const_tree block)
10652 {
10653   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
10654
10655   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10656      nodes in the function to point to themselves; ignore that if
10657      we're trying to output the abstract instance of this function.  */
10658   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
10659     return NULL_TREE;
10660
10661   if (immediate_origin == NULL_TREE)
10662     return NULL_TREE;
10663   else
10664     {
10665       tree ret_val;
10666       tree lookahead = immediate_origin;
10667
10668       do
10669         {
10670           ret_val = lookahead;
10671           lookahead = (TREE_CODE (ret_val) == BLOCK
10672                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
10673         }
10674       while (lookahead != NULL && lookahead != ret_val);
10675
10676       /* The block's abstract origin chain may not be the *ultimate* origin of
10677          the block. It could lead to a DECL that has an abstract origin set.
10678          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10679          will give us if it has one).  Note that DECL's abstract origins are
10680          supposed to be the most distant ancestor (or so decl_ultimate_origin
10681          claims), so we don't need to loop following the DECL origins.  */
10682       if (DECL_P (ret_val))
10683         return DECL_ORIGIN (ret_val);
10684
10685       return ret_val;
10686     }
10687 }
10688
10689 /* Return true if T1 and T2 are equivalent lists.  */
10690
10691 bool
10692 list_equal_p (const_tree t1, const_tree t2)
10693 {
10694   for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
10695     if (TREE_VALUE (t1) != TREE_VALUE (t2))
10696       return false;
10697   return !t1 && !t2;
10698 }
10699
10700 /* Return true iff conversion in EXP generates no instruction.  Mark
10701    it inline so that we fully inline into the stripping functions even
10702    though we have two uses of this function.  */
10703
10704 static inline bool
10705 tree_nop_conversion (const_tree exp)
10706 {
10707   tree outer_type, inner_type;
10708
10709   if (!CONVERT_EXPR_P (exp)
10710       && TREE_CODE (exp) != NON_LVALUE_EXPR)
10711     return false;
10712   if (TREE_OPERAND (exp, 0) == error_mark_node)
10713     return false;
10714
10715   outer_type = TREE_TYPE (exp);
10716   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10717
10718   if (!inner_type)
10719     return false;
10720
10721   /* Use precision rather then machine mode when we can, which gives
10722      the correct answer even for submode (bit-field) types.  */
10723   if ((INTEGRAL_TYPE_P (outer_type)
10724        || POINTER_TYPE_P (outer_type)
10725        || TREE_CODE (outer_type) == OFFSET_TYPE)
10726       && (INTEGRAL_TYPE_P (inner_type)
10727           || POINTER_TYPE_P (inner_type)
10728           || TREE_CODE (inner_type) == OFFSET_TYPE))
10729     return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
10730
10731   /* Otherwise fall back on comparing machine modes (e.g. for
10732      aggregate types, floats).  */
10733   return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
10734 }
10735
10736 /* Return true iff conversion in EXP generates no instruction.  Don't
10737    consider conversions changing the signedness.  */
10738
10739 static bool
10740 tree_sign_nop_conversion (const_tree exp)
10741 {
10742   tree outer_type, inner_type;
10743
10744   if (!tree_nop_conversion (exp))
10745     return false;
10746
10747   outer_type = TREE_TYPE (exp);
10748   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10749
10750   return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
10751           && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
10752 }
10753
10754 /* Strip conversions from EXP according to tree_nop_conversion and
10755    return the resulting expression.  */
10756
10757 tree
10758 tree_strip_nop_conversions (tree exp)
10759 {
10760   while (tree_nop_conversion (exp))
10761     exp = TREE_OPERAND (exp, 0);
10762   return exp;
10763 }
10764
10765 /* Strip conversions from EXP according to tree_sign_nop_conversion
10766    and return the resulting expression.  */
10767
10768 tree
10769 tree_strip_sign_nop_conversions (tree exp)
10770 {
10771   while (tree_sign_nop_conversion (exp))
10772     exp = TREE_OPERAND (exp, 0);
10773   return exp;
10774 }
10775
10776 static GTY(()) tree gcc_eh_personality_decl;
10777
10778 /* Return the GCC personality function decl.  */
10779
10780 tree
10781 lhd_gcc_personality (void)
10782 {
10783   if (!gcc_eh_personality_decl)
10784     gcc_eh_personality_decl
10785       = build_personality_function (USING_SJLJ_EXCEPTIONS
10786                                     ? "__gcc_personality_sj0"
10787                                     : "__gcc_personality_v0");
10788
10789   return gcc_eh_personality_decl;
10790 }
10791
10792 /* Try to find a base info of BINFO that would have its field decl at offset
10793    OFFSET within the BINFO type and which is of EXPECTED_TYPE.  If it can be
10794    found, return, otherwise return NULL_TREE.  */
10795
10796 tree
10797 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
10798 {
10799   tree type;
10800
10801   if (offset == 0)
10802     return binfo;
10803
10804   type = TREE_TYPE (binfo);
10805   while (offset > 0)
10806     {
10807       tree base_binfo, found_binfo;
10808       HOST_WIDE_INT pos, size;
10809       tree fld;
10810       int i;
10811
10812       if (TREE_CODE (type) != RECORD_TYPE)
10813         return NULL_TREE;
10814
10815       for (fld = TYPE_FIELDS (type); fld; fld = TREE_CHAIN (fld))
10816         {
10817           if (TREE_CODE (fld) != FIELD_DECL)
10818             continue;
10819
10820           pos = int_bit_position (fld);
10821           size = tree_low_cst (DECL_SIZE (fld), 1);
10822           if (pos <= offset && (pos + size) > offset)
10823             break;
10824         }
10825       if (!fld)
10826         return NULL_TREE;
10827
10828       found_binfo = NULL_TREE;
10829       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10830         if (TREE_TYPE (base_binfo) == TREE_TYPE (fld))
10831           {
10832             found_binfo = base_binfo;
10833             break;
10834           }
10835
10836       if (!found_binfo)
10837         return NULL_TREE;
10838
10839       type = TREE_TYPE (fld);
10840       binfo = found_binfo;
10841       offset -= pos;
10842     }
10843   if (type != expected_type)
10844     return NULL_TREE;
10845   return binfo;
10846 }
10847
10848 #include "gt-tree.h"