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