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