gcc/tree.c

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