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