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 "tm_p.h"
  39 #include "function.h"
  40 #include "obstack.h"
  41 #include "toplev.h"
  42 #include "ggc.h"
  43 #include "hashtab.h"
  44 #include "output.h"
  45 #include "target.h"
  46 #include "langhooks.h"
  47 #include "tree-inline.h"
  48 #include "tree-iterator.h"
  49 #include "basic-block.h"
  50 #include "tree-flow.h"
  51 #include "params.h"
  52 #include "pointer-set.h"
  53 #include "tree-pass.h"
  54 #include "langhooks-def.h"
  55 #include "diagnostic.h"
  56 #include "tree-diagnostic.h"
  57 #include "tree-pretty-print.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   "vecs",
 140   "binfos",
 141   "ssa names",
 142   "constructors",
 143   "random kinds",
 144   "lang_decl kinds",
 145   "lang_type kinds",
 146   "omp clauses",
 147 };
 148 #endif /* GATHER_STATISTICS */
 149
 150 /* Unique id for next decl created.  */
 151 static GTY(()) int next_decl_uid;
 152 /* Unique id for next type created.  */
 153 static GTY(()) int next_type_uid = 1;
 154 /* Unique id for next debug decl created.  Use negative numbers,
 155    to catch erroneous uses.  */
 156 static GTY(()) int next_debug_decl_uid;
 157
 158 /* Since we cannot rehash a type after it is in the table, we have to
 159    keep the hash code.  */
 160
 161 struct GTY(()) type_hash {
 162   unsigned long hash;
 163   tree type;
 164 };
 165
 166 /* Initial size of the hash table (rounded to next prime).  */
 167 #define TYPE_HASH_INITIAL_SIZE 1000
 168
 169 /* Now here is the hash table.  When recording a type, it is added to
 170    the slot whose index is the hash code.  Note that the hash table is
 171    used for several kinds of types (function types, array types and
 172    array index range types, for now).  While all these live in the
 173    same table, they are completely independent, and the hash code is
 174    computed differently for each of these.  */
 175
 176 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
 177      htab_t type_hash_table;
 178
 179 /* Hash table and temporary node for larger integer const values.  */
 180 static GTY (()) tree int_cst_node;
 181 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
 182      htab_t int_cst_hash_table;
 183
 184 /* Hash table for optimization flags and target option flags.  Use the same
 185    hash table for both sets of options.  Nodes for building the current
 186    optimization and target option nodes.  The assumption is most of the time
 187    the options created will already be in the hash table, so we avoid
 188    allocating and freeing up a node repeatably.  */
 189 static GTY (()) tree cl_optimization_node;
 190 static GTY (()) tree cl_target_option_node;
 191 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
 192      htab_t cl_option_hash_table;
 193
 194 /* General tree->tree mapping  structure for use in hash tables.  */
 195
 196
 197 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
 198      htab_t debug_expr_for_decl;
 199
 200 static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map)))
 201      htab_t value_expr_for_decl;
 202
 203 static GTY ((if_marked ("tree_priority_map_marked_p"),
 204              param_is (struct tree_priority_map)))
 205   htab_t init_priority_for_decl;
 206
 207 static void set_type_quals (tree, int);
 208 static int type_hash_eq (const void *, const void *);
 209 static hashval_t type_hash_hash (const void *);
 210 static hashval_t int_cst_hash_hash (const void *);
 211 static int int_cst_hash_eq (const void *, const void *);
 212 static hashval_t cl_option_hash_hash (const void *);
 213 static int cl_option_hash_eq (const void *, const void *);
 214 static void print_type_hash_statistics (void);
 215 static void print_debug_expr_statistics (void);
 216 static void print_value_expr_statistics (void);
 217 static int type_hash_marked_p (const void *);
 218 static unsigned int type_hash_list (const_tree, hashval_t);
 219 static unsigned int attribute_hash_list (const_tree, hashval_t);
 220
 221 tree global_trees[TI_MAX];
 222 tree integer_types[itk_none];
 223
 224 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
 225
 226 /* Number of operands for each OpenMP clause.  */
 227 unsigned const char omp_clause_num_ops[] =
 228 {
 229   0, /* OMP_CLAUSE_ERROR  */
 230   1, /* OMP_CLAUSE_PRIVATE  */
 231   1, /* OMP_CLAUSE_SHARED  */
 232   1, /* OMP_CLAUSE_FIRSTPRIVATE  */
 233   2, /* OMP_CLAUSE_LASTPRIVATE  */
 234   4, /* OMP_CLAUSE_REDUCTION  */
 235   1, /* OMP_CLAUSE_COPYIN  */
 236   1, /* OMP_CLAUSE_COPYPRIVATE  */
 237   1, /* OMP_CLAUSE_IF  */
 238   1, /* OMP_CLAUSE_NUM_THREADS  */
 239   1, /* OMP_CLAUSE_SCHEDULE  */
 240   0, /* OMP_CLAUSE_NOWAIT  */
 241   0, /* OMP_CLAUSE_ORDERED  */
 242   0, /* OMP_CLAUSE_DEFAULT  */
 243   3, /* OMP_CLAUSE_COLLAPSE  */
 244   0  /* OMP_CLAUSE_UNTIED   */
 245 };
 246
 247 const char * const omp_clause_code_name[] =
 248 {
 249   "error_clause",
 250   "private",
 251   "shared",
 252   "firstprivate",
 253   "lastprivate",
 254   "reduction",
 255   "copyin",
 256   "copyprivate",
 257   "if",
 258   "num_threads",
 259   "schedule",
 260   "nowait",
 261   "ordered",
 262   "default",
 263   "collapse",
 264   "untied"
 265 };
 266
 267
 268 /* Return the tree node structure used by tree code CODE.  */
 269
 270 static inline enum tree_node_structure_enum
 271 tree_node_structure_for_code (enum tree_code code)
 272 {
 273   switch (TREE_CODE_CLASS (code))
 274     {
 275     case tcc_declaration:
 276       {
 277         switch (code)
 278           {
 279           case FIELD_DECL:
 280             return TS_FIELD_DECL;
 281           case PARM_DECL:
 282             return TS_PARM_DECL;
 283           case VAR_DECL:
 284             return TS_VAR_DECL;
 285           case LABEL_DECL:
 286             return TS_LABEL_DECL;
 287           case RESULT_DECL:
 288             return TS_RESULT_DECL;
 289           case DEBUG_EXPR_DECL:
 290             return TS_DECL_WRTL;
 291           case CONST_DECL:
 292             return TS_CONST_DECL;
 293           case TYPE_DECL:
 294             return TS_TYPE_DECL;
 295           case FUNCTION_DECL:
 296             return TS_FUNCTION_DECL;
 297           default:
 298             return TS_DECL_NON_COMMON;
 299           }
 300       }
 301     case tcc_type:
 302       return TS_TYPE;
 303     case tcc_reference:
 304     case tcc_comparison:
 305     case tcc_unary:
 306     case tcc_binary:
 307     case tcc_expression:
 308     case tcc_statement:
 309     case tcc_vl_exp:
 310       return TS_EXP;
 311     default:  /* tcc_constant and tcc_exceptional */
 312       break;
 313     }
 314   switch (code)
 315     {
 316       /* tcc_constant cases.  */
 317     case INTEGER_CST:           return TS_INT_CST;
 318     case REAL_CST:              return TS_REAL_CST;
 319     case FIXED_CST:             return TS_FIXED_CST;
 320     case COMPLEX_CST:           return TS_COMPLEX;
 321     case VECTOR_CST:            return TS_VECTOR;
 322     case STRING_CST:            return TS_STRING;
 323       /* tcc_exceptional cases.  */
 324     case ERROR_MARK:            return TS_COMMON;
 325     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
 326     case TREE_LIST:             return TS_LIST;
 327     case TREE_VEC:              return TS_VEC;
 328     case SSA_NAME:              return TS_SSA_NAME;
 329     case PLACEHOLDER_EXPR:      return TS_COMMON;
 330     case STATEMENT_LIST:        return TS_STATEMENT_LIST;
 331     case BLOCK:                 return TS_BLOCK;
 332     case CONSTRUCTOR:           return TS_CONSTRUCTOR;
 333     case TREE_BINFO:            return TS_BINFO;
 334     case OMP_CLAUSE:            return TS_OMP_CLAUSE;
 335     case OPTIMIZATION_NODE:     return TS_OPTIMIZATION;
 336     case TARGET_OPTION_NODE:    return TS_TARGET_OPTION;
 337
 338     default:
 339       gcc_unreachable ();
 340     }
 341 }
 342
 343
 344 /* Initialize tree_contains_struct to describe the hierarchy of tree
 345    nodes.  */
 346
 347 static void
 348 initialize_tree_contains_struct (void)
 349 {
 350   unsigned i;
 351
 352 #define MARK_TS_BASE(C)                                 \
 353   do {                                                  \
 354     tree_contains_struct[C][TS_BASE] = 1;               \
 355   } while (0)
 356
 357 #define MARK_TS_COMMON(C)                               \
 358   do {                                                  \
 359     MARK_TS_BASE (C);                                   \
 360     tree_contains_struct[C][TS_COMMON] = 1;             \
 361   } while (0)
 362
 363 #define MARK_TS_DECL_MINIMAL(C)                         \
 364   do {                                                  \
 365     MARK_TS_COMMON (C);                                 \
 366     tree_contains_struct[C][TS_DECL_MINIMAL] = 1;       \
 367   } while (0)
 368
 369 #define MARK_TS_DECL_COMMON(C)                          \
 370   do {                                                  \
 371     MARK_TS_DECL_MINIMAL (C);                           \
 372     tree_contains_struct[C][TS_DECL_COMMON] = 1;        \
 373   } while (0)
 374
 375 #define MARK_TS_DECL_WRTL(C)                            \
 376   do {                                                  \
 377     MARK_TS_DECL_COMMON (C);                            \
 378     tree_contains_struct[C][TS_DECL_WRTL] = 1;          \
 379   } while (0)
 380
 381 #define MARK_TS_DECL_WITH_VIS(C)                        \
 382   do {                                                  \
 383     MARK_TS_DECL_WRTL (C);                              \
 384     tree_contains_struct[C][TS_DECL_WITH_VIS] = 1;      \
 385   } while (0)
 386
 387 #define MARK_TS_DECL_NON_COMMON(C)                      \
 388   do {                                                  \
 389     MARK_TS_DECL_WITH_VIS (C);                          \
 390     tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;    \
 391   } while (0)
 392
 393   for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
 394     {
 395       enum tree_code code;
 396       enum tree_node_structure_enum ts_code;
 397
 398       code = (enum tree_code) i;
 399       ts_code = tree_node_structure_for_code (code);
 400
 401       /* Mark the TS structure itself.  */
 402       tree_contains_struct[code][ts_code] = 1;
 403
 404       /* Mark all the structures that TS is derived from.  */
 405       switch (ts_code)
 406         {
 407         case TS_COMMON:
 408           MARK_TS_BASE (code);
 409           break;
 410
 411         case TS_INT_CST:
 412         case TS_REAL_CST:
 413         case TS_FIXED_CST:
 414         case TS_VECTOR:
 415         case TS_STRING:
 416         case TS_COMPLEX:
 417         case TS_IDENTIFIER:
 418         case TS_DECL_MINIMAL:
 419         case TS_TYPE:
 420         case TS_LIST:
 421         case TS_VEC:
 422         case TS_EXP:
 423         case TS_SSA_NAME:
 424         case TS_BLOCK:
 425         case TS_BINFO:
 426         case TS_STATEMENT_LIST:
 427         case TS_CONSTRUCTOR:
 428         case TS_OMP_CLAUSE:
 429         case TS_OPTIMIZATION:
 430         case TS_TARGET_OPTION:
 431           MARK_TS_COMMON (code);
 432           break;
 433
 434         case TS_DECL_COMMON:
 435           MARK_TS_DECL_MINIMAL (code);
 436           break;
 437
 438         case TS_DECL_WRTL:
 439           MARK_TS_DECL_COMMON (code);
 440           break;
 441
 442         case TS_DECL_NON_COMMON:
 443           MARK_TS_DECL_WITH_VIS (code);
 444           break;
 445
 446         case TS_DECL_WITH_VIS:
 447         case TS_PARM_DECL:
 448         case TS_LABEL_DECL:
 449         case TS_RESULT_DECL:
 450         case TS_CONST_DECL:
 451           MARK_TS_DECL_WRTL (code);
 452           break;
 453
 454         case TS_FIELD_DECL:
 455           MARK_TS_DECL_COMMON (code);
 456           break;
 457
 458         case TS_VAR_DECL:
 459           MARK_TS_DECL_WITH_VIS (code);
 460           break;
 461
 462         case TS_TYPE_DECL:
 463         case TS_FUNCTION_DECL:
 464           MARK_TS_DECL_NON_COMMON (code);
 465           break;
 466
 467         default:
 468           gcc_unreachable ();
 469         }
 470     }
 471
 472   /* Basic consistency checks for attributes used in fold.  */
 473   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
 474   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON]);
 475   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
 476   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
 477   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
 478   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
 479   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
 480   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
 481   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
 482   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
 483   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
 484   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
 485   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]);
 486   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
 487   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
 488   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
 489   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
 490   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
 491   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
 492   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
 493   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
 494   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
 495   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
 496   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
 497   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
 498   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
 499   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
 500   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
 501   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
 502   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
 503   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS]);
 504   gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
 505   gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
 506   gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
 507   gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
 508   gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
 509   gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
 510   gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
 511   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
 512   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
 513   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
 514
 515 #undef MARK_TS_BASE
 516 #undef MARK_TS_COMMON
 517 #undef MARK_TS_DECL_MINIMAL
 518 #undef MARK_TS_DECL_COMMON
 519 #undef MARK_TS_DECL_WRTL
 520 #undef MARK_TS_DECL_WITH_VIS
 521 #undef MARK_TS_DECL_NON_COMMON
 522 }
 523
 524
 525 /* Init tree.c.  */
 526
 527 void
 528 init_ttree (void)
 529 {
 530   /* Initialize the hash table of types.  */
 531   type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
 532                                      type_hash_eq, 0);
 533
 534   debug_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
 535                                          tree_decl_map_eq, 0);
 536
 537   value_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash,
 538                                          tree_decl_map_eq, 0);
 539   init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
 540                                             tree_priority_map_eq, 0);
 541
 542   int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
 543                                         int_cst_hash_eq, NULL);
 544
 545   int_cst_node = make_node (INTEGER_CST);
 546
 547   cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
 548                                           cl_option_hash_eq, NULL);
 549
 550   cl_optimization_node = make_node (OPTIMIZATION_NODE);
 551   cl_target_option_node = make_node (TARGET_OPTION_NODE);
 552
 553   /* Initialize the tree_contains_struct array.  */
 554   initialize_tree_contains_struct ();
 555   lang_hooks.init_ts ();
 556 }
 557
 558 \f
 559 /* The name of the object as the assembler will see it (but before any
 560    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
 561    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
 562 tree
 563 decl_assembler_name (tree decl)
 564 {
 565   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 566     lang_hooks.set_decl_assembler_name (decl);
 567   return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
 568 }
 569
 570 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
 571
 572 bool
 573 decl_assembler_name_equal (tree decl, const_tree asmname)
 574 {
 575   tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
 576   const char *decl_str;
 577   const char *asmname_str;
 578   bool test = false;
 579
 580   if (decl_asmname == asmname)
 581     return true;
 582
 583   decl_str = IDENTIFIER_POINTER (decl_asmname);
 584   asmname_str = IDENTIFIER_POINTER (asmname);
 585
 586
 587   /* If the target assembler name was set by the user, things are trickier.
 588      We have a leading '*' to begin with.  After that, it's arguable what
 589      is the correct thing to do with -fleading-underscore.  Arguably, we've
 590      historically been doing the wrong thing in assemble_alias by always
 591      printing the leading underscore.  Since we're not changing that, make
 592      sure user_label_prefix follows the '*' before matching.  */
 593   if (decl_str[0] == '*')
 594     {
 595       size_t ulp_len = strlen (user_label_prefix);
 596
 597       decl_str ++;
 598
 599       if (ulp_len == 0)
 600         test = true;
 601       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 602         decl_str += ulp_len, test=true;
 603       else
 604         decl_str --;
 605     }
 606   if (asmname_str[0] == '*')
 607     {
 608       size_t ulp_len = strlen (user_label_prefix);
 609
 610       asmname_str ++;
 611
 612       if (ulp_len == 0)
 613         test = true;
 614       else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
 615         asmname_str += ulp_len, test=true;
 616       else
 617         asmname_str --;
 618     }
 619
 620   if (!test)
 621     return false;
 622   return strcmp (decl_str, asmname_str) == 0;
 623 }
 624
 625 /* Hash asmnames ignoring the user specified marks.  */
 626
 627 hashval_t
 628 decl_assembler_name_hash (const_tree asmname)
 629 {
 630   if (IDENTIFIER_POINTER (asmname)[0] == '*')
 631     {
 632       const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
 633       size_t ulp_len = strlen (user_label_prefix);
 634
 635       if (ulp_len == 0)
 636         ;
 637       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 638         decl_str += ulp_len;
 639
 640       return htab_hash_string (decl_str);
 641     }
 642
 643   return htab_hash_string (IDENTIFIER_POINTER (asmname));
 644 }
 645
 646 /* Compute the number of bytes occupied by a tree with code CODE.
 647    This function cannot be used for nodes that have variable sizes,
 648    including TREE_VEC, STRING_CST, and CALL_EXPR.  */
 649 size_t
 650 tree_code_size (enum tree_code code)
 651 {
 652   switch (TREE_CODE_CLASS (code))
 653     {
 654     case tcc_declaration:  /* A decl node */
 655       {
 656         switch (code)
 657           {
 658           case FIELD_DECL:
 659             return sizeof (struct tree_field_decl);
 660           case PARM_DECL:
 661             return sizeof (struct tree_parm_decl);
 662           case VAR_DECL:
 663             return sizeof (struct tree_var_decl);
 664           case LABEL_DECL:
 665             return sizeof (struct tree_label_decl);
 666           case RESULT_DECL:
 667             return sizeof (struct tree_result_decl);
 668           case CONST_DECL:
 669             return sizeof (struct tree_const_decl);
 670           case TYPE_DECL:
 671             return sizeof (struct tree_type_decl);
 672           case FUNCTION_DECL:
 673             return sizeof (struct tree_function_decl);
 674           case DEBUG_EXPR_DECL:
 675             return sizeof (struct tree_decl_with_rtl);
 676           default:
 677             return sizeof (struct tree_decl_non_common);
 678           }
 679       }
 680
 681     case tcc_type:  /* a type node */
 682       return sizeof (struct tree_type);
 683
 684     case tcc_reference:   /* a reference */
 685     case tcc_expression:  /* an expression */
 686     case tcc_statement:   /* an expression with side effects */
 687     case tcc_comparison:  /* a comparison expression */
 688     case tcc_unary:       /* a unary arithmetic expression */
 689     case tcc_binary:      /* a binary arithmetic expression */
 690       return (sizeof (struct tree_exp)
 691               + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
 692
 693     case tcc_constant:  /* a constant */
 694       switch (code)
 695         {
 696         case INTEGER_CST:       return sizeof (struct tree_int_cst);
 697         case REAL_CST:          return sizeof (struct tree_real_cst);
 698         case FIXED_CST:         return sizeof (struct tree_fixed_cst);
 699         case COMPLEX_CST:       return sizeof (struct tree_complex);
 700         case VECTOR_CST:        return sizeof (struct tree_vector);
 701         case STRING_CST:        gcc_unreachable ();
 702         default:
 703           return lang_hooks.tree_size (code);
 704         }
 705
 706     case tcc_exceptional:  /* something random, like an identifier.  */
 707       switch (code)
 708         {
 709         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
 710         case TREE_LIST:         return sizeof (struct tree_list);
 711
 712         case ERROR_MARK:
 713         case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
 714
 715         case TREE_VEC:
 716         case OMP_CLAUSE:        gcc_unreachable ();
 717
 718         case SSA_NAME:          return sizeof (struct tree_ssa_name);
 719
 720         case STATEMENT_LIST:    return sizeof (struct tree_statement_list);
 721         case BLOCK:             return sizeof (struct tree_block);
 722         case CONSTRUCTOR:       return sizeof (struct tree_constructor);
 723         case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
 724         case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
 725
 726         default:
 727           return lang_hooks.tree_size (code);
 728         }
 729
 730     default:
 731       gcc_unreachable ();
 732     }
 733 }
 734
 735 /* Compute the number of bytes occupied by NODE.  This routine only
 736    looks at TREE_CODE, except for those nodes that have variable sizes.  */
 737 size_t
 738 tree_size (const_tree node)
 739 {
 740   const enum tree_code code = TREE_CODE (node);
 741   switch (code)
 742     {
 743     case TREE_BINFO:
 744       return (offsetof (struct tree_binfo, base_binfos)
 745               + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
 746
 747     case TREE_VEC:
 748       return (sizeof (struct tree_vec)
 749               + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
 750
 751     case STRING_CST:
 752       return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
 753
 754     case OMP_CLAUSE:
 755       return (sizeof (struct tree_omp_clause)
 756               + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
 757                 * sizeof (tree));
 758
 759     default:
 760       if (TREE_CODE_CLASS (code) == tcc_vl_exp)
 761         return (sizeof (struct tree_exp)
 762                 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
 763       else
 764         return tree_code_size (code);
 765     }
 766 }
 767
 768 /* Return a newly allocated node of code CODE.  For decl and type
 769    nodes, some other fields are initialized.  The rest of the node is
 770    initialized to zero.  This function cannot be used for TREE_VEC or
 771    OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
 772
 773    Achoo!  I got a code in the node.  */
 774
 775 tree
 776 make_node_stat (enum tree_code code MEM_STAT_DECL)
 777 {
 778   tree t;
 779   enum tree_code_class type = TREE_CODE_CLASS (code);
 780   size_t length = tree_code_size (code);
 781 #ifdef GATHER_STATISTICS
 782   tree_node_kind kind;
 783
 784   switch (type)
 785     {
 786     case tcc_declaration:  /* A decl node */
 787       kind = d_kind;
 788       break;
 789
 790     case tcc_type:  /* a type node */
 791       kind = t_kind;
 792       break;
 793
 794     case tcc_statement:  /* an expression with side effects */
 795       kind = s_kind;
 796       break;
 797
 798     case tcc_reference:  /* a reference */
 799       kind = r_kind;
 800       break;
 801
 802     case tcc_expression:  /* an expression */
 803     case tcc_comparison:  /* a comparison expression */
 804     case tcc_unary:  /* a unary arithmetic expression */
 805     case tcc_binary:  /* a binary arithmetic expression */
 806       kind = e_kind;
 807       break;
 808
 809     case tcc_constant:  /* a constant */
 810       kind = c_kind;
 811       break;
 812
 813     case tcc_exceptional:  /* something random, like an identifier.  */
 814       switch (code)
 815         {
 816         case IDENTIFIER_NODE:
 817           kind = id_kind;
 818           break;
 819
 820         case TREE_VEC:
 821           kind = vec_kind;
 822           break;
 823
 824         case TREE_BINFO:
 825           kind = binfo_kind;
 826           break;
 827
 828         case SSA_NAME:
 829           kind = ssa_name_kind;
 830           break;
 831
 832         case BLOCK:
 833           kind = b_kind;
 834           break;
 835
 836         case CONSTRUCTOR:
 837           kind = constr_kind;
 838           break;
 839
 840         default:
 841           kind = x_kind;
 842           break;
 843         }
 844       break;
 845
 846     default:
 847       gcc_unreachable ();
 848     }
 849
 850   tree_node_counts[(int) kind]++;
 851   tree_node_sizes[(int) kind] += length;
 852 #endif
 853
 854   t = ggc_alloc_zone_cleared_tree_node_stat (
 855                (code == IDENTIFIER_NODE) ? &tree_id_zone : &tree_zone,
 856                length PASS_MEM_STAT);
 857   TREE_SET_CODE (t, code);
 858
 859   switch (type)
 860     {
 861     case tcc_statement:
 862       TREE_SIDE_EFFECTS (t) = 1;
 863       break;
 864
 865     case tcc_declaration:
 866       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 867         {
 868           if (code == FUNCTION_DECL)
 869             {
 870               DECL_ALIGN (t) = FUNCTION_BOUNDARY;
 871               DECL_MODE (t) = FUNCTION_MODE;
 872             }
 873           else
 874             DECL_ALIGN (t) = 1;
 875         }
 876       DECL_SOURCE_LOCATION (t) = input_location;
 877       if (TREE_CODE (t) == DEBUG_EXPR_DECL)
 878         DECL_UID (t) = --next_debug_decl_uid;
 879       else
 880         {
 881           DECL_UID (t) = next_decl_uid++;
 882           SET_DECL_PT_UID (t, -1);
 883         }
 884       if (TREE_CODE (t) == LABEL_DECL)
 885         LABEL_DECL_UID (t) = -1;
 886
 887       break;
 888
 889     case tcc_type:
 890       TYPE_UID (t) = next_type_uid++;
 891       TYPE_ALIGN (t) = BITS_PER_UNIT;
 892       TYPE_USER_ALIGN (t) = 0;
 893       TYPE_MAIN_VARIANT (t) = t;
 894       TYPE_CANONICAL (t) = t;
 895
 896       /* Default to no attributes for type, but let target change that.  */
 897       TYPE_ATTRIBUTES (t) = NULL_TREE;
 898       targetm.set_default_type_attributes (t);
 899
 900       /* We have not yet computed the alias set for this type.  */
 901       TYPE_ALIAS_SET (t) = -1;
 902       break;
 903
 904     case tcc_constant:
 905       TREE_CONSTANT (t) = 1;
 906       break;
 907
 908     case tcc_expression:
 909       switch (code)
 910         {
 911         case INIT_EXPR:
 912         case MODIFY_EXPR:
 913         case VA_ARG_EXPR:
 914         case PREDECREMENT_EXPR:
 915         case PREINCREMENT_EXPR:
 916         case POSTDECREMENT_EXPR:
 917         case POSTINCREMENT_EXPR:
 918           /* All of these have side-effects, no matter what their
 919              operands are.  */
 920           TREE_SIDE_EFFECTS (t) = 1;
 921           break;
 922
 923         default:
 924           break;
 925         }
 926       break;
 927
 928     default:
 929       /* Other classes need no special treatment.  */
 930       break;
 931     }
 932
 933   return t;
 934 }
 935 \f
 936 /* Return a new node with the same contents as NODE except that its
 937    TREE_CHAIN is zero and it has a fresh uid.  */
 938
 939 tree
 940 copy_node_stat (tree node MEM_STAT_DECL)
 941 {
 942   tree t;
 943   enum tree_code code = TREE_CODE (node);
 944   size_t length;
 945
 946   gcc_assert (code != STATEMENT_LIST);
 947
 948   length = tree_size (node);
 949   t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
 950   memcpy (t, node, length);
 951
 952   TREE_CHAIN (t) = 0;
 953   TREE_ASM_WRITTEN (t) = 0;
 954   TREE_VISITED (t) = 0;
 955   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
 956     *DECL_VAR_ANN_PTR (t) = 0;
 957
 958   if (TREE_CODE_CLASS (code) == tcc_declaration)
 959     {
 960       if (code == DEBUG_EXPR_DECL)
 961         DECL_UID (t) = --next_debug_decl_uid;
 962       else
 963         {
 964           DECL_UID (t) = next_decl_uid++;
 965           if (DECL_PT_UID_SET_P (node))
 966             SET_DECL_PT_UID (t, DECL_PT_UID (node));
 967         }
 968       if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
 969           && DECL_HAS_VALUE_EXPR_P (node))
 970         {
 971           SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
 972           DECL_HAS_VALUE_EXPR_P (t) = 1;
 973         }
 974       if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
 975         {
 976           SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
 977           DECL_HAS_INIT_PRIORITY_P (t) = 1;
 978         }
 979     }
 980   else if (TREE_CODE_CLASS (code) == tcc_type)
 981     {
 982       TYPE_UID (t) = next_type_uid++;
 983       /* The following is so that the debug code for
 984          the copy is different from the original type.
 985          The two statements usually duplicate each other
 986          (because they clear fields of the same union),
 987          but the optimizer should catch that.  */
 988       TYPE_SYMTAB_POINTER (t) = 0;
 989       TYPE_SYMTAB_ADDRESS (t) = 0;
 990
 991       /* Do not copy the values cache.  */
 992       if (TYPE_CACHED_VALUES_P(t))
 993         {
 994           TYPE_CACHED_VALUES_P (t) = 0;
 995           TYPE_CACHED_VALUES (t) = NULL_TREE;
 996         }
 997     }
 998
 999   return t;
1000 }
1001
1002 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1003    For example, this can copy a list made of TREE_LIST nodes.  */
1004
1005 tree
1006 copy_list (tree list)
1007 {
1008   tree head;
1009   tree prev, next;
1010
1011   if (list == 0)
1012     return 0;
1013
1014   head = prev = copy_node (list);
1015   next = TREE_CHAIN (list);
1016   while (next)
1017     {
1018       TREE_CHAIN (prev) = copy_node (next);
1019       prev = TREE_CHAIN (prev);
1020       next = TREE_CHAIN (next);
1021     }
1022   return head;
1023 }
1024
1025 \f
1026 /* Create an INT_CST node with a LOW value sign extended.  */
1027
1028 tree
1029 build_int_cst (tree type, HOST_WIDE_INT low)
1030 {
1031   /* Support legacy code.  */
1032   if (!type)
1033     type = integer_type_node;
1034
1035   return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
1036 }
1037
1038 /* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
1039    if it is negative.  This function is similar to build_int_cst, but
1040    the extra bits outside of the type precision are cleared.  Constants
1041    with these extra bits may confuse the fold so that it detects overflows
1042    even in cases when they do not occur, and in general should be avoided.
1043    We cannot however make this a default behavior of build_int_cst without
1044    more intrusive changes, since there are parts of gcc that rely on the extra
1045    precision of the integer constants.  */
1046
1047 tree
1048 build_int_cst_type (tree type, HOST_WIDE_INT low)
1049 {
1050   gcc_assert (type);
1051
1052   return double_int_to_tree (type, shwi_to_double_int (low));
1053 }
1054
1055 /* Constructs tree in type TYPE from with value given by CST.  Signedness
1056    of CST is assumed to be the same as the signedness of TYPE.  */
1057
1058 tree
1059 double_int_to_tree (tree type, double_int cst)
1060 {
1061   /* Size types *are* sign extended.  */
1062   bool sign_extended_type = (!TYPE_UNSIGNED (type)
1063                              || (TREE_CODE (type) == INTEGER_TYPE
1064                                  && TYPE_IS_SIZETYPE (type)));
1065
1066   cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1067
1068   return build_int_cst_wide (type, cst.low, cst.high);
1069 }
1070
1071 /* Returns true if CST fits into range of TYPE.  Signedness of CST is assumed
1072    to be the same as the signedness of TYPE.  */
1073
1074 bool
1075 double_int_fits_to_tree_p (const_tree type, double_int cst)
1076 {
1077   /* Size types *are* sign extended.  */
1078   bool sign_extended_type = (!TYPE_UNSIGNED (type)
1079                              || (TREE_CODE (type) == INTEGER_TYPE
1080                                  && TYPE_IS_SIZETYPE (type)));
1081
1082   double_int ext
1083     = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
1084
1085   return double_int_equal_p (cst, ext);
1086 }
1087
1088 /* We force the double_int CST to the range of the type TYPE by sign or
1089    zero extending it.  OVERFLOWABLE indicates if we are interested in
1090    overflow of the value, when >0 we are only interested in signed
1091    overflow, for <0 we are interested in any overflow.  OVERFLOWED
1092    indicates whether overflow has already occurred.  CONST_OVERFLOWED
1093    indicates whether constant overflow has already occurred.  We force
1094    T's value to be within range of T's type (by setting to 0 or 1 all
1095    the bits outside the type's range).  We set TREE_OVERFLOWED if,
1096         OVERFLOWED is nonzero,
1097         or OVERFLOWABLE is >0 and signed overflow occurs
1098         or OVERFLOWABLE is <0 and any overflow occurs
1099    We return a new tree node for the extended double_int.  The node
1100    is shared if no overflow flags are set.  */
1101
1102
1103 tree
1104 force_fit_type_double (tree type, double_int cst, int overflowable,
1105                        bool overflowed)
1106 {
1107   bool sign_extended_type;
1108
1109   /* Size types *are* sign extended.  */
1110   sign_extended_type = (!TYPE_UNSIGNED (type)
1111                         || (TREE_CODE (type) == INTEGER_TYPE
1112                             && TYPE_IS_SIZETYPE (type)));
1113
1114   /* If we need to set overflow flags, return a new unshared node.  */
1115   if (overflowed || !double_int_fits_to_tree_p(type, cst))
1116     {
1117       if (overflowed
1118           || overflowable < 0
1119           || (overflowable > 0 && sign_extended_type))
1120         {
1121           tree t = make_node (INTEGER_CST);
1122           TREE_INT_CST (t) = double_int_ext (cst, TYPE_PRECISION (type),
1123                                              !sign_extended_type);
1124           TREE_TYPE (t) = type;
1125           TREE_OVERFLOW (t) = 1;
1126           return t;
1127         }
1128     }
1129
1130   /* Else build a shared node.  */
1131   return double_int_to_tree (type, cst);
1132 }
1133
1134 /* These are the hash table functions for the hash table of INTEGER_CST
1135    nodes of a sizetype.  */
1136
1137 /* Return the hash code code X, an INTEGER_CST.  */
1138
1139 static hashval_t
1140 int_cst_hash_hash (const void *x)
1141 {
1142   const_tree const t = (const_tree) x;
1143
1144   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1145           ^ htab_hash_pointer (TREE_TYPE (t)));
1146 }
1147
1148 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1149    is the same as that given by *Y, which is the same.  */
1150
1151 static int
1152 int_cst_hash_eq (const void *x, const void *y)
1153 {
1154   const_tree const xt = (const_tree) x;
1155   const_tree const yt = (const_tree) y;
1156
1157   return (TREE_TYPE (xt) == TREE_TYPE (yt)
1158           && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1159           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1160 }
1161
1162 /* Create an INT_CST node of TYPE and value HI:LOW.
1163    The returned node is always shared.  For small integers we use a
1164    per-type vector cache, for larger ones we use a single hash table.  */
1165
1166 tree
1167 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1168 {
1169   tree t;
1170   int ix = -1;
1171   int limit = 0;
1172
1173   gcc_assert (type);
1174
1175   switch (TREE_CODE (type))
1176     {
1177     case POINTER_TYPE:
1178     case REFERENCE_TYPE:
1179       /* Cache NULL pointer.  */
1180       if (!hi && !low)
1181         {
1182           limit = 1;
1183           ix = 0;
1184         }
1185       break;
1186
1187     case BOOLEAN_TYPE:
1188       /* Cache false or true.  */
1189       limit = 2;
1190       if (!hi && low < 2)
1191         ix = low;
1192       break;
1193
1194     case INTEGER_TYPE:
1195     case OFFSET_TYPE:
1196       if (TYPE_UNSIGNED (type))
1197         {
1198           /* Cache 0..N */
1199           limit = INTEGER_SHARE_LIMIT;
1200           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1201             ix = low;
1202         }
1203       else
1204         {
1205           /* Cache -1..N */
1206           limit = INTEGER_SHARE_LIMIT + 1;
1207           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1208             ix = low + 1;
1209           else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1210             ix = 0;
1211         }
1212       break;
1213
1214     case ENUMERAL_TYPE:
1215       break;
1216
1217     default:
1218       gcc_unreachable ();
1219     }
1220
1221   if (ix >= 0)
1222     {
1223       /* Look for it in the type's vector of small shared ints.  */
1224       if (!TYPE_CACHED_VALUES_P (type))
1225         {
1226           TYPE_CACHED_VALUES_P (type) = 1;
1227           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1228         }
1229
1230       t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1231       if (t)
1232         {
1233           /* Make sure no one is clobbering the shared constant.  */
1234           gcc_assert (TREE_TYPE (t) == type);
1235           gcc_assert (TREE_INT_CST_LOW (t) == low);
1236           gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1237         }
1238       else
1239         {
1240           /* Create a new shared int.  */
1241           t = make_node (INTEGER_CST);
1242
1243           TREE_INT_CST_LOW (t) = low;
1244           TREE_INT_CST_HIGH (t) = hi;
1245           TREE_TYPE (t) = type;
1246
1247           TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1248         }
1249     }
1250   else
1251     {
1252       /* Use the cache of larger shared ints.  */
1253       void **slot;
1254
1255       TREE_INT_CST_LOW (int_cst_node) = low;
1256       TREE_INT_CST_HIGH (int_cst_node) = hi;
1257       TREE_TYPE (int_cst_node) = type;
1258
1259       slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1260       t = (tree) *slot;
1261       if (!t)
1262         {
1263           /* Insert this one into the hash table.  */
1264           t = int_cst_node;
1265           *slot = t;
1266           /* Make a new node for next time round.  */
1267           int_cst_node = make_node (INTEGER_CST);
1268         }
1269     }
1270
1271   return t;
1272 }
1273
1274 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1275    and the rest are zeros.  */
1276
1277 tree
1278 build_low_bits_mask (tree type, unsigned bits)
1279 {
1280   double_int mask;
1281
1282   gcc_assert (bits <= TYPE_PRECISION (type));
1283
1284   if (bits == TYPE_PRECISION (type)
1285       && !TYPE_UNSIGNED (type))
1286     /* Sign extended all-ones mask.  */
1287     mask = double_int_minus_one;
1288   else
1289     mask = double_int_mask (bits);
1290
1291   return build_int_cst_wide (type, mask.low, mask.high);
1292 }
1293
1294 /* Checks that X is integer constant that can be expressed in (unsigned)
1295    HOST_WIDE_INT without loss of precision.  */
1296
1297 bool
1298 cst_and_fits_in_hwi (const_tree x)
1299 {
1300   if (TREE_CODE (x) != INTEGER_CST)
1301     return false;
1302
1303   if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1304     return false;
1305
1306   return (TREE_INT_CST_HIGH (x) == 0
1307           || TREE_INT_CST_HIGH (x) == -1);
1308 }
1309
1310 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1311    are in a list pointed to by VALS.  */
1312
1313 tree
1314 build_vector (tree type, tree vals)
1315 {
1316   tree v = make_node (VECTOR_CST);
1317   int over = 0;
1318   tree link;
1319   unsigned cnt = 0;
1320
1321   TREE_VECTOR_CST_ELTS (v) = vals;
1322   TREE_TYPE (v) = type;
1323
1324   /* Iterate through elements and check for overflow.  */
1325   for (link = vals; link; link = TREE_CHAIN (link))
1326     {
1327       tree value = TREE_VALUE (link);
1328       cnt++;
1329
1330       /* Don't crash if we get an address constant.  */
1331       if (!CONSTANT_CLASS_P (value))
1332         continue;
1333
1334       over |= TREE_OVERFLOW (value);
1335     }
1336
1337   gcc_assert (cnt == TYPE_VECTOR_SUBPARTS (type));
1338
1339   TREE_OVERFLOW (v) = over;
1340   return v;
1341 }
1342
1343 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1344    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1345
1346 tree
1347 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1348 {
1349   tree list = NULL_TREE;
1350   unsigned HOST_WIDE_INT idx;
1351   tree value;
1352
1353   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1354     list = tree_cons (NULL_TREE, value, list);
1355   for (; idx < TYPE_VECTOR_SUBPARTS (type); ++idx)
1356     list = tree_cons (NULL_TREE,
1357                       fold_convert (TREE_TYPE (type), integer_zero_node), list);
1358   return build_vector (type, nreverse (list));
1359 }
1360
1361 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1362    are in the VEC pointed to by VALS.  */
1363 tree
1364 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1365 {
1366   tree c = make_node (CONSTRUCTOR);
1367   unsigned int i;
1368   constructor_elt *elt;
1369   bool constant_p = true;
1370
1371   TREE_TYPE (c) = type;
1372   CONSTRUCTOR_ELTS (c) = vals;
1373
1374   FOR_EACH_VEC_ELT (constructor_elt, vals, i, elt)
1375     if (!TREE_CONSTANT (elt->value))
1376       {
1377         constant_p = false;
1378         break;
1379       }
1380
1381   TREE_CONSTANT (c) = constant_p;
1382
1383   return c;
1384 }
1385
1386 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1387    INDEX and VALUE.  */
1388 tree
1389 build_constructor_single (tree type, tree index, tree value)
1390 {
1391   VEC(constructor_elt,gc) *v;
1392   constructor_elt *elt;
1393
1394   v = VEC_alloc (constructor_elt, gc, 1);
1395   elt = VEC_quick_push (constructor_elt, v, NULL);
1396   elt->index = index;
1397   elt->value = value;
1398
1399   return build_constructor (type, v);
1400 }
1401
1402
1403 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1404    are in a list pointed to by VALS.  */
1405 tree
1406 build_constructor_from_list (tree type, tree vals)
1407 {
1408   tree t;
1409   VEC(constructor_elt,gc) *v = NULL;
1410
1411   if (vals)
1412     {
1413       v = VEC_alloc (constructor_elt, gc, list_length (vals));
1414       for (t = vals; t; t = TREE_CHAIN (t))
1415         CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1416     }
1417
1418   return build_constructor (type, v);
1419 }
1420
1421 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1422
1423 tree
1424 build_fixed (tree type, FIXED_VALUE_TYPE f)
1425 {
1426   tree v;
1427   FIXED_VALUE_TYPE *fp;
1428
1429   v = make_node (FIXED_CST);
1430   fp = ggc_alloc_fixed_value ();
1431   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1432
1433   TREE_TYPE (v) = type;
1434   TREE_FIXED_CST_PTR (v) = fp;
1435   return v;
1436 }
1437
1438 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1439
1440 tree
1441 build_real (tree type, REAL_VALUE_TYPE d)
1442 {
1443   tree v;
1444   REAL_VALUE_TYPE *dp;
1445   int overflow = 0;
1446
1447   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1448      Consider doing it via real_convert now.  */
1449
1450   v = make_node (REAL_CST);
1451   dp = ggc_alloc_real_value ();
1452   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1453
1454   TREE_TYPE (v) = type;
1455   TREE_REAL_CST_PTR (v) = dp;
1456   TREE_OVERFLOW (v) = overflow;
1457   return v;
1458 }
1459
1460 /* Return a new REAL_CST node whose type is TYPE
1461    and whose value is the integer value of the INTEGER_CST node I.  */
1462
1463 REAL_VALUE_TYPE
1464 real_value_from_int_cst (const_tree type, const_tree i)
1465 {
1466   REAL_VALUE_TYPE d;
1467
1468   /* Clear all bits of the real value type so that we can later do
1469      bitwise comparisons to see if two values are the same.  */
1470   memset (&d, 0, sizeof d);
1471
1472   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1473                      TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1474                      TYPE_UNSIGNED (TREE_TYPE (i)));
1475   return d;
1476 }
1477
1478 /* Given a tree representing an integer constant I, return a tree
1479    representing the same value as a floating-point constant of type TYPE.  */
1480
1481 tree
1482 build_real_from_int_cst (tree type, const_tree i)
1483 {
1484   tree v;
1485   int overflow = TREE_OVERFLOW (i);
1486
1487   v = build_real (type, real_value_from_int_cst (type, i));
1488
1489   TREE_OVERFLOW (v) |= overflow;
1490   return v;
1491 }
1492
1493 /* Return a newly constructed STRING_CST node whose value is
1494    the LEN characters at STR.
1495    The TREE_TYPE is not initialized.  */
1496
1497 tree
1498 build_string (int len, const char *str)
1499 {
1500   tree s;
1501   size_t length;
1502
1503   /* Do not waste bytes provided by padding of struct tree_string.  */
1504   length = len + offsetof (struct tree_string, str) + 1;
1505
1506 #ifdef GATHER_STATISTICS
1507   tree_node_counts[(int) c_kind]++;
1508   tree_node_sizes[(int) c_kind] += length;
1509 #endif
1510
1511   s = ggc_alloc_tree_node (length);
1512
1513   memset (s, 0, sizeof (struct tree_common));
1514   TREE_SET_CODE (s, STRING_CST);
1515   TREE_CONSTANT (s) = 1;
1516   TREE_STRING_LENGTH (s) = len;
1517   memcpy (s->string.str, str, len);
1518   s->string.str[len] = '\0';
1519
1520   return s;
1521 }
1522
1523 /* Return a newly constructed COMPLEX_CST node whose value is
1524    specified by the real and imaginary parts REAL and IMAG.
1525    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1526    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1527
1528 tree
1529 build_complex (tree type, tree real, tree imag)
1530 {
1531   tree t = make_node (COMPLEX_CST);
1532
1533   TREE_REALPART (t) = real;
1534   TREE_IMAGPART (t) = imag;
1535   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1536   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1537   return t;
1538 }
1539
1540 /* Return a constant of arithmetic type TYPE which is the
1541    multiplicative identity of the set TYPE.  */
1542
1543 tree
1544 build_one_cst (tree type)
1545 {
1546   switch (TREE_CODE (type))
1547     {
1548     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1549     case POINTER_TYPE: case REFERENCE_TYPE:
1550     case OFFSET_TYPE:
1551       return build_int_cst (type, 1);
1552
1553     case REAL_TYPE:
1554       return build_real (type, dconst1);
1555
1556     case FIXED_POINT_TYPE:
1557       /* We can only generate 1 for accum types.  */
1558       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1559       return build_fixed (type, FCONST1(TYPE_MODE (type)));
1560
1561     case VECTOR_TYPE:
1562       {
1563         tree scalar, cst;
1564         int i;
1565
1566         scalar = build_one_cst (TREE_TYPE (type));
1567
1568         /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
1569         cst = NULL_TREE;
1570         for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1571           cst = tree_cons (NULL_TREE, scalar, cst);
1572
1573         return build_vector (type, cst);
1574       }
1575
1576     case COMPLEX_TYPE:
1577       return build_complex (type,
1578                             build_one_cst (TREE_TYPE (type)),
1579                             fold_convert (TREE_TYPE (type), integer_zero_node));
1580
1581     default:
1582       gcc_unreachable ();
1583     }
1584 }
1585
1586 /* Build a BINFO with LEN language slots.  */
1587
1588 tree
1589 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1590 {
1591   tree t;
1592   size_t length = (offsetof (struct tree_binfo, base_binfos)
1593                    + VEC_embedded_size (tree, base_binfos));
1594
1595 #ifdef GATHER_STATISTICS
1596   tree_node_counts[(int) binfo_kind]++;
1597   tree_node_sizes[(int) binfo_kind] += length;
1598 #endif
1599
1600   t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
1601
1602   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1603
1604   TREE_SET_CODE (t, TREE_BINFO);
1605
1606   VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1607
1608   return t;
1609 }
1610
1611
1612 /* Build a newly constructed TREE_VEC node of length LEN.  */
1613
1614 tree
1615 make_tree_vec_stat (int len MEM_STAT_DECL)
1616 {
1617   tree t;
1618   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1619
1620 #ifdef GATHER_STATISTICS
1621   tree_node_counts[(int) vec_kind]++;
1622   tree_node_sizes[(int) vec_kind] += length;
1623 #endif
1624
1625   t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
1626
1627   TREE_SET_CODE (t, TREE_VEC);
1628   TREE_VEC_LENGTH (t) = len;
1629
1630   return t;
1631 }
1632 \f
1633 /* Return 1 if EXPR is the integer constant zero or a complex constant
1634    of zero.  */
1635
1636 int
1637 integer_zerop (const_tree expr)
1638 {
1639   STRIP_NOPS (expr);
1640
1641   return ((TREE_CODE (expr) == INTEGER_CST
1642            && TREE_INT_CST_LOW (expr) == 0
1643            && TREE_INT_CST_HIGH (expr) == 0)
1644           || (TREE_CODE (expr) == COMPLEX_CST
1645               && integer_zerop (TREE_REALPART (expr))
1646               && integer_zerop (TREE_IMAGPART (expr))));
1647 }
1648
1649 /* Return 1 if EXPR is the integer constant one or the corresponding
1650    complex constant.  */
1651
1652 int
1653 integer_onep (const_tree expr)
1654 {
1655   STRIP_NOPS (expr);
1656
1657   return ((TREE_CODE (expr) == INTEGER_CST
1658            && TREE_INT_CST_LOW (expr) == 1
1659            && TREE_INT_CST_HIGH (expr) == 0)
1660           || (TREE_CODE (expr) == COMPLEX_CST
1661               && integer_onep (TREE_REALPART (expr))
1662               && integer_zerop (TREE_IMAGPART (expr))));
1663 }
1664
1665 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1666    it contains.  Likewise for the corresponding complex constant.  */
1667
1668 int
1669 integer_all_onesp (const_tree expr)
1670 {
1671   int prec;
1672   int uns;
1673
1674   STRIP_NOPS (expr);
1675
1676   if (TREE_CODE (expr) == COMPLEX_CST
1677       && integer_all_onesp (TREE_REALPART (expr))
1678       && integer_zerop (TREE_IMAGPART (expr)))
1679     return 1;
1680
1681   else if (TREE_CODE (expr) != INTEGER_CST)
1682     return 0;
1683
1684   uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1685   if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1686       && TREE_INT_CST_HIGH (expr) == -1)
1687     return 1;
1688   if (!uns)
1689     return 0;
1690
1691   /* Note that using TYPE_PRECISION here is wrong.  We care about the
1692      actual bits, not the (arbitrary) range of the type.  */
1693   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1694   if (prec >= HOST_BITS_PER_WIDE_INT)
1695     {
1696       HOST_WIDE_INT high_value;
1697       int shift_amount;
1698
1699       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1700
1701       /* Can not handle precisions greater than twice the host int size.  */
1702       gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1703       if (shift_amount == HOST_BITS_PER_WIDE_INT)
1704         /* Shifting by the host word size is undefined according to the ANSI
1705            standard, so we must handle this as a special case.  */
1706         high_value = -1;
1707       else
1708         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1709
1710       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1711               && TREE_INT_CST_HIGH (expr) == high_value);
1712     }
1713   else
1714     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1715 }
1716
1717 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1718    one bit on).  */
1719
1720 int
1721 integer_pow2p (const_tree expr)
1722 {
1723   int prec;
1724   HOST_WIDE_INT high, low;
1725
1726   STRIP_NOPS (expr);
1727
1728   if (TREE_CODE (expr) == COMPLEX_CST
1729       && integer_pow2p (TREE_REALPART (expr))
1730       && integer_zerop (TREE_IMAGPART (expr)))
1731     return 1;
1732
1733   if (TREE_CODE (expr) != INTEGER_CST)
1734     return 0;
1735
1736   prec = TYPE_PRECISION (TREE_TYPE (expr));
1737   high = TREE_INT_CST_HIGH (expr);
1738   low = TREE_INT_CST_LOW (expr);
1739
1740   /* First clear all bits that are beyond the type's precision in case
1741      we've been sign extended.  */
1742
1743   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1744     ;
1745   else if (prec > HOST_BITS_PER_WIDE_INT)
1746     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1747   else
1748     {
1749       high = 0;
1750       if (prec < HOST_BITS_PER_WIDE_INT)
1751         low &= ~((HOST_WIDE_INT) (-1) << prec);
1752     }
1753
1754   if (high == 0 && low == 0)
1755     return 0;
1756
1757   return ((high == 0 && (low & (low - 1)) == 0)
1758           || (low == 0 && (high & (high - 1)) == 0));
1759 }
1760
1761 /* Return 1 if EXPR is an integer constant other than zero or a
1762    complex constant other than zero.  */
1763
1764 int
1765 integer_nonzerop (const_tree expr)
1766 {
1767   STRIP_NOPS (expr);
1768
1769   return ((TREE_CODE (expr) == INTEGER_CST
1770            && (TREE_INT_CST_LOW (expr) != 0
1771                || TREE_INT_CST_HIGH (expr) != 0))
1772           || (TREE_CODE (expr) == COMPLEX_CST
1773               && (integer_nonzerop (TREE_REALPART (expr))
1774                   || integer_nonzerop (TREE_IMAGPART (expr)))));
1775 }
1776
1777 /* Return 1 if EXPR is the fixed-point constant zero.  */
1778
1779 int
1780 fixed_zerop (const_tree expr)
1781 {
1782   return (TREE_CODE (expr) == FIXED_CST
1783           && double_int_zero_p (TREE_FIXED_CST (expr).data));
1784 }
1785
1786 /* Return the power of two represented by a tree node known to be a
1787    power of two.  */
1788
1789 int
1790 tree_log2 (const_tree expr)
1791 {
1792   int prec;
1793   HOST_WIDE_INT high, low;
1794
1795   STRIP_NOPS (expr);
1796
1797   if (TREE_CODE (expr) == COMPLEX_CST)
1798     return tree_log2 (TREE_REALPART (expr));
1799
1800   prec = TYPE_PRECISION (TREE_TYPE (expr));
1801   high = TREE_INT_CST_HIGH (expr);
1802   low = TREE_INT_CST_LOW (expr);
1803
1804   /* First clear all bits that are beyond the type's precision in case
1805      we've been sign extended.  */
1806
1807   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1808     ;
1809   else if (prec > HOST_BITS_PER_WIDE_INT)
1810     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1811   else
1812     {
1813       high = 0;
1814       if (prec < HOST_BITS_PER_WIDE_INT)
1815         low &= ~((HOST_WIDE_INT) (-1) << prec);
1816     }
1817
1818   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1819           : exact_log2 (low));
1820 }
1821
1822 /* Similar, but return the largest integer Y such that 2 ** Y is less
1823    than or equal to EXPR.  */
1824
1825 int
1826 tree_floor_log2 (const_tree expr)
1827 {
1828   int prec;
1829   HOST_WIDE_INT high, low;
1830
1831   STRIP_NOPS (expr);
1832
1833   if (TREE_CODE (expr) == COMPLEX_CST)
1834     return tree_log2 (TREE_REALPART (expr));
1835
1836   prec = TYPE_PRECISION (TREE_TYPE (expr));
1837   high = TREE_INT_CST_HIGH (expr);
1838   low = TREE_INT_CST_LOW (expr);
1839
1840   /* First clear all bits that are beyond the type's precision in case
1841      we've been sign extended.  Ignore if type's precision hasn't been set
1842      since what we are doing is setting it.  */
1843
1844   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1845     ;
1846   else if (prec > HOST_BITS_PER_WIDE_INT)
1847     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1848   else
1849     {
1850       high = 0;
1851       if (prec < HOST_BITS_PER_WIDE_INT)
1852         low &= ~((HOST_WIDE_INT) (-1) << prec);
1853     }
1854
1855   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1856           : floor_log2 (low));
1857 }
1858
1859 /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
1860    decimal float constants, so don't return 1 for them.  */
1861
1862 int
1863 real_zerop (const_tree expr)
1864 {
1865   STRIP_NOPS (expr);
1866
1867   return ((TREE_CODE (expr) == REAL_CST
1868            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1869            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1870           || (TREE_CODE (expr) == COMPLEX_CST
1871               && real_zerop (TREE_REALPART (expr))
1872               && real_zerop (TREE_IMAGPART (expr))));
1873 }
1874
1875 /* Return 1 if EXPR is the real constant one in real or complex form.
1876    Trailing zeroes matter for decimal float constants, so don't return
1877    1 for them.  */
1878
1879 int
1880 real_onep (const_tree expr)
1881 {
1882   STRIP_NOPS (expr);
1883
1884   return ((TREE_CODE (expr) == REAL_CST
1885            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1886            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1887           || (TREE_CODE (expr) == COMPLEX_CST
1888               && real_onep (TREE_REALPART (expr))
1889               && real_zerop (TREE_IMAGPART (expr))));
1890 }
1891
1892 /* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
1893    for decimal float constants, so don't return 1 for them.  */
1894
1895 int
1896 real_twop (const_tree expr)
1897 {
1898   STRIP_NOPS (expr);
1899
1900   return ((TREE_CODE (expr) == REAL_CST
1901            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1902            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1903           || (TREE_CODE (expr) == COMPLEX_CST
1904               && real_twop (TREE_REALPART (expr))
1905               && real_zerop (TREE_IMAGPART (expr))));
1906 }
1907
1908 /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
1909    matter for decimal float constants, so don't return 1 for them.  */
1910
1911 int
1912 real_minus_onep (const_tree expr)
1913 {
1914   STRIP_NOPS (expr);
1915
1916   return ((TREE_CODE (expr) == REAL_CST
1917            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1918            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1919           || (TREE_CODE (expr) == COMPLEX_CST
1920               && real_minus_onep (TREE_REALPART (expr))
1921               && real_zerop (TREE_IMAGPART (expr))));
1922 }
1923
1924 /* Nonzero if EXP is a constant or a cast of a constant.  */
1925
1926 int
1927 really_constant_p (const_tree exp)
1928 {
1929   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1930   while (CONVERT_EXPR_P (exp)
1931          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1932     exp = TREE_OPERAND (exp, 0);
1933   return TREE_CONSTANT (exp);
1934 }
1935 \f
1936 /* Return first list element whose TREE_VALUE is ELEM.
1937    Return 0 if ELEM is not in LIST.  */
1938
1939 tree
1940 value_member (tree elem, tree list)
1941 {
1942   while (list)
1943     {
1944       if (elem == TREE_VALUE (list))
1945         return list;
1946       list = TREE_CHAIN (list);
1947     }
1948   return NULL_TREE;
1949 }
1950
1951 /* Return first list element whose TREE_PURPOSE is ELEM.
1952    Return 0 if ELEM is not in LIST.  */
1953
1954 tree
1955 purpose_member (const_tree elem, tree list)
1956 {
1957   while (list)
1958     {
1959       if (elem == TREE_PURPOSE (list))
1960         return list;
1961       list = TREE_CHAIN (list);
1962     }
1963   return NULL_TREE;
1964 }
1965
1966 /* Return true if ELEM is in V.  */
1967
1968 bool
1969 vec_member (const_tree elem, VEC(tree,gc) *v)
1970 {
1971   unsigned ix;
1972   tree t;
1973   FOR_EACH_VEC_ELT (tree, v, ix, t)
1974     if (elem == t)
1975       return true;
1976   return false;
1977 }
1978
1979 /* Returns element number IDX (zero-origin) of chain CHAIN, or
1980    NULL_TREE.  */
1981
1982 tree
1983 chain_index (int idx, tree chain)
1984 {
1985   for (; chain && idx > 0; --idx)
1986     chain = TREE_CHAIN (chain);
1987   return chain;
1988 }
1989
1990 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1991
1992 int
1993 chain_member (const_tree elem, const_tree chain)
1994 {
1995   while (chain)
1996     {
1997       if (elem == chain)
1998         return 1;
1999       chain = DECL_CHAIN (chain);
2000     }
2001
2002   return 0;
2003 }
2004
2005 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2006    We expect a null pointer to mark the end of the chain.
2007    This is the Lisp primitive `length'.  */
2008
2009 int
2010 list_length (const_tree t)
2011 {
2012   const_tree p = t;
2013 #ifdef ENABLE_TREE_CHECKING
2014   const_tree q = t;
2015 #endif
2016   int len = 0;
2017
2018   while (p)
2019     {
2020       p = TREE_CHAIN (p);
2021 #ifdef ENABLE_TREE_CHECKING
2022       if (len % 2)
2023         q = TREE_CHAIN (q);
2024       gcc_assert (p != q);
2025 #endif
2026       len++;
2027     }
2028
2029   return len;
2030 }
2031
2032 /* Returns the number of FIELD_DECLs in TYPE.  */
2033
2034 int
2035 fields_length (const_tree type)
2036 {
2037   tree t = TYPE_FIELDS (type);
2038   int count = 0;
2039
2040   for (; t; t = DECL_CHAIN (t))
2041     if (TREE_CODE (t) == FIELD_DECL)
2042       ++count;
2043
2044   return count;
2045 }
2046
2047 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2048    UNION_TYPE TYPE, or NULL_TREE if none.  */
2049
2050 tree
2051 first_field (const_tree type)
2052 {
2053   tree t = TYPE_FIELDS (type);
2054   while (t && TREE_CODE (t) != FIELD_DECL)
2055     t = TREE_CHAIN (t);
2056   return t;
2057 }
2058
2059 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2060    by modifying the last node in chain 1 to point to chain 2.
2061    This is the Lisp primitive `nconc'.  */
2062
2063 tree
2064 chainon (tree op1, tree op2)
2065 {
2066   tree t1;
2067
2068   if (!op1)
2069     return op2;
2070   if (!op2)
2071     return op1;
2072
2073   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2074     continue;
2075   TREE_CHAIN (t1) = op2;
2076
2077 #ifdef ENABLE_TREE_CHECKING
2078   {
2079     tree t2;
2080     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2081       gcc_assert (t2 != t1);
2082   }
2083 #endif
2084
2085   return op1;
2086 }
2087
2088 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
2089
2090 tree
2091 tree_last (tree chain)
2092 {
2093   tree next;
2094   if (chain)
2095     while ((next = TREE_CHAIN (chain)))
2096       chain = next;
2097   return chain;
2098 }
2099
2100 /* Reverse the order of elements in the chain T,
2101    and return the new head of the chain (old last element).  */
2102
2103 tree
2104 nreverse (tree t)
2105 {
2106   tree prev = 0, decl, next;
2107   for (decl = t; decl; decl = next)
2108     {
2109       /* We shouldn't be using this function to reverse BLOCK chains; we
2110          have blocks_nreverse for that.  */
2111       gcc_checking_assert (TREE_CODE (decl) != BLOCK);
2112       next = TREE_CHAIN (decl);
2113       TREE_CHAIN (decl) = prev;
2114       prev = decl;
2115     }
2116   return prev;
2117 }
2118 \f
2119 /* Return a newly created TREE_LIST node whose
2120    purpose and value fields are PARM and VALUE.  */
2121
2122 tree
2123 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2124 {
2125   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2126   TREE_PURPOSE (t) = parm;
2127   TREE_VALUE (t) = value;
2128   return t;
2129 }
2130
2131 /* Build a chain of TREE_LIST nodes from a vector.  */
2132
2133 tree
2134 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2135 {
2136   tree ret = NULL_TREE;
2137   tree *pp = &ret;
2138   unsigned int i;
2139   tree t;
2140   FOR_EACH_VEC_ELT (tree, vec, i, t)
2141     {
2142       *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2143       pp = &TREE_CHAIN (*pp);
2144     }
2145   return ret;
2146 }
2147
2148 /* Return a newly created TREE_LIST node whose
2149    purpose and value fields are PURPOSE and VALUE
2150    and whose TREE_CHAIN is CHAIN.  */
2151
2152 tree
2153 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2154 {
2155   tree node;
2156
2157   node = ggc_alloc_zone_tree_node_stat (&tree_zone, sizeof (struct tree_list)
2158                                         PASS_MEM_STAT);
2159   memset (node, 0, sizeof (struct tree_common));
2160
2161 #ifdef GATHER_STATISTICS
2162   tree_node_counts[(int) x_kind]++;
2163   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2164 #endif
2165
2166   TREE_SET_CODE (node, TREE_LIST);
2167   TREE_CHAIN (node) = chain;
2168   TREE_PURPOSE (node) = purpose;
2169   TREE_VALUE (node) = value;
2170   return node;
2171 }
2172
2173 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2174    trees.  */
2175
2176 VEC(tree,gc) *
2177 ctor_to_vec (tree ctor)
2178 {
2179   VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2180   unsigned int ix;
2181   tree val;
2182
2183   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2184     VEC_quick_push (tree, vec, val);
2185
2186   return vec;
2187 }
2188 \f
2189 /* Return the size nominally occupied by an object of type TYPE
2190    when it resides in memory.  The value is measured in units of bytes,
2191    and its data type is that normally used for type sizes
2192    (which is the first type created by make_signed_type or
2193    make_unsigned_type).  */
2194
2195 tree
2196 size_in_bytes (const_tree type)
2197 {
2198   tree t;
2199
2200   if (type == error_mark_node)
2201     return integer_zero_node;
2202
2203   type = TYPE_MAIN_VARIANT (type);
2204   t = TYPE_SIZE_UNIT (type);
2205
2206   if (t == 0)
2207     {
2208       lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2209       return size_zero_node;
2210     }
2211
2212   return t;
2213 }
2214
2215 /* Return the size of TYPE (in bytes) as a wide integer
2216    or return -1 if the size can vary or is larger than an integer.  */
2217
2218 HOST_WIDE_INT
2219 int_size_in_bytes (const_tree type)
2220 {
2221   tree t;
2222
2223   if (type == error_mark_node)
2224     return 0;
2225
2226   type = TYPE_MAIN_VARIANT (type);
2227   t = TYPE_SIZE_UNIT (type);
2228   if (t == 0
2229       || TREE_CODE (t) != INTEGER_CST
2230       || TREE_INT_CST_HIGH (t) != 0
2231       /* If the result would appear negative, it's too big to represent.  */
2232       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2233     return -1;
2234
2235   return TREE_INT_CST_LOW (t);
2236 }
2237
2238 /* Return the maximum size of TYPE (in bytes) as a wide integer
2239    or return -1 if the size can vary or is larger than an integer.  */
2240
2241 HOST_WIDE_INT
2242 max_int_size_in_bytes (const_tree type)
2243 {
2244   HOST_WIDE_INT size = -1;
2245   tree size_tree;
2246
2247   /* If this is an array type, check for a possible MAX_SIZE attached.  */
2248
2249   if (TREE_CODE (type) == ARRAY_TYPE)
2250     {
2251       size_tree = TYPE_ARRAY_MAX_SIZE (type);
2252
2253       if (size_tree && host_integerp (size_tree, 1))
2254         size = tree_low_cst (size_tree, 1);
2255     }
2256
2257   /* If we still haven't been able to get a size, see if the language
2258      can compute a maximum size.  */
2259
2260   if (size == -1)
2261     {
2262       size_tree = lang_hooks.types.max_size (type);
2263
2264       if (size_tree && host_integerp (size_tree, 1))
2265         size = tree_low_cst (size_tree, 1);
2266     }
2267
2268   return size;
2269 }
2270
2271 /* Returns a tree for the size of EXP in bytes.  */
2272
2273 tree
2274 tree_expr_size (const_tree exp)
2275 {
2276   if (DECL_P (exp)
2277       && DECL_SIZE_UNIT (exp) != 0)
2278     return DECL_SIZE_UNIT (exp);
2279   else
2280     return size_in_bytes (TREE_TYPE (exp));
2281 }
2282 \f
2283 /* Return the bit position of FIELD, in bits from the start of the record.
2284    This is a tree of type bitsizetype.  */
2285
2286 tree
2287 bit_position (const_tree field)
2288 {
2289   return bit_from_pos (DECL_FIELD_OFFSET (field),
2290                        DECL_FIELD_BIT_OFFSET (field));
2291 }
2292
2293 /* Likewise, but return as an integer.  It must be representable in
2294    that way (since it could be a signed value, we don't have the
2295    option of returning -1 like int_size_in_byte can.  */
2296
2297 HOST_WIDE_INT
2298 int_bit_position (const_tree field)
2299 {
2300   return tree_low_cst (bit_position (field), 0);
2301 }
2302 \f
2303 /* Return the byte position of FIELD, in bytes from the start of the record.
2304    This is a tree of type sizetype.  */
2305
2306 tree
2307 byte_position (const_tree field)
2308 {
2309   return byte_from_pos (DECL_FIELD_OFFSET (field),
2310                         DECL_FIELD_BIT_OFFSET (field));
2311 }
2312
2313 /* Likewise, but return as an integer.  It must be representable in
2314    that way (since it could be a signed value, we don't have the
2315    option of returning -1 like int_size_in_byte can.  */
2316
2317 HOST_WIDE_INT
2318 int_byte_position (const_tree field)
2319 {
2320   return tree_low_cst (byte_position (field), 0);
2321 }
2322 \f
2323 /* Return the strictest alignment, in bits, that T is known to have.  */
2324
2325 unsigned int
2326 expr_align (const_tree t)
2327 {
2328   unsigned int align0, align1;
2329
2330   switch (TREE_CODE (t))
2331     {
2332     CASE_CONVERT:  case NON_LVALUE_EXPR:
2333       /* If we have conversions, we know that the alignment of the
2334          object must meet each of the alignments of the types.  */
2335       align0 = expr_align (TREE_OPERAND (t, 0));
2336       align1 = TYPE_ALIGN (TREE_TYPE (t));
2337       return MAX (align0, align1);
2338
2339     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
2340     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
2341     case CLEANUP_POINT_EXPR:
2342       /* These don't change the alignment of an object.  */
2343       return expr_align (TREE_OPERAND (t, 0));
2344
2345     case COND_EXPR:
2346       /* The best we can do is say that the alignment is the least aligned
2347          of the two arms.  */
2348       align0 = expr_align (TREE_OPERAND (t, 1));
2349       align1 = expr_align (TREE_OPERAND (t, 2));
2350       return MIN (align0, align1);
2351
2352       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2353          meaningfully, it's always 1.  */
2354     case LABEL_DECL:     case CONST_DECL:
2355     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
2356     case FUNCTION_DECL:
2357       gcc_assert (DECL_ALIGN (t) != 0);
2358       return DECL_ALIGN (t);
2359
2360     default:
2361       break;
2362     }
2363
2364   /* Otherwise take the alignment from that of the type.  */
2365   return TYPE_ALIGN (TREE_TYPE (t));
2366 }
2367 \f
2368 /* Return, as a tree node, the number of elements for TYPE (which is an
2369    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
2370
2371 tree
2372 array_type_nelts (const_tree type)
2373 {
2374   tree index_type, min, max;
2375
2376   /* If they did it with unspecified bounds, then we should have already
2377      given an error about it before we got here.  */
2378   if (! TYPE_DOMAIN (type))
2379     return error_mark_node;
2380
2381   index_type = TYPE_DOMAIN (type);
2382   min = TYPE_MIN_VALUE (index_type);
2383   max = TYPE_MAX_VALUE (index_type);
2384
2385   return (integer_zerop (min)
2386           ? max
2387           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2388 }
2389 \f
2390 /* If arg is static -- a reference to an object in static storage -- then
2391    return the object.  This is not the same as the C meaning of `static'.
2392    If arg isn't static, return NULL.  */
2393
2394 tree
2395 staticp (tree arg)
2396 {
2397   switch (TREE_CODE (arg))
2398     {
2399     case FUNCTION_DECL:
2400       /* Nested functions are static, even though taking their address will
2401          involve a trampoline as we unnest the nested function and create
2402          the trampoline on the tree level.  */
2403       return arg;
2404
2405     case VAR_DECL:
2406       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2407               && ! DECL_THREAD_LOCAL_P (arg)
2408               && ! DECL_DLLIMPORT_P (arg)
2409               ? arg : NULL);
2410
2411     case CONST_DECL:
2412       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2413               ? arg : NULL);
2414
2415     case CONSTRUCTOR:
2416       return TREE_STATIC (arg) ? arg : NULL;
2417
2418     case LABEL_DECL:
2419     case STRING_CST:
2420       return arg;
2421
2422     case COMPONENT_REF:
2423       /* If the thing being referenced is not a field, then it is
2424          something language specific.  */
2425       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2426
2427       /* If we are referencing a bitfield, we can't evaluate an
2428          ADDR_EXPR at compile time and so it isn't a constant.  */
2429       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2430         return NULL;
2431
2432       return staticp (TREE_OPERAND (arg, 0));
2433
2434     case BIT_FIELD_REF:
2435       return NULL;
2436
2437     case MISALIGNED_INDIRECT_REF:
2438     case INDIRECT_REF:
2439       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2440
2441     case ARRAY_REF:
2442     case ARRAY_RANGE_REF:
2443       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2444           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2445         return staticp (TREE_OPERAND (arg, 0));
2446       else
2447         return NULL;
2448
2449     case COMPOUND_LITERAL_EXPR:
2450       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2451
2452     default:
2453       return NULL;
2454     }
2455 }
2456
2457 \f
2458
2459
2460 /* Return whether OP is a DECL whose address is function-invariant.  */
2461
2462 bool
2463 decl_address_invariant_p (const_tree op)
2464 {
2465   /* The conditions below are slightly less strict than the one in
2466      staticp.  */
2467
2468   switch (TREE_CODE (op))
2469     {
2470     case PARM_DECL:
2471     case RESULT_DECL:
2472     case LABEL_DECL:
2473     case FUNCTION_DECL:
2474       return true;
2475
2476     case VAR_DECL:
2477       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2478           || DECL_THREAD_LOCAL_P (op)
2479           || DECL_CONTEXT (op) == current_function_decl
2480           || decl_function_context (op) == current_function_decl)
2481         return true;
2482       break;
2483
2484     case CONST_DECL:
2485       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2486           || decl_function_context (op) == current_function_decl)
2487         return true;
2488       break;
2489
2490     default:
2491       break;
2492     }
2493
2494   return false;
2495 }
2496
2497 /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
2498
2499 bool
2500 decl_address_ip_invariant_p (const_tree op)
2501 {
2502   /* The conditions below are slightly less strict than the one in
2503      staticp.  */
2504
2505   switch (TREE_CODE (op))
2506     {
2507     case LABEL_DECL:
2508     case FUNCTION_DECL:
2509     case STRING_CST:
2510       return true;
2511
2512     case VAR_DECL:
2513       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2514            && !DECL_DLLIMPORT_P (op))
2515           || DECL_THREAD_LOCAL_P (op))
2516         return true;
2517       break;
2518
2519     case CONST_DECL:
2520       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2521         return true;
2522       break;
2523
2524     default:
2525       break;
2526     }
2527
2528   return false;
2529 }
2530
2531
2532 /* Return true if T is function-invariant (internal function, does
2533    not handle arithmetic; that's handled in skip_simple_arithmetic and
2534    tree_invariant_p).  */
2535
2536 static bool tree_invariant_p (tree t);
2537
2538 static bool
2539 tree_invariant_p_1 (tree t)
2540 {
2541   tree op;
2542
2543   if (TREE_CONSTANT (t)
2544       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2545     return true;
2546
2547   switch (TREE_CODE (t))
2548     {
2549     case SAVE_EXPR:
2550       return true;
2551
2552     case ADDR_EXPR:
2553       op = TREE_OPERAND (t, 0);
2554       while (handled_component_p (op))
2555         {
2556           switch (TREE_CODE (op))
2557             {
2558             case ARRAY_REF:
2559             case ARRAY_RANGE_REF:
2560               if (!tree_invariant_p (TREE_OPERAND (op, 1))
2561                   || TREE_OPERAND (op, 2) != NULL_TREE
2562                   || TREE_OPERAND (op, 3) != NULL_TREE)
2563                 return false;
2564               break;
2565
2566             case COMPONENT_REF:
2567               if (TREE_OPERAND (op, 2) != NULL_TREE)
2568                 return false;
2569               break;
2570
2571             default:;
2572             }
2573           op = TREE_OPERAND (op, 0);
2574         }
2575
2576       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2577
2578     default:
2579       break;
2580     }
2581
2582   return false;
2583 }
2584
2585 /* Return true if T is function-invariant.  */
2586
2587 static bool
2588 tree_invariant_p (tree t)
2589 {
2590   tree inner = skip_simple_arithmetic (t);
2591   return tree_invariant_p_1 (inner);
2592 }
2593
2594 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2595    Do this to any expression which may be used in more than one place,
2596    but must be evaluated only once.
2597
2598    Normally, expand_expr would reevaluate the expression each time.
2599    Calling save_expr produces something that is evaluated and recorded
2600    the first time expand_expr is called on it.  Subsequent calls to
2601    expand_expr just reuse the recorded value.
2602
2603    The call to expand_expr that generates code that actually computes
2604    the value is the first call *at compile time*.  Subsequent calls
2605    *at compile time* generate code to use the saved value.
2606    This produces correct result provided that *at run time* control
2607    always flows through the insns made by the first expand_expr
2608    before reaching the other places where the save_expr was evaluated.
2609    You, the caller of save_expr, must make sure this is so.
2610
2611    Constants, and certain read-only nodes, are returned with no
2612    SAVE_EXPR because that is safe.  Expressions containing placeholders
2613    are not touched; see tree.def for an explanation of what these
2614    are used for.  */
2615
2616 tree
2617 save_expr (tree expr)
2618 {
2619   tree t = fold (expr);
2620   tree inner;
2621
2622   /* If the tree evaluates to a constant, then we don't want to hide that
2623      fact (i.e. this allows further folding, and direct checks for constants).
2624      However, a read-only object that has side effects cannot be bypassed.
2625      Since it is no problem to reevaluate literals, we just return the
2626      literal node.  */
2627   inner = skip_simple_arithmetic (t);
2628   if (TREE_CODE (inner) == ERROR_MARK)
2629     return inner;
2630
2631   if (tree_invariant_p_1 (inner))
2632     return t;
2633
2634   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2635      it means that the size or offset of some field of an object depends on
2636      the value within another field.
2637
2638      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2639      and some variable since it would then need to be both evaluated once and
2640      evaluated more than once.  Front-ends must assure this case cannot
2641      happen by surrounding any such subexpressions in their own SAVE_EXPR
2642      and forcing evaluation at the proper time.  */
2643   if (contains_placeholder_p (inner))
2644     return t;
2645
2646   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2647   SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2648
2649   /* This expression might be placed ahead of a jump to ensure that the
2650      value was computed on both sides of the jump.  So make sure it isn't
2651      eliminated as dead.  */
2652   TREE_SIDE_EFFECTS (t) = 1;
2653   return t;
2654 }
2655
2656 /* Look inside EXPR and into any simple arithmetic operations.  Return
2657    the innermost non-arithmetic node.  */
2658
2659 tree
2660 skip_simple_arithmetic (tree expr)
2661 {
2662   tree inner;
2663
2664   /* We don't care about whether this can be used as an lvalue in this
2665      context.  */
2666   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2667     expr = TREE_OPERAND (expr, 0);
2668
2669   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2670      a constant, it will be more efficient to not make another SAVE_EXPR since
2671      it will allow better simplification and GCSE will be able to merge the
2672      computations if they actually occur.  */
2673   inner = expr;
2674   while (1)
2675     {
2676       if (UNARY_CLASS_P (inner))
2677         inner = TREE_OPERAND (inner, 0);
2678       else if (BINARY_CLASS_P (inner))
2679         {
2680           if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2681             inner = TREE_OPERAND (inner, 0);
2682           else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2683             inner = TREE_OPERAND (inner, 1);
2684           else
2685             break;
2686         }
2687       else
2688         break;
2689     }
2690
2691   return inner;
2692 }
2693
2694
2695 /* Return which tree structure is used by T.  */
2696
2697 enum tree_node_structure_enum
2698 tree_node_structure (const_tree t)
2699 {
2700   const enum tree_code code = TREE_CODE (t);
2701   return tree_node_structure_for_code (code);
2702 }
2703
2704 /* Set various status flags when building a CALL_EXPR object T.  */
2705
2706 static void
2707 process_call_operands (tree t)
2708 {
2709   bool side_effects = TREE_SIDE_EFFECTS (t);
2710   bool read_only = false;
2711   int i = call_expr_flags (t);
2712
2713   /* Calls have side-effects, except those to const or pure functions.  */
2714   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2715     side_effects = true;
2716   /* Propagate TREE_READONLY of arguments for const functions.  */
2717   if (i & ECF_CONST)
2718     read_only = true;
2719
2720   if (!side_effects || read_only)
2721     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2722       {
2723         tree op = TREE_OPERAND (t, i);
2724         if (op && TREE_SIDE_EFFECTS (op))
2725           side_effects = true;
2726         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2727           read_only = false;
2728       }
2729
2730   TREE_SIDE_EFFECTS (t) = side_effects;
2731   TREE_READONLY (t) = read_only;
2732 }
2733 \f
2734 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2735    or offset that depends on a field within a record.  */
2736
2737 bool
2738 contains_placeholder_p (const_tree exp)
2739 {
2740   enum tree_code code;
2741
2742   if (!exp)
2743     return 0;
2744
2745   code = TREE_CODE (exp);
2746   if (code == PLACEHOLDER_EXPR)
2747     return 1;
2748
2749   switch (TREE_CODE_CLASS (code))
2750     {
2751     case tcc_reference:
2752       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2753          position computations since they will be converted into a
2754          WITH_RECORD_EXPR involving the reference, which will assume
2755          here will be valid.  */
2756       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2757
2758     case tcc_exceptional:
2759       if (code == TREE_LIST)
2760         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2761                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2762       break;
2763
2764     case tcc_unary:
2765     case tcc_binary:
2766     case tcc_comparison:
2767     case tcc_expression:
2768       switch (code)
2769         {
2770         case COMPOUND_EXPR:
2771           /* Ignoring the first operand isn't quite right, but works best.  */
2772           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2773
2774         case COND_EXPR:
2775           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2776                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2777                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2778
2779         case SAVE_EXPR:
2780           /* The save_expr function never wraps anything containing
2781              a PLACEHOLDER_EXPR. */
2782           return 0;
2783
2784         default:
2785           break;
2786         }
2787
2788       switch (TREE_CODE_LENGTH (code))
2789         {
2790         case 1:
2791           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2792         case 2:
2793           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2794                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2795         default:
2796           return 0;
2797         }
2798
2799     case tcc_vl_exp:
2800       switch (code)
2801         {
2802         case CALL_EXPR:
2803           {
2804             const_tree arg;
2805             const_call_expr_arg_iterator iter;
2806             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2807               if (CONTAINS_PLACEHOLDER_P (arg))
2808                 return 1;
2809             return 0;
2810           }
2811         default:
2812           return 0;
2813         }
2814
2815     default:
2816       return 0;
2817     }
2818   return 0;
2819 }
2820
2821 /* Return true if any part of the computation of TYPE involves a
2822    PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2823    (for QUAL_UNION_TYPE) and field positions.  */
2824
2825 static bool
2826 type_contains_placeholder_1 (const_tree type)
2827 {
2828   /* If the size contains a placeholder or the parent type (component type in
2829      the case of arrays) type involves a placeholder, this type does.  */
2830   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2831       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2832       || (TREE_TYPE (type) != 0
2833           && type_contains_placeholder_p (TREE_TYPE (type))))
2834     return true;
2835
2836   /* Now do type-specific checks.  Note that the last part of the check above
2837      greatly limits what we have to do below.  */
2838   switch (TREE_CODE (type))
2839     {
2840     case VOID_TYPE:
2841     case COMPLEX_TYPE:
2842     case ENUMERAL_TYPE:
2843     case BOOLEAN_TYPE:
2844     case POINTER_TYPE:
2845     case OFFSET_TYPE:
2846     case REFERENCE_TYPE:
2847     case METHOD_TYPE:
2848     case FUNCTION_TYPE:
2849     case VECTOR_TYPE:
2850       return false;
2851
2852     case INTEGER_TYPE:
2853     case REAL_TYPE:
2854     case FIXED_POINT_TYPE:
2855       /* Here we just check the bounds.  */
2856       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2857               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2858
2859     case ARRAY_TYPE:
2860       /* We're already checked the component type (TREE_TYPE), so just check
2861          the index type.  */
2862       return type_contains_placeholder_p (TYPE_DOMAIN (type));
2863
2864     case RECORD_TYPE:
2865     case UNION_TYPE:
2866     case QUAL_UNION_TYPE:
2867       {
2868         tree field;
2869
2870         for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2871           if (TREE_CODE (field) == FIELD_DECL
2872               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2873                   || (TREE_CODE (type) == QUAL_UNION_TYPE
2874                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2875                   || type_contains_placeholder_p (TREE_TYPE (field))))
2876             return true;
2877
2878         return false;
2879       }
2880
2881     default:
2882       gcc_unreachable ();
2883     }
2884 }
2885
2886 bool
2887 type_contains_placeholder_p (tree type)
2888 {
2889   bool result;
2890
2891   /* If the contains_placeholder_bits field has been initialized,
2892      then we know the answer.  */
2893   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2894     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2895
2896   /* Indicate that we've seen this type node, and the answer is false.
2897      This is what we want to return if we run into recursion via fields.  */
2898   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2899
2900   /* Compute the real value.  */
2901   result = type_contains_placeholder_1 (type);
2902
2903   /* Store the real value.  */
2904   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2905
2906   return result;
2907 }
2908 \f
2909 /* Push tree EXP onto vector QUEUE if it is not already present.  */
2910
2911 static void
2912 push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2913 {
2914   unsigned int i;
2915   tree iter;
2916
2917   FOR_EACH_VEC_ELT (tree, *queue, i, iter)
2918     if (simple_cst_equal (iter, exp) == 1)
2919       break;
2920
2921   if (!iter)
2922     VEC_safe_push (tree, heap, *queue, exp);
2923 }
2924
2925 /* Given a tree EXP, find all occurences of references to fields
2926    in a PLACEHOLDER_EXPR and place them in vector REFS without
2927    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
2928    we assume here that EXP contains only arithmetic expressions
2929    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2930    argument list.  */
2931
2932 void
2933 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2934 {
2935   enum tree_code code = TREE_CODE (exp);
2936   tree inner;
2937   int i;
2938
2939   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2940   if (code == TREE_LIST)
2941     {
2942       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2943       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2944     }
2945   else if (code == COMPONENT_REF)
2946     {
2947       for (inner = TREE_OPERAND (exp, 0);
2948            REFERENCE_CLASS_P (inner);
2949            inner = TREE_OPERAND (inner, 0))
2950         ;
2951
2952       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2953         push_without_duplicates (exp, refs);
2954       else
2955         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2956    }
2957   else
2958     switch (TREE_CODE_CLASS (code))
2959       {
2960       case tcc_constant:
2961         break;
2962
2963       case tcc_declaration:
2964         /* Variables allocated to static storage can stay.  */
2965         if (!TREE_STATIC (exp))
2966           push_without_duplicates (exp, refs);
2967         break;
2968
2969       case tcc_expression:
2970         /* This is the pattern built in ada/make_aligning_type.  */
2971         if (code == ADDR_EXPR
2972             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
2973           {
2974             push_without_duplicates (exp, refs);
2975             break;
2976           }
2977
2978         /* Fall through...  */
2979
2980       case tcc_exceptional:
2981       case tcc_unary:
2982       case tcc_binary:
2983       case tcc_comparison:
2984       case tcc_reference:
2985         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
2986           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2987         break;
2988
2989       case tcc_vl_exp:
2990         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
2991           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2992         break;
2993
2994       default:
2995         gcc_unreachable ();
2996       }
2997 }
2998
2999 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3000    return a tree with all occurrences of references to F in a
3001    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
3002    CONST_DECLs.  Note that we assume here that EXP contains only
3003    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3004    occurring only in their argument list.  */
3005
3006 tree
3007 substitute_in_expr (tree exp, tree f, tree r)
3008 {
3009   enum tree_code code = TREE_CODE (exp);
3010   tree op0, op1, op2, op3;
3011   tree new_tree;
3012
3013   /* We handle TREE_LIST and COMPONENT_REF separately.  */
3014   if (code == TREE_LIST)
3015     {
3016       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3017       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3018       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3019         return exp;
3020
3021       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3022     }
3023   else if (code == COMPONENT_REF)
3024     {
3025       tree inner;
3026
3027       /* If this expression is getting a value from a PLACEHOLDER_EXPR
3028          and it is the right field, replace it with R.  */
3029       for (inner = TREE_OPERAND (exp, 0);
3030            REFERENCE_CLASS_P (inner);
3031            inner = TREE_OPERAND (inner, 0))
3032         ;
3033
3034       /* The field.  */
3035       op1 = TREE_OPERAND (exp, 1);
3036
3037       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3038         return r;
3039
3040       /* If this expression hasn't been completed let, leave it alone.  */
3041       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3042         return exp;
3043
3044       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3045       if (op0 == TREE_OPERAND (exp, 0))
3046         return exp;
3047
3048       new_tree
3049         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3050    }
3051   else
3052     switch (TREE_CODE_CLASS (code))
3053       {
3054       case tcc_constant:
3055         return exp;
3056
3057       case tcc_declaration:
3058         if (exp == f)
3059           return r;
3060         else
3061           return exp;
3062
3063       case tcc_expression:
3064         if (exp == f)
3065           return r;
3066
3067         /* Fall through...  */
3068
3069       case tcc_exceptional:
3070       case tcc_unary:
3071       case tcc_binary:
3072       case tcc_comparison:
3073       case tcc_reference:
3074         switch (TREE_CODE_LENGTH (code))
3075           {
3076           case 0:
3077             return exp;
3078
3079           case 1:
3080             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3081             if (op0 == TREE_OPERAND (exp, 0))
3082               return exp;
3083
3084             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3085             break;
3086
3087           case 2:
3088             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3089             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3090
3091             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3092               return exp;
3093
3094             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3095             break;
3096
3097           case 3:
3098             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3099             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3100             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3101
3102             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3103                 && op2 == TREE_OPERAND (exp, 2))
3104               return exp;
3105
3106             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3107             break;
3108
3109           case 4:
3110             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3111             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3112             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3113             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3114
3115             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3116                 && op2 == TREE_OPERAND (exp, 2)
3117                 && op3 == TREE_OPERAND (exp, 3))
3118               return exp;
3119
3120             new_tree
3121               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3122             break;
3123
3124           default:
3125             gcc_unreachable ();
3126           }
3127         break;
3128
3129       case tcc_vl_exp:
3130         {
3131           int i;
3132
3133           new_tree = NULL_TREE;
3134
3135           /* If we are trying to replace F with a constant, inline back
3136              functions which do nothing else than computing a value from
3137              the arguments they are passed.  This makes it possible to
3138              fold partially or entirely the replacement expression.  */
3139           if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3140             {
3141               tree t = maybe_inline_call_in_expr (exp);
3142               if (t)
3143                 return SUBSTITUTE_IN_EXPR (t, f, r);
3144             }
3145
3146           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3147             {
3148               tree op = TREE_OPERAND (exp, i);
3149               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3150               if (new_op != op)
3151                 {
3152                   if (!new_tree)
3153                     new_tree = copy_node (exp);
3154                   TREE_OPERAND (new_tree, i) = new_op;
3155                 }
3156             }
3157
3158           if (new_tree)
3159             {
3160               new_tree = fold (new_tree);
3161               if (TREE_CODE (new_tree) == CALL_EXPR)
3162                 process_call_operands (new_tree);
3163             }
3164           else
3165             return exp;
3166         }
3167         break;
3168
3169       default:
3170         gcc_unreachable ();
3171       }
3172
3173   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3174   return new_tree;
3175 }
3176
3177 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3178    for it within OBJ, a tree that is an object or a chain of references.  */
3179
3180 tree
3181 substitute_placeholder_in_expr (tree exp, tree obj)
3182 {
3183   enum tree_code code = TREE_CODE (exp);
3184   tree op0, op1, op2, op3;
3185   tree new_tree;
3186
3187   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3188      in the chain of OBJ.  */
3189   if (code == PLACEHOLDER_EXPR)
3190     {
3191       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3192       tree elt;
3193
3194       for (elt = obj; elt != 0;
3195            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3196                    || TREE_CODE (elt) == COND_EXPR)
3197                   ? TREE_OPERAND (elt, 1)
3198                   : (REFERENCE_CLASS_P (elt)
3199                      || UNARY_CLASS_P (elt)
3200                      || BINARY_CLASS_P (elt)
3201                      || VL_EXP_CLASS_P (elt)
3202                      || EXPRESSION_CLASS_P (elt))
3203                   ? TREE_OPERAND (elt, 0) : 0))
3204         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3205           return elt;
3206
3207       for (elt = obj; elt != 0;
3208            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3209                    || TREE_CODE (elt) == COND_EXPR)
3210                   ? TREE_OPERAND (elt, 1)
3211                   : (REFERENCE_CLASS_P (elt)
3212                      || UNARY_CLASS_P (elt)
3213                      || BINARY_CLASS_P (elt)
3214                      || VL_EXP_CLASS_P (elt)
3215                      || EXPRESSION_CLASS_P (elt))
3216                   ? TREE_OPERAND (elt, 0) : 0))
3217         if (POINTER_TYPE_P (TREE_TYPE (elt))
3218             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3219                 == need_type))
3220           return fold_build1 (INDIRECT_REF, need_type, elt);
3221
3222       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3223          survives until RTL generation, there will be an error.  */
3224       return exp;
3225     }
3226
3227   /* TREE_LIST is special because we need to look at TREE_VALUE
3228      and TREE_CHAIN, not TREE_OPERANDS.  */
3229   else if (code == TREE_LIST)
3230     {
3231       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3232       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3233       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3234         return exp;
3235
3236       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3237     }
3238   else
3239     switch (TREE_CODE_CLASS (code))
3240       {
3241       case tcc_constant:
3242       case tcc_declaration:
3243         return exp;
3244
3245       case tcc_exceptional:
3246       case tcc_unary:
3247       case tcc_binary:
3248       case tcc_comparison:
3249       case tcc_expression:
3250       case tcc_reference:
3251       case tcc_statement:
3252         switch (TREE_CODE_LENGTH (code))
3253           {
3254           case 0:
3255             return exp;
3256
3257           case 1:
3258             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3259             if (op0 == TREE_OPERAND (exp, 0))
3260               return exp;
3261
3262             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3263             break;
3264
3265           case 2:
3266             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3267             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3268
3269             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3270               return exp;
3271
3272             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3273             break;
3274
3275           case 3:
3276             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3277             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3278             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3279
3280             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3281                 && op2 == TREE_OPERAND (exp, 2))
3282               return exp;
3283
3284             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3285             break;
3286
3287           case 4:
3288             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3289             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3290             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3291             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3292
3293             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3294                 && op2 == TREE_OPERAND (exp, 2)
3295                 && op3 == TREE_OPERAND (exp, 3))
3296               return exp;
3297
3298             new_tree
3299               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3300             break;
3301
3302           default:
3303             gcc_unreachable ();
3304           }
3305         break;
3306
3307       case tcc_vl_exp:
3308         {
3309           int i;
3310
3311           new_tree = NULL_TREE;
3312
3313           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3314             {
3315               tree op = TREE_OPERAND (exp, i);
3316               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3317               if (new_op != op)
3318                 {
3319                   if (!new_tree)
3320                     new_tree = copy_node (exp);
3321                   TREE_OPERAND (new_tree, i) = new_op;
3322                 }
3323             }
3324
3325           if (new_tree)
3326             {
3327               new_tree = fold (new_tree);
3328               if (TREE_CODE (new_tree) == CALL_EXPR)
3329                 process_call_operands (new_tree);
3330             }
3331           else
3332             return exp;
3333         }
3334         break;
3335
3336       default:
3337         gcc_unreachable ();
3338       }
3339
3340   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3341   return new_tree;
3342 }
3343 \f
3344 /* Stabilize a reference so that we can use it any number of times
3345    without causing its operands to be evaluated more than once.
3346    Returns the stabilized reference.  This works by means of save_expr,
3347    so see the caveats in the comments about save_expr.
3348
3349    Also allows conversion expressions whose operands are references.
3350    Any other kind of expression is returned unchanged.  */
3351
3352 tree
3353 stabilize_reference (tree ref)
3354 {
3355   tree result;
3356   enum tree_code code = TREE_CODE (ref);
3357
3358   switch (code)
3359     {
3360     case VAR_DECL:
3361     case PARM_DECL:
3362     case RESULT_DECL:
3363       /* No action is needed in this case.  */
3364       return ref;
3365
3366     CASE_CONVERT:
3367     case FLOAT_EXPR:
3368     case FIX_TRUNC_EXPR:
3369       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3370       break;
3371
3372     case INDIRECT_REF:
3373       result = build_nt (INDIRECT_REF,
3374                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3375       break;
3376
3377     case COMPONENT_REF:
3378       result = build_nt (COMPONENT_REF,
3379                          stabilize_reference (TREE_OPERAND (ref, 0)),
3380                          TREE_OPERAND (ref, 1), NULL_TREE);
3381       break;
3382
3383     case BIT_FIELD_REF:
3384       result = build_nt (BIT_FIELD_REF,
3385                          stabilize_reference (TREE_OPERAND (ref, 0)),
3386                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3387                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3388       break;
3389
3390     case ARRAY_REF:
3391       result = build_nt (ARRAY_REF,
3392                          stabilize_reference (TREE_OPERAND (ref, 0)),
3393                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3394                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3395       break;
3396
3397     case ARRAY_RANGE_REF:
3398       result = build_nt (ARRAY_RANGE_REF,
3399                          stabilize_reference (TREE_OPERAND (ref, 0)),
3400                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3401                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3402       break;
3403
3404     case COMPOUND_EXPR:
3405       /* We cannot wrap the first expression in a SAVE_EXPR, as then
3406          it wouldn't be ignored.  This matters when dealing with
3407          volatiles.  */
3408       return stabilize_reference_1 (ref);
3409
3410       /* If arg isn't a kind of lvalue we recognize, make no change.
3411          Caller should recognize the error for an invalid lvalue.  */
3412     default:
3413       return ref;
3414
3415     case ERROR_MARK:
3416       return error_mark_node;
3417     }
3418
3419   TREE_TYPE (result) = TREE_TYPE (ref);
3420   TREE_READONLY (result) = TREE_READONLY (ref);
3421   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3422   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3423
3424   return result;
3425 }
3426
3427 /* Subroutine of stabilize_reference; this is called for subtrees of
3428    references.  Any expression with side-effects must be put in a SAVE_EXPR
3429    to ensure that it is only evaluated once.
3430
3431    We don't put SAVE_EXPR nodes around everything, because assigning very
3432    simple expressions to temporaries causes us to miss good opportunities
3433    for optimizations.  Among other things, the opportunity to fold in the
3434    addition of a constant into an addressing mode often gets lost, e.g.
3435    "y[i+1] += x;".  In general, we take the approach that we should not make
3436    an assignment unless we are forced into it - i.e., that any non-side effect
3437    operator should be allowed, and that cse should take care of coalescing
3438    multiple utterances of the same expression should that prove fruitful.  */
3439
3440 tree
3441 stabilize_reference_1 (tree e)
3442 {
3443   tree result;
3444   enum tree_code code = TREE_CODE (e);
3445
3446   /* We cannot ignore const expressions because it might be a reference
3447      to a const array but whose index contains side-effects.  But we can
3448      ignore things that are actual constant or that already have been
3449      handled by this function.  */
3450
3451   if (tree_invariant_p (e))
3452     return e;
3453
3454   switch (TREE_CODE_CLASS (code))
3455     {
3456     case tcc_exceptional:
3457     case tcc_type:
3458     case tcc_declaration:
3459     case tcc_comparison:
3460     case tcc_statement:
3461     case tcc_expression:
3462     case tcc_reference:
3463     case tcc_vl_exp:
3464       /* If the expression has side-effects, then encase it in a SAVE_EXPR
3465          so that it will only be evaluated once.  */
3466       /* The reference (r) and comparison (<) classes could be handled as
3467          below, but it is generally faster to only evaluate them once.  */
3468       if (TREE_SIDE_EFFECTS (e))
3469         return save_expr (e);
3470       return e;
3471
3472     case tcc_constant:
3473       /* Constants need no processing.  In fact, we should never reach
3474          here.  */
3475       return e;
3476
3477     case tcc_binary:
3478       /* Division is slow and tends to be compiled with jumps,
3479          especially the division by powers of 2 that is often
3480          found inside of an array reference.  So do it just once.  */
3481       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3482           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3483           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3484           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3485         return save_expr (e);
3486       /* Recursively stabilize each operand.  */
3487       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3488                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
3489       break;
3490
3491     case tcc_unary:
3492       /* Recursively stabilize each operand.  */
3493       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3494       break;
3495
3496     default:
3497       gcc_unreachable ();
3498     }
3499
3500   TREE_TYPE (result) = TREE_TYPE (e);
3501   TREE_READONLY (result) = TREE_READONLY (e);
3502   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3503   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3504
3505   return result;
3506 }
3507 \f
3508 /* Low-level constructors for expressions.  */
3509
3510 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
3511    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
3512
3513 void
3514 recompute_tree_invariant_for_addr_expr (tree t)
3515 {
3516   tree node;
3517   bool tc = true, se = false;
3518
3519   /* We started out assuming this address is both invariant and constant, but
3520      does not have side effects.  Now go down any handled components and see if
3521      any of them involve offsets that are either non-constant or non-invariant.
3522      Also check for side-effects.
3523
3524      ??? Note that this code makes no attempt to deal with the case where
3525      taking the address of something causes a copy due to misalignment.  */
3526
3527 #define UPDATE_FLAGS(NODE)  \
3528 do { tree _node = (NODE); \
3529      if (_node && !TREE_CONSTANT (_node)) tc = false; \
3530      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3531
3532   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3533        node = TREE_OPERAND (node, 0))
3534     {
3535       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3536          array reference (probably made temporarily by the G++ front end),
3537          so ignore all the operands.  */
3538       if ((TREE_CODE (node) == ARRAY_REF
3539            || TREE_CODE (node) == ARRAY_RANGE_REF)
3540           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3541         {
3542           UPDATE_FLAGS (TREE_OPERAND (node, 1));
3543           if (TREE_OPERAND (node, 2))
3544             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3545           if (TREE_OPERAND (node, 3))
3546             UPDATE_FLAGS (TREE_OPERAND (node, 3));
3547         }
3548       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3549          FIELD_DECL, apparently.  The G++ front end can put something else
3550          there, at least temporarily.  */
3551       else if (TREE_CODE (node) == COMPONENT_REF
3552                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3553         {
3554           if (TREE_OPERAND (node, 2))
3555             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3556         }
3557       else if (TREE_CODE (node) == BIT_FIELD_REF)
3558         UPDATE_FLAGS (TREE_OPERAND (node, 2));
3559     }
3560
3561   node = lang_hooks.expr_to_decl (node, &tc, &se);
3562
3563   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
3564      the address, since &(*a)->b is a form of addition.  If it's a constant, the
3565      address is constant too.  If it's a decl, its address is constant if the
3566      decl is static.  Everything else is not constant and, furthermore,
3567      taking the address of a volatile variable is not volatile.  */
3568   if (TREE_CODE (node) == INDIRECT_REF
3569       || TREE_CODE (node) == MEM_REF)
3570     UPDATE_FLAGS (TREE_OPERAND (node, 0));
3571   else if (CONSTANT_CLASS_P (node))
3572     ;
3573   else if (DECL_P (node))
3574     tc &= (staticp (node) != NULL_TREE);
3575   else
3576     {
3577       tc = false;
3578       se |= TREE_SIDE_EFFECTS (node);
3579     }
3580
3581
3582   TREE_CONSTANT (t) = tc;
3583   TREE_SIDE_EFFECTS (t) = se;
3584 #undef UPDATE_FLAGS
3585 }
3586
3587 /* Build an expression of code CODE, data type TYPE, and operands as
3588    specified.  Expressions and reference nodes can be created this way.
3589    Constants, decls, types and misc nodes cannot be.
3590
3591    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
3592    enough for all extant tree codes.  */
3593
3594 tree
3595 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3596 {
3597   tree t;
3598
3599   gcc_assert (TREE_CODE_LENGTH (code) == 0);
3600
3601   t = make_node_stat (code PASS_MEM_STAT);
3602   TREE_TYPE (t) = tt;
3603
3604   return t;
3605 }
3606
3607 tree
3608 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3609 {
3610   int length = sizeof (struct tree_exp);
3611 #ifdef GATHER_STATISTICS
3612   tree_node_kind kind;
3613 #endif
3614   tree t;
3615
3616 #ifdef GATHER_STATISTICS
3617   switch (TREE_CODE_CLASS (code))
3618     {
3619     case tcc_statement:  /* an expression with side effects */
3620       kind = s_kind;
3621       break;
3622     case tcc_reference:  /* a reference */
3623       kind = r_kind;
3624       break;
3625     default:
3626       kind = e_kind;
3627       break;
3628     }
3629
3630   tree_node_counts[(int) kind]++;
3631   tree_node_sizes[(int) kind] += length;
3632 #endif
3633
3634   gcc_assert (TREE_CODE_LENGTH (code) == 1);
3635
3636   t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
3637
3638   memset (t, 0, sizeof (struct tree_common));
3639
3640   TREE_SET_CODE (t, code);
3641
3642   TREE_TYPE (t) = type;
3643   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3644   TREE_OPERAND (t, 0) = node;
3645   TREE_BLOCK (t) = NULL_TREE;
3646   if (node && !TYPE_P (node))
3647     {
3648       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3649       TREE_READONLY (t) = TREE_READONLY (node);
3650     }
3651
3652   if (TREE_CODE_CLASS (code) == tcc_statement)
3653     TREE_SIDE_EFFECTS (t) = 1;
3654   else switch (code)
3655     {
3656     case VA_ARG_EXPR:
3657       /* All of these have side-effects, no matter what their
3658          operands are.  */
3659       TREE_SIDE_EFFECTS (t) = 1;
3660       TREE_READONLY (t) = 0;
3661       break;
3662
3663     case MISALIGNED_INDIRECT_REF:
3664     case INDIRECT_REF:
3665       /* Whether a dereference is readonly has nothing to do with whether
3666          its operand is readonly.  */
3667       TREE_READONLY (t) = 0;
3668       break;
3669
3670     case ADDR_EXPR:
3671       if (node)
3672         recompute_tree_invariant_for_addr_expr (t);
3673       break;
3674
3675     default:
3676       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3677           && node && !TYPE_P (node)
3678           && TREE_CONSTANT (node))
3679         TREE_CONSTANT (t) = 1;
3680       if (TREE_CODE_CLASS (code) == tcc_reference
3681           && node && TREE_THIS_VOLATILE (node))
3682         TREE_THIS_VOLATILE (t) = 1;
3683       break;
3684     }
3685
3686   return t;
3687 }
3688
3689 #define PROCESS_ARG(N)                          \
3690   do {                                          \
3691     TREE_OPERAND (t, N) = arg##N;               \
3692     if (arg##N &&!TYPE_P (arg##N))              \
3693       {                                         \
3694         if (TREE_SIDE_EFFECTS (arg##N))         \
3695           side_effects = 1;                     \
3696         if (!TREE_READONLY (arg##N)             \
3697             && !CONSTANT_CLASS_P (arg##N))      \
3698           (void) (read_only = 0);               \
3699         if (!TREE_CONSTANT (arg##N))            \
3700           (void) (constant = 0);                \
3701       }                                         \
3702   } while (0)
3703
3704 tree
3705 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3706 {
3707   bool constant, read_only, side_effects;
3708   tree t;
3709
3710   gcc_assert (TREE_CODE_LENGTH (code) == 2);
3711
3712   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3713       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3714       /* When sizetype precision doesn't match that of pointers
3715          we need to be able to build explicit extensions or truncations
3716          of the offset argument.  */
3717       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3718     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3719                 && TREE_CODE (arg1) == INTEGER_CST);
3720
3721   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3722     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3723                 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3724                 && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3725
3726   t = make_node_stat (code PASS_MEM_STAT);
3727   TREE_TYPE (t) = tt;
3728
3729   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3730      result based on those same flags for the arguments.  But if the
3731      arguments aren't really even `tree' expressions, we shouldn't be trying
3732      to do this.  */
3733
3734   /* Expressions without side effects may be constant if their
3735      arguments are as well.  */
3736   constant = (TREE_CODE_CLASS (code) == tcc_comparison
3737               || TREE_CODE_CLASS (code) == tcc_binary);
3738   read_only = 1;
3739   side_effects = TREE_SIDE_EFFECTS (t);
3740
3741   PROCESS_ARG(0);
3742   PROCESS_ARG(1);
3743
3744   TREE_READONLY (t) = read_only;
3745   TREE_CONSTANT (t) = constant;
3746   TREE_SIDE_EFFECTS (t) = side_effects;
3747   TREE_THIS_VOLATILE (t)
3748     = (TREE_CODE_CLASS (code) == tcc_reference
3749        && arg0 && TREE_THIS_VOLATILE (arg0));
3750
3751   return t;
3752 }
3753
3754
3755 tree
3756 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3757              tree arg2 MEM_STAT_DECL)
3758 {
3759   bool constant, read_only, side_effects;
3760   tree t;
3761
3762   gcc_assert (TREE_CODE_LENGTH (code) == 3);
3763   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3764
3765   t = make_node_stat (code PASS_MEM_STAT);
3766   TREE_TYPE (t) = tt;
3767
3768   read_only = 1;
3769
3770   /* As a special exception, if COND_EXPR has NULL branches, we
3771      assume that it is a gimple statement and always consider
3772      it to have side effects.  */
3773   if (code == COND_EXPR
3774       && tt == void_type_node
3775       && arg1 == NULL_TREE
3776       && arg2 == NULL_TREE)
3777     side_effects = true;
3778   else
3779     side_effects = TREE_SIDE_EFFECTS (t);
3780
3781   PROCESS_ARG(0);
3782   PROCESS_ARG(1);
3783   PROCESS_ARG(2);
3784
3785   if (code == COND_EXPR)
3786     TREE_READONLY (t) = read_only;
3787
3788   TREE_SIDE_EFFECTS (t) = side_effects;
3789   TREE_THIS_VOLATILE (t)
3790     = (TREE_CODE_CLASS (code) == tcc_reference
3791        && arg0 && TREE_THIS_VOLATILE (arg0));
3792
3793   return t;
3794 }
3795
3796 tree
3797 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3798              tree arg2, tree arg3 MEM_STAT_DECL)
3799 {
3800   bool constant, read_only, side_effects;
3801   tree t;
3802
3803   gcc_assert (TREE_CODE_LENGTH (code) == 4);
3804
3805   t = make_node_stat (code PASS_MEM_STAT);
3806   TREE_TYPE (t) = tt;
3807
3808   side_effects = TREE_SIDE_EFFECTS (t);
3809
3810   PROCESS_ARG(0);
3811   PROCESS_ARG(1);
3812   PROCESS_ARG(2);
3813   PROCESS_ARG(3);
3814
3815   TREE_SIDE_EFFECTS (t) = side_effects;
3816   TREE_THIS_VOLATILE (t)
3817     = (TREE_CODE_CLASS (code) == tcc_reference
3818        && arg0 && TREE_THIS_VOLATILE (arg0));
3819
3820   return t;
3821 }
3822
3823 tree
3824 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3825              tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
3826 {
3827   bool constant, read_only, side_effects;
3828   tree t;
3829
3830   gcc_assert (TREE_CODE_LENGTH (code) == 5);
3831
3832   t = make_node_stat (code PASS_MEM_STAT);
3833   TREE_TYPE (t) = tt;
3834
3835   side_effects = TREE_SIDE_EFFECTS (t);
3836
3837   PROCESS_ARG(0);
3838   PROCESS_ARG(1);
3839   PROCESS_ARG(2);
3840   PROCESS_ARG(3);
3841   PROCESS_ARG(4);
3842
3843   TREE_SIDE_EFFECTS (t) = side_effects;
3844   TREE_THIS_VOLATILE (t)
3845     = (TREE_CODE_CLASS (code) == tcc_reference
3846        && arg0 && TREE_THIS_VOLATILE (arg0));
3847
3848   return t;
3849 }
3850
3851 tree
3852 build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3853              tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL)
3854 {
3855   bool constant, read_only, side_effects;
3856   tree t;
3857
3858   gcc_assert (code == TARGET_MEM_REF);
3859
3860   t = make_node_stat (code PASS_MEM_STAT);
3861   TREE_TYPE (t) = tt;
3862
3863   side_effects = TREE_SIDE_EFFECTS (t);
3864
3865   PROCESS_ARG(0);
3866   PROCESS_ARG(1);
3867   PROCESS_ARG(2);
3868   PROCESS_ARG(3);
3869   PROCESS_ARG(4);
3870   if (code == TARGET_MEM_REF)
3871     side_effects = 0;
3872   PROCESS_ARG(5);
3873
3874   TREE_SIDE_EFFECTS (t) = side_effects;
3875   TREE_THIS_VOLATILE (t)
3876     = (code == TARGET_MEM_REF
3877        && arg5 && TREE_THIS_VOLATILE (arg5));
3878
3879   return t;
3880 }
3881
3882 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
3883    on the pointer PTR.  */
3884
3885 tree
3886 build_simple_mem_ref_loc (location_t loc, tree ptr)
3887 {
3888   HOST_WIDE_INT offset = 0;
3889   tree ptype = TREE_TYPE (ptr);
3890   tree tem;
3891   /* For convenience allow addresses that collapse to a simple base
3892      and offset.  */
3893   if (TREE_CODE (ptr) == ADDR_EXPR
3894       && (handled_component_p (TREE_OPERAND (ptr, 0))
3895           || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
3896     {
3897       ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
3898       gcc_assert (ptr);
3899       ptr = build_fold_addr_expr (ptr);
3900       gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
3901     }
3902   tem = build2 (MEM_REF, TREE_TYPE (ptype),
3903                 ptr, build_int_cst (ptype, offset));
3904   SET_EXPR_LOCATION (tem, loc);
3905   return tem;
3906 }
3907
3908 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T.  */
3909
3910 double_int
3911 mem_ref_offset (const_tree t)
3912 {
3913   tree toff = TREE_CODE (t) == MEM_REF ? TREE_OPERAND (t, 1) : TMR_OFFSET (t);
3914   return double_int_sext (tree_to_double_int (toff),
3915                           TYPE_PRECISION (TREE_TYPE (toff)));
3916 }
3917
3918 /* Return the pointer-type relevant for TBAA purposes from the
3919    gimple memory reference tree T.  This is the type to be used for
3920    the offset operand of MEM_REF or TARGET_MEM_REF replacements of T.  */
3921
3922 tree
3923 reference_alias_ptr_type (const_tree t)
3924 {
3925   const_tree base = t;
3926   while (handled_component_p (base))
3927     base = TREE_OPERAND (base, 0);
3928   if (TREE_CODE (base) == MEM_REF)
3929     return TREE_TYPE (TREE_OPERAND (base, 1));
3930   else if (TREE_CODE (base) == TARGET_MEM_REF)
3931     return TREE_TYPE (TMR_OFFSET (base));
3932   else if (TREE_CODE (base) == MISALIGNED_INDIRECT_REF)
3933     return NULL_TREE;
3934   else
3935     return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (base)));
3936 }
3937
3938 /* Similar except don't specify the TREE_TYPE
3939    and leave the TREE_SIDE_EFFECTS as 0.
3940    It is permissible for arguments to be null,
3941    or even garbage if their values do not matter.  */
3942
3943 tree
3944 build_nt (enum tree_code code, ...)
3945 {
3946   tree t;
3947   int length;
3948   int i;
3949   va_list p;
3950
3951   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3952
3953   va_start (p, code);
3954
3955   t = make_node (code);
3956   length = TREE_CODE_LENGTH (code);
3957
3958   for (i = 0; i < length; i++)
3959     TREE_OPERAND (t, i) = va_arg (p, tree);
3960
3961   va_end (p);
3962   return t;
3963 }
3964
3965 /* Similar to build_nt, but for creating a CALL_EXPR object with a
3966    tree VEC.  */
3967
3968 tree
3969 build_nt_call_vec (tree fn, VEC(tree,gc) *args)
3970 {
3971   tree ret, t;
3972   unsigned int ix;
3973
3974   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
3975   CALL_EXPR_FN (ret) = fn;
3976   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3977   FOR_EACH_VEC_ELT (tree, args, ix, t)
3978     CALL_EXPR_ARG (ret, ix) = t;
3979   return ret;
3980 }
3981 \f
3982 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3983    We do NOT enter this node in any sort of symbol table.
3984
3985    LOC is the location of the decl.
3986
3987    layout_decl is used to set up the decl's storage layout.
3988    Other slots are initialized to 0 or null pointers.  */
3989
3990 tree
3991 build_decl_stat (location_t loc, enum tree_code code, tree name,
3992                  tree type MEM_STAT_DECL)
3993 {
3994   tree t;
3995
3996   t = make_node_stat (code PASS_MEM_STAT);
3997   DECL_SOURCE_LOCATION (t) = loc;
3998
3999 /*  if (type == error_mark_node)
4000     type = integer_type_node; */
4001 /* That is not done, deliberately, so that having error_mark_node
4002    as the type can suppress useless errors in the use of this variable.  */
4003
4004   DECL_NAME (t) = name;
4005   TREE_TYPE (t) = type;
4006
4007   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4008     layout_decl (t, 0);
4009
4010   return t;
4011 }
4012
4013 /* Builds and returns function declaration with NAME and TYPE.  */
4014
4015 tree
4016 build_fn_decl (const char *name, tree type)
4017 {
4018   tree id = get_identifier (name);
4019   tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4020
4021   DECL_EXTERNAL (decl) = 1;
4022   TREE_PUBLIC (decl) = 1;
4023   DECL_ARTIFICIAL (decl) = 1;
4024   TREE_NOTHROW (decl) = 1;
4025
4026   return decl;
4027 }
4028
4029 \f
4030 /* BLOCK nodes are used to represent the structure of binding contours
4031    and declarations, once those contours have been exited and their contents
4032    compiled.  This information is used for outputting debugging info.  */
4033
4034 tree
4035 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4036 {
4037   tree block = make_node (BLOCK);
4038
4039   BLOCK_VARS (block) = vars;
4040   BLOCK_SUBBLOCKS (block) = subblocks;
4041   BLOCK_SUPERCONTEXT (block) = supercontext;
4042   BLOCK_CHAIN (block) = chain;
4043   return block;
4044 }
4045
4046 \f
4047 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4048
4049    LOC is the location to use in tree T.  */
4050
4051 void
4052 protected_set_expr_location (tree t, location_t loc)
4053 {
4054   if (t && CAN_HAVE_LOCATION_P (t))
4055     SET_EXPR_LOCATION (t, loc);
4056 }
4057 \f
4058 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4059    is ATTRIBUTE.  */
4060
4061 tree
4062 build_decl_attribute_variant (tree ddecl, tree attribute)
4063 {
4064   DECL_ATTRIBUTES (ddecl) = attribute;
4065   return ddecl;
4066 }
4067
4068 /* Borrowed from hashtab.c iterative_hash implementation.  */
4069 #define mix(a,b,c) \
4070 { \
4071   a -= b; a -= c; a ^= (c>>13); \
4072   b -= c; b -= a; b ^= (a<< 8); \
4073   c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4074   a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4075   b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4076   c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4077   a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4078   b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4079   c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4080 }
4081
4082
4083 /* Produce good hash value combining VAL and VAL2.  */
4084 hashval_t
4085 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
4086 {
4087   /* the golden ratio; an arbitrary value.  */
4088   hashval_t a = 0x9e3779b9;
4089
4090   mix (a, val, val2);
4091   return val2;
4092 }
4093
4094 /* Produce good hash value combining VAL and VAL2.  */
4095 hashval_t
4096 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4097 {
4098   if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4099     return iterative_hash_hashval_t (val, val2);
4100   else
4101     {
4102       hashval_t a = (hashval_t) val;
4103       /* Avoid warnings about shifting of more than the width of the type on
4104          hosts that won't execute this path.  */
4105       int zero = 0;
4106       hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4107       mix (a, b, val2);
4108       if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4109         {
4110           hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4111           hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4112           mix (a, b, val2);
4113         }
4114       return val2;
4115     }
4116 }
4117
4118 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4119    is ATTRIBUTE and its qualifiers are QUALS.
4120
4121    Record such modified types already made so we don't make duplicates.  */
4122
4123 tree
4124 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4125 {
4126   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4127     {
4128       hashval_t hashcode = 0;
4129       tree ntype;
4130       enum tree_code code = TREE_CODE (ttype);
4131
4132       /* Building a distinct copy of a tagged type is inappropriate; it
4133          causes breakage in code that expects there to be a one-to-one
4134          relationship between a struct and its fields.
4135          build_duplicate_type is another solution (as used in
4136          handle_transparent_union_attribute), but that doesn't play well
4137          with the stronger C++ type identity model.  */
4138       if (TREE_CODE (ttype) == RECORD_TYPE
4139           || TREE_CODE (ttype) == UNION_TYPE
4140           || TREE_CODE (ttype) == QUAL_UNION_TYPE
4141           || TREE_CODE (ttype) == ENUMERAL_TYPE)
4142         {
4143           warning (OPT_Wattributes,
4144                    "ignoring attributes applied to %qT after definition",
4145                    TYPE_MAIN_VARIANT (ttype));
4146           return build_qualified_type (ttype, quals);
4147         }
4148
4149       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4150       ntype = build_distinct_type_copy (ttype);
4151
4152       TYPE_ATTRIBUTES (ntype) = attribute;
4153
4154       hashcode = iterative_hash_object (code, hashcode);
4155       if (TREE_TYPE (ntype))
4156         hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4157                                           hashcode);
4158       hashcode = attribute_hash_list (attribute, hashcode);
4159
4160       switch (TREE_CODE (ntype))
4161         {
4162         case FUNCTION_TYPE:
4163           hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4164           break;
4165         case ARRAY_TYPE:
4166           if (TYPE_DOMAIN (ntype))
4167             hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4168                                               hashcode);
4169           break;
4170         case INTEGER_TYPE:
4171           hashcode = iterative_hash_object
4172             (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4173           hashcode = iterative_hash_object
4174             (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4175           break;
4176         case REAL_TYPE:
4177         case FIXED_POINT_TYPE:
4178           {
4179             unsigned int precision = TYPE_PRECISION (ntype);
4180             hashcode = iterative_hash_object (precision, hashcode);
4181           }
4182           break;
4183         default:
4184           break;
4185         }
4186
4187       ntype = type_hash_canon (hashcode, ntype);
4188
4189       /* If the target-dependent attributes make NTYPE different from
4190          its canonical type, we will need to use structural equality
4191          checks for this type. */
4192       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4193           || !targetm.comp_type_attributes (ntype, ttype))
4194         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4195       else if (TYPE_CANONICAL (ntype) == ntype)
4196         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4197
4198       ttype = build_qualified_type (ntype, quals);
4199     }
4200   else if (TYPE_QUALS (ttype) != quals)
4201     ttype = build_qualified_type (ttype, quals);
4202
4203   return ttype;
4204 }
4205
4206
4207 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4208    is ATTRIBUTE.
4209
4210    Record such modified types already made so we don't make duplicates.  */
4211
4212 tree
4213 build_type_attribute_variant (tree ttype, tree attribute)
4214 {
4215   return build_type_attribute_qual_variant (ttype, attribute,
4216                                             TYPE_QUALS (ttype));
4217 }
4218
4219
4220 /* Reset the expression *EXPR_P, a size or position.
4221
4222    ??? We could reset all non-constant sizes or positions.  But it's cheap
4223    enough to not do so and refrain from adding workarounds to dwarf2out.c.
4224
4225    We need to reset self-referential sizes or positions because they cannot
4226    be gimplified and thus can contain a CALL_EXPR after the gimplification
4227    is finished, which will run afoul of LTO streaming.  And they need to be
4228    reset to something essentially dummy but not constant, so as to preserve
4229    the properties of the object they are attached to.  */
4230
4231 static inline void
4232 free_lang_data_in_one_sizepos (tree *expr_p)
4233 {
4234   tree expr = *expr_p;
4235   if (CONTAINS_PLACEHOLDER_P (expr))
4236     *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4237 }
4238
4239
4240 /* Reset all the fields in a binfo node BINFO.  We only keep
4241    BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref.  */
4242
4243 static void
4244 free_lang_data_in_binfo (tree binfo)
4245 {
4246   unsigned i;
4247   tree t;
4248
4249   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4250
4251   BINFO_VTABLE (binfo) = NULL_TREE;
4252   BINFO_BASE_ACCESSES (binfo) = NULL;
4253   BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4254   BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4255
4256   FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (binfo), i, t)
4257     free_lang_data_in_binfo (t);
4258 }
4259
4260
4261 /* Reset all language specific information still present in TYPE.  */
4262
4263 static void
4264 free_lang_data_in_type (tree type)
4265 {
4266   gcc_assert (TYPE_P (type));
4267
4268   /* Give the FE a chance to remove its own data first.  */
4269   lang_hooks.free_lang_data (type);
4270
4271   TREE_LANG_FLAG_0 (type) = 0;
4272   TREE_LANG_FLAG_1 (type) = 0;
4273   TREE_LANG_FLAG_2 (type) = 0;
4274   TREE_LANG_FLAG_3 (type) = 0;
4275   TREE_LANG_FLAG_4 (type) = 0;
4276   TREE_LANG_FLAG_5 (type) = 0;
4277   TREE_LANG_FLAG_6 (type) = 0;
4278
4279   if (TREE_CODE (type) == FUNCTION_TYPE)
4280     {
4281       /* Remove the const and volatile qualifiers from arguments.  The
4282          C++ front end removes them, but the C front end does not,
4283          leading to false ODR violation errors when merging two
4284          instances of the same function signature compiled by
4285          different front ends.  */
4286       tree p;
4287
4288       for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4289         {
4290           tree arg_type = TREE_VALUE (p);
4291
4292           if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4293             {
4294               int quals = TYPE_QUALS (arg_type)
4295                           & ~TYPE_QUAL_CONST
4296                           & ~TYPE_QUAL_VOLATILE;
4297               TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4298               free_lang_data_in_type (TREE_VALUE (p));
4299             }
4300         }
4301     }
4302
4303   /* Remove members that are not actually FIELD_DECLs from the field
4304      list of an aggregate.  These occur in C++.  */
4305   if (RECORD_OR_UNION_TYPE_P (type))
4306     {
4307       tree prev, member;
4308
4309       /* Note that TYPE_FIELDS can be shared across distinct
4310          TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
4311          to be removed, we cannot set its TREE_CHAIN to NULL.
4312          Otherwise, we would not be able to find all the other fields
4313          in the other instances of this TREE_TYPE.
4314
4315          This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
4316       prev = NULL_TREE;
4317       member = TYPE_FIELDS (type);
4318       while (member)
4319         {
4320           if (TREE_CODE (member) == FIELD_DECL)
4321             {
4322               if (prev)
4323                 TREE_CHAIN (prev) = member;
4324               else
4325                 TYPE_FIELDS (type) = member;
4326               prev = member;
4327             }
4328
4329           member = TREE_CHAIN (member);
4330         }
4331
4332       if (prev)
4333         TREE_CHAIN (prev) = NULL_TREE;
4334       else
4335         TYPE_FIELDS (type) = NULL_TREE;
4336
4337       TYPE_METHODS (type) = NULL_TREE;
4338       if (TYPE_BINFO (type))
4339         free_lang_data_in_binfo (TYPE_BINFO (type));
4340     }
4341   else
4342     {
4343       /* For non-aggregate types, clear out the language slot (which
4344          overloads TYPE_BINFO).  */
4345       TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4346
4347       if (INTEGRAL_TYPE_P (type)
4348           || SCALAR_FLOAT_TYPE_P (type)
4349           || FIXED_POINT_TYPE_P (type))
4350         {
4351           free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
4352           free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
4353         }
4354     }
4355
4356   free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
4357   free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
4358
4359   if (debug_info_level < DINFO_LEVEL_TERSE
4360       || (TYPE_CONTEXT (type)
4361           && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
4362           && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL))
4363     TYPE_CONTEXT (type) = NULL_TREE;
4364
4365   if (debug_info_level < DINFO_LEVEL_TERSE)
4366     TYPE_STUB_DECL (type) = NULL_TREE;
4367 }
4368
4369
4370 /* Return true if DECL may need an assembler name to be set.  */
4371
4372 static inline bool
4373 need_assembler_name_p (tree decl)
4374 {
4375   /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
4376   if (TREE_CODE (decl) != FUNCTION_DECL
4377       && TREE_CODE (decl) != VAR_DECL)
4378     return false;
4379
4380   /* If DECL already has its assembler name set, it does not need a
4381      new one.  */
4382   if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4383       || DECL_ASSEMBLER_NAME_SET_P (decl))
4384     return false;
4385
4386   /* Abstract decls do not need an assembler name.  */
4387   if (DECL_ABSTRACT (decl))
4388     return false;
4389
4390   /* For VAR_DECLs, only static, public and external symbols need an
4391      assembler name.  */
4392   if (TREE_CODE (decl) == VAR_DECL
4393       && !TREE_STATIC (decl)
4394       && !TREE_PUBLIC (decl)
4395       && !DECL_EXTERNAL (decl))
4396     return false;
4397
4398   if (TREE_CODE (decl) == FUNCTION_DECL)
4399     {
4400       /* Do not set assembler name on builtins.  Allow RTL expansion to
4401          decide whether to expand inline or via a regular call.  */
4402       if (DECL_BUILT_IN (decl)
4403           && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4404         return false;
4405
4406       /* Functions represented in the callgraph need an assembler name.  */
4407       if (cgraph_get_node (decl) != NULL)
4408         return true;
4409
4410       /* Unused and not public functions don't need an assembler name.  */
4411       if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
4412         return false;
4413     }
4414
4415   return true;
4416 }
4417
4418
4419 /* Remove all the non-variable decls from BLOCK.  LOCALS is the set of
4420    variables in DECL_STRUCT_FUNCTION (FN)->local_decls.  Every decl
4421    in BLOCK that is not in LOCALS is removed.  */
4422
4423 static void
4424 free_lang_data_in_block (tree fn, tree block, struct pointer_set_t *locals)
4425 {
4426   tree *tp, t;
4427
4428   tp = &BLOCK_VARS (block);
4429   while (*tp)
4430     {
4431       if (!pointer_set_contains (locals, *tp))
4432         *tp = TREE_CHAIN (*tp);
4433       else
4434         tp = &TREE_CHAIN (*tp);
4435     }
4436
4437   for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
4438     free_lang_data_in_block (fn, t, locals);
4439 }
4440
4441
4442 /* Reset all language specific information still present in symbol
4443    DECL.  */
4444
4445 static void
4446 free_lang_data_in_decl (tree decl)
4447 {
4448   gcc_assert (DECL_P (decl));
4449
4450   /* Give the FE a chance to remove its own data first.  */
4451   lang_hooks.free_lang_data (decl);
4452
4453   TREE_LANG_FLAG_0 (decl) = 0;
4454   TREE_LANG_FLAG_1 (decl) = 0;
4455   TREE_LANG_FLAG_2 (decl) = 0;
4456   TREE_LANG_FLAG_3 (decl) = 0;
4457   TREE_LANG_FLAG_4 (decl) = 0;
4458   TREE_LANG_FLAG_5 (decl) = 0;
4459   TREE_LANG_FLAG_6 (decl) = 0;
4460
4461   /* Identifiers need not have a type.  */
4462   if (DECL_NAME (decl))
4463     TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
4464
4465   /* Ignore any intervening types, because we are going to clear their
4466      TYPE_CONTEXT fields.  */
4467   if (TREE_CODE (decl) != FIELD_DECL
4468       && TREE_CODE (decl) != FUNCTION_DECL)
4469     DECL_CONTEXT (decl) = decl_function_context (decl);
4470
4471   if (DECL_CONTEXT (decl)
4472       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
4473     DECL_CONTEXT (decl) = NULL_TREE;
4474
4475  if (TREE_CODE (decl) == VAR_DECL)
4476    {
4477      tree context = DECL_CONTEXT (decl);
4478
4479      if (context)
4480        {
4481          enum tree_code code = TREE_CODE (context);
4482          if (code == FUNCTION_DECL && DECL_ABSTRACT (context))
4483            {
4484              /* Do not clear the decl context here, that will promote
4485                 all vars to global ones.  */
4486              DECL_INITIAL (decl) = NULL_TREE;
4487            }
4488
4489          if (TREE_STATIC (decl))
4490            DECL_CONTEXT (decl) = NULL_TREE;
4491        }
4492    }
4493
4494   free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
4495   free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
4496   if (TREE_CODE (decl) == FIELD_DECL)
4497     free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
4498
4499  /* DECL_FCONTEXT is only used for debug info generation.  */
4500  if (TREE_CODE (decl) == FIELD_DECL
4501      && debug_info_level < DINFO_LEVEL_TERSE)
4502    DECL_FCONTEXT (decl) = NULL_TREE;
4503
4504  if (TREE_CODE (decl) == FUNCTION_DECL)
4505     {
4506       if (gimple_has_body_p (decl))
4507         {
4508           tree t;
4509           unsigned ix;
4510           struct pointer_set_t *locals;
4511
4512           /* If DECL has a gimple body, then the context for its
4513              arguments must be DECL.  Otherwise, it doesn't really
4514              matter, as we will not be emitting any code for DECL.  In
4515              general, there may be other instances of DECL created by
4516              the front end and since PARM_DECLs are generally shared,
4517              their DECL_CONTEXT changes as the replicas of DECL are
4518              created.  The only time where DECL_CONTEXT is important
4519              is for the FUNCTION_DECLs that have a gimple body (since
4520              the PARM_DECL will be used in the function's body).  */
4521           for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
4522             DECL_CONTEXT (t) = decl;
4523
4524           /* Collect all the symbols declared in DECL.  */
4525           locals = pointer_set_create ();
4526           FOR_EACH_LOCAL_DECL (DECL_STRUCT_FUNCTION (decl), ix, t)
4527             {
4528               pointer_set_insert (locals, t);
4529
4530               /* All the local symbols should have DECL as their
4531                  context.  */
4532               DECL_CONTEXT (t) = decl;
4533             }
4534
4535           /* Get rid of any decl not in local_decls.  */
4536           free_lang_data_in_block (decl, DECL_INITIAL (decl), locals);
4537
4538           pointer_set_destroy (locals);
4539         }
4540
4541       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4542          At this point, it is not needed anymore.  */
4543       DECL_SAVED_TREE (decl) = NULL_TREE;
4544     }
4545   else if (TREE_CODE (decl) == VAR_DECL)
4546     {
4547       tree expr = DECL_DEBUG_EXPR (decl);
4548       if (expr
4549           && TREE_CODE (expr) == VAR_DECL
4550           && !TREE_STATIC (expr) && !DECL_EXTERNAL (expr))
4551         SET_DECL_DEBUG_EXPR (decl, NULL_TREE);
4552
4553       if (DECL_EXTERNAL (decl)
4554           && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
4555         DECL_INITIAL (decl) = NULL_TREE;
4556     }
4557   else if (TREE_CODE (decl) == TYPE_DECL)
4558     {
4559       DECL_INITIAL (decl) = NULL_TREE;
4560
4561       /* DECL_CONTEXT is overloaded as DECL_FIELD_CONTEXT for
4562          FIELD_DECLs, which should be preserved.  Otherwise,
4563          we shouldn't be concerned with source-level lexical
4564          nesting beyond this point. */
4565       DECL_CONTEXT (decl) = NULL_TREE;
4566     }
4567 }
4568
4569
4570 /* Data used when collecting DECLs and TYPEs for language data removal.  */
4571
4572 struct free_lang_data_d
4573 {
4574   /* Worklist to avoid excessive recursion.  */
4575   VEC(tree,heap) *worklist;
4576
4577   /* Set of traversed objects.  Used to avoid duplicate visits.  */
4578   struct pointer_set_t *pset;
4579
4580   /* Array of symbols to process with free_lang_data_in_decl.  */
4581   VEC(tree,heap) *decls;
4582
4583   /* Array of types to process with free_lang_data_in_type.  */
4584   VEC(tree,heap) *types;
4585 };
4586
4587
4588 /* Save all language fields needed to generate proper debug information
4589    for DECL.  This saves most fields cleared out by free_lang_data_in_decl.  */
4590
4591 static void
4592 save_debug_info_for_decl (tree t)
4593 {
4594   /*struct saved_debug_info_d *sdi;*/
4595
4596   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
4597
4598   /* FIXME.  Partial implementation for saving debug info removed.  */
4599 }
4600
4601
4602 /* Save all language fields needed to generate proper debug information
4603    for TYPE.  This saves most fields cleared out by free_lang_data_in_type.  */
4604
4605 static void
4606 save_debug_info_for_type (tree t)
4607 {
4608   /*struct saved_debug_info_d *sdi;*/
4609
4610   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
4611
4612   /* FIXME.  Partial implementation for saving debug info removed.  */
4613 }
4614
4615
4616 /* Add type or decl T to one of the list of tree nodes that need their
4617    language data removed.  The lists are held inside FLD.  */
4618
4619 static void
4620 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
4621 {
4622   if (DECL_P (t))
4623     {
4624       VEC_safe_push (tree, heap, fld->decls, t);
4625       if (debug_info_level > DINFO_LEVEL_TERSE)
4626         save_debug_info_for_decl (t);
4627     }
4628   else if (TYPE_P (t))
4629     {
4630       VEC_safe_push (tree, heap, fld->types, t);
4631       if (debug_info_level > DINFO_LEVEL_TERSE)
4632         save_debug_info_for_type (t);
4633     }
4634   else
4635     gcc_unreachable ();
4636 }
4637
4638 /* Push tree node T into FLD->WORKLIST.  */
4639
4640 static inline void
4641 fld_worklist_push (tree t, struct free_lang_data_d *fld)
4642 {
4643   if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t))
4644     VEC_safe_push (tree, heap, fld->worklist, (t));
4645 }
4646
4647
4648 /* Operand callback helper for free_lang_data_in_node.  *TP is the
4649    subtree operand being considered.  */
4650
4651 static tree
4652 find_decls_types_r (tree *tp, int *ws, void *data)
4653 {
4654   tree t = *tp;
4655   struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
4656
4657   if (TREE_CODE (t) == TREE_LIST)
4658     return NULL_TREE;
4659
4660   /* Language specific nodes will be removed, so there is no need
4661      to gather anything under them.  */
4662   if (is_lang_specific (t))
4663     {
4664       *ws = 0;
4665       return NULL_TREE;
4666     }
4667
4668   if (DECL_P (t))
4669     {
4670       /* Note that walk_tree does not traverse every possible field in
4671          decls, so we have to do our own traversals here.  */
4672       add_tree_to_fld_list (t, fld);
4673
4674       fld_worklist_push (DECL_NAME (t), fld);
4675       fld_worklist_push (DECL_CONTEXT (t), fld);
4676       fld_worklist_push (DECL_SIZE (t), fld);
4677       fld_worklist_push (DECL_SIZE_UNIT (t), fld);
4678
4679       /* We are going to remove everything under DECL_INITIAL for
4680          TYPE_DECLs.  No point walking them.  */
4681       if (TREE_CODE (t) != TYPE_DECL)
4682         fld_worklist_push (DECL_INITIAL (t), fld);
4683
4684       fld_worklist_push (DECL_ATTRIBUTES (t), fld);
4685       fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
4686
4687       if (TREE_CODE (t) == FUNCTION_DECL)
4688         {
4689           fld_worklist_push (DECL_ARGUMENTS (t), fld);
4690           fld_worklist_push (DECL_RESULT (t), fld);
4691         }
4692       else if (TREE_CODE (t) == TYPE_DECL)
4693         {
4694           fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
4695           fld_worklist_push (DECL_VINDEX (t), fld);
4696         }
4697       else if (TREE_CODE (t) == FIELD_DECL)
4698         {
4699           fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
4700           fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
4701           fld_worklist_push (DECL_QUALIFIER (t), fld);
4702           fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
4703           fld_worklist_push (DECL_FCONTEXT (t), fld);
4704         }
4705       else if (TREE_CODE (t) == VAR_DECL)
4706         {
4707           fld_worklist_push (DECL_SECTION_NAME (t), fld);
4708           fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
4709         }
4710
4711       if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
4712           && DECL_HAS_VALUE_EXPR_P (t))
4713         fld_worklist_push (DECL_VALUE_EXPR (t), fld);
4714
4715       if (TREE_CODE (t) != FIELD_DECL
4716           && TREE_CODE (t) != TYPE_DECL)
4717         fld_worklist_push (TREE_CHAIN (t), fld);
4718       *ws = 0;
4719     }
4720   else if (TYPE_P (t))
4721     {
4722       /* Note that walk_tree does not traverse every possible field in
4723          types, so we have to do our own traversals here.  */
4724       add_tree_to_fld_list (t, fld);
4725
4726       if (!RECORD_OR_UNION_TYPE_P (t))
4727         fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
4728       fld_worklist_push (TYPE_SIZE (t), fld);
4729       fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
4730       fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
4731       fld_worklist_push (TYPE_POINTER_TO (t), fld);
4732       fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
4733       fld_worklist_push (TYPE_NAME (t), fld);
4734       /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  We do not stream
4735          them and thus do not and want not to reach unused pointer types
4736          this way.  */
4737       if (!POINTER_TYPE_P (t))
4738         fld_worklist_push (TYPE_MINVAL (t), fld);
4739       if (!RECORD_OR_UNION_TYPE_P (t))
4740         fld_worklist_push (TYPE_MAXVAL (t), fld);
4741       fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
4742       /* Do not walk TYPE_NEXT_VARIANT.  We do not stream it and thus
4743          do not and want not to reach unused variants this way.  */
4744       fld_worklist_push (TYPE_CONTEXT (t), fld);
4745       /* Do not walk TYPE_CANONICAL.  We do not stream it and thus do not
4746          and want not to reach unused types this way.  */
4747
4748       if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
4749         {
4750           unsigned i;
4751           tree tem;
4752           for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)),
4753                                    i, tem); ++i)
4754             fld_worklist_push (TREE_TYPE (tem), fld);
4755           tem = BINFO_VIRTUALS (TYPE_BINFO (t));
4756           if (tem
4757               /* The Java FE overloads BINFO_VIRTUALS for its own purpose.  */
4758               && TREE_CODE (tem) == TREE_LIST)
4759             do
4760               {
4761                 fld_worklist_push (TREE_VALUE (tem), fld);
4762                 tem = TREE_CHAIN (tem);
4763               }
4764             while (tem);
4765         }
4766       if (RECORD_OR_UNION_TYPE_P (t))
4767         {
4768           tree tem;
4769           /* Push all TYPE_FIELDS - there can be interleaving interesting
4770              and non-interesting things.  */
4771           tem = TYPE_FIELDS (t);
4772           while (tem)
4773             {
4774               if (TREE_CODE (tem) == FIELD_DECL)
4775                 fld_worklist_push (tem, fld);
4776               tem = TREE_CHAIN (tem);
4777             }
4778         }
4779
4780       fld_worklist_push (TREE_CHAIN (t), fld);
4781       *ws = 0;
4782     }
4783   else if (TREE_CODE (t) == BLOCK)
4784     {
4785       tree tem;
4786       for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
4787         fld_worklist_push (tem, fld);
4788       for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
4789         fld_worklist_push (tem, fld);
4790       fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
4791     }
4792
4793   fld_worklist_push (TREE_TYPE (t), fld);
4794
4795   return NULL_TREE;
4796 }
4797
4798
4799 /* Find decls and types in T.  */
4800
4801 static void
4802 find_decls_types (tree t, struct free_lang_data_d *fld)
4803 {
4804   while (1)
4805     {
4806       if (!pointer_set_contains (fld->pset, t))
4807         walk_tree (&t, find_decls_types_r, fld, fld->pset);
4808       if (VEC_empty (tree, fld->worklist))
4809         break;
4810       t = VEC_pop (tree, fld->worklist);
4811     }
4812 }
4813
4814 /* Translate all the types in LIST with the corresponding runtime
4815    types.  */
4816
4817 static tree
4818 get_eh_types_for_runtime (tree list)
4819 {
4820   tree head, prev;
4821
4822   if (list == NULL_TREE)
4823     return NULL_TREE;
4824
4825   head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4826   prev = head;
4827   list = TREE_CHAIN (list);
4828   while (list)
4829     {
4830       tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4831       TREE_CHAIN (prev) = n;
4832       prev = TREE_CHAIN (prev);
4833       list = TREE_CHAIN (list);
4834     }
4835
4836   return head;
4837 }
4838
4839
4840 /* Find decls and types referenced in EH region R and store them in
4841    FLD->DECLS and FLD->TYPES.  */
4842
4843 static void
4844 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
4845 {
4846   switch (r->type)
4847     {
4848     case ERT_CLEANUP:
4849       break;
4850
4851     case ERT_TRY:
4852       {
4853         eh_catch c;
4854
4855         /* The types referenced in each catch must first be changed to the
4856            EH types used at runtime.  This removes references to FE types
4857            in the region.  */
4858         for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
4859           {
4860             c->type_list = get_eh_types_for_runtime (c->type_list);
4861             walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
4862           }
4863       }
4864       break;
4865
4866     case ERT_ALLOWED_EXCEPTIONS:
4867       r->u.allowed.type_list
4868         = get_eh_types_for_runtime (r->u.allowed.type_list);
4869       walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
4870       break;
4871
4872     case ERT_MUST_NOT_THROW:
4873       walk_tree (&r->u.must_not_throw.failure_decl,
4874                  find_decls_types_r, fld, fld->pset);
4875       break;
4876     }
4877 }
4878
4879
4880 /* Find decls and types referenced in cgraph node N and store them in
4881    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4882    look for *every* kind of DECL and TYPE node reachable from N,
4883    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4884    NAMESPACE_DECLs, etc).  */
4885
4886 static void
4887 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
4888 {
4889   basic_block bb;
4890   struct function *fn;
4891   unsigned ix;
4892   tree t;
4893
4894   find_decls_types (n->decl, fld);
4895
4896   if (!gimple_has_body_p (n->decl))
4897     return;
4898
4899   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
4900
4901   fn = DECL_STRUCT_FUNCTION (n->decl);
4902
4903   /* Traverse locals. */
4904   FOR_EACH_LOCAL_DECL (fn, ix, t)
4905     find_decls_types (t, fld);
4906
4907   /* Traverse EH regions in FN.  */
4908   {
4909     eh_region r;
4910     FOR_ALL_EH_REGION_FN (r, fn)
4911       find_decls_types_in_eh_region (r, fld);
4912   }
4913
4914   /* Traverse every statement in FN.  */
4915   FOR_EACH_BB_FN (bb, fn)
4916     {
4917       gimple_stmt_iterator si;
4918       unsigned i;
4919
4920       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4921         {
4922           gimple phi = gsi_stmt (si);
4923
4924           for (i = 0; i < gimple_phi_num_args (phi); i++)
4925             {
4926               tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
4927               find_decls_types (*arg_p, fld);
4928             }
4929         }
4930
4931       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
4932         {
4933           gimple stmt = gsi_stmt (si);
4934
4935           for (i = 0; i < gimple_num_ops (stmt); i++)
4936             {
4937               tree arg = gimple_op (stmt, i);
4938               find_decls_types (arg, fld);
4939             }
4940         }
4941     }
4942 }
4943
4944
4945 /* Find decls and types referenced in varpool node N and store them in
4946    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4947    look for *every* kind of DECL and TYPE node reachable from N,
4948    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4949    NAMESPACE_DECLs, etc).  */
4950
4951 static void
4952 find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
4953 {
4954   find_decls_types (v->decl, fld);
4955 }
4956
4957 /* If T needs an assembler name, have one created for it.  */
4958
4959 void
4960 assign_assembler_name_if_neeeded (tree t)
4961 {
4962   if (need_assembler_name_p (t))
4963     {
4964       /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
4965          diagnostics that use input_location to show locus
4966          information.  The problem here is that, at this point,
4967          input_location is generally anchored to the end of the file
4968          (since the parser is long gone), so we don't have a good
4969          position to pin it to.
4970
4971          To alleviate this problem, this uses the location of T's
4972          declaration.  Examples of this are
4973          testsuite/g++.dg/template/cond2.C and
4974          testsuite/g++.dg/template/pr35240.C.  */
4975       location_t saved_location = input_location;
4976       input_location = DECL_SOURCE_LOCATION (t);
4977
4978       decl_assembler_name (t);
4979
4980       input_location = saved_location;
4981     }
4982 }
4983
4984
4985 /* Free language specific information for every operand and expression
4986    in every node of the call graph.  This process operates in three stages:
4987
4988    1- Every callgraph node and varpool node is traversed looking for
4989       decls and types embedded in them.  This is a more exhaustive
4990       search than that done by find_referenced_vars, because it will
4991       also collect individual fields, decls embedded in types, etc.
4992
4993    2- All the decls found are sent to free_lang_data_in_decl.
4994
4995    3- All the types found are sent to free_lang_data_in_type.
4996
4997    The ordering between decls and types is important because
4998    free_lang_data_in_decl sets assembler names, which includes
4999    mangling.  So types cannot be freed up until assembler names have
5000    been set up.  */
5001
5002 static void
5003 free_lang_data_in_cgraph (void)
5004 {
5005   struct cgraph_node *n;
5006   struct varpool_node *v;
5007   struct free_lang_data_d fld;
5008   tree t;
5009   unsigned i;
5010   alias_pair *p;
5011
5012   /* Initialize sets and arrays to store referenced decls and types.  */
5013   fld.pset = pointer_set_create ();
5014   fld.worklist = NULL;
5015   fld.decls = VEC_alloc (tree, heap, 100);
5016   fld.types = VEC_alloc (tree, heap, 100);
5017
5018   /* Find decls and types in the body of every function in the callgraph.  */
5019   for (n = cgraph_nodes; n; n = n->next)
5020     find_decls_types_in_node (n, &fld);
5021
5022   FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
5023     find_decls_types (p->decl, &fld);
5024
5025   /* Find decls and types in every varpool symbol.  */
5026   for (v = varpool_nodes_queue; v; v = v->next_needed)
5027     find_decls_types_in_var (v, &fld);
5028
5029   /* Set the assembler name on every decl found.  We need to do this
5030      now because free_lang_data_in_decl will invalidate data needed
5031      for mangling.  This breaks mangling on interdependent decls.  */
5032   FOR_EACH_VEC_ELT (tree, fld.decls, i, t)
5033     assign_assembler_name_if_neeeded (t);
5034
5035   /* Traverse every decl found freeing its language data.  */
5036   FOR_EACH_VEC_ELT (tree, fld.decls, i, t)
5037     free_lang_data_in_decl (t);
5038
5039   /* Traverse every type found freeing its language data.  */
5040   FOR_EACH_VEC_ELT (tree, fld.types, i, t)
5041     free_lang_data_in_type (t);
5042
5043   pointer_set_destroy (fld.pset);
5044   VEC_free (tree, heap, fld.worklist);
5045   VEC_free (tree, heap, fld.decls);
5046   VEC_free (tree, heap, fld.types);
5047 }
5048
5049
5050 /* Free resources that are used by FE but are not needed once they are done. */
5051
5052 static unsigned
5053 free_lang_data (void)
5054 {
5055   unsigned i;
5056
5057   /* If we are the LTO frontend we have freed lang-specific data already.  */
5058   if (in_lto_p
5059       || !flag_generate_lto)
5060     return 0;
5061
5062   /* Allocate and assign alias sets to the standard integer types
5063      while the slots are still in the way the frontends generated them.  */
5064   for (i = 0; i < itk_none; ++i)
5065     if (integer_types[i])
5066       TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5067
5068   /* Traverse the IL resetting language specific information for
5069      operands, expressions, etc.  */
5070   free_lang_data_in_cgraph ();
5071
5072   /* Create gimple variants for common types.  */
5073   ptrdiff_type_node = integer_type_node;
5074   fileptr_type_node = ptr_type_node;
5075   if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE
5076       || (TYPE_MODE (boolean_type_node)
5077           != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0))
5078       || TYPE_PRECISION (boolean_type_node) != 1
5079       || !TYPE_UNSIGNED (boolean_type_node))
5080     {
5081       boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
5082       TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
5083       TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
5084       TYPE_PRECISION (boolean_type_node) = 1;
5085       boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
5086       boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
5087     }
5088
5089   /* Unify char_type_node with its properly signed variant.  */
5090   if (TYPE_UNSIGNED (char_type_node))
5091     unsigned_char_type_node = char_type_node;
5092   else
5093     signed_char_type_node = char_type_node;
5094
5095   /* Reset some langhooks.  Do not reset types_compatible_p, it may
5096      still be used indirectly via the get_alias_set langhook.  */
5097   lang_hooks.callgraph.analyze_expr = NULL;
5098   lang_hooks.dwarf_name = lhd_dwarf_name;
5099   lang_hooks.decl_printable_name = gimple_decl_printable_name;
5100   lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
5101
5102   /* Reset diagnostic machinery.  */
5103   diagnostic_starter (global_dc) = default_tree_diagnostic_starter;
5104   diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
5105   diagnostic_format_decoder (global_dc) = default_tree_printer;
5106
5107   return 0;
5108 }
5109
5110
5111 struct simple_ipa_opt_pass pass_ipa_free_lang_data =
5112 {
5113  {
5114   SIMPLE_IPA_PASS,
5115   "*free_lang_data",                    /* name */
5116   NULL,                                 /* gate */
5117   free_lang_data,                       /* execute */
5118   NULL,                                 /* sub */
5119   NULL,                                 /* next */
5120   0,                                    /* static_pass_number */
5121   TV_IPA_FREE_LANG_DATA,                /* tv_id */
5122   0,                                    /* properties_required */
5123   0,                                    /* properties_provided */
5124   0,                                    /* properties_destroyed */
5125   0,                                    /* todo_flags_start */
5126   TODO_ggc_collect                      /* todo_flags_finish */
5127  }
5128 };
5129
5130 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5131    or zero if not.
5132
5133    We try both `text' and `__text__', ATTR may be either one.  */
5134 /* ??? It might be a reasonable simplification to require ATTR to be only
5135    `text'.  One might then also require attribute lists to be stored in
5136    their canonicalized form.  */
5137
5138 static int
5139 is_attribute_with_length_p (const char *attr, int attr_len, const_tree ident)
5140 {
5141   int ident_len;
5142   const char *p;
5143
5144   if (TREE_CODE (ident) != IDENTIFIER_NODE)
5145     return 0;
5146
5147   p = IDENTIFIER_POINTER (ident);
5148   ident_len = IDENTIFIER_LENGTH (ident);
5149
5150   if (ident_len == attr_len
5151       && strcmp (attr, p) == 0)
5152     return 1;
5153
5154   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
5155   if (attr[0] == '_')
5156     {
5157       gcc_assert (attr[1] == '_');
5158       gcc_assert (attr[attr_len - 2] == '_');
5159       gcc_assert (attr[attr_len - 1] == '_');
5160       if (ident_len == attr_len - 4
5161           && strncmp (attr + 2, p, attr_len - 4) == 0)
5162         return 1;
5163     }
5164   else
5165     {
5166       if (ident_len == attr_len + 4
5167           && p[0] == '_' && p[1] == '_'
5168           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5169           && strncmp (attr, p + 2, attr_len) == 0)
5170         return 1;
5171     }
5172
5173   return 0;
5174 }
5175
5176 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5177    or zero if not.
5178
5179    We try both `text' and `__text__', ATTR may be either one.  */
5180
5181 int
5182 is_attribute_p (const char *attr, const_tree ident)
5183 {
5184   return is_attribute_with_length_p (attr, strlen (attr), ident);
5185 }
5186
5187 /* Given an attribute name and a list of attributes, return a pointer to the
5188    attribute's list element if the attribute is part of the list, or NULL_TREE
5189    if not found.  If the attribute appears more than once, this only
5190    returns the first occurrence; the TREE_CHAIN of the return value should
5191    be passed back in if further occurrences are wanted.  */
5192
5193 tree
5194 lookup_attribute (const char *attr_name, tree list)
5195 {
5196   tree l;
5197   size_t attr_len = strlen (attr_name);
5198
5199   for (l = list; l; l = TREE_CHAIN (l))
5200     {
5201       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5202       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5203         return l;
5204     }
5205   return NULL_TREE;
5206 }
5207
5208 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5209    modified list.  */
5210
5211 tree
5212 remove_attribute (const char *attr_name, tree list)
5213 {
5214   tree *p;
5215   size_t attr_len = strlen (attr_name);
5216
5217   for (p = &list; *p; )
5218     {
5219       tree l = *p;
5220       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5221       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5222         *p = TREE_CHAIN (l);
5223       else
5224         p = &TREE_CHAIN (l);
5225     }
5226
5227   return list;
5228 }
5229
5230 /* Return an attribute list that is the union of a1 and a2.  */
5231
5232 tree
5233 merge_attributes (tree a1, tree a2)
5234 {
5235   tree attributes;
5236
5237   /* Either one unset?  Take the set one.  */
5238
5239   if ((attributes = a1) == 0)
5240     attributes = a2;
5241
5242   /* One that completely contains the other?  Take it.  */
5243
5244   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5245     {
5246       if (attribute_list_contained (a2, a1))
5247         attributes = a2;
5248       else
5249         {
5250           /* Pick the longest list, and hang on the other list.  */
5251
5252           if (list_length (a1) < list_length (a2))
5253             attributes = a2, a2 = a1;
5254
5255           for (; a2 != 0; a2 = TREE_CHAIN (a2))
5256             {
5257               tree a;
5258               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5259                                          attributes);
5260                    a != NULL_TREE;
5261                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5262                                          TREE_CHAIN (a)))
5263                 {
5264                   if (TREE_VALUE (a) != NULL
5265                       && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
5266                       && TREE_VALUE (a2) != NULL
5267                       && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
5268                     {
5269                       if (simple_cst_list_equal (TREE_VALUE (a),
5270                                                  TREE_VALUE (a2)) == 1)
5271                         break;
5272                     }
5273                   else if (simple_cst_equal (TREE_VALUE (a),
5274                                              TREE_VALUE (a2)) == 1)
5275                     break;
5276                 }
5277               if (a == NULL_TREE)
5278                 {
5279                   a1 = copy_node (a2);
5280                   TREE_CHAIN (a1) = attributes;
5281                   attributes = a1;
5282                 }
5283             }
5284         }
5285     }
5286   return attributes;
5287 }
5288
5289 /* Given types T1 and T2, merge their attributes and return
5290   the result.  */
5291
5292 tree
5293 merge_type_attributes (tree t1, tree t2)
5294 {
5295   return merge_attributes (TYPE_ATTRIBUTES (t1),
5296                            TYPE_ATTRIBUTES (t2));
5297 }
5298
5299 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5300    the result.  */
5301
5302 tree
5303 merge_decl_attributes (tree olddecl, tree newdecl)
5304 {
5305   return merge_attributes (DECL_ATTRIBUTES (olddecl),
5306                            DECL_ATTRIBUTES (newdecl));
5307 }
5308
5309 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5310
5311 /* Specialization of merge_decl_attributes for various Windows targets.
5312
5313    This handles the following situation:
5314
5315      __declspec (dllimport) int foo;
5316      int foo;
5317
5318    The second instance of `foo' nullifies the dllimport.  */
5319
5320 tree
5321 merge_dllimport_decl_attributes (tree old, tree new_tree)
5322 {
5323   tree a;
5324   int delete_dllimport_p = 1;
5325
5326   /* What we need to do here is remove from `old' dllimport if it doesn't
5327      appear in `new'.  dllimport behaves like extern: if a declaration is
5328      marked dllimport and a definition appears later, then the object
5329      is not dllimport'd.  We also remove a `new' dllimport if the old list
5330      contains dllexport:  dllexport always overrides dllimport, regardless
5331      of the order of declaration.  */
5332   if (!VAR_OR_FUNCTION_DECL_P (new_tree))
5333     delete_dllimport_p = 0;
5334   else if (DECL_DLLIMPORT_P (new_tree)
5335            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
5336     {
5337       DECL_DLLIMPORT_P (new_tree) = 0;
5338       warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
5339               "dllimport ignored", new_tree);
5340     }
5341   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
5342     {
5343       /* Warn about overriding a symbol that has already been used, e.g.:
5344            extern int __attribute__ ((dllimport)) foo;
5345            int* bar () {return &foo;}
5346            int foo;
5347       */
5348       if (TREE_USED (old))
5349         {
5350           warning (0, "%q+D redeclared without dllimport attribute "
5351                    "after being referenced with dll linkage", new_tree);
5352           /* If we have used a variable's address with dllimport linkage,
5353               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5354               decl may already have had TREE_CONSTANT computed.
5355               We still remove the attribute so that assembler code refers
5356               to '&foo rather than '_imp__foo'.  */
5357           if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
5358             DECL_DLLIMPORT_P (new_tree) = 1;
5359         }
5360
5361       /* Let an inline definition silently override the external reference,
5362          but otherwise warn about attribute inconsistency.  */
5363       else if (TREE_CODE (new_tree) == VAR_DECL
5364                || !DECL_DECLARED_INLINE_P (new_tree))
5365         warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
5366                   "previous dllimport ignored", new_tree);
5367     }
5368   else
5369     delete_dllimport_p = 0;
5370
5371   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
5372
5373   if (delete_dllimport_p)
5374     {
5375       tree prev, t;
5376       const size_t attr_len = strlen ("dllimport");
5377
5378       /* Scan the list for dllimport and delete it.  */
5379       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
5380         {
5381           if (is_attribute_with_length_p ("dllimport", attr_len,
5382                                           TREE_PURPOSE (t)))
5383             {
5384               if (prev == NULL_TREE)
5385                 a = TREE_CHAIN (a);
5386               else
5387                 TREE_CHAIN (prev) = TREE_CHAIN (t);
5388               break;
5389             }
5390         }
5391     }
5392
5393   return a;
5394 }
5395
5396 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5397    struct attribute_spec.handler.  */
5398
5399 tree
5400 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
5401                       bool *no_add_attrs)
5402 {
5403   tree node = *pnode;
5404   bool is_dllimport;
5405
5406   /* These attributes may apply to structure and union types being created,
5407      but otherwise should pass to the declaration involved.  */
5408   if (!DECL_P (node))
5409     {
5410       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
5411                    | (int) ATTR_FLAG_ARRAY_NEXT))
5412         {
5413           *no_add_attrs = true;
5414           return tree_cons (name, args, NULL_TREE);
5415         }
5416       if (TREE_CODE (node) == RECORD_TYPE
5417           || TREE_CODE (node) == UNION_TYPE)
5418         {
5419           node = TYPE_NAME (node);
5420           if (!node)
5421             return NULL_TREE;
5422         }
5423       else
5424         {
5425           warning (OPT_Wattributes, "%qE attribute ignored",
5426                    name);
5427           *no_add_attrs = true;
5428           return NULL_TREE;
5429         }
5430     }
5431
5432   if (TREE_CODE (node) != FUNCTION_DECL
5433       && TREE_CODE (node) != VAR_DECL
5434       && TREE_CODE (node) != TYPE_DECL)
5435     {
5436       *no_add_attrs = true;
5437       warning (OPT_Wattributes, "%qE attribute ignored",
5438                name);
5439       return NULL_TREE;
5440     }
5441
5442   if (TREE_CODE (node) == TYPE_DECL
5443       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
5444       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
5445     {
5446       *no_add_attrs = true;
5447       warning (OPT_Wattributes, "%qE attribute ignored",
5448                name);
5449       return NULL_TREE;
5450     }
5451
5452   is_dllimport = is_attribute_p ("dllimport", name);
5453
5454   /* Report error on dllimport ambiguities seen now before they cause
5455      any damage.  */
5456   if (is_dllimport)
5457     {
5458       /* Honor any target-specific overrides. */
5459       if (!targetm.valid_dllimport_attribute_p (node))
5460         *no_add_attrs = true;
5461
5462      else if (TREE_CODE (node) == FUNCTION_DECL
5463                 && DECL_DECLARED_INLINE_P (node))
5464         {
5465           warning (OPT_Wattributes, "inline function %q+D declared as "
5466                   " dllimport: attribute ignored", node);
5467           *no_add_attrs = true;
5468         }
5469       /* Like MS, treat definition of dllimported variables and
5470          non-inlined functions on declaration as syntax errors. */
5471      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
5472         {
5473           error ("function %q+D definition is marked dllimport", node);
5474           *no_add_attrs = true;
5475         }
5476
5477      else if (TREE_CODE (node) == VAR_DECL)
5478         {
5479           if (DECL_INITIAL (node))
5480             {
5481               error ("variable %q+D definition is marked dllimport",
5482                      node);
5483               *no_add_attrs = true;
5484             }
5485
5486           /* `extern' needn't be specified with dllimport.
5487              Specify `extern' now and hope for the best.  Sigh.  */
5488           DECL_EXTERNAL (node) = 1;
5489           /* Also, implicitly give dllimport'd variables declared within
5490              a function global scope, unless declared static.  */
5491           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
5492             TREE_PUBLIC (node) = 1;
5493         }
5494
5495       if (*no_add_attrs == false)
5496         DECL_DLLIMPORT_P (node) = 1;
5497     }
5498   else if (TREE_CODE (node) == FUNCTION_DECL
5499            && DECL_DECLARED_INLINE_P (node))
5500     /* An exported function, even if inline, must be emitted.  */
5501     DECL_EXTERNAL (node) = 0;
5502
5503   /*  Report error if symbol is not accessible at global scope.  */
5504   if (!TREE_PUBLIC (node)
5505       && (TREE_CODE (node) == VAR_DECL
5506           || TREE_CODE (node) == FUNCTION_DECL))
5507     {
5508       error ("external linkage required for symbol %q+D because of "
5509              "%qE attribute", node, name);
5510       *no_add_attrs = true;
5511     }
5512
5513   /* A dllexport'd entity must have default visibility so that other
5514      program units (shared libraries or the main executable) can see
5515      it.  A dllimport'd entity must have default visibility so that
5516      the linker knows that undefined references within this program
5517      unit can be resolved by the dynamic linker.  */
5518   if (!*no_add_attrs)
5519     {
5520       if (DECL_VISIBILITY_SPECIFIED (node)
5521           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
5522         error ("%qE implies default visibility, but %qD has already "
5523                "been declared with a different visibility",
5524                name, node);
5525       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
5526       DECL_VISIBILITY_SPECIFIED (node) = 1;
5527     }
5528
5529   return NULL_TREE;
5530 }
5531
5532 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
5533 \f
5534 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5535    of the various TYPE_QUAL values.  */
5536
5537 static void
5538 set_type_quals (tree type, int type_quals)
5539 {
5540   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
5541   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
5542   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
5543   TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
5544 }
5545
5546 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
5547
5548 bool
5549 check_qualified_type (const_tree cand, const_tree base, int type_quals)
5550 {
5551   return (TYPE_QUALS (cand) == type_quals
5552           && TYPE_NAME (cand) == TYPE_NAME (base)
5553           /* Apparently this is needed for Objective-C.  */
5554           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5555           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5556                                    TYPE_ATTRIBUTES (base)));
5557 }
5558
5559 /* Return a version of the TYPE, qualified as indicated by the
5560    TYPE_QUALS, if one exists.  If no qualified version exists yet,
5561    return NULL_TREE.  */
5562
5563 tree
5564 get_qualified_type (tree type, int type_quals)
5565 {
5566   tree t;
5567
5568   if (TYPE_QUALS (type) == type_quals)
5569     return type;
5570
5571   /* Search the chain of variants to see if there is already one there just
5572      like the one we need to have.  If so, use that existing one.  We must
5573      preserve the TYPE_NAME, since there is code that depends on this.  */
5574   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5575     if (check_qualified_type (t, type, type_quals))
5576       return t;
5577
5578   return NULL_TREE;
5579 }
5580
5581 /* Like get_qualified_type, but creates the type if it does not
5582    exist.  This function never returns NULL_TREE.  */
5583
5584 tree
5585 build_qualified_type (tree type, int type_quals)
5586 {
5587   tree t;
5588
5589   /* See if we already have the appropriate qualified variant.  */
5590   t = get_qualified_type (type, type_quals);
5591
5592   /* If not, build it.  */
5593   if (!t)
5594     {
5595       t = build_variant_type_copy (type);
5596       set_type_quals (t, type_quals);
5597
5598       if (TYPE_STRUCTURAL_EQUALITY_P (type))
5599         /* Propagate structural equality. */
5600         SET_TYPE_STRUCTURAL_EQUALITY (t);
5601       else if (TYPE_CANONICAL (type) != type)
5602         /* Build the underlying canonical type, since it is different
5603            from TYPE. */
5604         TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
5605                                                    type_quals);
5606       else
5607         /* T is its own canonical type. */
5608         TYPE_CANONICAL (t) = t;
5609
5610     }
5611
5612   return t;
5613 }
5614
5615 /* Create a new distinct copy of TYPE.  The new type is made its own
5616    MAIN_VARIANT. If TYPE requires structural equality checks, the
5617    resulting type requires structural equality checks; otherwise, its
5618    TYPE_CANONICAL points to itself. */
5619
5620 tree
5621 build_distinct_type_copy (tree type)
5622 {
5623   tree t = copy_node (type);
5624
5625   TYPE_POINTER_TO (t) = 0;
5626   TYPE_REFERENCE_TO (t) = 0;
5627
5628   /* Set the canonical type either to a new equivalence class, or
5629      propagate the need for structural equality checks. */
5630   if (TYPE_STRUCTURAL_EQUALITY_P (type))
5631     SET_TYPE_STRUCTURAL_EQUALITY (t);
5632   else
5633     TYPE_CANONICAL (t) = t;
5634
5635   /* Make it its own variant.  */
5636   TYPE_MAIN_VARIANT (t) = t;
5637   TYPE_NEXT_VARIANT (t) = 0;
5638
5639   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5640      whose TREE_TYPE is not t.  This can also happen in the Ada
5641      frontend when using subtypes.  */
5642
5643   return t;
5644 }
5645
5646 /* Create a new variant of TYPE, equivalent but distinct.  This is so
5647    the caller can modify it. TYPE_CANONICAL for the return type will
5648    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5649    are considered equal by the language itself (or that both types
5650    require structural equality checks). */
5651
5652 tree
5653 build_variant_type_copy (tree type)
5654 {
5655   tree t, m = TYPE_MAIN_VARIANT (type);
5656
5657   t = build_distinct_type_copy (type);
5658
5659   /* Since we're building a variant, assume that it is a non-semantic
5660      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5661   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
5662
5663   /* Add the new type to the chain of variants of TYPE.  */
5664   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
5665   TYPE_NEXT_VARIANT (m) = t;
5666   TYPE_MAIN_VARIANT (t) = m;
5667
5668   return t;
5669 }
5670 \f
5671 /* Return true if the from tree in both tree maps are equal.  */
5672
5673 int
5674 tree_map_base_eq (const void *va, const void *vb)
5675 {
5676   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
5677     *const b = (const struct tree_map_base *) vb;
5678   return (a->from == b->from);
5679 }
5680
5681 /* Hash a from tree in a tree_base_map.  */
5682
5683 unsigned int
5684 tree_map_base_hash (const void *item)
5685 {
5686   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
5687 }
5688
5689 /* Return true if this tree map structure is marked for garbage collection
5690    purposes.  We simply return true if the from tree is marked, so that this
5691    structure goes away when the from tree goes away.  */
5692
5693 int
5694 tree_map_base_marked_p (const void *p)
5695 {
5696   return ggc_marked_p (((const struct tree_map_base *) p)->from);
5697 }
5698
5699 /* Hash a from tree in a tree_map.  */
5700
5701 unsigned int
5702 tree_map_hash (const void *item)
5703 {
5704   return (((const struct tree_map *) item)->hash);
5705 }
5706
5707 /* Hash a from tree in a tree_decl_map.  */
5708
5709 unsigned int
5710 tree_decl_map_hash (const void *item)
5711 {
5712   return DECL_UID (((const struct tree_decl_map *) item)->base.from);
5713 }
5714
5715 /* Return the initialization priority for DECL.  */
5716
5717 priority_type
5718 decl_init_priority_lookup (tree decl)
5719 {
5720   struct tree_priority_map *h;
5721   struct tree_map_base in;
5722
5723   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5724   in.from = decl;
5725   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5726   return h ? h->init : DEFAULT_INIT_PRIORITY;
5727 }
5728
5729 /* Return the finalization priority for DECL.  */
5730
5731 priority_type
5732 decl_fini_priority_lookup (tree decl)
5733 {
5734   struct tree_priority_map *h;
5735   struct tree_map_base in;
5736
5737   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5738   in.from = decl;
5739   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5740   return h ? h->fini : DEFAULT_INIT_PRIORITY;
5741 }
5742
5743 /* Return the initialization and finalization priority information for
5744    DECL.  If there is no previous priority information, a freshly
5745    allocated structure is returned.  */
5746
5747 static struct tree_priority_map *
5748 decl_priority_info (tree decl)
5749 {
5750   struct tree_priority_map in;
5751   struct tree_priority_map *h;
5752   void **loc;
5753
5754   in.base.from = decl;
5755   loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
5756   h = (struct tree_priority_map *) *loc;
5757   if (!h)
5758     {
5759       h = ggc_alloc_cleared_tree_priority_map ();
5760       *loc = h;
5761       h->base.from = decl;
5762       h->init = DEFAULT_INIT_PRIORITY;
5763       h->fini = DEFAULT_INIT_PRIORITY;
5764     }
5765
5766   return h;
5767 }
5768
5769 /* Set the initialization priority for DECL to PRIORITY.  */
5770
5771 void
5772 decl_init_priority_insert (tree decl, priority_type priority)
5773 {
5774   struct tree_priority_map *h;
5775
5776   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5777   h = decl_priority_info (decl);
5778   h->init = priority;
5779 }
5780
5781 /* Set the finalization priority for DECL to PRIORITY.  */
5782
5783 void
5784 decl_fini_priority_insert (tree decl, priority_type priority)
5785 {
5786   struct tree_priority_map *h;
5787
5788   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5789   h = decl_priority_info (decl);
5790   h->fini = priority;
5791 }
5792
5793 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
5794
5795 static void
5796 print_debug_expr_statistics (void)
5797 {
5798   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5799            (long) htab_size (debug_expr_for_decl),
5800            (long) htab_elements (debug_expr_for_decl),
5801            htab_collisions (debug_expr_for_decl));
5802 }
5803
5804 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
5805
5806 static void
5807 print_value_expr_statistics (void)
5808 {
5809   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5810            (long) htab_size (value_expr_for_decl),
5811            (long) htab_elements (value_expr_for_decl),
5812            htab_collisions (value_expr_for_decl));
5813 }
5814
5815 /* Lookup a debug expression for FROM, and return it if we find one.  */
5816
5817 tree
5818 decl_debug_expr_lookup (tree from)
5819 {
5820   struct tree_decl_map *h, in;
5821   in.base.from = from;
5822
5823   h = (struct tree_decl_map *)
5824       htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from));
5825   if (h)
5826     return h->to;
5827   return NULL_TREE;
5828 }
5829
5830 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
5831
5832 void
5833 decl_debug_expr_insert (tree from, tree to)
5834 {
5835   struct tree_decl_map *h;
5836   void **loc;
5837
5838   h = ggc_alloc_tree_decl_map ();
5839   h->base.from = from;
5840   h->to = to;
5841   loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from),
5842                                   INSERT);
5843   *(struct tree_decl_map **) loc = h;
5844 }
5845
5846 /* Lookup a value expression for FROM, and return it if we find one.  */
5847
5848 tree
5849 decl_value_expr_lookup (tree from)
5850 {
5851   struct tree_decl_map *h, in;
5852   in.base.from = from;
5853
5854   h = (struct tree_decl_map *)
5855       htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from));
5856   if (h)
5857     return h->to;
5858   return NULL_TREE;
5859 }
5860
5861 /* Insert a mapping FROM->TO in the value expression hashtable.  */
5862
5863 void
5864 decl_value_expr_insert (tree from, tree to)
5865 {
5866   struct tree_decl_map *h;
5867   void **loc;
5868
5869   h = ggc_alloc_tree_decl_map ();
5870   h->base.from = from;
5871   h->to = to;
5872   loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from),
5873                                   INSERT);
5874   *(struct tree_decl_map **) loc = h;
5875 }
5876
5877 /* Hashing of types so that we don't make duplicates.
5878    The entry point is `type_hash_canon'.  */
5879
5880 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
5881    with types in the TREE_VALUE slots), by adding the hash codes
5882    of the individual types.  */
5883
5884 static unsigned int
5885 type_hash_list (const_tree list, hashval_t hashcode)
5886 {
5887   const_tree tail;
5888
5889   for (tail = list; tail; tail = TREE_CHAIN (tail))
5890     if (TREE_VALUE (tail) != error_mark_node)
5891       hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
5892                                         hashcode);
5893
5894   return hashcode;
5895 }
5896
5897 /* These are the Hashtable callback functions.  */
5898
5899 /* Returns true iff the types are equivalent.  */
5900
5901 static int
5902 type_hash_eq (const void *va, const void *vb)
5903 {
5904   const struct type_hash *const a = (const struct type_hash *) va,
5905     *const b = (const struct type_hash *) vb;
5906
5907   /* First test the things that are the same for all types.  */
5908   if (a->hash != b->hash
5909       || TREE_CODE (a->type) != TREE_CODE (b->type)
5910       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
5911       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
5912                                  TYPE_ATTRIBUTES (b->type))
5913       || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
5914       || TYPE_MODE (a->type) != TYPE_MODE (b->type)
5915       || (TREE_CODE (a->type) != COMPLEX_TYPE
5916           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
5917     return 0;
5918
5919   switch (TREE_CODE (a->type))
5920     {
5921     case VOID_TYPE:
5922     case COMPLEX_TYPE:
5923     case POINTER_TYPE:
5924     case REFERENCE_TYPE:
5925       return 1;
5926
5927     case VECTOR_TYPE:
5928       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
5929
5930     case ENUMERAL_TYPE:
5931       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
5932           && !(TYPE_VALUES (a->type)
5933                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
5934                && TYPE_VALUES (b->type)
5935                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
5936                && type_list_equal (TYPE_VALUES (a->type),
5937                                    TYPE_VALUES (b->type))))
5938         return 0;
5939
5940       /* ... fall through ... */
5941
5942     case INTEGER_TYPE:
5943     case REAL_TYPE:
5944     case BOOLEAN_TYPE:
5945       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
5946                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
5947                                       TYPE_MAX_VALUE (b->type)))
5948               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
5949                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
5950                                          TYPE_MIN_VALUE (b->type))));
5951
5952     case FIXED_POINT_TYPE:
5953       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
5954
5955     case OFFSET_TYPE:
5956       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
5957
5958     case METHOD_TYPE:
5959       return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
5960               && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5961                   || (TYPE_ARG_TYPES (a->type)
5962                       && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5963                       && TYPE_ARG_TYPES (b->type)
5964                       && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5965                       && type_list_equal (TYPE_ARG_TYPES (a->type),
5966                                           TYPE_ARG_TYPES (b->type)))));
5967
5968     case ARRAY_TYPE:
5969       return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
5970
5971     case RECORD_TYPE:
5972     case UNION_TYPE:
5973     case QUAL_UNION_TYPE:
5974       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
5975               || (TYPE_FIELDS (a->type)
5976                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
5977                   && TYPE_FIELDS (b->type)
5978                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
5979                   && type_list_equal (TYPE_FIELDS (a->type),
5980                                       TYPE_FIELDS (b->type))));
5981
5982     case FUNCTION_TYPE:
5983       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5984           || (TYPE_ARG_TYPES (a->type)
5985               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5986               && TYPE_ARG_TYPES (b->type)
5987               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5988               && type_list_equal (TYPE_ARG_TYPES (a->type),
5989                                   TYPE_ARG_TYPES (b->type))))
5990         break;
5991       return 0;
5992
5993     default:
5994       return 0;
5995     }
5996
5997   if (lang_hooks.types.type_hash_eq != NULL)
5998     return lang_hooks.types.type_hash_eq (a->type, b->type);
5999
6000   return 1;
6001 }
6002
6003 /* Return the cached hash value.  */
6004
6005 static hashval_t
6006 type_hash_hash (const void *item)
6007 {
6008   return ((const struct type_hash *) item)->hash;
6009 }
6010
6011 /* Look in the type hash table for a type isomorphic to TYPE.
6012    If one is found, return it.  Otherwise return 0.  */
6013
6014 tree
6015 type_hash_lookup (hashval_t hashcode, tree type)
6016 {
6017   struct type_hash *h, in;
6018
6019   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6020      must call that routine before comparing TYPE_ALIGNs.  */
6021   layout_type (type);
6022
6023   in.hash = hashcode;
6024   in.type = type;
6025
6026   h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
6027                                                 hashcode);
6028   if (h)
6029     return h->type;
6030   return NULL_TREE;
6031 }
6032
6033 /* Add an entry to the type-hash-table
6034    for a type TYPE whose hash code is HASHCODE.  */
6035
6036 void
6037 type_hash_add (hashval_t hashcode, tree type)
6038 {
6039   struct type_hash *h;
6040   void **loc;
6041
6042   h = ggc_alloc_type_hash ();
6043   h->hash = hashcode;
6044   h->type = type;
6045   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
6046   *loc = (void *)h;
6047 }
6048
6049 /* Given TYPE, and HASHCODE its hash code, return the canonical
6050    object for an identical type if one already exists.
6051    Otherwise, return TYPE, and record it as the canonical object.
6052
6053    To use this function, first create a type of the sort you want.
6054    Then compute its hash code from the fields of the type that
6055    make it different from other similar types.
6056    Then call this function and use the value.  */
6057
6058 tree
6059 type_hash_canon (unsigned int hashcode, tree type)
6060 {
6061   tree t1;
6062
6063   /* The hash table only contains main variants, so ensure that's what we're
6064      being passed.  */
6065   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
6066
6067   if (!lang_hooks.types.hash_types)
6068     return type;
6069
6070   /* See if the type is in the hash table already.  If so, return it.
6071      Otherwise, add the type.  */
6072   t1 = type_hash_lookup (hashcode, type);
6073   if (t1 != 0)
6074     {
6075 #ifdef GATHER_STATISTICS
6076       tree_node_counts[(int) t_kind]--;
6077       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
6078 #endif
6079       return t1;
6080     }
6081   else
6082     {
6083       type_hash_add (hashcode, type);
6084       return type;
6085     }
6086 }
6087
6088 /* See if the data pointed to by the type hash table is marked.  We consider
6089    it marked if the type is marked or if a debug type number or symbol
6090    table entry has been made for the type.  */
6091
6092 static int
6093 type_hash_marked_p (const void *p)
6094 {
6095   const_tree const type = ((const struct type_hash *) p)->type;
6096
6097   return ggc_marked_p (type);
6098 }
6099
6100 static void
6101 print_type_hash_statistics (void)
6102 {
6103   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6104            (long) htab_size (type_hash_table),
6105            (long) htab_elements (type_hash_table),
6106            htab_collisions (type_hash_table));
6107 }
6108
6109 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6110    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6111    by adding the hash codes of the individual attributes.  */
6112
6113 static unsigned int
6114 attribute_hash_list (const_tree list, hashval_t hashcode)
6115 {
6116   const_tree tail;
6117
6118   for (tail = list; tail; tail = TREE_CHAIN (tail))
6119     /* ??? Do we want to add in TREE_VALUE too? */
6120     hashcode = iterative_hash_object
6121       (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
6122   return hashcode;
6123 }
6124
6125 /* Given two lists of attributes, return true if list l2 is
6126    equivalent to l1.  */
6127
6128 int
6129 attribute_list_equal (const_tree l1, const_tree l2)
6130 {
6131   return attribute_list_contained (l1, l2)
6132          && attribute_list_contained (l2, l1);
6133 }
6134
6135 /* Given two lists of attributes, return true if list L2 is
6136    completely contained within L1.  */
6137 /* ??? This would be faster if attribute names were stored in a canonicalized
6138    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6139    must be used to show these elements are equivalent (which they are).  */
6140 /* ??? It's not clear that attributes with arguments will always be handled
6141    correctly.  */
6142
6143 int
6144 attribute_list_contained (const_tree l1, const_tree l2)
6145 {
6146   const_tree t1, t2;
6147
6148   /* First check the obvious, maybe the lists are identical.  */
6149   if (l1 == l2)
6150     return 1;
6151
6152   /* Maybe the lists are similar.  */
6153   for (t1 = l1, t2 = l2;
6154        t1 != 0 && t2 != 0
6155         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
6156         && TREE_VALUE (t1) == TREE_VALUE (t2);
6157        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
6158
6159   /* Maybe the lists are equal.  */
6160   if (t1 == 0 && t2 == 0)
6161     return 1;
6162
6163   for (; t2 != 0; t2 = TREE_CHAIN (t2))
6164     {
6165       const_tree attr;
6166       /* This CONST_CAST is okay because lookup_attribute does not
6167          modify its argument and the return value is assigned to a
6168          const_tree.  */
6169       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6170                                     CONST_CAST_TREE(l1));
6171            attr != NULL_TREE;
6172            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6173                                     TREE_CHAIN (attr)))
6174         {
6175           if (TREE_VALUE (t2) != NULL
6176               && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
6177               && TREE_VALUE (attr) != NULL
6178               && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
6179             {
6180               if (simple_cst_list_equal (TREE_VALUE (t2),
6181                                          TREE_VALUE (attr)) == 1)
6182                 break;
6183             }
6184           else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
6185             break;
6186         }
6187
6188       if (attr == 0)
6189         return 0;
6190     }
6191
6192   return 1;
6193 }
6194
6195 /* Given two lists of types
6196    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6197    return 1 if the lists contain the same types in the same order.
6198    Also, the TREE_PURPOSEs must match.  */
6199
6200 int
6201 type_list_equal (const_tree l1, const_tree l2)
6202 {
6203   const_tree t1, t2;
6204
6205   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6206     if (TREE_VALUE (t1) != TREE_VALUE (t2)
6207         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6208             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6209                   && (TREE_TYPE (TREE_PURPOSE (t1))
6210                       == TREE_TYPE (TREE_PURPOSE (t2))))))
6211       return 0;
6212
6213   return t1 == t2;
6214 }
6215
6216 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6217    given by TYPE.  If the argument list accepts variable arguments,
6218    then this function counts only the ordinary arguments.  */
6219
6220 int
6221 type_num_arguments (const_tree type)
6222 {
6223   int i = 0;
6224   tree t;
6225
6226   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6227     /* If the function does not take a variable number of arguments,
6228        the last element in the list will have type `void'.  */
6229     if (VOID_TYPE_P (TREE_VALUE (t)))
6230       break;
6231     else
6232       ++i;
6233
6234   return i;
6235 }
6236
6237 /* Nonzero if integer constants T1 and T2
6238    represent the same constant value.  */
6239
6240 int
6241 tree_int_cst_equal (const_tree t1, const_tree t2)
6242 {
6243   if (t1 == t2)
6244     return 1;
6245
6246   if (t1 == 0 || t2 == 0)
6247     return 0;
6248
6249   if (TREE_CODE (t1) == INTEGER_CST
6250       && TREE_CODE (t2) == INTEGER_CST
6251       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6252       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
6253     return 1;
6254
6255   return 0;
6256 }
6257
6258 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6259    The precise way of comparison depends on their data type.  */
6260
6261 int
6262 tree_int_cst_lt (const_tree t1, const_tree t2)
6263 {
6264   if (t1 == t2)
6265     return 0;
6266
6267   if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
6268     {
6269       int t1_sgn = tree_int_cst_sgn (t1);
6270       int t2_sgn = tree_int_cst_sgn (t2);
6271
6272       if (t1_sgn < t2_sgn)
6273         return 1;
6274       else if (t1_sgn > t2_sgn)
6275         return 0;
6276       /* Otherwise, both are non-negative, so we compare them as
6277          unsigned just in case one of them would overflow a signed
6278          type.  */
6279     }
6280   else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
6281     return INT_CST_LT (t1, t2);
6282
6283   return INT_CST_LT_UNSIGNED (t1, t2);
6284 }
6285
6286 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
6287
6288 int
6289 tree_int_cst_compare (const_tree t1, const_tree t2)
6290 {
6291   if (tree_int_cst_lt (t1, t2))
6292     return -1;
6293   else if (tree_int_cst_lt (t2, t1))
6294     return 1;
6295   else
6296     return 0;
6297 }
6298
6299 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6300    the host.  If POS is zero, the value can be represented in a single
6301    HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
6302    be represented in a single unsigned HOST_WIDE_INT.  */
6303
6304 int
6305 host_integerp (const_tree t, int pos)
6306 {
6307   if (t == NULL_TREE)
6308     return 0;
6309
6310   return (TREE_CODE (t) == INTEGER_CST
6311           && ((TREE_INT_CST_HIGH (t) == 0
6312                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
6313               || (! pos && TREE_INT_CST_HIGH (t) == -1
6314                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
6315                   && (!TYPE_UNSIGNED (TREE_TYPE (t))
6316                       || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6317                           && TYPE_IS_SIZETYPE (TREE_TYPE (t)))))
6318               || (pos && TREE_INT_CST_HIGH (t) == 0)));
6319 }
6320
6321 /* Return the HOST_WIDE_INT least significant bits of T if it is an
6322    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
6323    be non-negative.  We must be able to satisfy the above conditions.  */
6324
6325 HOST_WIDE_INT
6326 tree_low_cst (const_tree t, int pos)
6327 {
6328   gcc_assert (host_integerp (t, pos));
6329   return TREE_INT_CST_LOW (t);
6330 }
6331
6332 /* Return the most significant bit of the integer constant T.  */
6333
6334 int
6335 tree_int_cst_msb (const_tree t)
6336 {
6337   int prec;
6338   HOST_WIDE_INT h;
6339   unsigned HOST_WIDE_INT l;
6340
6341   /* Note that using TYPE_PRECISION here is wrong.  We care about the
6342      actual bits, not the (arbitrary) range of the type.  */
6343   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
6344   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
6345                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
6346   return (l & 1) == 1;
6347 }
6348
6349 /* Return an indication of the sign of the integer constant T.
6350    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6351    Note that -1 will never be returned if T's type is unsigned.  */
6352
6353 int
6354 tree_int_cst_sgn (const_tree t)
6355 {
6356   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
6357     return 0;
6358   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
6359     return 1;
6360   else if (TREE_INT_CST_HIGH (t) < 0)
6361     return -1;
6362   else
6363     return 1;
6364 }
6365
6366 /* Return the minimum number of bits needed to represent VALUE in a
6367    signed or unsigned type, UNSIGNEDP says which.  */
6368
6369 unsigned int
6370 tree_int_cst_min_precision (tree value, bool unsignedp)
6371 {
6372   int log;
6373
6374   /* If the value is negative, compute its negative minus 1.  The latter
6375      adjustment is because the absolute value of the largest negative value
6376      is one larger than the largest positive value.  This is equivalent to
6377      a bit-wise negation, so use that operation instead.  */
6378
6379   if (tree_int_cst_sgn (value) < 0)
6380     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
6381
6382   /* Return the number of bits needed, taking into account the fact
6383      that we need one more bit for a signed than unsigned type.  */
6384
6385   if (integer_zerop (value))
6386     log = 0;
6387   else
6388     log = tree_floor_log2 (value);
6389
6390   return log + 1 + !unsignedp;
6391 }
6392
6393 /* Compare two constructor-element-type constants.  Return 1 if the lists
6394    are known to be equal; otherwise return 0.  */
6395
6396 int
6397 simple_cst_list_equal (const_tree l1, const_tree l2)
6398 {
6399   while (l1 != NULL_TREE && l2 != NULL_TREE)
6400     {
6401       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
6402         return 0;
6403
6404       l1 = TREE_CHAIN (l1);
6405       l2 = TREE_CHAIN (l2);
6406     }
6407
6408   return l1 == l2;
6409 }
6410
6411 /* Return truthvalue of whether T1 is the same tree structure as T2.
6412    Return 1 if they are the same.
6413    Return 0 if they are understandably different.
6414    Return -1 if either contains tree structure not understood by
6415    this function.  */
6416
6417 int
6418 simple_cst_equal (const_tree t1, const_tree t2)
6419 {
6420   enum tree_code code1, code2;
6421   int cmp;
6422   int i;
6423
6424   if (t1 == t2)
6425     return 1;
6426   if (t1 == 0 || t2 == 0)
6427     return 0;
6428
6429   code1 = TREE_CODE (t1);
6430   code2 = TREE_CODE (t2);
6431
6432   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
6433     {
6434       if (CONVERT_EXPR_CODE_P (code2)
6435           || code2 == NON_LVALUE_EXPR)
6436         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6437       else
6438         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
6439     }
6440
6441   else if (CONVERT_EXPR_CODE_P (code2)
6442            || code2 == NON_LVALUE_EXPR)
6443     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
6444
6445   if (code1 != code2)
6446     return 0;
6447
6448   switch (code1)
6449     {
6450     case INTEGER_CST:
6451       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6452               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
6453
6454     case REAL_CST:
6455       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
6456
6457     case FIXED_CST:
6458       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
6459
6460     case STRING_CST:
6461       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
6462               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
6463                          TREE_STRING_LENGTH (t1)));
6464
6465     case CONSTRUCTOR:
6466       {
6467         unsigned HOST_WIDE_INT idx;
6468         VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
6469         VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
6470
6471         if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
6472           return false;
6473
6474         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
6475           /* ??? Should we handle also fields here? */
6476           if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
6477                                  VEC_index (constructor_elt, v2, idx)->value))
6478             return false;
6479         return true;
6480       }
6481
6482     case SAVE_EXPR:
6483       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6484
6485     case CALL_EXPR:
6486       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
6487       if (cmp <= 0)
6488         return cmp;
6489       if (call_expr_nargs (t1) != call_expr_nargs (t2))
6490         return 0;
6491       {
6492         const_tree arg1, arg2;
6493         const_call_expr_arg_iterator iter1, iter2;
6494         for (arg1 = first_const_call_expr_arg (t1, &iter1),
6495                arg2 = first_const_call_expr_arg (t2, &iter2);
6496              arg1 && arg2;
6497              arg1 = next_const_call_expr_arg (&iter1),
6498                arg2 = next_const_call_expr_arg (&iter2))
6499           {
6500             cmp = simple_cst_equal (arg1, arg2);
6501             if (cmp <= 0)
6502               return cmp;
6503           }
6504         return arg1 == arg2;
6505       }
6506
6507     case TARGET_EXPR:
6508       /* Special case: if either target is an unallocated VAR_DECL,
6509          it means that it's going to be unified with whatever the
6510          TARGET_EXPR is really supposed to initialize, so treat it
6511          as being equivalent to anything.  */
6512       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
6513            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
6514            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
6515           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
6516               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
6517               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
6518         cmp = 1;
6519       else
6520         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6521
6522       if (cmp <= 0)
6523         return cmp;
6524
6525       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
6526
6527     case WITH_CLEANUP_EXPR:
6528       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6529       if (cmp <= 0)
6530         return cmp;
6531
6532       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
6533
6534     case COMPONENT_REF:
6535       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
6536         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6537
6538       return 0;
6539
6540     case VAR_DECL:
6541     case PARM_DECL:
6542     case CONST_DECL:
6543     case FUNCTION_DECL:
6544       return 0;
6545
6546     default:
6547       break;
6548     }
6549
6550   /* This general rule works for most tree codes.  All exceptions should be
6551      handled above.  If this is a language-specific tree code, we can't
6552      trust what might be in the operand, so say we don't know
6553      the situation.  */
6554   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
6555     return -1;
6556
6557   switch (TREE_CODE_CLASS (code1))
6558     {
6559     case tcc_unary:
6560     case tcc_binary:
6561     case tcc_comparison:
6562     case tcc_expression:
6563     case tcc_reference:
6564     case tcc_statement:
6565       cmp = 1;
6566       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
6567         {
6568           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
6569           if (cmp <= 0)
6570             return cmp;
6571         }
6572
6573       return cmp;
6574
6575     default:
6576       return -1;
6577     }
6578 }
6579
6580 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6581    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6582    than U, respectively.  */
6583
6584 int
6585 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
6586 {
6587   if (tree_int_cst_sgn (t) < 0)
6588     return -1;
6589   else if (TREE_INT_CST_HIGH (t) != 0)
6590     return 1;
6591   else if (TREE_INT_CST_LOW (t) == u)
6592     return 0;
6593   else if (TREE_INT_CST_LOW (t) < u)
6594     return -1;
6595   else
6596     return 1;
6597 }
6598
6599 /* Return true if CODE represents an associative tree code.  Otherwise
6600    return false.  */
6601 bool
6602 associative_tree_code (enum tree_code code)
6603 {
6604   switch (code)
6605     {
6606     case BIT_IOR_EXPR:
6607     case BIT_AND_EXPR:
6608     case BIT_XOR_EXPR:
6609     case PLUS_EXPR:
6610     case MULT_EXPR:
6611     case MIN_EXPR:
6612     case MAX_EXPR:
6613       return true;
6614
6615     default:
6616       break;
6617     }
6618   return false;
6619 }
6620
6621 /* Return true if CODE represents a commutative tree code.  Otherwise
6622    return false.  */
6623 bool
6624 commutative_tree_code (enum tree_code code)
6625 {
6626   switch (code)
6627     {
6628     case PLUS_EXPR:
6629     case MULT_EXPR:
6630     case MIN_EXPR:
6631     case MAX_EXPR:
6632     case BIT_IOR_EXPR:
6633     case BIT_XOR_EXPR:
6634     case BIT_AND_EXPR:
6635     case NE_EXPR:
6636     case EQ_EXPR:
6637     case UNORDERED_EXPR:
6638     case ORDERED_EXPR:
6639     case UNEQ_EXPR:
6640     case LTGT_EXPR:
6641     case TRUTH_AND_EXPR:
6642     case TRUTH_XOR_EXPR:
6643     case TRUTH_OR_EXPR:
6644       return true;
6645
6646     default:
6647       break;
6648     }
6649   return false;
6650 }
6651
6652 /* Return true if CODE represents a ternary tree code for which the
6653    first two operands are commutative.  Otherwise return false.  */
6654 bool
6655 commutative_ternary_tree_code (enum tree_code code)
6656 {
6657   switch (code)
6658     {
6659     case WIDEN_MULT_PLUS_EXPR:
6660     case WIDEN_MULT_MINUS_EXPR:
6661       return true;
6662
6663     default:
6664       break;
6665     }
6666   return false;
6667 }
6668
6669 /* Generate a hash value for an expression.  This can be used iteratively
6670    by passing a previous result as the VAL argument.
6671
6672    This function is intended to produce the same hash for expressions which
6673    would compare equal using operand_equal_p.  */
6674
6675 hashval_t
6676 iterative_hash_expr (const_tree t, hashval_t val)
6677 {
6678   int i;
6679   enum tree_code code;
6680   char tclass;
6681
6682   if (t == NULL_TREE)
6683     return iterative_hash_hashval_t (0, val);
6684
6685   code = TREE_CODE (t);
6686
6687   switch (code)
6688     {
6689     /* Alas, constants aren't shared, so we can't rely on pointer
6690        identity.  */
6691     case INTEGER_CST:
6692       val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
6693       return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
6694     case REAL_CST:
6695       {
6696         unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
6697
6698         return iterative_hash_hashval_t (val2, val);
6699       }
6700     case FIXED_CST:
6701       {
6702         unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
6703
6704         return iterative_hash_hashval_t (val2, val);
6705       }
6706     case STRING_CST:
6707       return iterative_hash (TREE_STRING_POINTER (t),
6708                              TREE_STRING_LENGTH (t), val);
6709     case COMPLEX_CST:
6710       val = iterative_hash_expr (TREE_REALPART (t), val);
6711       return iterative_hash_expr (TREE_IMAGPART (t), val);
6712     case VECTOR_CST:
6713       return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
6714     case SSA_NAME:
6715       /* We can just compare by pointer.  */
6716       return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
6717     case PLACEHOLDER_EXPR:
6718       /* The node itself doesn't matter.  */
6719       return val;
6720     case TREE_LIST:
6721       /* A list of expressions, for a CALL_EXPR or as the elements of a
6722          VECTOR_CST.  */
6723       for (; t; t = TREE_CHAIN (t))
6724         val = iterative_hash_expr (TREE_VALUE (t), val);
6725       return val;
6726     case CONSTRUCTOR:
6727       {
6728         unsigned HOST_WIDE_INT idx;
6729         tree field, value;
6730         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
6731           {
6732             val = iterative_hash_expr (field, val);
6733             val = iterative_hash_expr (value, val);
6734           }
6735         return val;
6736       }
6737     case FUNCTION_DECL:
6738       /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
6739          Otherwise nodes that compare equal according to operand_equal_p might
6740          get different hash codes.  However, don't do this for machine specific
6741          or front end builtins, since the function code is overloaded in those
6742          cases.  */
6743       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
6744           && built_in_decls[DECL_FUNCTION_CODE (t)])
6745         {
6746           t = built_in_decls[DECL_FUNCTION_CODE (t)];
6747           code = TREE_CODE (t);
6748         }
6749       /* FALL THROUGH */
6750     default:
6751       tclass = TREE_CODE_CLASS (code);
6752
6753       if (tclass == tcc_declaration)
6754         {
6755           /* DECL's have a unique ID */
6756           val = iterative_hash_host_wide_int (DECL_UID (t), val);
6757         }
6758       else
6759         {
6760           gcc_assert (IS_EXPR_CODE_CLASS (tclass));
6761
6762           val = iterative_hash_object (code, val);
6763
6764           /* Don't hash the type, that can lead to having nodes which
6765              compare equal according to operand_equal_p, but which
6766              have different hash codes.  */
6767           if (CONVERT_EXPR_CODE_P (code)
6768               || code == NON_LVALUE_EXPR)
6769             {
6770               /* Make sure to include signness in the hash computation.  */
6771               val += TYPE_UNSIGNED (TREE_TYPE (t));
6772               val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
6773             }
6774
6775           else if (commutative_tree_code (code))
6776             {
6777               /* It's a commutative expression.  We want to hash it the same
6778                  however it appears.  We do this by first hashing both operands
6779                  and then rehashing based on the order of their independent
6780                  hashes.  */
6781               hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
6782               hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
6783               hashval_t t;
6784
6785               if (one > two)
6786                 t = one, one = two, two = t;
6787
6788               val = iterative_hash_hashval_t (one, val);
6789               val = iterative_hash_hashval_t (two, val);
6790             }
6791           else
6792             for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
6793               val = iterative_hash_expr (TREE_OPERAND (t, i), val);
6794         }
6795       return val;
6796       break;
6797     }
6798 }
6799
6800 /* Generate a hash value for a pair of expressions.  This can be used
6801    iteratively by passing a previous result as the VAL argument.
6802
6803    The same hash value is always returned for a given pair of expressions,
6804    regardless of the order in which they are presented.  This is useful in
6805    hashing the operands of commutative functions.  */
6806
6807 hashval_t
6808 iterative_hash_exprs_commutative (const_tree t1,
6809                                   const_tree t2, hashval_t val)
6810 {
6811   hashval_t one = iterative_hash_expr (t1, 0);
6812   hashval_t two = iterative_hash_expr (t2, 0);
6813   hashval_t t;
6814
6815   if (one > two)
6816     t = one, one = two, two = t;
6817   val = iterative_hash_hashval_t (one, val);
6818   val = iterative_hash_hashval_t (two, val);
6819
6820   return val;
6821 }
6822 \f
6823 /* Constructors for pointer, array and function types.
6824    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
6825    constructed by language-dependent code, not here.)  */
6826
6827 /* Construct, lay out and return the type of pointers to TO_TYPE with
6828    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
6829    reference all of memory. If such a type has already been
6830    constructed, reuse it.  */
6831
6832 tree
6833 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
6834                              bool can_alias_all)
6835 {
6836   tree t;
6837
6838   if (to_type == error_mark_node)
6839     return error_mark_node;
6840
6841   /* If the pointed-to type has the may_alias attribute set, force
6842      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6843   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6844     can_alias_all = true;
6845
6846   /* In some cases, languages will have things that aren't a POINTER_TYPE
6847      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
6848      In that case, return that type without regard to the rest of our
6849      operands.
6850
6851      ??? This is a kludge, but consistent with the way this function has
6852      always operated and there doesn't seem to be a good way to avoid this
6853      at the moment.  */
6854   if (TYPE_POINTER_TO (to_type) != 0
6855       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
6856     return TYPE_POINTER_TO (to_type);
6857
6858   /* First, if we already have a type for pointers to TO_TYPE and it's
6859      the proper mode, use it.  */
6860   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
6861     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6862       return t;
6863
6864   t = make_node (POINTER_TYPE);
6865
6866   TREE_TYPE (t) = to_type;
6867   SET_TYPE_MODE (t, mode);
6868   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6869   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
6870   TYPE_POINTER_TO (to_type) = t;
6871
6872   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6873     SET_TYPE_STRUCTURAL_EQUALITY (t);
6874   else if (TYPE_CANONICAL (to_type) != to_type)
6875     TYPE_CANONICAL (t)
6876       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
6877                                      mode, can_alias_all);
6878
6879   /* Lay out the type.  This function has many callers that are concerned
6880      with expression-construction, and this simplifies them all.  */
6881   layout_type (t);
6882
6883   return t;
6884 }
6885
6886 /* By default build pointers in ptr_mode.  */
6887
6888 tree
6889 build_pointer_type (tree to_type)
6890 {
6891   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6892                                               : TYPE_ADDR_SPACE (to_type);
6893   enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6894   return build_pointer_type_for_mode (to_type, pointer_mode, false);
6895 }
6896
6897 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
6898
6899 tree
6900 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
6901                                bool can_alias_all)
6902 {
6903   tree t;
6904
6905   if (to_type == error_mark_node)
6906     return error_mark_node;
6907
6908   /* If the pointed-to type has the may_alias attribute set, force
6909      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6910   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6911     can_alias_all = true;
6912
6913   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
6914      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
6915      In that case, return that type without regard to the rest of our
6916      operands.
6917
6918      ??? This is a kludge, but consistent with the way this function has
6919      always operated and there doesn't seem to be a good way to avoid this
6920      at the moment.  */
6921   if (TYPE_REFERENCE_TO (to_type) != 0
6922       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
6923     return TYPE_REFERENCE_TO (to_type);
6924
6925   /* First, if we already have a type for pointers to TO_TYPE and it's
6926      the proper mode, use it.  */
6927   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
6928     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6929       return t;
6930
6931   t = make_node (REFERENCE_TYPE);
6932
6933   TREE_TYPE (t) = to_type;
6934   SET_TYPE_MODE (t, mode);
6935   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6936   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
6937   TYPE_REFERENCE_TO (to_type) = t;
6938
6939   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6940     SET_TYPE_STRUCTURAL_EQUALITY (t);
6941   else if (TYPE_CANONICAL (to_type) != to_type)
6942     TYPE_CANONICAL (t)
6943       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
6944                                        mode, can_alias_all);
6945
6946   layout_type (t);
6947
6948   return t;
6949 }
6950
6951
6952 /* Build the node for the type of references-to-TO_TYPE by default
6953    in ptr_mode.  */
6954
6955 tree
6956 build_reference_type (tree to_type)
6957 {
6958   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6959                                               : TYPE_ADDR_SPACE (to_type);
6960   enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6961   return build_reference_type_for_mode (to_type, pointer_mode, false);
6962 }
6963
6964 /* Build a type that is compatible with t but has no cv quals anywhere
6965    in its type, thus
6966
6967    const char *const *const *  ->  char ***.  */
6968
6969 tree
6970 build_type_no_quals (tree t)
6971 {
6972   switch (TREE_CODE (t))
6973     {
6974     case POINTER_TYPE:
6975       return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6976                                           TYPE_MODE (t),
6977                                           TYPE_REF_CAN_ALIAS_ALL (t));
6978     case REFERENCE_TYPE:
6979       return
6980         build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6981                                        TYPE_MODE (t),
6982                                        TYPE_REF_CAN_ALIAS_ALL (t));
6983     default:
6984       return TYPE_MAIN_VARIANT (t);
6985     }
6986 }
6987
6988 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
6989    MAXVAL should be the maximum value in the domain
6990    (one less than the length of the array).
6991
6992    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
6993    We don't enforce this limit, that is up to caller (e.g. language front end).
6994    The limit exists because the result is a signed type and we don't handle
6995    sizes that use more than one HOST_WIDE_INT.  */
6996
6997 tree
6998 build_index_type (tree maxval)
6999 {
7000   tree itype = make_node (INTEGER_TYPE);
7001
7002   TREE_TYPE (itype) = sizetype;
7003   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
7004   TYPE_MIN_VALUE (itype) = size_zero_node;
7005   TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
7006   SET_TYPE_MODE (itype, TYPE_MODE (sizetype));
7007   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
7008   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
7009   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
7010   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
7011
7012   if (host_integerp (maxval, 1))
7013     return type_hash_canon (tree_low_cst (maxval, 1), itype);
7014   else
7015     {
7016       /* Since we cannot hash this type, we need to compare it using
7017          structural equality checks. */
7018       SET_TYPE_STRUCTURAL_EQUALITY (itype);
7019       return itype;
7020     }
7021 }
7022
7023 #define MAX_INT_CACHED_PREC \
7024   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7025 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
7026
7027 /* Builds a signed or unsigned integer type of precision PRECISION.
7028    Used for C bitfields whose precision does not match that of
7029    built-in target types.  */
7030 tree
7031 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
7032                                 int unsignedp)
7033 {
7034   tree itype, ret;
7035
7036   if (unsignedp)
7037     unsignedp = MAX_INT_CACHED_PREC + 1;
7038
7039   if (precision <= MAX_INT_CACHED_PREC)
7040     {
7041       itype = nonstandard_integer_type_cache[precision + unsignedp];
7042       if (itype)
7043         return itype;
7044     }
7045
7046   itype = make_node (INTEGER_TYPE);
7047   TYPE_PRECISION (itype) = precision;
7048
7049   if (unsignedp)
7050     fixup_unsigned_type (itype);
7051   else
7052     fixup_signed_type (itype);
7053
7054   ret = itype;
7055   if (host_integerp (TYPE_MAX_VALUE (itype), 1))
7056     ret = type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
7057   if (precision <= MAX_INT_CACHED_PREC && lang_hooks.types.hash_types)
7058     nonstandard_integer_type_cache[precision + unsignedp] = ret;
7059
7060   return ret;
7061 }
7062
7063 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
7064    ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
7065    high bound HIGHVAL.  If TYPE is NULL, sizetype is used.  */
7066
7067 tree
7068 build_range_type (tree type, tree lowval, tree highval)
7069 {
7070   tree itype = make_node (INTEGER_TYPE);
7071
7072   TREE_TYPE (itype) = type;
7073   if (type == NULL_TREE)
7074     type = sizetype;
7075
7076   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
7077   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
7078
7079   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
7080   SET_TYPE_MODE (itype, TYPE_MODE (type));
7081   TYPE_SIZE (itype) = TYPE_SIZE (type);
7082   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
7083   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
7084   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
7085
7086   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
7087     return type_hash_canon (tree_low_cst (highval, 0)
7088                             - tree_low_cst (lowval, 0),
7089                             itype);
7090   else
7091     return itype;
7092 }
7093
7094 /* Return true if the debug information for TYPE, a subtype, should be emitted
7095    as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
7096    high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
7097    debug info and doesn't reflect the source code.  */
7098
7099 bool
7100 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7101 {
7102   tree base_type = TREE_TYPE (type), low, high;
7103
7104   /* Subrange types have a base type which is an integral type.  */
7105   if (!INTEGRAL_TYPE_P (base_type))
7106     return false;
7107
7108   /* Get the real bounds of the subtype.  */
7109   if (lang_hooks.types.get_subrange_bounds)
7110     lang_hooks.types.get_subrange_bounds (type, &low, &high);
7111   else
7112     {
7113       low = TYPE_MIN_VALUE (type);
7114       high = TYPE_MAX_VALUE (type);
7115     }
7116
7117   /* If the type and its base type have the same representation and the same
7118      name, then the type is not a subrange but a copy of the base type.  */
7119   if ((TREE_CODE (base_type) == INTEGER_TYPE
7120        || TREE_CODE (base_type) == BOOLEAN_TYPE)
7121       && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7122       && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7123       && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
7124     {
7125       tree type_name = TYPE_NAME (type);
7126       tree base_type_name = TYPE_NAME (base_type);
7127
7128       if (type_name && TREE_CODE (type_name) == TYPE_DECL)
7129         type_name = DECL_NAME (type_name);
7130
7131       if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
7132         base_type_name = DECL_NAME (base_type_name);
7133
7134       if (type_name == base_type_name)
7135         return false;
7136     }
7137
7138   if (lowval)
7139     *lowval = low;
7140   if (highval)
7141     *highval = high;
7142   return true;
7143 }
7144
7145 /* Just like build_index_type, but takes lowval and highval instead
7146    of just highval (maxval).  */
7147
7148 tree
7149 build_index_2_type (tree lowval, tree highval)
7150 {
7151   return build_range_type (sizetype, lowval, highval);
7152 }
7153
7154 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7155    and number of elements specified by the range of values of INDEX_TYPE.
7156    If such a type has already been constructed, reuse it.  */
7157
7158 tree
7159 build_array_type (tree elt_type, tree index_type)
7160 {
7161   tree t;
7162   hashval_t hashcode = 0;
7163
7164   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7165     {
7166       error ("arrays of functions are not meaningful");
7167       elt_type = integer_type_node;
7168     }
7169
7170   t = make_node (ARRAY_TYPE);
7171   TREE_TYPE (t) = elt_type;
7172   TYPE_DOMAIN (t) = index_type;
7173   TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7174   layout_type (t);
7175
7176   /* If the element type is incomplete at this point we get marked for
7177      structural equality.  Do not record these types in the canonical
7178      type hashtable.  */
7179   if (TYPE_STRUCTURAL_EQUALITY_P (t))
7180     return t;
7181
7182   hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
7183   if (index_type)
7184     hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
7185   t = type_hash_canon (hashcode, t);
7186
7187   if (TYPE_CANONICAL (t) == t)
7188     {
7189       if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7190           || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7191         SET_TYPE_STRUCTURAL_EQUALITY (t);
7192       else if (TYPE_CANONICAL (elt_type) != elt_type
7193                || (index_type && TYPE_CANONICAL (index_type) != index_type))
7194         TYPE_CANONICAL (t)
7195           = build_array_type (TYPE_CANONICAL (elt_type),
7196                               index_type ? TYPE_CANONICAL (index_type) : NULL);
7197     }
7198
7199   return t;
7200 }
7201
7202 /* Recursively examines the array elements of TYPE, until a non-array
7203    element type is found.  */
7204
7205 tree
7206 strip_array_types (tree type)
7207 {
7208   while (TREE_CODE (type) == ARRAY_TYPE)
7209     type = TREE_TYPE (type);
7210
7211   return type;
7212 }
7213
7214 /* Computes the canonical argument types from the argument type list
7215    ARGTYPES.
7216
7217    Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7218    on entry to this function, or if any of the ARGTYPES are
7219    structural.
7220
7221    Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7222    true on entry to this function, or if any of the ARGTYPES are
7223    non-canonical.
7224
7225    Returns a canonical argument list, which may be ARGTYPES when the
7226    canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7227    true) or would not differ from ARGTYPES.  */
7228
7229 static tree
7230 maybe_canonicalize_argtypes(tree argtypes,
7231                             bool *any_structural_p,
7232                             bool *any_noncanonical_p)
7233 {
7234   tree arg;
7235   bool any_noncanonical_argtypes_p = false;
7236
7237   for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7238     {
7239       if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7240         /* Fail gracefully by stating that the type is structural.  */
7241         *any_structural_p = true;
7242       else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7243         *any_structural_p = true;
7244       else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7245                || TREE_PURPOSE (arg))
7246         /* If the argument has a default argument, we consider it
7247            non-canonical even though the type itself is canonical.
7248            That way, different variants of function and method types
7249            with default arguments will all point to the variant with
7250            no defaults as their canonical type.  */
7251         any_noncanonical_argtypes_p = true;
7252     }
7253
7254   if (*any_structural_p)
7255     return argtypes;
7256
7257   if (any_noncanonical_argtypes_p)
7258     {
7259       /* Build the canonical list of argument types.  */
7260       tree canon_argtypes = NULL_TREE;
7261       bool is_void = false;
7262
7263       for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7264         {
7265           if (arg == void_list_node)
7266             is_void = true;
7267           else
7268             canon_argtypes = tree_cons (NULL_TREE,
7269                                         TYPE_CANONICAL (TREE_VALUE (arg)),
7270                                         canon_argtypes);
7271         }
7272
7273       canon_argtypes = nreverse (canon_argtypes);
7274       if (is_void)
7275         canon_argtypes = chainon (canon_argtypes, void_list_node);
7276
7277       /* There is a non-canonical type.  */
7278       *any_noncanonical_p = true;
7279       return canon_argtypes;
7280     }
7281
7282   /* The canonical argument types are the same as ARGTYPES.  */
7283   return argtypes;
7284 }
7285
7286 /* Construct, lay out and return
7287    the type of functions returning type VALUE_TYPE
7288    given arguments of types ARG_TYPES.
7289    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7290    are data type nodes for the arguments of the function.
7291    If such a type has already been constructed, reuse it.  */
7292
7293 tree
7294 build_function_type (tree value_type, tree arg_types)
7295 {
7296   tree t;
7297   hashval_t hashcode = 0;
7298   bool any_structural_p, any_noncanonical_p;
7299   tree canon_argtypes;
7300
7301   if (TREE_CODE (value_type) == FUNCTION_TYPE)
7302     {
7303       error ("function return type cannot be function");
7304       value_type = integer_type_node;
7305     }
7306
7307   /* Make a node of the sort we want.  */
7308   t = make_node (FUNCTION_TYPE);
7309   TREE_TYPE (t) = value_type;
7310   TYPE_ARG_TYPES (t) = arg_types;
7311
7312   /* If we already have such a type, use the old one.  */
7313   hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
7314   hashcode = type_hash_list (arg_types, hashcode);
7315   t = type_hash_canon (hashcode, t);
7316
7317   /* Set up the canonical type. */
7318   any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
7319   any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
7320   canon_argtypes = maybe_canonicalize_argtypes (arg_types,
7321                                                 &any_structural_p,
7322                                                 &any_noncanonical_p);
7323   if (any_structural_p)
7324     SET_TYPE_STRUCTURAL_EQUALITY (t);
7325   else if (any_noncanonical_p)
7326     TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
7327                                               canon_argtypes);
7328
7329   if (!COMPLETE_TYPE_P (t))
7330     layout_type (t);
7331   return t;
7332 }
7333
7334 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.  */
7335
7336 tree
7337 build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
7338 {
7339   tree new_type = NULL;
7340   tree args, new_args = NULL, t;
7341   tree new_reversed;
7342   int i = 0;
7343
7344   for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
7345        args = TREE_CHAIN (args), i++)
7346     if (!bitmap_bit_p (args_to_skip, i))
7347       new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
7348
7349   new_reversed = nreverse (new_args);
7350   if (args)
7351     {
7352       if (new_reversed)
7353         TREE_CHAIN (new_args) = void_list_node;
7354       else
7355         new_reversed = void_list_node;
7356     }
7357
7358   /* Use copy_node to preserve as much as possible from original type
7359      (debug info, attribute lists etc.)
7360      Exception is METHOD_TYPEs must have THIS argument.
7361      When we are asked to remove it, we need to build new FUNCTION_TYPE
7362      instead.  */
7363   if (TREE_CODE (orig_type) != METHOD_TYPE
7364       || !bitmap_bit_p (args_to_skip, 0))
7365     {
7366       new_type = build_distinct_type_copy (orig_type);
7367       TYPE_ARG_TYPES (new_type) = new_reversed;
7368     }
7369   else
7370     {
7371       new_type
7372         = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
7373                                                          new_reversed));
7374       TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
7375     }
7376
7377   /* This is a new type, not a copy of an old type.  Need to reassociate
7378      variants.  We can handle everything except the main variant lazily.  */
7379   t = TYPE_MAIN_VARIANT (orig_type);
7380   if (orig_type != t)
7381     {
7382       TYPE_MAIN_VARIANT (new_type) = t;
7383       TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
7384       TYPE_NEXT_VARIANT (t) = new_type;
7385     }
7386   else
7387     {
7388       TYPE_MAIN_VARIANT (new_type) = new_type;
7389       TYPE_NEXT_VARIANT (new_type) = NULL;
7390     }
7391   return new_type;
7392 }
7393
7394 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
7395
7396    Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7397    linked by TREE_CHAIN directly.  The caller is responsible for eliminating
7398    them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
7399
7400 tree
7401 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
7402 {
7403   tree new_decl = copy_node (orig_decl);
7404   tree new_type;
7405
7406   new_type = TREE_TYPE (orig_decl);
7407   if (prototype_p (new_type))
7408     new_type = build_function_type_skip_args (new_type, args_to_skip);
7409   TREE_TYPE (new_decl) = new_type;
7410
7411   /* For declarations setting DECL_VINDEX (i.e. methods)
7412      we expect first argument to be THIS pointer.   */
7413   if (bitmap_bit_p (args_to_skip, 0))
7414     DECL_VINDEX (new_decl) = NULL_TREE;
7415
7416   /* When signature changes, we need to clear builtin info.  */
7417   if (DECL_BUILT_IN (new_decl) && !bitmap_empty_p (args_to_skip))
7418     {
7419       DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
7420       DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
7421     }
7422   return new_decl;
7423 }
7424
7425 /* Build a function type.  The RETURN_TYPE is the type returned by the
7426    function.  If VAARGS is set, no void_type_node is appended to the
7427    the list.  ARGP must be always be terminated be a NULL_TREE.  */
7428
7429 static tree
7430 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
7431 {
7432   tree t, args, last;
7433
7434   t = va_arg (argp, tree);
7435   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
7436     args = tree_cons (NULL_TREE, t, args);
7437
7438   if (vaargs)
7439     {
7440       last = args;
7441       if (args != NULL_TREE)
7442         args = nreverse (args);
7443       gcc_assert (last != void_list_node);
7444     }
7445   else if (args == NULL_TREE)
7446     args = void_list_node;
7447   else
7448     {
7449       last = args;
7450       args = nreverse (args);
7451       TREE_CHAIN (last) = void_list_node;
7452     }
7453   args = build_function_type (return_type, args);
7454
7455   return args;
7456 }
7457
7458 /* Build a function type.  The RETURN_TYPE is the type returned by the
7459    function.  If additional arguments are provided, they are
7460    additional argument types.  The list of argument types must always
7461    be terminated by NULL_TREE.  */
7462
7463 tree
7464 build_function_type_list (tree return_type, ...)
7465 {
7466   tree args;
7467   va_list p;
7468
7469   va_start (p, return_type);
7470   args = build_function_type_list_1 (false, return_type, p);
7471   va_end (p);
7472   return args;
7473 }
7474
7475 /* Build a variable argument function type.  The RETURN_TYPE is the
7476    type returned by the function.  If additional arguments are provided,
7477    they are additional argument types.  The list of argument types must
7478    always be terminated by NULL_TREE.  */
7479
7480 tree
7481 build_varargs_function_type_list (tree return_type, ...)
7482 {
7483   tree args;
7484   va_list p;
7485
7486   va_start (p, return_type);
7487   args = build_function_type_list_1 (true, return_type, p);
7488   va_end (p);
7489
7490   return args;
7491 }
7492
7493 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
7494    and ARGTYPES (a TREE_LIST) are the return type and arguments types
7495    for the method.  An implicit additional parameter (of type
7496    pointer-to-BASETYPE) is added to the ARGTYPES.  */
7497
7498 tree
7499 build_method_type_directly (tree basetype,
7500                             tree rettype,
7501                             tree argtypes)
7502 {
7503   tree t;
7504   tree ptype;
7505   int hashcode = 0;
7506   bool any_structural_p, any_noncanonical_p;
7507   tree canon_argtypes;
7508
7509   /* Make a node of the sort we want.  */
7510   t = make_node (METHOD_TYPE);
7511
7512   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7513   TREE_TYPE (t) = rettype;
7514   ptype = build_pointer_type (basetype);
7515
7516   /* The actual arglist for this function includes a "hidden" argument
7517      which is "this".  Put it into the list of argument types.  */
7518   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
7519   TYPE_ARG_TYPES (t) = argtypes;
7520
7521   /* If we already have such a type, use the old one.  */
7522   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7523   hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
7524   hashcode = type_hash_list (argtypes, hashcode);
7525   t = type_hash_canon (hashcode, t);
7526
7527   /* Set up the canonical type. */
7528   any_structural_p
7529     = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7530        || TYPE_STRUCTURAL_EQUALITY_P (rettype));
7531   any_noncanonical_p
7532     = (TYPE_CANONICAL (basetype) != basetype
7533        || TYPE_CANONICAL (rettype) != rettype);
7534   canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
7535                                                 &any_structural_p,
7536                                                 &any_noncanonical_p);
7537   if (any_structural_p)
7538     SET_TYPE_STRUCTURAL_EQUALITY (t);
7539   else if (any_noncanonical_p)
7540     TYPE_CANONICAL (t)
7541       = build_method_type_directly (TYPE_CANONICAL (basetype),
7542                                     TYPE_CANONICAL (rettype),
7543                                     canon_argtypes);
7544   if (!COMPLETE_TYPE_P (t))
7545     layout_type (t);
7546
7547   return t;
7548 }
7549
7550 /* Construct, lay out and return the type of methods belonging to class
7551    BASETYPE and whose arguments and values are described by TYPE.
7552    If that type exists already, reuse it.
7553    TYPE must be a FUNCTION_TYPE node.  */
7554
7555 tree
7556 build_method_type (tree basetype, tree type)
7557 {
7558   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
7559
7560   return build_method_type_directly (basetype,
7561                                      TREE_TYPE (type),
7562                                      TYPE_ARG_TYPES (type));
7563 }
7564
7565 /* Construct, lay out and return the type of offsets to a value
7566    of type TYPE, within an object of type BASETYPE.
7567    If a suitable offset type exists already, reuse it.  */
7568
7569 tree
7570 build_offset_type (tree basetype, tree type)
7571 {
7572   tree t;
7573   hashval_t hashcode = 0;
7574
7575   /* Make a node of the sort we want.  */
7576   t = make_node (OFFSET_TYPE);
7577
7578   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7579   TREE_TYPE (t) = type;
7580
7581   /* If we already have such a type, use the old one.  */
7582   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7583   hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
7584   t = type_hash_canon (hashcode, t);
7585
7586   if (!COMPLETE_TYPE_P (t))
7587     layout_type (t);
7588
7589   if (TYPE_CANONICAL (t) == t)
7590     {
7591       if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7592           || TYPE_STRUCTURAL_EQUALITY_P (type))
7593         SET_TYPE_STRUCTURAL_EQUALITY (t);
7594       else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
7595                || TYPE_CANONICAL (type) != type)
7596         TYPE_CANONICAL (t)
7597           = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
7598                                TYPE_CANONICAL (type));
7599     }
7600
7601   return t;
7602 }
7603
7604 /* Create a complex type whose components are COMPONENT_TYPE.  */
7605
7606 tree
7607 build_complex_type (tree component_type)
7608 {
7609   tree t;
7610   hashval_t hashcode;
7611
7612   gcc_assert (INTEGRAL_TYPE_P (component_type)
7613               || SCALAR_FLOAT_TYPE_P (component_type)
7614               || FIXED_POINT_TYPE_P (component_type));
7615
7616   /* Make a node of the sort we want.  */
7617   t = make_node (COMPLEX_TYPE);
7618
7619   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
7620
7621   /* If we already have such a type, use the old one.  */
7622   hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
7623   t = type_hash_canon (hashcode, t);
7624
7625   if (!COMPLETE_TYPE_P (t))
7626     layout_type (t);
7627
7628   if (TYPE_CANONICAL (t) == t)
7629     {
7630       if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
7631         SET_TYPE_STRUCTURAL_EQUALITY (t);
7632       else if (TYPE_CANONICAL (component_type) != component_type)
7633         TYPE_CANONICAL (t)
7634           = build_complex_type (TYPE_CANONICAL (component_type));
7635     }
7636
7637   /* We need to create a name, since complex is a fundamental type.  */
7638   if (! TYPE_NAME (t))
7639     {
7640       const char *name;
7641       if (component_type == char_type_node)
7642         name = "complex char";
7643       else if (component_type == signed_char_type_node)
7644         name = "complex signed char";
7645       else if (component_type == unsigned_char_type_node)
7646         name = "complex unsigned char";
7647       else if (component_type == short_integer_type_node)
7648         name = "complex short int";
7649       else if (component_type == short_unsigned_type_node)
7650         name = "complex short unsigned int";
7651       else if (component_type == integer_type_node)
7652         name = "complex int";
7653       else if (component_type == unsigned_type_node)
7654         name = "complex unsigned int";
7655       else if (component_type == long_integer_type_node)
7656         name = "complex long int";
7657       else if (component_type == long_unsigned_type_node)
7658         name = "complex long unsigned int";
7659       else if (component_type == long_long_integer_type_node)
7660         name = "complex long long int";
7661       else if (component_type == long_long_unsigned_type_node)
7662         name = "complex long long unsigned int";
7663       else
7664         name = 0;
7665
7666       if (name != 0)
7667         TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
7668                                     get_identifier (name), t);
7669     }
7670
7671   return build_qualified_type (t, TYPE_QUALS (component_type));
7672 }
7673
7674 /* If TYPE is a real or complex floating-point type and the target
7675    does not directly support arithmetic on TYPE then return the wider
7676    type to be used for arithmetic on TYPE.  Otherwise, return
7677    NULL_TREE.  */
7678
7679 tree
7680 excess_precision_type (tree type)
7681 {
7682   if (flag_excess_precision != EXCESS_PRECISION_FAST)
7683     {
7684       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
7685       switch (TREE_CODE (type))
7686         {
7687         case REAL_TYPE:
7688           switch (flt_eval_method)
7689             {
7690             case 1:
7691               if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
7692                 return double_type_node;
7693               break;
7694             case 2:
7695               if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
7696                   || TYPE_MODE (type) == TYPE_MODE (double_type_node))
7697                 return long_double_type_node;
7698               break;
7699             default:
7700               gcc_unreachable ();
7701             }
7702           break;
7703         case COMPLEX_TYPE:
7704           if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
7705             return NULL_TREE;
7706           switch (flt_eval_method)
7707             {
7708             case 1:
7709               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
7710                 return complex_double_type_node;
7711               break;
7712             case 2:
7713               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
7714                   || (TYPE_MODE (TREE_TYPE (type))
7715                       == TYPE_MODE (double_type_node)))
7716                 return complex_long_double_type_node;
7717               break;
7718             default:
7719               gcc_unreachable ();
7720             }
7721           break;
7722         default:
7723           break;
7724         }
7725     }
7726   return NULL_TREE;
7727 }
7728 \f
7729 /* Return OP, stripped of any conversions to wider types as much as is safe.
7730    Converting the value back to OP's type makes a value equivalent to OP.
7731
7732    If FOR_TYPE is nonzero, we return a value which, if converted to
7733    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
7734
7735    OP must have integer, real or enumeral type.  Pointers are not allowed!
7736
7737    There are some cases where the obvious value we could return
7738    would regenerate to OP if converted to OP's type,
7739    but would not extend like OP to wider types.
7740    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
7741    For example, if OP is (unsigned short)(signed char)-1,
7742    we avoid returning (signed char)-1 if FOR_TYPE is int,
7743    even though extending that to an unsigned short would regenerate OP,
7744    since the result of extending (signed char)-1 to (int)
7745    is different from (int) OP.  */
7746
7747 tree
7748 get_unwidened (tree op, tree for_type)
7749 {
7750   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
7751   tree type = TREE_TYPE (op);
7752   unsigned final_prec
7753     = TYPE_PRECISION (for_type != 0 ? for_type : type);
7754   int uns
7755     = (for_type != 0 && for_type != type
7756        && final_prec > TYPE_PRECISION (type)
7757        && TYPE_UNSIGNED (type));
7758   tree win = op;
7759
7760   while (CONVERT_EXPR_P (op))
7761     {
7762       int bitschange;
7763
7764       /* TYPE_PRECISION on vector types has different meaning
7765          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
7766          so avoid them here.  */
7767       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
7768         break;
7769
7770       bitschange = TYPE_PRECISION (TREE_TYPE (op))
7771                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
7772
7773       /* Truncations are many-one so cannot be removed.
7774          Unless we are later going to truncate down even farther.  */
7775       if (bitschange < 0
7776           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
7777         break;
7778
7779       /* See what's inside this conversion.  If we decide to strip it,
7780          we will set WIN.  */
7781       op = TREE_OPERAND (op, 0);
7782
7783       /* If we have not stripped any zero-extensions (uns is 0),
7784          we can strip any kind of extension.
7785          If we have previously stripped a zero-extension,
7786          only zero-extensions can safely be stripped.
7787          Any extension can be stripped if the bits it would produce
7788          are all going to be discarded later by truncating to FOR_TYPE.  */
7789
7790       if (bitschange > 0)
7791         {
7792           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
7793             win = op;
7794           /* TYPE_UNSIGNED says whether this is a zero-extension.
7795              Let's avoid computing it if it does not affect WIN
7796              and if UNS will not be needed again.  */
7797           if ((uns
7798                || CONVERT_EXPR_P (op))
7799               && TYPE_UNSIGNED (TREE_TYPE (op)))
7800             {
7801               uns = 1;
7802               win = op;
7803             }
7804         }
7805     }
7806
7807   /* If we finally reach a constant see if it fits in for_type and
7808      in that case convert it.  */
7809   if (for_type
7810       && TREE_CODE (win) == INTEGER_CST
7811       && TREE_TYPE (win) != for_type
7812       && int_fits_type_p (win, for_type))
7813     win = fold_convert (for_type, win);
7814
7815   return win;
7816 }
7817 \f
7818 /* Return OP or a simpler expression for a narrower value
7819    which can be sign-extended or zero-extended to give back OP.
7820    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
7821    or 0 if the value should be sign-extended.  */
7822
7823 tree
7824 get_narrower (tree op, int *unsignedp_ptr)
7825 {
7826   int uns = 0;
7827   int first = 1;
7828   tree win = op;
7829   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
7830
7831   while (TREE_CODE (op) == NOP_EXPR)
7832     {
7833       int bitschange
7834         = (TYPE_PRECISION (TREE_TYPE (op))
7835            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
7836
7837       /* Truncations are many-one so cannot be removed.  */
7838       if (bitschange < 0)
7839         break;
7840
7841       /* See what's inside this conversion.  If we decide to strip it,
7842          we will set WIN.  */
7843
7844       if (bitschange > 0)
7845         {
7846           op = TREE_OPERAND (op, 0);
7847           /* An extension: the outermost one can be stripped,
7848              but remember whether it is zero or sign extension.  */
7849           if (first)
7850             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7851           /* Otherwise, if a sign extension has been stripped,
7852              only sign extensions can now be stripped;
7853              if a zero extension has been stripped, only zero-extensions.  */
7854           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
7855             break;
7856           first = 0;
7857         }
7858       else /* bitschange == 0 */
7859         {
7860           /* A change in nominal type can always be stripped, but we must
7861              preserve the unsignedness.  */
7862           if (first)
7863             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7864           first = 0;
7865           op = TREE_OPERAND (op, 0);
7866           /* Keep trying to narrow, but don't assign op to win if it
7867              would turn an integral type into something else.  */
7868           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
7869             continue;
7870         }
7871
7872       win = op;
7873     }
7874
7875   if (TREE_CODE (op) == COMPONENT_REF
7876       /* Since type_for_size always gives an integer type.  */
7877       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
7878       && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
7879       /* Ensure field is laid out already.  */
7880       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
7881       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
7882     {
7883       unsigned HOST_WIDE_INT innerprec
7884         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
7885       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
7886                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
7887       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
7888
7889       /* We can get this structure field in a narrower type that fits it,
7890          but the resulting extension to its nominal type (a fullword type)
7891          must satisfy the same conditions as for other extensions.
7892
7893          Do this only for fields that are aligned (not bit-fields),
7894          because when bit-field insns will be used there is no
7895          advantage in doing this.  */
7896
7897       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
7898           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
7899           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
7900           && type != 0)
7901         {
7902           if (first)
7903             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
7904           win = fold_convert (type, op);
7905         }
7906     }
7907
7908   *unsignedp_ptr = uns;
7909   return win;
7910 }
7911 \f
7912 /* Returns true if integer constant C has a value that is permissible
7913    for type TYPE (an INTEGER_TYPE).  */
7914
7915 bool
7916 int_fits_type_p (const_tree c, const_tree type)
7917 {
7918   tree type_low_bound, type_high_bound;
7919   bool ok_for_low_bound, ok_for_high_bound, unsc;
7920   double_int dc, dd;
7921
7922   dc = tree_to_double_int (c);
7923   unsc = TYPE_UNSIGNED (TREE_TYPE (c));
7924
7925   if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE
7926       && TYPE_IS_SIZETYPE (TREE_TYPE (c))
7927       && unsc)
7928     /* So c is an unsigned integer whose type is sizetype and type is not.
7929        sizetype'd integers are sign extended even though they are
7930        unsigned. If the integer value fits in the lower end word of c,
7931        and if the higher end word has all its bits set to 1, that
7932        means the higher end bits are set to 1 only for sign extension.
7933        So let's convert c into an equivalent zero extended unsigned
7934        integer.  */
7935     dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c)));
7936
7937 retry:
7938   type_low_bound = TYPE_MIN_VALUE (type);
7939   type_high_bound = TYPE_MAX_VALUE (type);
7940
7941   /* If at least one bound of the type is a constant integer, we can check
7942      ourselves and maybe make a decision. If no such decision is possible, but
7943      this type is a subtype, try checking against that.  Otherwise, use
7944      double_int_fits_to_tree_p, which checks against the precision.
7945
7946      Compute the status for each possibly constant bound, and return if we see
7947      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
7948      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
7949      for "constant known to fit".  */
7950
7951   /* Check if c >= type_low_bound.  */
7952   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
7953     {
7954       dd = tree_to_double_int (type_low_bound);
7955       if (TREE_CODE (type) == INTEGER_TYPE
7956           && TYPE_IS_SIZETYPE (type)
7957           && TYPE_UNSIGNED (type))
7958         dd = double_int_zext (dd, TYPE_PRECISION (type));
7959       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
7960         {
7961           int c_neg = (!unsc && double_int_negative_p (dc));
7962           int t_neg = (unsc && double_int_negative_p (dd));
7963
7964           if (c_neg && !t_neg)
7965             return false;
7966           if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0)
7967             return false;
7968         }
7969       else if (double_int_cmp (dc, dd, unsc) < 0)
7970         return false;
7971       ok_for_low_bound = true;
7972     }
7973   else
7974     ok_for_low_bound = false;
7975
7976   /* Check if c <= type_high_bound.  */
7977   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
7978     {
7979       dd = tree_to_double_int (type_high_bound);
7980       if (TREE_CODE (type) == INTEGER_TYPE
7981           && TYPE_IS_SIZETYPE (type)
7982           && TYPE_UNSIGNED (type))
7983         dd = double_int_zext (dd, TYPE_PRECISION (type));
7984       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
7985         {
7986           int c_neg = (!unsc && double_int_negative_p (dc));
7987           int t_neg = (unsc && double_int_negative_p (dd));
7988
7989           if (t_neg && !c_neg)
7990             return false;
7991           if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0)
7992             return false;
7993         }
7994       else if (double_int_cmp (dc, dd, unsc) > 0)
7995         return false;
7996       ok_for_high_bound = true;
7997     }
7998   else
7999     ok_for_high_bound = false;
8000
8001   /* If the constant fits both bounds, the result is known.  */
8002   if (ok_for_low_bound && ok_for_high_bound)
8003     return true;
8004
8005   /* Perform some generic filtering which may allow making a decision
8006      even if the bounds are not constant.  First, negative integers
8007      never fit in unsigned types, */
8008   if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc))
8009     return false;
8010
8011   /* Second, narrower types always fit in wider ones.  */
8012   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
8013     return true;
8014
8015   /* Third, unsigned integers with top bit set never fit signed types.  */
8016   if (! TYPE_UNSIGNED (type) && unsc)
8017     {
8018       int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1;
8019       if (prec < HOST_BITS_PER_WIDE_INT)
8020         {
8021           if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
8022             return false;
8023         }
8024       else if (((((unsigned HOST_WIDE_INT) 1)
8025                  << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
8026         return false;
8027     }
8028
8029   /* If we haven't been able to decide at this point, there nothing more we
8030      can check ourselves here.  Look at the base type if we have one and it
8031      has the same precision.  */
8032   if (TREE_CODE (type) == INTEGER_TYPE
8033       && TREE_TYPE (type) != 0
8034       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
8035     {
8036       type = TREE_TYPE (type);
8037       goto retry;
8038     }
8039
8040   /* Or to double_int_fits_to_tree_p, if nothing else.  */
8041   return double_int_fits_to_tree_p (type, dc);
8042 }
8043
8044 /* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
8045    bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8046    represented (assuming two's-complement arithmetic) within the bit
8047    precision of the type are returned instead.  */
8048
8049 void
8050 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
8051 {
8052   if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
8053       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
8054     mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
8055                         TYPE_UNSIGNED (type));
8056   else
8057     {
8058       if (TYPE_UNSIGNED (type))
8059         mpz_set_ui (min, 0);
8060       else
8061         {
8062           double_int mn;
8063           mn = double_int_mask (TYPE_PRECISION (type) - 1);
8064           mn = double_int_sext (double_int_add (mn, double_int_one),
8065                                 TYPE_PRECISION (type));
8066           mpz_set_double_int (min, mn, false);
8067         }
8068     }
8069
8070   if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
8071       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
8072     mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
8073                         TYPE_UNSIGNED (type));
8074   else
8075     {
8076       if (TYPE_UNSIGNED (type))
8077         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)),
8078                             true);
8079       else
8080         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1),
8081                             true);
8082     }
8083 }
8084
8085 /* Return true if VAR is an automatic variable defined in function FN.  */
8086
8087 bool
8088 auto_var_in_fn_p (const_tree var, const_tree fn)
8089 {
8090   return (DECL_P (var) && DECL_CONTEXT (var) == fn
8091           && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
8092                 || TREE_CODE (var) == PARM_DECL)
8093                && ! TREE_STATIC (var))
8094               || TREE_CODE (var) == LABEL_DECL
8095               || TREE_CODE (var) == RESULT_DECL));
8096 }
8097
8098 /* Subprogram of following function.  Called by walk_tree.
8099
8100    Return *TP if it is an automatic variable or parameter of the
8101    function passed in as DATA.  */
8102
8103 static tree
8104 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8105 {
8106   tree fn = (tree) data;
8107
8108   if (TYPE_P (*tp))
8109     *walk_subtrees = 0;
8110
8111   else if (DECL_P (*tp)
8112            && auto_var_in_fn_p (*tp, fn))
8113     return *tp;
8114
8115   return NULL_TREE;
8116 }
8117
8118 /* Returns true if T is, contains, or refers to a type with variable
8119    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8120    arguments, but not the return type.  If FN is nonzero, only return
8121    true if a modifier of the type or position of FN is a variable or
8122    parameter inside FN.
8123
8124    This concept is more general than that of C99 'variably modified types':
8125    in C99, a struct type is never variably modified because a VLA may not
8126    appear as a structure member.  However, in GNU C code like:
8127
8128      struct S { int i[f()]; };
8129
8130    is valid, and other languages may define similar constructs.  */
8131
8132 bool
8133 variably_modified_type_p (tree type, tree fn)
8134 {
8135   tree t;
8136
8137 /* Test if T is either variable (if FN is zero) or an expression containing
8138    a variable in FN.  */
8139 #define RETURN_TRUE_IF_VAR(T)                                           \
8140   do { tree _t = (T);                                                   \
8141     if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
8142         && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
8143       return true;  } while (0)
8144
8145   if (type == error_mark_node)
8146     return false;
8147
8148   /* If TYPE itself has variable size, it is variably modified.  */
8149   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8150   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8151
8152   switch (TREE_CODE (type))
8153     {
8154     case POINTER_TYPE:
8155     case REFERENCE_TYPE:
8156     case VECTOR_TYPE:
8157       if (variably_modified_type_p (TREE_TYPE (type), fn))
8158         return true;
8159       break;
8160
8161     case FUNCTION_TYPE:
8162     case METHOD_TYPE:
8163       /* If TYPE is a function type, it is variably modified if the
8164          return type is variably modified.  */
8165       if (variably_modified_type_p (TREE_TYPE (type), fn))
8166           return true;
8167       break;
8168
8169     case INTEGER_TYPE:
8170     case REAL_TYPE:
8171     case FIXED_POINT_TYPE:
8172     case ENUMERAL_TYPE:
8173     case BOOLEAN_TYPE:
8174       /* Scalar types are variably modified if their end points
8175          aren't constant.  */
8176       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8177       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8178       break;
8179
8180     case RECORD_TYPE:
8181     case UNION_TYPE:
8182     case QUAL_UNION_TYPE:
8183       /* We can't see if any of the fields are variably-modified by the
8184          definition we normally use, since that would produce infinite
8185          recursion via pointers.  */
8186       /* This is variably modified if some field's type is.  */
8187       for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
8188         if (TREE_CODE (t) == FIELD_DECL)
8189           {
8190             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8191             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8192             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8193
8194             if (TREE_CODE (type) == QUAL_UNION_TYPE)
8195               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8196           }
8197         break;
8198
8199     case ARRAY_TYPE:
8200       /* Do not call ourselves to avoid infinite recursion.  This is
8201          variably modified if the element type is.  */
8202       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8203       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8204       break;
8205
8206     default:
8207       break;
8208     }
8209
8210   /* The current language may have other cases to check, but in general,
8211      all other types are not variably modified.  */
8212   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8213
8214 #undef RETURN_TRUE_IF_VAR
8215 }
8216
8217 /* Given a DECL or TYPE, return the scope in which it was declared, or
8218    NULL_TREE if there is no containing scope.  */
8219
8220 tree
8221 get_containing_scope (const_tree t)
8222 {
8223   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8224 }
8225
8226 /* Return the innermost context enclosing DECL that is
8227    a FUNCTION_DECL, or zero if none.  */
8228
8229 tree
8230 decl_function_context (const_tree decl)
8231 {
8232   tree context;
8233
8234   if (TREE_CODE (decl) == ERROR_MARK)
8235     return 0;
8236
8237   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8238      where we look up the function at runtime.  Such functions always take
8239      a first argument of type 'pointer to real context'.
8240
8241      C++ should really be fixed to use DECL_CONTEXT for the real context,
8242      and use something else for the "virtual context".  */
8243   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8244     context
8245       = TYPE_MAIN_VARIANT
8246         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8247   else
8248     context = DECL_CONTEXT (decl);
8249
8250   while (context && TREE_CODE (context) != FUNCTION_DECL)
8251     {
8252       if (TREE_CODE (context) == BLOCK)
8253         context = BLOCK_SUPERCONTEXT (context);
8254       else
8255         context = get_containing_scope (context);
8256     }
8257
8258   return context;
8259 }
8260
8261 /* Return the innermost context enclosing DECL that is
8262    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8263    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
8264
8265 tree
8266 decl_type_context (const_tree decl)
8267 {
8268   tree context = DECL_CONTEXT (decl);
8269
8270   while (context)
8271     switch (TREE_CODE (context))
8272       {
8273       case NAMESPACE_DECL:
8274       case TRANSLATION_UNIT_DECL:
8275         return NULL_TREE;
8276
8277       case RECORD_TYPE:
8278       case UNION_TYPE:
8279       case QUAL_UNION_TYPE:
8280         return context;
8281
8282       case TYPE_DECL:
8283       case FUNCTION_DECL:
8284         context = DECL_CONTEXT (context);
8285         break;
8286
8287       case BLOCK:
8288         context = BLOCK_SUPERCONTEXT (context);
8289         break;
8290
8291       default:
8292         gcc_unreachable ();
8293       }
8294
8295   return NULL_TREE;
8296 }
8297
8298 /* CALL is a CALL_EXPR.  Return the declaration for the function
8299    called, or NULL_TREE if the called function cannot be
8300    determined.  */
8301
8302 tree
8303 get_callee_fndecl (const_tree call)
8304 {
8305   tree addr;
8306
8307   if (call == error_mark_node)
8308     return error_mark_node;
8309
8310   /* It's invalid to call this function with anything but a
8311      CALL_EXPR.  */
8312   gcc_assert (TREE_CODE (call) == CALL_EXPR);
8313
8314   /* The first operand to the CALL is the address of the function
8315      called.  */
8316   addr = CALL_EXPR_FN (call);
8317
8318   STRIP_NOPS (addr);
8319
8320   /* If this is a readonly function pointer, extract its initial value.  */
8321   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8322       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8323       && DECL_INITIAL (addr))
8324     addr = DECL_INITIAL (addr);
8325
8326   /* If the address is just `&f' for some function `f', then we know
8327      that `f' is being called.  */
8328   if (TREE_CODE (addr) == ADDR_EXPR
8329       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8330     return TREE_OPERAND (addr, 0);
8331
8332   /* We couldn't figure out what was being called.  */
8333   return NULL_TREE;
8334 }
8335
8336 /* Print debugging information about tree nodes generated during the compile,
8337    and any language-specific information.  */
8338
8339 void
8340 dump_tree_statistics (void)
8341 {
8342 #ifdef GATHER_STATISTICS
8343   int i;
8344   int total_nodes, total_bytes;
8345 #endif
8346
8347   fprintf (stderr, "\n??? tree nodes created\n\n");
8348 #ifdef GATHER_STATISTICS
8349   fprintf (stderr, "Kind                   Nodes      Bytes\n");
8350   fprintf (stderr, "---------------------------------------\n");
8351   total_nodes = total_bytes = 0;
8352   for (i = 0; i < (int) all_kinds; i++)
8353     {
8354       fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8355                tree_node_counts[i], tree_node_sizes[i]);
8356       total_nodes += tree_node_counts[i];
8357       total_bytes += tree_node_sizes[i];
8358     }
8359   fprintf (stderr, "---------------------------------------\n");
8360   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8361   fprintf (stderr, "---------------------------------------\n");
8362   ssanames_print_statistics ();
8363   phinodes_print_statistics ();
8364 #else
8365   fprintf (stderr, "(No per-node statistics)\n");
8366 #endif
8367   print_type_hash_statistics ();
8368   print_debug_expr_statistics ();
8369   print_value_expr_statistics ();
8370   lang_hooks.print_statistics ();
8371 }
8372 \f
8373 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8374
8375 /* Generate a crc32 of a string.  */
8376
8377 unsigned
8378 crc32_string (unsigned chksum, const char *string)
8379 {
8380   do
8381     {
8382       unsigned value = *string << 24;
8383       unsigned ix;
8384
8385       for (ix = 8; ix--; value <<= 1)
8386         {
8387           unsigned feedback;
8388
8389           feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
8390           chksum <<= 1;
8391           chksum ^= feedback;
8392         }
8393     }
8394   while (*string++);
8395   return chksum;
8396 }
8397
8398 /* P is a string that will be used in a symbol.  Mask out any characters
8399    that are not valid in that context.  */
8400
8401 void
8402 clean_symbol_name (char *p)
8403 {
8404   for (; *p; p++)
8405     if (! (ISALNUM (*p)
8406 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
8407             || *p == '$'
8408 #endif
8409 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
8410             || *p == '.'
8411 #endif
8412            ))
8413       *p = '_';
8414 }
8415
8416 /* Generate a name for a special-purpose function function.
8417    The generated name may need to be unique across the whole link.
8418    TYPE is some string to identify the purpose of this function to the
8419    linker or collect2; it must start with an uppercase letter,
8420    one of:
8421    I - for constructors
8422    D - for destructors
8423    N - for C++ anonymous namespaces
8424    F - for DWARF unwind frame information.  */
8425
8426 tree
8427 get_file_function_name (const char *type)
8428 {
8429   char *buf;
8430   const char *p;
8431   char *q;
8432
8433   /* If we already have a name we know to be unique, just use that.  */
8434   if (first_global_object_name)
8435     p = q = ASTRDUP (first_global_object_name);
8436   /* If the target is handling the constructors/destructors, they
8437      will be local to this file and the name is only necessary for
8438      debugging purposes.  */
8439   else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
8440     {
8441       const char *file = main_input_filename;
8442       if (! file)
8443         file = input_filename;
8444       /* Just use the file's basename, because the full pathname
8445          might be quite long.  */
8446       p = strrchr (file, '/');
8447       if (p)
8448         p++;
8449       else
8450         p = file;
8451       p = q = ASTRDUP (p);
8452     }
8453   else
8454     {
8455       /* Otherwise, the name must be unique across the entire link.
8456          We don't have anything that we know to be unique to this translation
8457          unit, so use what we do have and throw in some randomness.  */
8458       unsigned len;
8459       const char *name = weak_global_object_name;
8460       const char *file = main_input_filename;
8461
8462       if (! name)
8463         name = "";
8464       if (! file)
8465         file = input_filename;
8466
8467       len = strlen (file);
8468       q = (char *) alloca (9 * 2 + len + 1);
8469       memcpy (q, file, len + 1);
8470
8471       sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
8472                crc32_string (0, get_random_seed (false)));
8473
8474       p = q;
8475     }
8476
8477   clean_symbol_name (q);
8478   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
8479                          + strlen (type));
8480
8481   /* Set up the name of the file-level functions we may need.
8482      Use a global object (which is already required to be unique over
8483      the program) rather than the file name (which imposes extra
8484      constraints).  */
8485   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
8486
8487   return get_identifier (buf);
8488 }
8489 \f
8490 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8491
8492 /* Complain that the tree code of NODE does not match the expected 0
8493    terminated list of trailing codes. The trailing code list can be
8494    empty, for a more vague error message.  FILE, LINE, and FUNCTION
8495    are of the caller.  */
8496
8497 void
8498 tree_check_failed (const_tree node, const char *file,
8499                    int line, const char *function, ...)
8500 {
8501   va_list args;
8502   const char *buffer;
8503   unsigned length = 0;
8504   int code;
8505
8506   va_start (args, function);
8507   while ((code = va_arg (args, int)))
8508     length += 4 + strlen (tree_code_name[code]);
8509   va_end (args);
8510   if (length)
8511     {
8512       char *tmp;
8513       va_start (args, function);
8514       length += strlen ("expected ");
8515       buffer = tmp = (char *) alloca (length);
8516       length = 0;
8517       while ((code = va_arg (args, int)))
8518         {
8519           const char *prefix = length ? " or " : "expected ";
8520
8521           strcpy (tmp + length, prefix);
8522           length += strlen (prefix);
8523           strcpy (tmp + length, tree_code_name[code]);
8524           length += strlen (tree_code_name[code]);
8525         }
8526       va_end (args);
8527     }
8528   else
8529     buffer = "unexpected node";
8530
8531   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8532                   buffer, tree_code_name[TREE_CODE (node)],
8533                   function, trim_filename (file), line);
8534 }
8535
8536 /* Complain that the tree code of NODE does match the expected 0
8537    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8538    the caller.  */
8539
8540 void
8541 tree_not_check_failed (const_tree node, const char *file,
8542                        int line, const char *function, ...)
8543 {
8544   va_list args;
8545   char *buffer;
8546   unsigned length = 0;
8547   int code;
8548
8549   va_start (args, function);
8550   while ((code = va_arg (args, int)))
8551     length += 4 + strlen (tree_code_name[code]);
8552   va_end (args);
8553   va_start (args, function);
8554   buffer = (char *) alloca (length);
8555   length = 0;
8556   while ((code = va_arg (args, int)))
8557     {
8558       if (length)
8559         {
8560           strcpy (buffer + length, " or ");
8561           length += 4;
8562         }
8563       strcpy (buffer + length, tree_code_name[code]);
8564       length += strlen (tree_code_name[code]);
8565     }
8566   va_end (args);
8567
8568   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8569                   buffer, tree_code_name[TREE_CODE (node)],
8570                   function, trim_filename (file), line);
8571 }
8572
8573 /* Similar to tree_check_failed, except that we check for a class of tree
8574    code, given in CL.  */
8575
8576 void
8577 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
8578                          const char *file, int line, const char *function)
8579 {
8580   internal_error
8581     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8582      TREE_CODE_CLASS_STRING (cl),
8583      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8584      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8585 }
8586
8587 /* Similar to tree_check_failed, except that instead of specifying a
8588    dozen codes, use the knowledge that they're all sequential.  */
8589
8590 void
8591 tree_range_check_failed (const_tree node, const char *file, int line,
8592                          const char *function, enum tree_code c1,
8593                          enum tree_code c2)
8594 {
8595   char *buffer;
8596   unsigned length = 0;
8597   unsigned int c;
8598
8599   for (c = c1; c <= c2; ++c)
8600     length += 4 + strlen (tree_code_name[c]);
8601
8602   length += strlen ("expected ");
8603   buffer = (char *) alloca (length);
8604   length = 0;
8605
8606   for (c = c1; c <= c2; ++c)
8607     {
8608       const char *prefix = length ? " or " : "expected ";
8609
8610       strcpy (buffer + length, prefix);
8611       length += strlen (prefix);
8612       strcpy (buffer + length, tree_code_name[c]);
8613       length += strlen (tree_code_name[c]);
8614     }
8615
8616   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8617                   buffer, tree_code_name[TREE_CODE (node)],
8618                   function, trim_filename (file), line);
8619 }
8620
8621
8622 /* Similar to tree_check_failed, except that we check that a tree does
8623    not have the specified code, given in CL.  */
8624
8625 void
8626 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
8627                              const char *file, int line, const char *function)
8628 {
8629   internal_error
8630     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8631      TREE_CODE_CLASS_STRING (cl),
8632      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8633      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8634 }
8635
8636
8637 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
8638
8639 void
8640 omp_clause_check_failed (const_tree node, const char *file, int line,
8641                          const char *function, enum omp_clause_code code)
8642 {
8643   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8644                   omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
8645                   function, trim_filename (file), line);
8646 }
8647
8648
8649 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
8650
8651 void
8652 omp_clause_range_check_failed (const_tree node, const char *file, int line,
8653                                const char *function, enum omp_clause_code c1,
8654                                enum omp_clause_code c2)
8655 {
8656   char *buffer;
8657   unsigned length = 0;
8658   unsigned int c;
8659
8660   for (c = c1; c <= c2; ++c)
8661     length += 4 + strlen (omp_clause_code_name[c]);
8662
8663   length += strlen ("expected ");
8664   buffer = (char *) alloca (length);
8665   length = 0;
8666
8667   for (c = c1; c <= c2; ++c)
8668     {
8669       const char *prefix = length ? " or " : "expected ";
8670
8671       strcpy (buffer + length, prefix);
8672       length += strlen (prefix);
8673       strcpy (buffer + length, omp_clause_code_name[c]);
8674       length += strlen (omp_clause_code_name[c]);
8675     }
8676
8677   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8678                   buffer, omp_clause_code_name[TREE_CODE (node)],
8679                   function, trim_filename (file), line);
8680 }
8681
8682
8683 #undef DEFTREESTRUCT
8684 #define DEFTREESTRUCT(VAL, NAME) NAME,
8685
8686 static const char *ts_enum_names[] = {
8687 #include "treestruct.def"
8688 };
8689 #undef DEFTREESTRUCT
8690
8691 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8692
8693 /* Similar to tree_class_check_failed, except that we check for
8694    whether CODE contains the tree structure identified by EN.  */
8695
8696 void
8697 tree_contains_struct_check_failed (const_tree node,
8698                                    const enum tree_node_structure_enum en,
8699                                    const char *file, int line,
8700                                    const char *function)
8701 {
8702   internal_error
8703     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8704      TS_ENUM_NAME(en),
8705      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8706 }
8707
8708
8709 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
8710    (dynamically sized) vector.  */
8711
8712 void
8713 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
8714                            const char *function)
8715 {
8716   internal_error
8717     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8718      idx + 1, len, function, trim_filename (file), line);
8719 }
8720
8721 /* Similar to above, except that the check is for the bounds of the operand
8722    vector of an expression node EXP.  */
8723
8724 void
8725 tree_operand_check_failed (int idx, const_tree exp, const char *file,
8726                            int line, const char *function)
8727 {
8728   int code = TREE_CODE (exp);
8729   internal_error
8730     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8731      idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
8732      function, trim_filename (file), line);
8733 }
8734
8735 /* Similar to above, except that the check is for the number of
8736    operands of an OMP_CLAUSE node.  */
8737
8738 void
8739 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
8740                                  int line, const char *function)
8741 {
8742   internal_error
8743     ("tree check: accessed operand %d of omp_clause %s with %d operands "
8744      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
8745      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
8746      trim_filename (file), line);
8747 }
8748 #endif /* ENABLE_TREE_CHECKING */
8749 \f
8750 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8751    and mapped to the machine mode MODE.  Initialize its fields and build
8752    the information necessary for debugging output.  */
8753
8754 static tree
8755 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
8756 {
8757   tree t;
8758   hashval_t hashcode = 0;
8759
8760   t = make_node (VECTOR_TYPE);
8761   TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
8762   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
8763   SET_TYPE_MODE (t, mode);
8764
8765   if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
8766     SET_TYPE_STRUCTURAL_EQUALITY (t);
8767   else if (TYPE_CANONICAL (innertype) != innertype
8768            || mode != VOIDmode)
8769     TYPE_CANONICAL (t)
8770       = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
8771
8772   layout_type (t);
8773
8774   {
8775     tree index = build_int_cst (NULL_TREE, nunits - 1);
8776     tree array = build_array_type (TYPE_MAIN_VARIANT (innertype),
8777                                    build_index_type (index));
8778     tree rt = make_node (RECORD_TYPE);
8779
8780     TYPE_FIELDS (rt) = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
8781                                    get_identifier ("f"), array);
8782     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
8783     layout_type (rt);
8784     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
8785     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
8786        the representation type, and we want to find that die when looking up
8787        the vector type.  This is most easily achieved by making the TYPE_UID
8788        numbers equal.  */
8789     TYPE_UID (rt) = TYPE_UID (t);
8790   }
8791
8792   hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
8793   hashcode = iterative_hash_host_wide_int (nunits, hashcode);
8794   hashcode = iterative_hash_host_wide_int (mode, hashcode);
8795   hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
8796   t = type_hash_canon (hashcode, t);
8797
8798   /* We have built a main variant, based on the main variant of the
8799      inner type. Use it to build the variant we return.  */
8800   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
8801       && TREE_TYPE (t) != innertype)
8802     return build_type_attribute_qual_variant (t,
8803                                               TYPE_ATTRIBUTES (innertype),
8804                                               TYPE_QUALS (innertype));
8805
8806   return t;
8807 }
8808
8809 static tree
8810 make_or_reuse_type (unsigned size, int unsignedp)
8811 {
8812   if (size == INT_TYPE_SIZE)
8813     return unsignedp ? unsigned_type_node : integer_type_node;
8814   if (size == CHAR_TYPE_SIZE)
8815     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
8816   if (size == SHORT_TYPE_SIZE)
8817     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
8818   if (size == LONG_TYPE_SIZE)
8819     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
8820   if (size == LONG_LONG_TYPE_SIZE)
8821     return (unsignedp ? long_long_unsigned_type_node
8822             : long_long_integer_type_node);
8823   if (size == 128 && int128_integer_type_node)
8824     return (unsignedp ? int128_unsigned_type_node
8825             : int128_integer_type_node);
8826
8827   if (unsignedp)
8828     return make_unsigned_type (size);
8829   else
8830     return make_signed_type (size);
8831 }
8832
8833 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
8834
8835 static tree
8836 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
8837 {
8838   if (satp)
8839     {
8840       if (size == SHORT_FRACT_TYPE_SIZE)
8841         return unsignedp ? sat_unsigned_short_fract_type_node
8842                          : sat_short_fract_type_node;
8843       if (size == FRACT_TYPE_SIZE)
8844         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
8845       if (size == LONG_FRACT_TYPE_SIZE)
8846         return unsignedp ? sat_unsigned_long_fract_type_node
8847                          : sat_long_fract_type_node;
8848       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8849         return unsignedp ? sat_unsigned_long_long_fract_type_node
8850                          : sat_long_long_fract_type_node;
8851     }
8852   else
8853     {
8854       if (size == SHORT_FRACT_TYPE_SIZE)
8855         return unsignedp ? unsigned_short_fract_type_node
8856                          : short_fract_type_node;
8857       if (size == FRACT_TYPE_SIZE)
8858         return unsignedp ? unsigned_fract_type_node : fract_type_node;
8859       if (size == LONG_FRACT_TYPE_SIZE)
8860         return unsignedp ? unsigned_long_fract_type_node
8861                          : long_fract_type_node;
8862       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8863         return unsignedp ? unsigned_long_long_fract_type_node
8864                          : long_long_fract_type_node;
8865     }
8866
8867   return make_fract_type (size, unsignedp, satp);
8868 }
8869
8870 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
8871
8872 static tree
8873 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
8874 {
8875   if (satp)
8876     {
8877       if (size == SHORT_ACCUM_TYPE_SIZE)
8878         return unsignedp ? sat_unsigned_short_accum_type_node
8879                          : sat_short_accum_type_node;
8880       if (size == ACCUM_TYPE_SIZE)
8881         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
8882       if (size == LONG_ACCUM_TYPE_SIZE)
8883         return unsignedp ? sat_unsigned_long_accum_type_node
8884                          : sat_long_accum_type_node;
8885       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8886         return unsignedp ? sat_unsigned_long_long_accum_type_node
8887                          : sat_long_long_accum_type_node;
8888     }
8889   else
8890     {
8891       if (size == SHORT_ACCUM_TYPE_SIZE)
8892         return unsignedp ? unsigned_short_accum_type_node
8893                          : short_accum_type_node;
8894       if (size == ACCUM_TYPE_SIZE)
8895         return unsignedp ? unsigned_accum_type_node : accum_type_node;
8896       if (size == LONG_ACCUM_TYPE_SIZE)
8897         return unsignedp ? unsigned_long_accum_type_node
8898                          : long_accum_type_node;
8899       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8900         return unsignedp ? unsigned_long_long_accum_type_node
8901                          : long_long_accum_type_node;
8902     }
8903
8904   return make_accum_type (size, unsignedp, satp);
8905 }
8906
8907 /* Create nodes for all integer types (and error_mark_node) using the sizes
8908    of C datatypes.  The caller should call set_sizetype soon after calling
8909    this function to select one of the types as sizetype.  */
8910
8911 void
8912 build_common_tree_nodes (bool signed_char)
8913 {
8914   error_mark_node = make_node (ERROR_MARK);
8915   TREE_TYPE (error_mark_node) = error_mark_node;
8916
8917   initialize_sizetypes ();
8918
8919   /* Define both `signed char' and `unsigned char'.  */
8920   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
8921   TYPE_STRING_FLAG (signed_char_type_node) = 1;
8922   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
8923   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
8924
8925   /* Define `char', which is like either `signed char' or `unsigned char'
8926      but not the same as either.  */
8927   char_type_node
8928     = (signed_char
8929        ? make_signed_type (CHAR_TYPE_SIZE)
8930        : make_unsigned_type (CHAR_TYPE_SIZE));
8931   TYPE_STRING_FLAG (char_type_node) = 1;
8932
8933   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
8934   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
8935   integer_type_node = make_signed_type (INT_TYPE_SIZE);
8936   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
8937   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
8938   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
8939   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
8940   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
8941 #if HOST_BITS_PER_WIDE_INT >= 64
8942     /* TODO: This isn't correct, but as logic depends at the moment on
8943        host's instead of target's wide-integer.
8944        If there is a target not supporting TImode, but has an 128-bit
8945        integer-scalar register, this target check needs to be adjusted. */
8946     if (targetm.scalar_mode_supported_p (TImode))
8947       {
8948         int128_integer_type_node = make_signed_type (128);
8949         int128_unsigned_type_node = make_unsigned_type (128);
8950       }
8951 #endif
8952   /* Define a boolean type.  This type only represents boolean values but
8953      may be larger than char depending on the value of BOOL_TYPE_SIZE.
8954      Front ends which want to override this size (i.e. Java) can redefine
8955      boolean_type_node before calling build_common_tree_nodes_2.  */
8956   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
8957   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
8958   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
8959   TYPE_PRECISION (boolean_type_node) = 1;
8960
8961   /* Fill in the rest of the sized types.  Reuse existing type nodes
8962      when possible.  */
8963   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
8964   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
8965   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
8966   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
8967   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
8968
8969   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
8970   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
8971   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
8972   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
8973   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
8974
8975   access_public_node = get_identifier ("public");
8976   access_protected_node = get_identifier ("protected");
8977   access_private_node = get_identifier ("private");
8978 }
8979
8980 /* Call this function after calling build_common_tree_nodes and set_sizetype.
8981    It will create several other common tree nodes.  */
8982
8983 void
8984 build_common_tree_nodes_2 (int short_double)
8985 {
8986   /* Define these next since types below may used them.  */
8987   integer_zero_node = build_int_cst (integer_type_node, 0);
8988   integer_one_node = build_int_cst (integer_type_node, 1);
8989   integer_three_node = build_int_cst (integer_type_node, 3);
8990   integer_minus_one_node = build_int_cst (integer_type_node, -1);
8991
8992   size_zero_node = size_int (0);
8993   size_one_node = size_int (1);
8994   bitsize_zero_node = bitsize_int (0);
8995   bitsize_one_node = bitsize_int (1);
8996   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
8997
8998   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
8999   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
9000
9001   void_type_node = make_node (VOID_TYPE);
9002   layout_type (void_type_node);
9003
9004   /* We are not going to have real types in C with less than byte alignment,
9005      so we might as well not have any types that claim to have it.  */
9006   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
9007   TYPE_USER_ALIGN (void_type_node) = 0;
9008
9009   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
9010   layout_type (TREE_TYPE (null_pointer_node));
9011
9012   ptr_type_node = build_pointer_type (void_type_node);
9013   const_ptr_type_node
9014     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
9015   fileptr_type_node = ptr_type_node;
9016
9017   float_type_node = make_node (REAL_TYPE);
9018   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
9019   layout_type (float_type_node);
9020
9021   double_type_node = make_node (REAL_TYPE);
9022   if (short_double)
9023     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
9024   else
9025     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
9026   layout_type (double_type_node);
9027
9028   long_double_type_node = make_node (REAL_TYPE);
9029   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
9030   layout_type (long_double_type_node);
9031
9032   float_ptr_type_node = build_pointer_type (float_type_node);
9033   double_ptr_type_node = build_pointer_type (double_type_node);
9034   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
9035   integer_ptr_type_node = build_pointer_type (integer_type_node);
9036
9037   /* Fixed size integer types.  */
9038   uint32_type_node = build_nonstandard_integer_type (32, true);
9039   uint64_type_node = build_nonstandard_integer_type (64, true);
9040
9041   /* Decimal float types. */
9042   dfloat32_type_node = make_node (REAL_TYPE);
9043   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
9044   layout_type (dfloat32_type_node);
9045   SET_TYPE_MODE (dfloat32_type_node, SDmode);
9046   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
9047
9048   dfloat64_type_node = make_node (REAL_TYPE);
9049   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
9050   layout_type (dfloat64_type_node);
9051   SET_TYPE_MODE (dfloat64_type_node, DDmode);
9052   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
9053
9054   dfloat128_type_node = make_node (REAL_TYPE);
9055   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
9056   layout_type (dfloat128_type_node);
9057   SET_TYPE_MODE (dfloat128_type_node, TDmode);
9058   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
9059
9060   complex_integer_type_node = build_complex_type (integer_type_node);
9061   complex_float_type_node = build_complex_type (float_type_node);
9062   complex_double_type_node = build_complex_type (double_type_node);
9063   complex_long_double_type_node = build_complex_type (long_double_type_node);
9064
9065 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
9066 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9067   sat_ ## KIND ## _type_node = \
9068     make_sat_signed_ ## KIND ## _type (SIZE); \
9069   sat_unsigned_ ## KIND ## _type_node = \
9070     make_sat_unsigned_ ## KIND ## _type (SIZE); \
9071   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9072   unsigned_ ## KIND ## _type_node = \
9073     make_unsigned_ ## KIND ## _type (SIZE);
9074
9075 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9076   sat_ ## WIDTH ## KIND ## _type_node = \
9077     make_sat_signed_ ## KIND ## _type (SIZE); \
9078   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9079     make_sat_unsigned_ ## KIND ## _type (SIZE); \
9080   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9081   unsigned_ ## WIDTH ## KIND ## _type_node = \
9082     make_unsigned_ ## KIND ## _type (SIZE);
9083
9084 /* Make fixed-point type nodes based on four different widths.  */
9085 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9086   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9087   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9088   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9089   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9090
9091 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
9092 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9093   NAME ## _type_node = \
9094     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9095   u ## NAME ## _type_node = \
9096     make_or_reuse_unsigned_ ## KIND ## _type \
9097       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9098   sat_ ## NAME ## _type_node = \
9099     make_or_reuse_sat_signed_ ## KIND ## _type \
9100       (GET_MODE_BITSIZE (MODE ## mode)); \
9101   sat_u ## NAME ## _type_node = \
9102     make_or_reuse_sat_unsigned_ ## KIND ## _type \
9103       (GET_MODE_BITSIZE (U ## MODE ## mode));
9104
9105   /* Fixed-point type and mode nodes.  */
9106   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
9107   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
9108   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
9109   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
9110   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
9111   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
9112   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
9113   MAKE_FIXED_MODE_NODE (accum, ha, HA)
9114   MAKE_FIXED_MODE_NODE (accum, sa, SA)
9115   MAKE_FIXED_MODE_NODE (accum, da, DA)
9116   MAKE_FIXED_MODE_NODE (accum, ta, TA)
9117
9118   {
9119     tree t = targetm.build_builtin_va_list ();
9120
9121     /* Many back-ends define record types without setting TYPE_NAME.
9122        If we copied the record type here, we'd keep the original
9123        record type without a name.  This breaks name mangling.  So,
9124        don't copy record types and let c_common_nodes_and_builtins()
9125        declare the type to be __builtin_va_list.  */
9126     if (TREE_CODE (t) != RECORD_TYPE)
9127       t = build_variant_type_copy (t);
9128
9129     va_list_type_node = t;
9130   }
9131 }
9132
9133 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
9134
9135 static void
9136 local_define_builtin (const char *name, tree type, enum built_in_function code,
9137                       const char *library_name, int ecf_flags)
9138 {
9139   tree decl;
9140
9141   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
9142                                library_name, NULL_TREE);
9143   if (ecf_flags & ECF_CONST)
9144     TREE_READONLY (decl) = 1;
9145   if (ecf_flags & ECF_PURE)
9146     DECL_PURE_P (decl) = 1;
9147   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
9148     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
9149   if (ecf_flags & ECF_NORETURN)
9150     TREE_THIS_VOLATILE (decl) = 1;
9151   if (ecf_flags & ECF_NOTHROW)
9152     TREE_NOTHROW (decl) = 1;
9153   if (ecf_flags & ECF_MALLOC)
9154     DECL_IS_MALLOC (decl) = 1;
9155
9156   built_in_decls[code] = decl;
9157   implicit_built_in_decls[code] = decl;
9158 }
9159
9160 /* Call this function after instantiating all builtins that the language
9161    front end cares about.  This will build the rest of the builtins that
9162    are relied upon by the tree optimizers and the middle-end.  */
9163
9164 void
9165 build_common_builtin_nodes (void)
9166 {
9167   tree tmp, ftype;
9168
9169   if (built_in_decls[BUILT_IN_MEMCPY] == NULL
9170       || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9171     {
9172       ftype = build_function_type_list (ptr_type_node,
9173                                         ptr_type_node, const_ptr_type_node,
9174                                         size_type_node, NULL_TREE);
9175
9176       if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
9177         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9178                               "memcpy", ECF_NOTHROW);
9179       if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9180         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9181                               "memmove", ECF_NOTHROW);
9182     }
9183
9184   if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
9185     {
9186       ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
9187                                         const_ptr_type_node, size_type_node,
9188                                         NULL_TREE);
9189       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9190                             "memcmp", ECF_PURE | ECF_NOTHROW);
9191     }
9192
9193   if (built_in_decls[BUILT_IN_MEMSET] == NULL)
9194     {
9195       ftype = build_function_type_list (ptr_type_node,
9196                                         ptr_type_node, integer_type_node,
9197                                         size_type_node, NULL_TREE);
9198       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9199                             "memset", ECF_NOTHROW);
9200     }
9201
9202   if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
9203     {
9204       ftype = build_function_type_list (ptr_type_node,
9205                                         size_type_node, NULL_TREE);
9206       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
9207                             "alloca", ECF_MALLOC | ECF_NOTHROW);
9208     }
9209
9210   /* If we're checking the stack, `alloca' can throw.  */
9211   if (flag_stack_check)
9212     TREE_NOTHROW (built_in_decls[BUILT_IN_ALLOCA]) = 0;
9213
9214   ftype = build_function_type_list (void_type_node,
9215                                     ptr_type_node, ptr_type_node,
9216                                     ptr_type_node, NULL_TREE);
9217   local_define_builtin ("__builtin_init_trampoline", ftype,
9218                         BUILT_IN_INIT_TRAMPOLINE,
9219                         "__builtin_init_trampoline", ECF_NOTHROW);
9220
9221   ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
9222   local_define_builtin ("__builtin_adjust_trampoline", ftype,
9223                         BUILT_IN_ADJUST_TRAMPOLINE,
9224                         "__builtin_adjust_trampoline",
9225                         ECF_CONST | ECF_NOTHROW);
9226
9227   ftype = build_function_type_list (void_type_node,
9228                                     ptr_type_node, ptr_type_node, NULL_TREE);
9229   local_define_builtin ("__builtin_nonlocal_goto", ftype,
9230                         BUILT_IN_NONLOCAL_GOTO,
9231                         "__builtin_nonlocal_goto",
9232                         ECF_NORETURN | ECF_NOTHROW);
9233
9234   ftype = build_function_type_list (void_type_node,
9235                                     ptr_type_node, ptr_type_node, NULL_TREE);
9236   local_define_builtin ("__builtin_setjmp_setup", ftype,
9237                         BUILT_IN_SETJMP_SETUP,
9238                         "__builtin_setjmp_setup", ECF_NOTHROW);
9239
9240   ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
9241   local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
9242                         BUILT_IN_SETJMP_DISPATCHER,
9243                         "__builtin_setjmp_dispatcher",
9244                         ECF_PURE | ECF_NOTHROW);
9245
9246   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9247   local_define_builtin ("__builtin_setjmp_receiver", ftype,
9248                         BUILT_IN_SETJMP_RECEIVER,
9249                         "__builtin_setjmp_receiver", ECF_NOTHROW);
9250
9251   ftype = build_function_type_list (ptr_type_node, NULL_TREE);
9252   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
9253                         "__builtin_stack_save", ECF_NOTHROW);
9254
9255   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9256   local_define_builtin ("__builtin_stack_restore", ftype,
9257                         BUILT_IN_STACK_RESTORE,
9258                         "__builtin_stack_restore", ECF_NOTHROW);
9259
9260   ftype = build_function_type_list (void_type_node, NULL_TREE);
9261   local_define_builtin ("__builtin_profile_func_enter", ftype,
9262                         BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
9263   local_define_builtin ("__builtin_profile_func_exit", ftype,
9264                         BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
9265
9266   /* If there's a possibility that we might use the ARM EABI, build the
9267     alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
9268   if (targetm.arm_eabi_unwinder)
9269     {
9270       ftype = build_function_type_list (void_type_node, NULL_TREE);
9271       local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
9272                             BUILT_IN_CXA_END_CLEANUP,
9273                             "__cxa_end_cleanup", ECF_NORETURN);
9274     }
9275
9276   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
9277   local_define_builtin ("__builtin_unwind_resume", ftype,
9278                         BUILT_IN_UNWIND_RESUME,
9279                         (USING_SJLJ_EXCEPTIONS
9280                          ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9281                         ECF_NORETURN);
9282
9283   /* The exception object and filter values from the runtime.  The argument
9284      must be zero before exception lowering, i.e. from the front end.  After
9285      exception lowering, it will be the region number for the exception
9286      landing pad.  These functions are PURE instead of CONST to prevent
9287      them from being hoisted past the exception edge that will initialize
9288      its value in the landing pad.  */
9289   ftype = build_function_type_list (ptr_type_node,
9290                                     integer_type_node, NULL_TREE);
9291   local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
9292                         "__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW);
9293
9294   tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
9295   ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
9296   local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
9297                         "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW);
9298
9299   ftype = build_function_type_list (void_type_node,
9300                                     integer_type_node, integer_type_node,
9301                                     NULL_TREE);
9302   local_define_builtin ("__builtin_eh_copy_values", ftype,
9303                         BUILT_IN_EH_COPY_VALUES,
9304                         "__builtin_eh_copy_values", ECF_NOTHROW);
9305
9306   /* Complex multiplication and division.  These are handled as builtins
9307      rather than optabs because emit_library_call_value doesn't support
9308      complex.  Further, we can do slightly better with folding these
9309      beasties if the real and complex parts of the arguments are separate.  */
9310   {
9311     int mode;
9312
9313     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
9314       {
9315         char mode_name_buf[4], *q;
9316         const char *p;
9317         enum built_in_function mcode, dcode;
9318         tree type, inner_type;
9319
9320         type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
9321         if (type == NULL)
9322           continue;
9323         inner_type = TREE_TYPE (type);
9324
9325         ftype = build_function_type_list (type, inner_type, inner_type,
9326                                           inner_type, inner_type, NULL_TREE);
9327
9328         mcode = ((enum built_in_function)
9329                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9330         dcode = ((enum built_in_function)
9331                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9332
9333         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
9334           *q = TOLOWER (*p);
9335         *q = '\0';
9336
9337         built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
9338         local_define_builtin (built_in_names[mcode], ftype, mcode,
9339                               built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
9340
9341         built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
9342         local_define_builtin (built_in_names[dcode], ftype, dcode,
9343                               built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
9344       }
9345   }
9346 }
9347
9348 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
9349    better way.
9350
9351    If we requested a pointer to a vector, build up the pointers that
9352    we stripped off while looking for the inner type.  Similarly for
9353    return values from functions.
9354
9355    The argument TYPE is the top of the chain, and BOTTOM is the
9356    new type which we will point to.  */
9357
9358 tree
9359 reconstruct_complex_type (tree type, tree bottom)
9360 {
9361   tree inner, outer;
9362
9363   if (TREE_CODE (type) == POINTER_TYPE)
9364     {
9365       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9366       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
9367                                            TYPE_REF_CAN_ALIAS_ALL (type));
9368     }
9369   else if (TREE_CODE (type) == REFERENCE_TYPE)
9370     {
9371       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9372       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
9373                                              TYPE_REF_CAN_ALIAS_ALL (type));
9374     }
9375   else if (TREE_CODE (type) == ARRAY_TYPE)
9376     {
9377       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9378       outer = build_array_type (inner, TYPE_DOMAIN (type));
9379     }
9380   else if (TREE_CODE (type) == FUNCTION_TYPE)
9381     {
9382       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9383       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
9384     }
9385   else if (TREE_CODE (type) == METHOD_TYPE)
9386     {
9387       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9388       /* The build_method_type_directly() routine prepends 'this' to argument list,
9389          so we must compensate by getting rid of it.  */
9390       outer
9391         = build_method_type_directly
9392             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
9393              inner,
9394              TREE_CHAIN (TYPE_ARG_TYPES (type)));
9395     }
9396   else if (TREE_CODE (type) == OFFSET_TYPE)
9397     {
9398       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9399       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
9400     }
9401   else
9402     return bottom;
9403
9404   return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
9405                                             TYPE_QUALS (type));
9406 }
9407
9408 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9409    the inner type.  */
9410 tree
9411 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
9412 {
9413   int nunits;
9414
9415   switch (GET_MODE_CLASS (mode))
9416     {
9417     case MODE_VECTOR_INT:
9418     case MODE_VECTOR_FLOAT:
9419     case MODE_VECTOR_FRACT:
9420     case MODE_VECTOR_UFRACT:
9421     case MODE_VECTOR_ACCUM:
9422     case MODE_VECTOR_UACCUM:
9423       nunits = GET_MODE_NUNITS (mode);
9424       break;
9425
9426     case MODE_INT:
9427       /* Check that there are no leftover bits.  */
9428       gcc_assert (GET_MODE_BITSIZE (mode)
9429                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
9430
9431       nunits = GET_MODE_BITSIZE (mode)
9432                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
9433       break;
9434
9435     default:
9436       gcc_unreachable ();
9437     }
9438
9439   return make_vector_type (innertype, nunits, mode);
9440 }
9441
9442 /* Similarly, but takes the inner type and number of units, which must be
9443    a power of two.  */
9444
9445 tree
9446 build_vector_type (tree innertype, int nunits)
9447 {
9448   return make_vector_type (innertype, nunits, VOIDmode);
9449 }
9450
9451 /* Similarly, but takes the inner type and number of units, which must be
9452    a power of two.  */
9453
9454 tree
9455 build_opaque_vector_type (tree innertype, int nunits)
9456 {
9457   tree t;
9458   innertype = build_distinct_type_copy (innertype);
9459   t = make_vector_type (innertype, nunits, VOIDmode);
9460   TYPE_VECTOR_OPAQUE (t) = true;
9461   return t;
9462 }
9463
9464
9465 /* Given an initializer INIT, return TRUE if INIT is zero or some
9466    aggregate of zeros.  Otherwise return FALSE.  */
9467 bool
9468 initializer_zerop (const_tree init)
9469 {
9470   tree elt;
9471
9472   STRIP_NOPS (init);
9473
9474   switch (TREE_CODE (init))
9475     {
9476     case INTEGER_CST:
9477       return integer_zerop (init);
9478
9479     case REAL_CST:
9480       /* ??? Note that this is not correct for C4X float formats.  There,
9481          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9482          negative exponent.  */
9483       return real_zerop (init)
9484         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
9485
9486     case FIXED_CST:
9487       return fixed_zerop (init);
9488
9489     case COMPLEX_CST:
9490       return integer_zerop (init)
9491         || (real_zerop (init)
9492             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
9493             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
9494
9495     case VECTOR_CST:
9496       for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
9497         if (!initializer_zerop (TREE_VALUE (elt)))
9498           return false;
9499       return true;
9500
9501     case CONSTRUCTOR:
9502       {
9503         unsigned HOST_WIDE_INT idx;
9504
9505         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
9506           if (!initializer_zerop (elt))
9507             return false;
9508         return true;
9509       }
9510
9511     case STRING_CST:
9512       {
9513         int i;
9514
9515         /* We need to loop through all elements to handle cases like
9516            "\0" and "\0foobar".  */
9517         for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
9518           if (TREE_STRING_POINTER (init)[i] != '\0')
9519             return false;
9520
9521         return true;
9522       }
9523
9524     default:
9525       return false;
9526     }
9527 }
9528
9529 /* Build an empty statement at location LOC.  */
9530
9531 tree
9532 build_empty_stmt (location_t loc)
9533 {
9534   tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
9535   SET_EXPR_LOCATION (t, loc);
9536   return t;
9537 }
9538
9539
9540 /* Build an OpenMP clause with code CODE.  LOC is the location of the
9541    clause.  */
9542
9543 tree
9544 build_omp_clause (location_t loc, enum omp_clause_code code)
9545 {
9546   tree t;
9547   int size, length;
9548
9549   length = omp_clause_num_ops[code];
9550   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
9551
9552   t = ggc_alloc_tree_node (size);
9553   memset (t, 0, size);
9554   TREE_SET_CODE (t, OMP_CLAUSE);
9555   OMP_CLAUSE_SET_CODE (t, code);
9556   OMP_CLAUSE_LOCATION (t) = loc;
9557
9558 #ifdef GATHER_STATISTICS
9559   tree_node_counts[(int) omp_clause_kind]++;
9560   tree_node_sizes[(int) omp_clause_kind] += size;
9561 #endif
9562
9563   return t;
9564 }
9565
9566 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
9567    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9568    Except for the CODE and operand count field, other storage for the
9569    object is initialized to zeros.  */
9570
9571 tree
9572 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
9573 {
9574   tree t;
9575   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
9576
9577   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
9578   gcc_assert (len >= 1);
9579
9580 #ifdef GATHER_STATISTICS
9581   tree_node_counts[(int) e_kind]++;
9582   tree_node_sizes[(int) e_kind] += length;
9583 #endif
9584
9585   t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
9586
9587   TREE_SET_CODE (t, code);
9588
9589   /* Can't use TREE_OPERAND to store the length because if checking is
9590      enabled, it will try to check the length before we store it.  :-P  */
9591   t->exp.operands[0] = build_int_cst (sizetype, len);
9592
9593   return t;
9594 }
9595
9596 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9597    FN and a null static chain slot.  NARGS is the number of call arguments
9598    which are specified as "..." arguments.  */
9599
9600 tree
9601 build_call_nary (tree return_type, tree fn, int nargs, ...)
9602 {
9603   tree ret;
9604   va_list args;
9605   va_start (args, nargs);
9606   ret = build_call_valist (return_type, fn, nargs, args);
9607   va_end (args);
9608   return ret;
9609 }
9610
9611 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9612    FN and a null static chain slot.  NARGS is the number of call arguments
9613    which are specified as a va_list ARGS.  */
9614
9615 tree
9616 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
9617 {
9618   tree t;
9619   int i;
9620
9621   t = build_vl_exp (CALL_EXPR, nargs + 3);
9622   TREE_TYPE (t) = return_type;
9623   CALL_EXPR_FN (t) = fn;
9624   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9625   for (i = 0; i < nargs; i++)
9626     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
9627   process_call_operands (t);
9628   return t;
9629 }
9630
9631 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9632    FN and a null static chain slot.  NARGS is the number of call arguments
9633    which are specified as a tree array ARGS.  */
9634
9635 tree
9636 build_call_array_loc (location_t loc, tree return_type, tree fn,
9637                       int nargs, const tree *args)
9638 {
9639   tree t;
9640   int i;
9641
9642   t = build_vl_exp (CALL_EXPR, nargs + 3);
9643   TREE_TYPE (t) = return_type;
9644   CALL_EXPR_FN (t) = fn;
9645   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9646   for (i = 0; i < nargs; i++)
9647     CALL_EXPR_ARG (t, i) = args[i];
9648   process_call_operands (t);
9649   SET_EXPR_LOCATION (t, loc);
9650   return t;
9651 }
9652
9653 /* Like build_call_array, but takes a VEC.  */
9654
9655 tree
9656 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
9657 {
9658   tree ret, t;
9659   unsigned int ix;
9660
9661   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
9662   TREE_TYPE (ret) = return_type;
9663   CALL_EXPR_FN (ret) = fn;
9664   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
9665   FOR_EACH_VEC_ELT (tree, args, ix, t)
9666     CALL_EXPR_ARG (ret, ix) = t;
9667   process_call_operands (ret);
9668   return ret;
9669 }
9670
9671
9672 /* Returns true if it is possible to prove that the index of
9673    an array access REF (an ARRAY_REF expression) falls into the
9674    array bounds.  */
9675
9676 bool
9677 in_array_bounds_p (tree ref)
9678 {
9679   tree idx = TREE_OPERAND (ref, 1);
9680   tree min, max;
9681
9682   if (TREE_CODE (idx) != INTEGER_CST)
9683     return false;
9684
9685   min = array_ref_low_bound (ref);
9686   max = array_ref_up_bound (ref);
9687   if (!min
9688       || !max
9689       || TREE_CODE (min) != INTEGER_CST
9690       || TREE_CODE (max) != INTEGER_CST)
9691     return false;
9692
9693   if (tree_int_cst_lt (idx, min)
9694       || tree_int_cst_lt (max, idx))
9695     return false;
9696
9697   return true;
9698 }
9699
9700 /* Returns true if it is possible to prove that the range of
9701    an array access REF (an ARRAY_RANGE_REF expression) falls
9702    into the array bounds.  */
9703
9704 bool
9705 range_in_array_bounds_p (tree ref)
9706 {
9707   tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
9708   tree range_min, range_max, min, max;
9709
9710   range_min = TYPE_MIN_VALUE (domain_type);
9711   range_max = TYPE_MAX_VALUE (domain_type);
9712   if (!range_min
9713       || !range_max
9714       || TREE_CODE (range_min) != INTEGER_CST
9715       || TREE_CODE (range_max) != INTEGER_CST)
9716     return false;
9717
9718   min = array_ref_low_bound (ref);
9719   max = array_ref_up_bound (ref);
9720   if (!min
9721       || !max
9722       || TREE_CODE (min) != INTEGER_CST
9723       || TREE_CODE (max) != INTEGER_CST)
9724     return false;
9725
9726   if (tree_int_cst_lt (range_min, min)
9727       || tree_int_cst_lt (max, range_max))
9728     return false;
9729
9730   return true;
9731 }
9732
9733 /* Return true if T (assumed to be a DECL) must be assigned a memory
9734    location.  */
9735
9736 bool
9737 needs_to_live_in_memory (const_tree t)
9738 {
9739   if (TREE_CODE (t) == SSA_NAME)
9740     t = SSA_NAME_VAR (t);
9741
9742   return (TREE_ADDRESSABLE (t)
9743           || is_global_var (t)
9744           || (TREE_CODE (t) == RESULT_DECL
9745               && !DECL_BY_REFERENCE (t)
9746               && aggregate_value_p (t, current_function_decl)));
9747 }
9748
9749 /* There are situations in which a language considers record types
9750    compatible which have different field lists.  Decide if two fields
9751    are compatible.  It is assumed that the parent records are compatible.  */
9752
9753 bool
9754 fields_compatible_p (const_tree f1, const_tree f2)
9755 {
9756   if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
9757                         DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
9758     return false;
9759
9760   if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
9761                         DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
9762     return false;
9763
9764   if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
9765     return false;
9766
9767   return true;
9768 }
9769
9770 /* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
9771
9772 tree
9773 find_compatible_field (tree record, tree orig_field)
9774 {
9775   tree f;
9776
9777   for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
9778     if (TREE_CODE (f) == FIELD_DECL
9779         && fields_compatible_p (f, orig_field))
9780       return f;
9781
9782   /* ??? Why isn't this on the main fields list?  */
9783   f = TYPE_VFIELD (record);
9784   if (f && TREE_CODE (f) == FIELD_DECL
9785       && fields_compatible_p (f, orig_field))
9786     return f;
9787
9788   /* ??? We should abort here, but Java appears to do Bad Things
9789      with inherited fields.  */
9790   return orig_field;
9791 }
9792
9793 /* Return value of a constant X and sign-extend it.  */
9794
9795 HOST_WIDE_INT
9796 int_cst_value (const_tree x)
9797 {
9798   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9799   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
9800
9801   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9802   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9803               || TREE_INT_CST_HIGH (x) == -1);
9804
9805   if (bits < HOST_BITS_PER_WIDE_INT)
9806     {
9807       bool negative = ((val >> (bits - 1)) & 1) != 0;
9808       if (negative)
9809         val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
9810       else
9811         val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
9812     }
9813
9814   return val;
9815 }
9816
9817 /* Return value of a constant X and sign-extend it.  */
9818
9819 HOST_WIDEST_INT
9820 widest_int_cst_value (const_tree x)
9821 {
9822   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9823   unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
9824
9825 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9826   gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
9827   val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
9828           << HOST_BITS_PER_WIDE_INT);
9829 #else
9830   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9831   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9832               || TREE_INT_CST_HIGH (x) == -1);
9833 #endif
9834
9835   if (bits < HOST_BITS_PER_WIDEST_INT)
9836     {
9837       bool negative = ((val >> (bits - 1)) & 1) != 0;
9838       if (negative)
9839         val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
9840       else
9841         val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
9842     }
9843
9844   return val;
9845 }
9846
9847 /* If TYPE is an integral type, return an equivalent type which is
9848     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
9849     return TYPE itself.  */
9850
9851 tree
9852 signed_or_unsigned_type_for (int unsignedp, tree type)
9853 {
9854   tree t = type;
9855   if (POINTER_TYPE_P (type))
9856     {
9857       /* If the pointer points to the normal address space, use the
9858          size_type_node.  Otherwise use an appropriate size for the pointer
9859          based on the named address space it points to.  */
9860       if (!TYPE_ADDR_SPACE (TREE_TYPE (t)))
9861         t = size_type_node;
9862       else
9863         return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9864     }
9865
9866   if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
9867     return t;
9868
9869   return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9870 }
9871
9872 /* Returns unsigned variant of TYPE.  */
9873
9874 tree
9875 unsigned_type_for (tree type)
9876 {
9877   return signed_or_unsigned_type_for (1, type);
9878 }
9879
9880 /* Returns signed variant of TYPE.  */
9881
9882 tree
9883 signed_type_for (tree type)
9884 {
9885   return signed_or_unsigned_type_for (0, type);
9886 }
9887
9888 /* Returns the largest value obtainable by casting something in INNER type to
9889    OUTER type.  */
9890
9891 tree
9892 upper_bound_in_type (tree outer, tree inner)
9893 {
9894   unsigned HOST_WIDE_INT lo, hi;
9895   unsigned int det = 0;
9896   unsigned oprec = TYPE_PRECISION (outer);
9897   unsigned iprec = TYPE_PRECISION (inner);
9898   unsigned prec;
9899
9900   /* Compute a unique number for every combination.  */
9901   det |= (oprec > iprec) ? 4 : 0;
9902   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
9903   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
9904
9905   /* Determine the exponent to use.  */
9906   switch (det)
9907     {
9908     case 0:
9909     case 1:
9910       /* oprec <= iprec, outer: signed, inner: don't care.  */
9911       prec = oprec - 1;
9912       break;
9913     case 2:
9914     case 3:
9915       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
9916       prec = oprec;
9917       break;
9918     case 4:
9919       /* oprec > iprec, outer: signed, inner: signed.  */
9920       prec = iprec - 1;
9921       break;
9922     case 5:
9923       /* oprec > iprec, outer: signed, inner: unsigned.  */
9924       prec = iprec;
9925       break;
9926     case 6:
9927       /* oprec > iprec, outer: unsigned, inner: signed.  */
9928       prec = oprec;
9929       break;
9930     case 7:
9931       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
9932       prec = iprec;
9933       break;
9934     default:
9935       gcc_unreachable ();
9936     }
9937
9938   /* Compute 2^^prec - 1.  */
9939   if (prec <= HOST_BITS_PER_WIDE_INT)
9940     {
9941       hi = 0;
9942       lo = ((~(unsigned HOST_WIDE_INT) 0)
9943             >> (HOST_BITS_PER_WIDE_INT - prec));
9944     }
9945   else
9946     {
9947       hi = ((~(unsigned HOST_WIDE_INT) 0)
9948             >> (2 * HOST_BITS_PER_WIDE_INT - prec));
9949       lo = ~(unsigned HOST_WIDE_INT) 0;
9950     }
9951
9952   return build_int_cst_wide (outer, lo, hi);
9953 }
9954
9955 /* Returns the smallest value obtainable by casting something in INNER type to
9956    OUTER type.  */
9957
9958 tree
9959 lower_bound_in_type (tree outer, tree inner)
9960 {
9961   unsigned HOST_WIDE_INT lo, hi;
9962   unsigned oprec = TYPE_PRECISION (outer);
9963   unsigned iprec = TYPE_PRECISION (inner);
9964
9965   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
9966      and obtain 0.  */
9967   if (TYPE_UNSIGNED (outer)
9968       /* If we are widening something of an unsigned type, OUTER type
9969          contains all values of INNER type.  In particular, both INNER
9970          and OUTER types have zero in common.  */
9971       || (oprec > iprec && TYPE_UNSIGNED (inner)))
9972     lo = hi = 0;
9973   else
9974     {
9975       /* If we are widening a signed type to another signed type, we
9976          want to obtain -2^^(iprec-1).  If we are keeping the
9977          precision or narrowing to a signed type, we want to obtain
9978          -2^(oprec-1).  */
9979       unsigned prec = oprec > iprec ? iprec : oprec;
9980
9981       if (prec <= HOST_BITS_PER_WIDE_INT)
9982         {
9983           hi = ~(unsigned HOST_WIDE_INT) 0;
9984           lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
9985         }
9986       else
9987         {
9988           hi = ((~(unsigned HOST_WIDE_INT) 0)
9989                 << (prec - HOST_BITS_PER_WIDE_INT - 1));
9990           lo = 0;
9991         }
9992     }
9993
9994   return build_int_cst_wide (outer, lo, hi);
9995 }
9996
9997 /* Return nonzero if two operands that are suitable for PHI nodes are
9998    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
9999    SSA_NAME or invariant.  Note that this is strictly an optimization.
10000    That is, callers of this function can directly call operand_equal_p
10001    and get the same result, only slower.  */
10002
10003 int
10004 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
10005 {
10006   if (arg0 == arg1)
10007     return 1;
10008   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
10009     return 0;
10010   return operand_equal_p (arg0, arg1, 0);
10011 }
10012
10013 /* Returns number of zeros at the end of binary representation of X.
10014
10015    ??? Use ffs if available?  */
10016
10017 tree
10018 num_ending_zeros (const_tree x)
10019 {
10020   unsigned HOST_WIDE_INT fr, nfr;
10021   unsigned num, abits;
10022   tree type = TREE_TYPE (x);
10023
10024   if (TREE_INT_CST_LOW (x) == 0)
10025     {
10026       num = HOST_BITS_PER_WIDE_INT;
10027       fr = TREE_INT_CST_HIGH (x);
10028     }
10029   else
10030     {
10031       num = 0;
10032       fr = TREE_INT_CST_LOW (x);
10033     }
10034
10035   for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
10036     {
10037       nfr = fr >> abits;
10038       if (nfr << abits == fr)
10039         {
10040           num += abits;
10041           fr = nfr;
10042         }
10043     }
10044
10045   if (num > TYPE_PRECISION (type))
10046     num = TYPE_PRECISION (type);
10047
10048   return build_int_cst_type (type, num);
10049 }
10050
10051
10052 #define WALK_SUBTREE(NODE)                              \
10053   do                                                    \
10054     {                                                   \
10055       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
10056       if (result)                                       \
10057         return result;                                  \
10058     }                                                   \
10059   while (0)
10060
10061 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10062    be walked whenever a type is seen in the tree.  Rest of operands and return
10063    value are as for walk_tree.  */
10064
10065 static tree
10066 walk_type_fields (tree type, walk_tree_fn func, void *data,
10067                   struct pointer_set_t *pset, walk_tree_lh lh)
10068 {
10069   tree result = NULL_TREE;
10070
10071   switch (TREE_CODE (type))
10072     {
10073     case POINTER_TYPE:
10074     case REFERENCE_TYPE:
10075       /* We have to worry about mutually recursive pointers.  These can't
10076          be written in C.  They can in Ada.  It's pathological, but
10077          there's an ACATS test (c38102a) that checks it.  Deal with this
10078          by checking if we're pointing to another pointer, that one
10079          points to another pointer, that one does too, and we have no htab.
10080          If so, get a hash table.  We check three levels deep to avoid
10081          the cost of the hash table if we don't need one.  */
10082       if (POINTER_TYPE_P (TREE_TYPE (type))
10083           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
10084           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
10085           && !pset)
10086         {
10087           result = walk_tree_without_duplicates (&TREE_TYPE (type),
10088                                                  func, data);
10089           if (result)
10090             return result;
10091
10092           break;
10093         }
10094
10095       /* ... fall through ... */
10096
10097     case COMPLEX_TYPE:
10098       WALK_SUBTREE (TREE_TYPE (type));
10099       break;
10100
10101     case METHOD_TYPE:
10102       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
10103
10104       /* Fall through.  */
10105
10106     case FUNCTION_TYPE:
10107       WALK_SUBTREE (TREE_TYPE (type));
10108       {
10109         tree arg;
10110
10111         /* We never want to walk into default arguments.  */
10112         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
10113           WALK_SUBTREE (TREE_VALUE (arg));
10114       }
10115       break;
10116
10117     case ARRAY_TYPE:
10118       /* Don't follow this nodes's type if a pointer for fear that
10119          we'll have infinite recursion.  If we have a PSET, then we
10120          need not fear.  */
10121       if (pset
10122           || (!POINTER_TYPE_P (TREE_TYPE (type))
10123               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
10124         WALK_SUBTREE (TREE_TYPE (type));
10125       WALK_SUBTREE (TYPE_DOMAIN (type));
10126       break;
10127
10128     case OFFSET_TYPE:
10129       WALK_SUBTREE (TREE_TYPE (type));
10130       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
10131       break;
10132
10133     default:
10134       break;
10135     }
10136
10137   return NULL_TREE;
10138 }
10139
10140 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
10141    called with the DATA and the address of each sub-tree.  If FUNC returns a
10142    non-NULL value, the traversal is stopped, and the value returned by FUNC
10143    is returned.  If PSET is non-NULL it is used to record the nodes visited,
10144    and to avoid visiting a node more than once.  */
10145
10146 tree
10147 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10148              struct pointer_set_t *pset, walk_tree_lh lh)
10149 {
10150   enum tree_code code;
10151   int walk_subtrees;
10152   tree result;
10153
10154 #define WALK_SUBTREE_TAIL(NODE)                         \
10155   do                                                    \
10156     {                                                   \
10157        tp = & (NODE);                                   \
10158        goto tail_recurse;                               \
10159     }                                                   \
10160   while (0)
10161
10162  tail_recurse:
10163   /* Skip empty subtrees.  */
10164   if (!*tp)
10165     return NULL_TREE;
10166
10167   /* Don't walk the same tree twice, if the user has requested
10168      that we avoid doing so.  */
10169   if (pset && pointer_set_insert (pset, *tp))
10170     return NULL_TREE;
10171
10172   /* Call the function.  */
10173   walk_subtrees = 1;
10174   result = (*func) (tp, &walk_subtrees, data);
10175
10176   /* If we found something, return it.  */
10177   if (result)
10178     return result;
10179
10180   code = TREE_CODE (*tp);
10181
10182   /* Even if we didn't, FUNC may have decided that there was nothing
10183      interesting below this point in the tree.  */
10184   if (!walk_subtrees)
10185     {
10186       /* But we still need to check our siblings.  */
10187       if (code == TREE_LIST)
10188         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10189       else if (code == OMP_CLAUSE)
10190         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10191       else
10192         return NULL_TREE;
10193     }
10194
10195   if (lh)
10196     {
10197       result = (*lh) (tp, &walk_subtrees, func, data, pset);
10198       if (result || !walk_subtrees)
10199         return result;
10200     }
10201
10202   switch (code)
10203     {
10204     case ERROR_MARK:
10205     case IDENTIFIER_NODE:
10206     case INTEGER_CST:
10207     case REAL_CST:
10208     case FIXED_CST:
10209     case VECTOR_CST:
10210     case STRING_CST:
10211     case BLOCK:
10212     case PLACEHOLDER_EXPR:
10213     case SSA_NAME:
10214     case FIELD_DECL:
10215     case RESULT_DECL:
10216       /* None of these have subtrees other than those already walked
10217          above.  */
10218       break;
10219
10220     case TREE_LIST:
10221       WALK_SUBTREE (TREE_VALUE (*tp));
10222       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10223       break;
10224
10225     case TREE_VEC:
10226       {
10227         int len = TREE_VEC_LENGTH (*tp);
10228
10229         if (len == 0)
10230           break;
10231
10232         /* Walk all elements but the first.  */
10233         while (--len)
10234           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
10235
10236         /* Now walk the first one as a tail call.  */
10237         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
10238       }
10239
10240     case COMPLEX_CST:
10241       WALK_SUBTREE (TREE_REALPART (*tp));
10242       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
10243
10244     case CONSTRUCTOR:
10245       {
10246         unsigned HOST_WIDE_INT idx;
10247         constructor_elt *ce;
10248
10249         for (idx = 0;
10250              VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
10251              idx++)
10252           WALK_SUBTREE (ce->value);
10253       }
10254       break;
10255
10256     case SAVE_EXPR:
10257       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
10258
10259     case BIND_EXPR:
10260       {
10261         tree decl;
10262         for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
10263           {
10264             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
10265                into declarations that are just mentioned, rather than
10266                declared; they don't really belong to this part of the tree.
10267                And, we can see cycles: the initializer for a declaration
10268                can refer to the declaration itself.  */
10269             WALK_SUBTREE (DECL_INITIAL (decl));
10270             WALK_SUBTREE (DECL_SIZE (decl));
10271             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
10272           }
10273         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
10274       }
10275
10276     case STATEMENT_LIST:
10277       {
10278         tree_stmt_iterator i;
10279         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
10280           WALK_SUBTREE (*tsi_stmt_ptr (i));
10281       }
10282       break;
10283
10284     case OMP_CLAUSE:
10285       switch (OMP_CLAUSE_CODE (*tp))
10286         {
10287         case OMP_CLAUSE_PRIVATE:
10288         case OMP_CLAUSE_SHARED:
10289         case OMP_CLAUSE_FIRSTPRIVATE:
10290         case OMP_CLAUSE_COPYIN:
10291         case OMP_CLAUSE_COPYPRIVATE:
10292         case OMP_CLAUSE_IF:
10293         case OMP_CLAUSE_NUM_THREADS:
10294         case OMP_CLAUSE_SCHEDULE:
10295           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
10296           /* FALLTHRU */
10297
10298         case OMP_CLAUSE_NOWAIT:
10299         case OMP_CLAUSE_ORDERED:
10300         case OMP_CLAUSE_DEFAULT:
10301         case OMP_CLAUSE_UNTIED:
10302           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10303
10304         case OMP_CLAUSE_LASTPRIVATE:
10305           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
10306           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
10307           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10308
10309         case OMP_CLAUSE_COLLAPSE:
10310           {
10311             int i;
10312             for (i = 0; i < 3; i++)
10313               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10314             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10315           }
10316
10317         case OMP_CLAUSE_REDUCTION:
10318           {
10319             int i;
10320             for (i = 0; i < 4; i++)
10321               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10322             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10323           }
10324
10325         default:
10326           gcc_unreachable ();
10327         }
10328       break;
10329
10330     case TARGET_EXPR:
10331       {
10332         int i, len;
10333
10334         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10335            But, we only want to walk once.  */
10336         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
10337         for (i = 0; i < len; ++i)
10338           WALK_SUBTREE (TREE_OPERAND (*tp, i));
10339         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
10340       }
10341
10342     case DECL_EXPR:
10343       /* If this is a TYPE_DECL, walk into the fields of the type that it's
10344          defining.  We only want to walk into these fields of a type in this
10345          case and not in the general case of a mere reference to the type.
10346
10347          The criterion is as follows: if the field can be an expression, it
10348          must be walked only here.  This should be in keeping with the fields
10349          that are directly gimplified in gimplify_type_sizes in order for the
10350          mark/copy-if-shared/unmark machinery of the gimplifier to work with
10351          variable-sized types.
10352
10353          Note that DECLs get walked as part of processing the BIND_EXPR.  */
10354       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
10355         {
10356           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
10357           if (TREE_CODE (*type_p) == ERROR_MARK)
10358             return NULL_TREE;
10359
10360           /* Call the function for the type.  See if it returns anything or
10361              doesn't want us to continue.  If we are to continue, walk both
10362              the normal fields and those for the declaration case.  */
10363           result = (*func) (type_p, &walk_subtrees, data);
10364           if (result || !walk_subtrees)
10365             return result;
10366
10367           result = walk_type_fields (*type_p, func, data, pset, lh);
10368           if (result)
10369             return result;
10370
10371           /* If this is a record type, also walk the fields.  */
10372           if (RECORD_OR_UNION_TYPE_P (*type_p))
10373             {
10374               tree field;
10375
10376               for (field = TYPE_FIELDS (*type_p); field;
10377                    field = DECL_CHAIN (field))
10378                 {
10379                   /* We'd like to look at the type of the field, but we can
10380                      easily get infinite recursion.  So assume it's pointed
10381                      to elsewhere in the tree.  Also, ignore things that
10382                      aren't fields.  */
10383                   if (TREE_CODE (field) != FIELD_DECL)
10384                     continue;
10385
10386                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
10387                   WALK_SUBTREE (DECL_SIZE (field));
10388                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
10389                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10390                     WALK_SUBTREE (DECL_QUALIFIER (field));
10391                 }
10392             }
10393
10394           /* Same for scalar types.  */
10395           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
10396                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
10397                    || TREE_CODE (*type_p) == INTEGER_TYPE
10398                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
10399                    || TREE_CODE (*type_p) == REAL_TYPE)
10400             {
10401               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
10402               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
10403             }
10404
10405           WALK_SUBTREE (TYPE_SIZE (*type_p));
10406           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
10407         }
10408       /* FALLTHRU */
10409
10410     default:
10411       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
10412         {
10413           int i, len;
10414
10415           /* Walk over all the sub-trees of this operand.  */
10416           len = TREE_OPERAND_LENGTH (*tp);
10417
10418           /* Go through the subtrees.  We need to do this in forward order so
10419              that the scope of a FOR_EXPR is handled properly.  */
10420           if (len)
10421             {
10422               for (i = 0; i < len - 1; ++i)
10423                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
10424               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
10425             }
10426         }
10427       /* If this is a type, walk the needed fields in the type.  */
10428       else if (TYPE_P (*tp))
10429         return walk_type_fields (*tp, func, data, pset, lh);
10430       break;
10431     }
10432
10433   /* We didn't find what we were looking for.  */
10434   return NULL_TREE;
10435
10436 #undef WALK_SUBTREE_TAIL
10437 }
10438 #undef WALK_SUBTREE
10439
10440 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
10441
10442 tree
10443 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
10444                                 walk_tree_lh lh)
10445 {
10446   tree result;
10447   struct pointer_set_t *pset;
10448
10449   pset = pointer_set_create ();
10450   result = walk_tree_1 (tp, func, data, pset, lh);
10451   pointer_set_destroy (pset);
10452   return result;
10453 }
10454
10455
10456 tree *
10457 tree_block (tree t)
10458 {
10459   char const c = TREE_CODE_CLASS (TREE_CODE (t));
10460
10461   if (IS_EXPR_CODE_CLASS (c))
10462     return &t->exp.block;
10463   gcc_unreachable ();
10464   return NULL;
10465 }
10466
10467 /* Create a nameless artificial label and put it in the current
10468    function context.  The label has a location of LOC.  Returns the
10469    newly created label.  */
10470
10471 tree
10472 create_artificial_label (location_t loc)
10473 {
10474   tree lab = build_decl (loc,
10475                          LABEL_DECL, NULL_TREE, void_type_node);
10476
10477   DECL_ARTIFICIAL (lab) = 1;
10478   DECL_IGNORED_P (lab) = 1;
10479   DECL_CONTEXT (lab) = current_function_decl;
10480   return lab;
10481 }
10482
10483 /*  Given a tree, try to return a useful variable name that we can use
10484     to prefix a temporary that is being assigned the value of the tree.
10485     I.E. given  <temp> = &A, return A.  */
10486
10487 const char *
10488 get_name (tree t)
10489 {
10490   tree stripped_decl;
10491
10492   stripped_decl = t;
10493   STRIP_NOPS (stripped_decl);
10494   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
10495     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
10496   else
10497     {
10498       switch (TREE_CODE (stripped_decl))
10499         {
10500         case ADDR_EXPR:
10501           return get_name (TREE_OPERAND (stripped_decl, 0));
10502         default:
10503           return NULL;
10504         }
10505     }
10506 }
10507
10508 /* Return true if TYPE has a variable argument list.  */
10509
10510 bool
10511 stdarg_p (const_tree fntype)
10512 {
10513   function_args_iterator args_iter;
10514   tree n = NULL_TREE, t;
10515
10516   if (!fntype)
10517     return false;
10518
10519   FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
10520     {
10521       n = t;
10522     }
10523
10524   return n != NULL_TREE && n != void_type_node;
10525 }
10526
10527 /* Return true if TYPE has a prototype.  */
10528
10529 bool
10530 prototype_p (tree fntype)
10531 {
10532   tree t;
10533
10534   gcc_assert (fntype != NULL_TREE);
10535
10536   t = TYPE_ARG_TYPES (fntype);
10537   return (t != NULL_TREE);
10538 }
10539
10540 /* If BLOCK is inlined from an __attribute__((__artificial__))
10541    routine, return pointer to location from where it has been
10542    called.  */
10543 location_t *
10544 block_nonartificial_location (tree block)
10545 {
10546   location_t *ret = NULL;
10547
10548   while (block && TREE_CODE (block) == BLOCK
10549          && BLOCK_ABSTRACT_ORIGIN (block))
10550     {
10551       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
10552
10553       while (TREE_CODE (ao) == BLOCK
10554              && BLOCK_ABSTRACT_ORIGIN (ao)
10555              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
10556         ao = BLOCK_ABSTRACT_ORIGIN (ao);
10557
10558       if (TREE_CODE (ao) == FUNCTION_DECL)
10559         {
10560           /* If AO is an artificial inline, point RET to the
10561              call site locus at which it has been inlined and continue
10562              the loop, in case AO's caller is also an artificial
10563              inline.  */
10564           if (DECL_DECLARED_INLINE_P (ao)
10565               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
10566             ret = &BLOCK_SOURCE_LOCATION (block);
10567           else
10568             break;
10569         }
10570       else if (TREE_CODE (ao) != BLOCK)
10571         break;
10572
10573       block = BLOCK_SUPERCONTEXT (block);
10574     }
10575   return ret;
10576 }
10577
10578
10579 /* If EXP is inlined from an __attribute__((__artificial__))
10580    function, return the location of the original call expression.  */
10581
10582 location_t
10583 tree_nonartificial_location (tree exp)
10584 {
10585   location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
10586
10587   if (loc)
10588     return *loc;
10589   else
10590     return EXPR_LOCATION (exp);
10591 }
10592
10593
10594 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10595    nodes.  */
10596
10597 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
10598
10599 static hashval_t
10600 cl_option_hash_hash (const void *x)
10601 {
10602   const_tree const t = (const_tree) x;
10603   const char *p;
10604   size_t i;
10605   size_t len = 0;
10606   hashval_t hash = 0;
10607
10608   if (TREE_CODE (t) == OPTIMIZATION_NODE)
10609     {
10610       p = (const char *)TREE_OPTIMIZATION (t);
10611       len = sizeof (struct cl_optimization);
10612     }
10613
10614   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
10615     {
10616       p = (const char *)TREE_TARGET_OPTION (t);
10617       len = sizeof (struct cl_target_option);
10618     }
10619
10620   else
10621     gcc_unreachable ();
10622
10623   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10624      something else.  */
10625   for (i = 0; i < len; i++)
10626     if (p[i])
10627       hash = (hash << 4) ^ ((i << 2) | p[i]);
10628
10629   return hash;
10630 }
10631
10632 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
10633    TARGET_OPTION tree node) is the same as that given by *Y, which is the
10634    same.  */
10635
10636 static int
10637 cl_option_hash_eq (const void *x, const void *y)
10638 {
10639   const_tree const xt = (const_tree) x;
10640   const_tree const yt = (const_tree) y;
10641   const char *xp;
10642   const char *yp;
10643   size_t len;
10644
10645   if (TREE_CODE (xt) != TREE_CODE (yt))
10646     return 0;
10647
10648   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
10649     {
10650       xp = (const char *)TREE_OPTIMIZATION (xt);
10651       yp = (const char *)TREE_OPTIMIZATION (yt);
10652       len = sizeof (struct cl_optimization);
10653     }
10654
10655   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
10656     {
10657       xp = (const char *)TREE_TARGET_OPTION (xt);
10658       yp = (const char *)TREE_TARGET_OPTION (yt);
10659       len = sizeof (struct cl_target_option);
10660     }
10661
10662   else
10663     gcc_unreachable ();
10664
10665   return (memcmp (xp, yp, len) == 0);
10666 }
10667
10668 /* Build an OPTIMIZATION_NODE based on the current options.  */
10669
10670 tree
10671 build_optimization_node (void)
10672 {
10673   tree t;
10674   void **slot;
10675
10676   /* Use the cache of optimization nodes.  */
10677
10678   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node));
10679
10680   slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
10681   t = (tree) *slot;
10682   if (!t)
10683     {
10684       /* Insert this one into the hash table.  */
10685       t = cl_optimization_node;
10686       *slot = t;
10687
10688       /* Make a new node for next time round.  */
10689       cl_optimization_node = make_node (OPTIMIZATION_NODE);
10690     }
10691
10692   return t;
10693 }
10694
10695 /* Build a TARGET_OPTION_NODE based on the current options.  */
10696
10697 tree
10698 build_target_option_node (void)
10699 {
10700   tree t;
10701   void **slot;
10702
10703   /* Use the cache of optimization nodes.  */
10704
10705   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node));
10706
10707   slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
10708   t = (tree) *slot;
10709   if (!t)
10710     {
10711       /* Insert this one into the hash table.  */
10712       t = cl_target_option_node;
10713       *slot = t;
10714
10715       /* Make a new node for next time round.  */
10716       cl_target_option_node = make_node (TARGET_OPTION_NODE);
10717     }
10718
10719   return t;
10720 }
10721
10722 /* Determine the "ultimate origin" of a block.  The block may be an inlined
10723    instance of an inlined instance of a block which is local to an inline
10724    function, so we have to trace all of the way back through the origin chain
10725    to find out what sort of node actually served as the original seed for the
10726    given block.  */
10727
10728 tree
10729 block_ultimate_origin (const_tree block)
10730 {
10731   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
10732
10733   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10734      nodes in the function to point to themselves; ignore that if
10735      we're trying to output the abstract instance of this function.  */
10736   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
10737     return NULL_TREE;
10738
10739   if (immediate_origin == NULL_TREE)
10740     return NULL_TREE;
10741   else
10742     {
10743       tree ret_val;
10744       tree lookahead = immediate_origin;
10745
10746       do
10747         {
10748           ret_val = lookahead;
10749           lookahead = (TREE_CODE (ret_val) == BLOCK
10750                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
10751         }
10752       while (lookahead != NULL && lookahead != ret_val);
10753
10754       /* The block's abstract origin chain may not be the *ultimate* origin of
10755          the block. It could lead to a DECL that has an abstract origin set.
10756          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10757          will give us if it has one).  Note that DECL's abstract origins are
10758          supposed to be the most distant ancestor (or so decl_ultimate_origin
10759          claims), so we don't need to loop following the DECL origins.  */
10760       if (DECL_P (ret_val))
10761         return DECL_ORIGIN (ret_val);
10762
10763       return ret_val;
10764     }
10765 }
10766
10767 /* Return true if T1 and T2 are equivalent lists.  */
10768
10769 bool
10770 list_equal_p (const_tree t1, const_tree t2)
10771 {
10772   for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
10773     if (TREE_VALUE (t1) != TREE_VALUE (t2))
10774       return false;
10775   return !t1 && !t2;
10776 }
10777
10778 /* Return true iff conversion in EXP generates no instruction.  Mark
10779    it inline so that we fully inline into the stripping functions even
10780    though we have two uses of this function.  */
10781
10782 static inline bool
10783 tree_nop_conversion (const_tree exp)
10784 {
10785   tree outer_type, inner_type;
10786
10787   if (!CONVERT_EXPR_P (exp)
10788       && TREE_CODE (exp) != NON_LVALUE_EXPR)
10789     return false;
10790   if (TREE_OPERAND (exp, 0) == error_mark_node)
10791     return false;
10792
10793   outer_type = TREE_TYPE (exp);
10794   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10795
10796   if (!inner_type)
10797     return false;
10798
10799   /* Use precision rather then machine mode when we can, which gives
10800      the correct answer even for submode (bit-field) types.  */
10801   if ((INTEGRAL_TYPE_P (outer_type)
10802        || POINTER_TYPE_P (outer_type)
10803        || TREE_CODE (outer_type) == OFFSET_TYPE)
10804       && (INTEGRAL_TYPE_P (inner_type)
10805           || POINTER_TYPE_P (inner_type)
10806           || TREE_CODE (inner_type) == OFFSET_TYPE))
10807     return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
10808
10809   /* Otherwise fall back on comparing machine modes (e.g. for
10810      aggregate types, floats).  */
10811   return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
10812 }
10813
10814 /* Return true iff conversion in EXP generates no instruction.  Don't
10815    consider conversions changing the signedness.  */
10816
10817 static bool
10818 tree_sign_nop_conversion (const_tree exp)
10819 {
10820   tree outer_type, inner_type;
10821
10822   if (!tree_nop_conversion (exp))
10823     return false;
10824
10825   outer_type = TREE_TYPE (exp);
10826   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10827
10828   return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
10829           && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
10830 }
10831
10832 /* Strip conversions from EXP according to tree_nop_conversion and
10833    return the resulting expression.  */
10834
10835 tree
10836 tree_strip_nop_conversions (tree exp)
10837 {
10838   while (tree_nop_conversion (exp))
10839     exp = TREE_OPERAND (exp, 0);
10840   return exp;
10841 }
10842
10843 /* Strip conversions from EXP according to tree_sign_nop_conversion
10844    and return the resulting expression.  */
10845
10846 tree
10847 tree_strip_sign_nop_conversions (tree exp)
10848 {
10849   while (tree_sign_nop_conversion (exp))
10850     exp = TREE_OPERAND (exp, 0);
10851   return exp;
10852 }
10853
10854 static GTY(()) tree gcc_eh_personality_decl;
10855
10856 /* Return the GCC personality function decl.  */
10857
10858 tree
10859 lhd_gcc_personality (void)
10860 {
10861   if (!gcc_eh_personality_decl)
10862     gcc_eh_personality_decl
10863       = build_personality_function (USING_SJLJ_EXCEPTIONS
10864                                     ? "__gcc_personality_sj0"
10865                                     : "__gcc_personality_v0");
10866
10867   return gcc_eh_personality_decl;
10868 }
10869
10870 /* Try to find a base info of BINFO that would have its field decl at offset
10871    OFFSET within the BINFO type and which is of EXPECTED_TYPE.  If it can be
10872    found, return, otherwise return NULL_TREE.  */
10873
10874 tree
10875 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
10876 {
10877   tree type;
10878
10879   if (offset == 0)
10880     return binfo;
10881
10882   type = TREE_TYPE (binfo);
10883   while (offset > 0)
10884     {
10885       tree base_binfo, found_binfo;
10886       HOST_WIDE_INT pos, size;
10887       tree fld;
10888       int i;
10889
10890       if (TREE_CODE (type) != RECORD_TYPE)
10891         return NULL_TREE;
10892
10893       for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
10894         {
10895           if (TREE_CODE (fld) != FIELD_DECL)
10896             continue;
10897
10898           pos = int_bit_position (fld);
10899           size = tree_low_cst (DECL_SIZE (fld), 1);
10900           if (pos <= offset && (pos + size) > offset)
10901             break;
10902         }
10903       if (!fld)
10904         return NULL_TREE;
10905
10906       found_binfo = NULL_TREE;
10907       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10908         if (TREE_TYPE (base_binfo) == TREE_TYPE (fld))
10909           {
10910             found_binfo = base_binfo;
10911             break;
10912           }
10913
10914       if (!found_binfo)
10915         return NULL_TREE;
10916
10917       type = TREE_TYPE (fld);
10918       binfo = found_binfo;
10919       offset -= pos;
10920     }
10921   if (type != expected_type)
10922     return NULL_TREE;
10923   return binfo;
10924 }
10925
10926 /* Returns true if X is a typedef decl.  */
10927
10928 bool
10929 is_typedef_decl (tree x)
10930 {
10931   return (x && TREE_CODE (x) == TYPE_DECL
10932           && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
10933 }
10934
10935 /* Returns true iff TYPE is a type variant created for a typedef. */
10936
10937 bool
10938 typedef_variant_p (tree type)
10939 {
10940   return is_typedef_decl (TYPE_NAME (type));
10941 }
10942
10943 #include "gt-tree.h"