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