gcc/tree.c

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