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