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 && ! DECL_EXTERNAL (var))
7940                 || TREE_CODE (var) == PARM_DECL)
7941                && ! TREE_STATIC (var))
7942               || TREE_CODE (var) == LABEL_DECL
7943               || TREE_CODE (var) == RESULT_DECL));
7944 }
7945
7946 /* Subprogram of following function.  Called by walk_tree.
7947
7948    Return *TP if it is an automatic variable or parameter of the
7949    function passed in as DATA.  */
7950
7951 static tree
7952 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
7953 {
7954   tree fn = (tree) data;
7955
7956   if (TYPE_P (*tp))
7957     *walk_subtrees = 0;
7958
7959   else if (DECL_P (*tp)
7960            && auto_var_in_fn_p (*tp, fn))
7961     return *tp;
7962
7963   return NULL_TREE;
7964 }
7965
7966 /* Returns true if T is, contains, or refers to a type with variable
7967    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
7968    arguments, but not the return type.  If FN is nonzero, only return
7969    true if a modifier of the type or position of FN is a variable or
7970    parameter inside FN.
7971
7972    This concept is more general than that of C99 'variably modified types':
7973    in C99, a struct type is never variably modified because a VLA may not
7974    appear as a structure member.  However, in GNU C code like:
7975
7976      struct S { int i[f()]; };
7977
7978    is valid, and other languages may define similar constructs.  */
7979
7980 bool
7981 variably_modified_type_p (tree type, tree fn)
7982 {
7983   tree t;
7984
7985 /* Test if T is either variable (if FN is zero) or an expression containing
7986    a variable in FN.  */
7987 #define RETURN_TRUE_IF_VAR(T)                                           \
7988   do { tree _t = (T);                                                   \
7989     if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
7990         && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
7991       return true;  } while (0)
7992
7993   if (type == error_mark_node)
7994     return false;
7995
7996   /* If TYPE itself has variable size, it is variably modified.  */
7997   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
7998   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
7999
8000   switch (TREE_CODE (type))
8001     {
8002     case POINTER_TYPE:
8003     case REFERENCE_TYPE:
8004     case VECTOR_TYPE:
8005       if (variably_modified_type_p (TREE_TYPE (type), fn))
8006         return true;
8007       break;
8008
8009     case FUNCTION_TYPE:
8010     case METHOD_TYPE:
8011       /* If TYPE is a function type, it is variably modified if the
8012          return type is variably modified.  */
8013       if (variably_modified_type_p (TREE_TYPE (type), fn))
8014           return true;
8015       break;
8016
8017     case INTEGER_TYPE:
8018     case REAL_TYPE:
8019     case FIXED_POINT_TYPE:
8020     case ENUMERAL_TYPE:
8021     case BOOLEAN_TYPE:
8022       /* Scalar types are variably modified if their end points
8023          aren't constant.  */
8024       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8025       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8026       break;
8027
8028     case RECORD_TYPE:
8029     case UNION_TYPE:
8030     case QUAL_UNION_TYPE:
8031       /* We can't see if any of the fields are variably-modified by the
8032          definition we normally use, since that would produce infinite
8033          recursion via pointers.  */
8034       /* This is variably modified if some field's type is.  */
8035       for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
8036         if (TREE_CODE (t) == FIELD_DECL)
8037           {
8038             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8039             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8040             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8041
8042             if (TREE_CODE (type) == QUAL_UNION_TYPE)
8043               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8044           }
8045         break;
8046
8047     case ARRAY_TYPE:
8048       /* Do not call ourselves to avoid infinite recursion.  This is
8049          variably modified if the element type is.  */
8050       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8051       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8052       break;
8053
8054     default:
8055       break;
8056     }
8057
8058   /* The current language may have other cases to check, but in general,
8059      all other types are not variably modified.  */
8060   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8061
8062 #undef RETURN_TRUE_IF_VAR
8063 }
8064
8065 /* Given a DECL or TYPE, return the scope in which it was declared, or
8066    NULL_TREE if there is no containing scope.  */
8067
8068 tree
8069 get_containing_scope (const_tree t)
8070 {
8071   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8072 }
8073
8074 /* Return the innermost context enclosing DECL that is
8075    a FUNCTION_DECL, or zero if none.  */
8076
8077 tree
8078 decl_function_context (const_tree decl)
8079 {
8080   tree context;
8081
8082   if (TREE_CODE (decl) == ERROR_MARK)
8083     return 0;
8084
8085   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8086      where we look up the function at runtime.  Such functions always take
8087      a first argument of type 'pointer to real context'.
8088
8089      C++ should really be fixed to use DECL_CONTEXT for the real context,
8090      and use something else for the "virtual context".  */
8091   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8092     context
8093       = TYPE_MAIN_VARIANT
8094         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8095   else
8096     context = DECL_CONTEXT (decl);
8097
8098   while (context && TREE_CODE (context) != FUNCTION_DECL)
8099     {
8100       if (TREE_CODE (context) == BLOCK)
8101         context = BLOCK_SUPERCONTEXT (context);
8102       else
8103         context = get_containing_scope (context);
8104     }
8105
8106   return context;
8107 }
8108
8109 /* Return the innermost context enclosing DECL that is
8110    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8111    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
8112
8113 tree
8114 decl_type_context (const_tree decl)
8115 {
8116   tree context = DECL_CONTEXT (decl);
8117
8118   while (context)
8119     switch (TREE_CODE (context))
8120       {
8121       case NAMESPACE_DECL:
8122       case TRANSLATION_UNIT_DECL:
8123         return NULL_TREE;
8124
8125       case RECORD_TYPE:
8126       case UNION_TYPE:
8127       case QUAL_UNION_TYPE:
8128         return context;
8129
8130       case TYPE_DECL:
8131       case FUNCTION_DECL:
8132         context = DECL_CONTEXT (context);
8133         break;
8134
8135       case BLOCK:
8136         context = BLOCK_SUPERCONTEXT (context);
8137         break;
8138
8139       default:
8140         gcc_unreachable ();
8141       }
8142
8143   return NULL_TREE;
8144 }
8145
8146 /* CALL is a CALL_EXPR.  Return the declaration for the function
8147    called, or NULL_TREE if the called function cannot be
8148    determined.  */
8149
8150 tree
8151 get_callee_fndecl (const_tree call)
8152 {
8153   tree addr;
8154
8155   if (call == error_mark_node)
8156     return error_mark_node;
8157
8158   /* It's invalid to call this function with anything but a
8159      CALL_EXPR.  */
8160   gcc_assert (TREE_CODE (call) == CALL_EXPR);
8161
8162   /* The first operand to the CALL is the address of the function
8163      called.  */
8164   addr = CALL_EXPR_FN (call);
8165
8166   STRIP_NOPS (addr);
8167
8168   /* If this is a readonly function pointer, extract its initial value.  */
8169   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8170       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8171       && DECL_INITIAL (addr))
8172     addr = DECL_INITIAL (addr);
8173
8174   /* If the address is just `&f' for some function `f', then we know
8175      that `f' is being called.  */
8176   if (TREE_CODE (addr) == ADDR_EXPR
8177       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8178     return TREE_OPERAND (addr, 0);
8179
8180   /* We couldn't figure out what was being called.  */
8181   return NULL_TREE;
8182 }
8183
8184 /* Print debugging information about tree nodes generated during the compile,
8185    and any language-specific information.  */
8186
8187 void
8188 dump_tree_statistics (void)
8189 {
8190 #ifdef GATHER_STATISTICS
8191   int i;
8192   int total_nodes, total_bytes;
8193 #endif
8194
8195   fprintf (stderr, "\n??? tree nodes created\n\n");
8196 #ifdef GATHER_STATISTICS
8197   fprintf (stderr, "Kind                   Nodes      Bytes\n");
8198   fprintf (stderr, "---------------------------------------\n");
8199   total_nodes = total_bytes = 0;
8200   for (i = 0; i < (int) all_kinds; i++)
8201     {
8202       fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8203                tree_node_counts[i], tree_node_sizes[i]);
8204       total_nodes += tree_node_counts[i];
8205       total_bytes += tree_node_sizes[i];
8206     }
8207   fprintf (stderr, "---------------------------------------\n");
8208   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8209   fprintf (stderr, "---------------------------------------\n");
8210   ssanames_print_statistics ();
8211   phinodes_print_statistics ();
8212 #else
8213   fprintf (stderr, "(No per-node statistics)\n");
8214 #endif
8215   print_type_hash_statistics ();
8216   print_debug_expr_statistics ();
8217   print_value_expr_statistics ();
8218   lang_hooks.print_statistics ();
8219 }
8220 \f
8221 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8222
8223 /* Generate a crc32 of a string.  */
8224
8225 unsigned
8226 crc32_string (unsigned chksum, const char *string)
8227 {
8228   do
8229     {
8230       unsigned value = *string << 24;
8231       unsigned ix;
8232
8233       for (ix = 8; ix--; value <<= 1)
8234         {
8235           unsigned feedback;
8236
8237           feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
8238           chksum <<= 1;
8239           chksum ^= feedback;
8240         }
8241     }
8242   while (*string++);
8243   return chksum;
8244 }
8245
8246 /* P is a string that will be used in a symbol.  Mask out any characters
8247    that are not valid in that context.  */
8248
8249 void
8250 clean_symbol_name (char *p)
8251 {
8252   for (; *p; p++)
8253     if (! (ISALNUM (*p)
8254 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
8255             || *p == '$'
8256 #endif
8257 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
8258             || *p == '.'
8259 #endif
8260            ))
8261       *p = '_';
8262 }
8263
8264 /* Generate a name for a special-purpose function function.
8265    The generated name may need to be unique across the whole link.
8266    TYPE is some string to identify the purpose of this function to the
8267    linker or collect2; it must start with an uppercase letter,
8268    one of:
8269    I - for constructors
8270    D - for destructors
8271    N - for C++ anonymous namespaces
8272    F - for DWARF unwind frame information.  */
8273
8274 tree
8275 get_file_function_name (const char *type)
8276 {
8277   char *buf;
8278   const char *p;
8279   char *q;
8280
8281   /* If we already have a name we know to be unique, just use that.  */
8282   if (first_global_object_name)
8283     p = q = ASTRDUP (first_global_object_name);
8284   /* If the target is handling the constructors/destructors, they
8285      will be local to this file and the name is only necessary for
8286      debugging purposes.  */
8287   else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
8288     {
8289       const char *file = main_input_filename;
8290       if (! file)
8291         file = input_filename;
8292       /* Just use the file's basename, because the full pathname
8293          might be quite long.  */
8294       p = strrchr (file, '/');
8295       if (p)
8296         p++;
8297       else
8298         p = file;
8299       p = q = ASTRDUP (p);
8300     }
8301   else
8302     {
8303       /* Otherwise, the name must be unique across the entire link.
8304          We don't have anything that we know to be unique to this translation
8305          unit, so use what we do have and throw in some randomness.  */
8306       unsigned len;
8307       const char *name = weak_global_object_name;
8308       const char *file = main_input_filename;
8309
8310       if (! name)
8311         name = "";
8312       if (! file)
8313         file = input_filename;
8314
8315       len = strlen (file);
8316       q = (char *) alloca (9 * 2 + len + 1);
8317       memcpy (q, file, len + 1);
8318
8319       sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
8320                crc32_string (0, get_random_seed (false)));
8321
8322       p = q;
8323     }
8324
8325   clean_symbol_name (q);
8326   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
8327                          + strlen (type));
8328
8329   /* Set up the name of the file-level functions we may need.
8330      Use a global object (which is already required to be unique over
8331      the program) rather than the file name (which imposes extra
8332      constraints).  */
8333   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
8334
8335   return get_identifier (buf);
8336 }
8337 \f
8338 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8339
8340 /* Complain that the tree code of NODE does not match the expected 0
8341    terminated list of trailing codes. The trailing code list can be
8342    empty, for a more vague error message.  FILE, LINE, and FUNCTION
8343    are of the caller.  */
8344
8345 void
8346 tree_check_failed (const_tree node, const char *file,
8347                    int line, const char *function, ...)
8348 {
8349   va_list args;
8350   const char *buffer;
8351   unsigned length = 0;
8352   int code;
8353
8354   va_start (args, function);
8355   while ((code = va_arg (args, int)))
8356     length += 4 + strlen (tree_code_name[code]);
8357   va_end (args);
8358   if (length)
8359     {
8360       char *tmp;
8361       va_start (args, function);
8362       length += strlen ("expected ");
8363       buffer = tmp = (char *) alloca (length);
8364       length = 0;
8365       while ((code = va_arg (args, int)))
8366         {
8367           const char *prefix = length ? " or " : "expected ";
8368
8369           strcpy (tmp + length, prefix);
8370           length += strlen (prefix);
8371           strcpy (tmp + length, tree_code_name[code]);
8372           length += strlen (tree_code_name[code]);
8373         }
8374       va_end (args);
8375     }
8376   else
8377     buffer = "unexpected node";
8378
8379   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8380                   buffer, tree_code_name[TREE_CODE (node)],
8381                   function, trim_filename (file), line);
8382 }
8383
8384 /* Complain that the tree code of NODE does match the expected 0
8385    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8386    the caller.  */
8387
8388 void
8389 tree_not_check_failed (const_tree node, const char *file,
8390                        int line, const char *function, ...)
8391 {
8392   va_list args;
8393   char *buffer;
8394   unsigned length = 0;
8395   int code;
8396
8397   va_start (args, function);
8398   while ((code = va_arg (args, int)))
8399     length += 4 + strlen (tree_code_name[code]);
8400   va_end (args);
8401   va_start (args, function);
8402   buffer = (char *) alloca (length);
8403   length = 0;
8404   while ((code = va_arg (args, int)))
8405     {
8406       if (length)
8407         {
8408           strcpy (buffer + length, " or ");
8409           length += 4;
8410         }
8411       strcpy (buffer + length, tree_code_name[code]);
8412       length += strlen (tree_code_name[code]);
8413     }
8414   va_end (args);
8415
8416   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8417                   buffer, tree_code_name[TREE_CODE (node)],
8418                   function, trim_filename (file), line);
8419 }
8420
8421 /* Similar to tree_check_failed, except that we check for a class of tree
8422    code, given in CL.  */
8423
8424 void
8425 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
8426                          const char *file, int line, const char *function)
8427 {
8428   internal_error
8429     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8430      TREE_CODE_CLASS_STRING (cl),
8431      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8432      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8433 }
8434
8435 /* Similar to tree_check_failed, except that instead of specifying a
8436    dozen codes, use the knowledge that they're all sequential.  */
8437
8438 void
8439 tree_range_check_failed (const_tree node, const char *file, int line,
8440                          const char *function, enum tree_code c1,
8441                          enum tree_code c2)
8442 {
8443   char *buffer;
8444   unsigned length = 0;
8445   unsigned int c;
8446
8447   for (c = c1; c <= c2; ++c)
8448     length += 4 + strlen (tree_code_name[c]);
8449
8450   length += strlen ("expected ");
8451   buffer = (char *) alloca (length);
8452   length = 0;
8453
8454   for (c = c1; c <= c2; ++c)
8455     {
8456       const char *prefix = length ? " or " : "expected ";
8457
8458       strcpy (buffer + length, prefix);
8459       length += strlen (prefix);
8460       strcpy (buffer + length, tree_code_name[c]);
8461       length += strlen (tree_code_name[c]);
8462     }
8463
8464   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8465                   buffer, tree_code_name[TREE_CODE (node)],
8466                   function, trim_filename (file), line);
8467 }
8468
8469
8470 /* Similar to tree_check_failed, except that we check that a tree does
8471    not have the specified code, given in CL.  */
8472
8473 void
8474 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
8475                              const char *file, int line, const char *function)
8476 {
8477   internal_error
8478     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8479      TREE_CODE_CLASS_STRING (cl),
8480      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8481      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8482 }
8483
8484
8485 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
8486
8487 void
8488 omp_clause_check_failed (const_tree node, const char *file, int line,
8489                          const char *function, enum omp_clause_code code)
8490 {
8491   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8492                   omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
8493                   function, trim_filename (file), line);
8494 }
8495
8496
8497 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
8498
8499 void
8500 omp_clause_range_check_failed (const_tree node, const char *file, int line,
8501                                const char *function, enum omp_clause_code c1,
8502                                enum omp_clause_code c2)
8503 {
8504   char *buffer;
8505   unsigned length = 0;
8506   unsigned int c;
8507
8508   for (c = c1; c <= c2; ++c)
8509     length += 4 + strlen (omp_clause_code_name[c]);
8510
8511   length += strlen ("expected ");
8512   buffer = (char *) alloca (length);
8513   length = 0;
8514
8515   for (c = c1; c <= c2; ++c)
8516     {
8517       const char *prefix = length ? " or " : "expected ";
8518
8519       strcpy (buffer + length, prefix);
8520       length += strlen (prefix);
8521       strcpy (buffer + length, omp_clause_code_name[c]);
8522       length += strlen (omp_clause_code_name[c]);
8523     }
8524
8525   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8526                   buffer, omp_clause_code_name[TREE_CODE (node)],
8527                   function, trim_filename (file), line);
8528 }
8529
8530
8531 #undef DEFTREESTRUCT
8532 #define DEFTREESTRUCT(VAL, NAME) NAME,
8533
8534 static const char *ts_enum_names[] = {
8535 #include "treestruct.def"
8536 };
8537 #undef DEFTREESTRUCT
8538
8539 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8540
8541 /* Similar to tree_class_check_failed, except that we check for
8542    whether CODE contains the tree structure identified by EN.  */
8543
8544 void
8545 tree_contains_struct_check_failed (const_tree node,
8546                                    const enum tree_node_structure_enum en,
8547                                    const char *file, int line,
8548                                    const char *function)
8549 {
8550   internal_error
8551     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8552      TS_ENUM_NAME(en),
8553      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8554 }
8555
8556
8557 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
8558    (dynamically sized) vector.  */
8559
8560 void
8561 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
8562                            const char *function)
8563 {
8564   internal_error
8565     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8566      idx + 1, len, function, trim_filename (file), line);
8567 }
8568
8569 /* Similar to above, except that the check is for the bounds of the operand
8570    vector of an expression node EXP.  */
8571
8572 void
8573 tree_operand_check_failed (int idx, const_tree exp, const char *file,
8574                            int line, const char *function)
8575 {
8576   int code = TREE_CODE (exp);
8577   internal_error
8578     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8579      idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
8580      function, trim_filename (file), line);
8581 }
8582
8583 /* Similar to above, except that the check is for the number of
8584    operands of an OMP_CLAUSE node.  */
8585
8586 void
8587 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
8588                                  int line, const char *function)
8589 {
8590   internal_error
8591     ("tree check: accessed operand %d of omp_clause %s with %d operands "
8592      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
8593      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
8594      trim_filename (file), line);
8595 }
8596 #endif /* ENABLE_TREE_CHECKING */
8597 \f
8598 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8599    and mapped to the machine mode MODE.  Initialize its fields and build
8600    the information necessary for debugging output.  */
8601
8602 static tree
8603 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
8604 {
8605   tree t;
8606   hashval_t hashcode = 0;
8607
8608   t = make_node (VECTOR_TYPE);
8609   TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
8610   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
8611   SET_TYPE_MODE (t, mode);
8612
8613   if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
8614     SET_TYPE_STRUCTURAL_EQUALITY (t);
8615   else if (TYPE_CANONICAL (innertype) != innertype
8616            || mode != VOIDmode)
8617     TYPE_CANONICAL (t)
8618       = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
8619
8620   layout_type (t);
8621
8622   {
8623     tree index = build_int_cst (NULL_TREE, nunits - 1);
8624     tree array = build_array_type (TYPE_MAIN_VARIANT (innertype),
8625                                    build_index_type (index));
8626     tree rt = make_node (RECORD_TYPE);
8627
8628     TYPE_FIELDS (rt) = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
8629                                    get_identifier ("f"), array);
8630     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
8631     layout_type (rt);
8632     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
8633     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
8634        the representation type, and we want to find that die when looking up
8635        the vector type.  This is most easily achieved by making the TYPE_UID
8636        numbers equal.  */
8637     TYPE_UID (rt) = TYPE_UID (t);
8638   }
8639
8640   hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
8641   hashcode = iterative_hash_host_wide_int (nunits, hashcode);
8642   hashcode = iterative_hash_host_wide_int (mode, hashcode);
8643   hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
8644   t = type_hash_canon (hashcode, t);
8645
8646   /* We have built a main variant, based on the main variant of the
8647      inner type. Use it to build the variant we return.  */
8648   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
8649       && TREE_TYPE (t) != innertype)
8650     return build_type_attribute_qual_variant (t,
8651                                               TYPE_ATTRIBUTES (innertype),
8652                                               TYPE_QUALS (innertype));
8653
8654   return t;
8655 }
8656
8657 static tree
8658 make_or_reuse_type (unsigned size, int unsignedp)
8659 {
8660   if (size == INT_TYPE_SIZE)
8661     return unsignedp ? unsigned_type_node : integer_type_node;
8662   if (size == CHAR_TYPE_SIZE)
8663     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
8664   if (size == SHORT_TYPE_SIZE)
8665     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
8666   if (size == LONG_TYPE_SIZE)
8667     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
8668   if (size == LONG_LONG_TYPE_SIZE)
8669     return (unsignedp ? long_long_unsigned_type_node
8670             : long_long_integer_type_node);
8671
8672   if (unsignedp)
8673     return make_unsigned_type (size);
8674   else
8675     return make_signed_type (size);
8676 }
8677
8678 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
8679
8680 static tree
8681 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
8682 {
8683   if (satp)
8684     {
8685       if (size == SHORT_FRACT_TYPE_SIZE)
8686         return unsignedp ? sat_unsigned_short_fract_type_node
8687                          : sat_short_fract_type_node;
8688       if (size == FRACT_TYPE_SIZE)
8689         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
8690       if (size == LONG_FRACT_TYPE_SIZE)
8691         return unsignedp ? sat_unsigned_long_fract_type_node
8692                          : sat_long_fract_type_node;
8693       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8694         return unsignedp ? sat_unsigned_long_long_fract_type_node
8695                          : sat_long_long_fract_type_node;
8696     }
8697   else
8698     {
8699       if (size == SHORT_FRACT_TYPE_SIZE)
8700         return unsignedp ? unsigned_short_fract_type_node
8701                          : short_fract_type_node;
8702       if (size == FRACT_TYPE_SIZE)
8703         return unsignedp ? unsigned_fract_type_node : fract_type_node;
8704       if (size == LONG_FRACT_TYPE_SIZE)
8705         return unsignedp ? unsigned_long_fract_type_node
8706                          : long_fract_type_node;
8707       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8708         return unsignedp ? unsigned_long_long_fract_type_node
8709                          : long_long_fract_type_node;
8710     }
8711
8712   return make_fract_type (size, unsignedp, satp);
8713 }
8714
8715 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
8716
8717 static tree
8718 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
8719 {
8720   if (satp)
8721     {
8722       if (size == SHORT_ACCUM_TYPE_SIZE)
8723         return unsignedp ? sat_unsigned_short_accum_type_node
8724                          : sat_short_accum_type_node;
8725       if (size == ACCUM_TYPE_SIZE)
8726         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
8727       if (size == LONG_ACCUM_TYPE_SIZE)
8728         return unsignedp ? sat_unsigned_long_accum_type_node
8729                          : sat_long_accum_type_node;
8730       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8731         return unsignedp ? sat_unsigned_long_long_accum_type_node
8732                          : sat_long_long_accum_type_node;
8733     }
8734   else
8735     {
8736       if (size == SHORT_ACCUM_TYPE_SIZE)
8737         return unsignedp ? unsigned_short_accum_type_node
8738                          : short_accum_type_node;
8739       if (size == ACCUM_TYPE_SIZE)
8740         return unsignedp ? unsigned_accum_type_node : accum_type_node;
8741       if (size == LONG_ACCUM_TYPE_SIZE)
8742         return unsignedp ? unsigned_long_accum_type_node
8743                          : long_accum_type_node;
8744       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8745         return unsignedp ? unsigned_long_long_accum_type_node
8746                          : long_long_accum_type_node;
8747     }
8748
8749   return make_accum_type (size, unsignedp, satp);
8750 }
8751
8752 /* Create nodes for all integer types (and error_mark_node) using the sizes
8753    of C datatypes.  The caller should call set_sizetype soon after calling
8754    this function to select one of the types as sizetype.  */
8755
8756 void
8757 build_common_tree_nodes (bool signed_char)
8758 {
8759   error_mark_node = make_node (ERROR_MARK);
8760   TREE_TYPE (error_mark_node) = error_mark_node;
8761
8762   initialize_sizetypes ();
8763
8764   /* Define both `signed char' and `unsigned char'.  */
8765   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
8766   TYPE_STRING_FLAG (signed_char_type_node) = 1;
8767   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
8768   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
8769
8770   /* Define `char', which is like either `signed char' or `unsigned char'
8771      but not the same as either.  */
8772   char_type_node
8773     = (signed_char
8774        ? make_signed_type (CHAR_TYPE_SIZE)
8775        : make_unsigned_type (CHAR_TYPE_SIZE));
8776   TYPE_STRING_FLAG (char_type_node) = 1;
8777
8778   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
8779   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
8780   integer_type_node = make_signed_type (INT_TYPE_SIZE);
8781   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
8782   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
8783   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
8784   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
8785   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
8786
8787   /* Define a boolean type.  This type only represents boolean values but
8788      may be larger than char depending on the value of BOOL_TYPE_SIZE.
8789      Front ends which want to override this size (i.e. Java) can redefine
8790      boolean_type_node before calling build_common_tree_nodes_2.  */
8791   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
8792   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
8793   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
8794   TYPE_PRECISION (boolean_type_node) = 1;
8795
8796   /* Fill in the rest of the sized types.  Reuse existing type nodes
8797      when possible.  */
8798   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
8799   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
8800   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
8801   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
8802   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
8803
8804   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
8805   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
8806   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
8807   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
8808   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
8809
8810   access_public_node = get_identifier ("public");
8811   access_protected_node = get_identifier ("protected");
8812   access_private_node = get_identifier ("private");
8813 }
8814
8815 /* Call this function after calling build_common_tree_nodes and set_sizetype.
8816    It will create several other common tree nodes.  */
8817
8818 void
8819 build_common_tree_nodes_2 (int short_double)
8820 {
8821   /* Define these next since types below may used them.  */
8822   integer_zero_node = build_int_cst (NULL_TREE, 0);
8823   integer_one_node = build_int_cst (NULL_TREE, 1);
8824   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
8825
8826   size_zero_node = size_int (0);
8827   size_one_node = size_int (1);
8828   bitsize_zero_node = bitsize_int (0);
8829   bitsize_one_node = bitsize_int (1);
8830   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
8831
8832   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
8833   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
8834
8835   void_type_node = make_node (VOID_TYPE);
8836   layout_type (void_type_node);
8837
8838   /* We are not going to have real types in C with less than byte alignment,
8839      so we might as well not have any types that claim to have it.  */
8840   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
8841   TYPE_USER_ALIGN (void_type_node) = 0;
8842
8843   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
8844   layout_type (TREE_TYPE (null_pointer_node));
8845
8846   ptr_type_node = build_pointer_type (void_type_node);
8847   const_ptr_type_node
8848     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
8849   fileptr_type_node = ptr_type_node;
8850
8851   float_type_node = make_node (REAL_TYPE);
8852   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
8853   layout_type (float_type_node);
8854
8855   double_type_node = make_node (REAL_TYPE);
8856   if (short_double)
8857     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
8858   else
8859     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
8860   layout_type (double_type_node);
8861
8862   long_double_type_node = make_node (REAL_TYPE);
8863   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
8864   layout_type (long_double_type_node);
8865
8866   float_ptr_type_node = build_pointer_type (float_type_node);
8867   double_ptr_type_node = build_pointer_type (double_type_node);
8868   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
8869   integer_ptr_type_node = build_pointer_type (integer_type_node);
8870
8871   /* Fixed size integer types.  */
8872   uint32_type_node = build_nonstandard_integer_type (32, true);
8873   uint64_type_node = build_nonstandard_integer_type (64, true);
8874
8875   /* Decimal float types. */
8876   dfloat32_type_node = make_node (REAL_TYPE);
8877   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
8878   layout_type (dfloat32_type_node);
8879   SET_TYPE_MODE (dfloat32_type_node, SDmode);
8880   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
8881
8882   dfloat64_type_node = make_node (REAL_TYPE);
8883   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
8884   layout_type (dfloat64_type_node);
8885   SET_TYPE_MODE (dfloat64_type_node, DDmode);
8886   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
8887
8888   dfloat128_type_node = make_node (REAL_TYPE);
8889   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
8890   layout_type (dfloat128_type_node);
8891   SET_TYPE_MODE (dfloat128_type_node, TDmode);
8892   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
8893
8894   complex_integer_type_node = build_complex_type (integer_type_node);
8895   complex_float_type_node = build_complex_type (float_type_node);
8896   complex_double_type_node = build_complex_type (double_type_node);
8897   complex_long_double_type_node = build_complex_type (long_double_type_node);
8898
8899 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
8900 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
8901   sat_ ## KIND ## _type_node = \
8902     make_sat_signed_ ## KIND ## _type (SIZE); \
8903   sat_unsigned_ ## KIND ## _type_node = \
8904     make_sat_unsigned_ ## KIND ## _type (SIZE); \
8905   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8906   unsigned_ ## KIND ## _type_node = \
8907     make_unsigned_ ## KIND ## _type (SIZE);
8908
8909 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
8910   sat_ ## WIDTH ## KIND ## _type_node = \
8911     make_sat_signed_ ## KIND ## _type (SIZE); \
8912   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
8913     make_sat_unsigned_ ## KIND ## _type (SIZE); \
8914   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8915   unsigned_ ## WIDTH ## KIND ## _type_node = \
8916     make_unsigned_ ## KIND ## _type (SIZE);
8917
8918 /* Make fixed-point type nodes based on four different widths.  */
8919 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
8920   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
8921   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
8922   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
8923   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
8924
8925 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
8926 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
8927   NAME ## _type_node = \
8928     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
8929   u ## NAME ## _type_node = \
8930     make_or_reuse_unsigned_ ## KIND ## _type \
8931       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
8932   sat_ ## NAME ## _type_node = \
8933     make_or_reuse_sat_signed_ ## KIND ## _type \
8934       (GET_MODE_BITSIZE (MODE ## mode)); \
8935   sat_u ## NAME ## _type_node = \
8936     make_or_reuse_sat_unsigned_ ## KIND ## _type \
8937       (GET_MODE_BITSIZE (U ## MODE ## mode));
8938
8939   /* Fixed-point type and mode nodes.  */
8940   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
8941   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
8942   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
8943   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
8944   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
8945   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
8946   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
8947   MAKE_FIXED_MODE_NODE (accum, ha, HA)
8948   MAKE_FIXED_MODE_NODE (accum, sa, SA)
8949   MAKE_FIXED_MODE_NODE (accum, da, DA)
8950   MAKE_FIXED_MODE_NODE (accum, ta, TA)
8951
8952   {
8953     tree t = targetm.build_builtin_va_list ();
8954
8955     /* Many back-ends define record types without setting TYPE_NAME.
8956        If we copied the record type here, we'd keep the original
8957        record type without a name.  This breaks name mangling.  So,
8958        don't copy record types and let c_common_nodes_and_builtins()
8959        declare the type to be __builtin_va_list.  */
8960     if (TREE_CODE (t) != RECORD_TYPE)
8961       t = build_variant_type_copy (t);
8962
8963     va_list_type_node = t;
8964   }
8965 }
8966
8967 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
8968
8969 static void
8970 local_define_builtin (const char *name, tree type, enum built_in_function code,
8971                       const char *library_name, int ecf_flags)
8972 {
8973   tree decl;
8974
8975   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
8976                                library_name, NULL_TREE);
8977   if (ecf_flags & ECF_CONST)
8978     TREE_READONLY (decl) = 1;
8979   if (ecf_flags & ECF_PURE)
8980     DECL_PURE_P (decl) = 1;
8981   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
8982     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
8983   if (ecf_flags & ECF_NORETURN)
8984     TREE_THIS_VOLATILE (decl) = 1;
8985   if (ecf_flags & ECF_NOTHROW)
8986     TREE_NOTHROW (decl) = 1;
8987   if (ecf_flags & ECF_MALLOC)
8988     DECL_IS_MALLOC (decl) = 1;
8989
8990   built_in_decls[code] = decl;
8991   implicit_built_in_decls[code] = decl;
8992 }
8993
8994 /* Call this function after instantiating all builtins that the language
8995    front end cares about.  This will build the rest of the builtins that
8996    are relied upon by the tree optimizers and the middle-end.  */
8997
8998 void
8999 build_common_builtin_nodes (void)
9000 {
9001   tree tmp, tmp2, ftype;
9002
9003   if (built_in_decls[BUILT_IN_MEMCPY] == NULL
9004       || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9005     {
9006       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9007       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9008       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9009       ftype = build_function_type (ptr_type_node, tmp);
9010
9011       if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
9012         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9013                               "memcpy", ECF_NOTHROW);
9014       if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9015         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9016                               "memmove", ECF_NOTHROW);
9017     }
9018
9019   if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
9020     {
9021       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9022       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9023       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9024       ftype = build_function_type (integer_type_node, tmp);
9025       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9026                             "memcmp", ECF_PURE | ECF_NOTHROW);
9027     }
9028
9029   if (built_in_decls[BUILT_IN_MEMSET] == NULL)
9030     {
9031       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9032       tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9033       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9034       ftype = build_function_type (ptr_type_node, tmp);
9035       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9036                             "memset", ECF_NOTHROW);
9037     }
9038
9039   if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
9040     {
9041       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9042       ftype = build_function_type (ptr_type_node, tmp);
9043       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
9044                             "alloca",
9045                             ECF_MALLOC | (flag_stack_check ? 0 : ECF_NOTHROW));
9046     }
9047
9048   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9049   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9050   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9051   ftype = build_function_type (void_type_node, tmp);
9052   local_define_builtin ("__builtin_init_trampoline", ftype,
9053                         BUILT_IN_INIT_TRAMPOLINE,
9054                         "__builtin_init_trampoline", ECF_NOTHROW);
9055
9056   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9057   ftype = build_function_type (ptr_type_node, tmp);
9058   local_define_builtin ("__builtin_adjust_trampoline", ftype,
9059                         BUILT_IN_ADJUST_TRAMPOLINE,
9060                         "__builtin_adjust_trampoline",
9061                         ECF_CONST | ECF_NOTHROW);
9062
9063   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9064   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9065   ftype = build_function_type (void_type_node, tmp);
9066   local_define_builtin ("__builtin_nonlocal_goto", ftype,
9067                         BUILT_IN_NONLOCAL_GOTO,
9068                         "__builtin_nonlocal_goto",
9069                         ECF_NORETURN | ECF_NOTHROW);
9070
9071   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9072   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9073   ftype = build_function_type (void_type_node, tmp);
9074   local_define_builtin ("__builtin_setjmp_setup", ftype,
9075                         BUILT_IN_SETJMP_SETUP,
9076                         "__builtin_setjmp_setup", ECF_NOTHROW);
9077
9078   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9079   ftype = build_function_type (ptr_type_node, tmp);
9080   local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
9081                         BUILT_IN_SETJMP_DISPATCHER,
9082                         "__builtin_setjmp_dispatcher",
9083                         ECF_PURE | ECF_NOTHROW);
9084
9085   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9086   ftype = build_function_type (void_type_node, tmp);
9087   local_define_builtin ("__builtin_setjmp_receiver", ftype,
9088                         BUILT_IN_SETJMP_RECEIVER,
9089                         "__builtin_setjmp_receiver", ECF_NOTHROW);
9090
9091   ftype = build_function_type (ptr_type_node, void_list_node);
9092   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
9093                         "__builtin_stack_save", ECF_NOTHROW);
9094
9095   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9096   ftype = build_function_type (void_type_node, tmp);
9097   local_define_builtin ("__builtin_stack_restore", ftype,
9098                         BUILT_IN_STACK_RESTORE,
9099                         "__builtin_stack_restore", ECF_NOTHROW);
9100
9101   ftype = build_function_type (void_type_node, void_list_node);
9102   local_define_builtin ("__builtin_profile_func_enter", ftype,
9103                         BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
9104   local_define_builtin ("__builtin_profile_func_exit", ftype,
9105                         BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
9106
9107   /* If there's a possibility that we might use the ARM EABI, build the
9108     alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
9109   if (targetm.arm_eabi_unwinder)
9110     {
9111       ftype = build_function_type (void_type_node, void_list_node);
9112       local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
9113                             BUILT_IN_CXA_END_CLEANUP,
9114                             "__cxa_end_cleanup", ECF_NORETURN);
9115     }
9116
9117   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9118   ftype = build_function_type (void_type_node, tmp);
9119   local_define_builtin ("__builtin_unwind_resume", ftype,
9120                         BUILT_IN_UNWIND_RESUME,
9121                         (USING_SJLJ_EXCEPTIONS
9122                          ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9123                         ECF_NORETURN);
9124
9125   /* The exception object and filter values from the runtime.  The argument
9126      must be zero before exception lowering, i.e. from the front end.  After
9127      exception lowering, it will be the region number for the exception
9128      landing pad.  These functions are PURE instead of CONST to prevent
9129      them from being hoisted past the exception edge that will initialize
9130      its value in the landing pad.  */
9131   tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9132   ftype = build_function_type (ptr_type_node, tmp);
9133   local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
9134                         "__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW);
9135
9136   tmp2 = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
9137   ftype = build_function_type (tmp2, tmp);
9138   local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
9139                         "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW);
9140
9141   tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9142   tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9143   ftype = build_function_type (void_type_node, tmp);
9144   local_define_builtin ("__builtin_eh_copy_values", ftype,
9145                         BUILT_IN_EH_COPY_VALUES,
9146                         "__builtin_eh_copy_values", ECF_NOTHROW);
9147
9148   /* Complex multiplication and division.  These are handled as builtins
9149      rather than optabs because emit_library_call_value doesn't support
9150      complex.  Further, we can do slightly better with folding these
9151      beasties if the real and complex parts of the arguments are separate.  */
9152   {
9153     int mode;
9154
9155     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
9156       {
9157         char mode_name_buf[4], *q;
9158         const char *p;
9159         enum built_in_function mcode, dcode;
9160         tree type, inner_type;
9161
9162         type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
9163         if (type == NULL)
9164           continue;
9165         inner_type = TREE_TYPE (type);
9166
9167         tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
9168         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9169         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9170         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9171         ftype = build_function_type (type, tmp);
9172
9173         mcode = ((enum built_in_function)
9174                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9175         dcode = ((enum built_in_function)
9176                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9177
9178         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
9179           *q = TOLOWER (*p);
9180         *q = '\0';
9181
9182         built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
9183         local_define_builtin (built_in_names[mcode], ftype, mcode,
9184                               built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
9185
9186         built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
9187         local_define_builtin (built_in_names[dcode], ftype, dcode,
9188                               built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
9189       }
9190   }
9191 }
9192
9193 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
9194    better way.
9195
9196    If we requested a pointer to a vector, build up the pointers that
9197    we stripped off while looking for the inner type.  Similarly for
9198    return values from functions.
9199
9200    The argument TYPE is the top of the chain, and BOTTOM is the
9201    new type which we will point to.  */
9202
9203 tree
9204 reconstruct_complex_type (tree type, tree bottom)
9205 {
9206   tree inner, outer;
9207
9208   if (TREE_CODE (type) == POINTER_TYPE)
9209     {
9210       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9211       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
9212                                            TYPE_REF_CAN_ALIAS_ALL (type));
9213     }
9214   else if (TREE_CODE (type) == REFERENCE_TYPE)
9215     {
9216       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9217       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
9218                                              TYPE_REF_CAN_ALIAS_ALL (type));
9219     }
9220   else if (TREE_CODE (type) == ARRAY_TYPE)
9221     {
9222       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9223       outer = build_array_type (inner, TYPE_DOMAIN (type));
9224     }
9225   else if (TREE_CODE (type) == FUNCTION_TYPE)
9226     {
9227       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9228       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
9229     }
9230   else if (TREE_CODE (type) == METHOD_TYPE)
9231     {
9232       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9233       /* The build_method_type_directly() routine prepends 'this' to argument list,
9234          so we must compensate by getting rid of it.  */
9235       outer
9236         = build_method_type_directly
9237             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
9238              inner,
9239              TREE_CHAIN (TYPE_ARG_TYPES (type)));
9240     }
9241   else if (TREE_CODE (type) == OFFSET_TYPE)
9242     {
9243       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9244       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
9245     }
9246   else
9247     return bottom;
9248
9249   return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
9250                                             TYPE_QUALS (type));
9251 }
9252
9253 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9254    the inner type.  */
9255 tree
9256 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
9257 {
9258   int nunits;
9259
9260   switch (GET_MODE_CLASS (mode))
9261     {
9262     case MODE_VECTOR_INT:
9263     case MODE_VECTOR_FLOAT:
9264     case MODE_VECTOR_FRACT:
9265     case MODE_VECTOR_UFRACT:
9266     case MODE_VECTOR_ACCUM:
9267     case MODE_VECTOR_UACCUM:
9268       nunits = GET_MODE_NUNITS (mode);
9269       break;
9270
9271     case MODE_INT:
9272       /* Check that there are no leftover bits.  */
9273       gcc_assert (GET_MODE_BITSIZE (mode)
9274                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
9275
9276       nunits = GET_MODE_BITSIZE (mode)
9277                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
9278       break;
9279
9280     default:
9281       gcc_unreachable ();
9282     }
9283
9284   return make_vector_type (innertype, nunits, mode);
9285 }
9286
9287 /* Similarly, but takes the inner type and number of units, which must be
9288    a power of two.  */
9289
9290 tree
9291 build_vector_type (tree innertype, int nunits)
9292 {
9293   return make_vector_type (innertype, nunits, VOIDmode);
9294 }
9295
9296 /* Similarly, but takes the inner type and number of units, which must be
9297    a power of two.  */
9298
9299 tree
9300 build_opaque_vector_type (tree innertype, int nunits)
9301 {
9302   tree t;
9303   innertype = build_distinct_type_copy (innertype);
9304   t = make_vector_type (innertype, nunits, VOIDmode);
9305   TYPE_VECTOR_OPAQUE (t) = true;
9306   return t;
9307 }
9308
9309
9310 /* Given an initializer INIT, return TRUE if INIT is zero or some
9311    aggregate of zeros.  Otherwise return FALSE.  */
9312 bool
9313 initializer_zerop (const_tree init)
9314 {
9315   tree elt;
9316
9317   STRIP_NOPS (init);
9318
9319   switch (TREE_CODE (init))
9320     {
9321     case INTEGER_CST:
9322       return integer_zerop (init);
9323
9324     case REAL_CST:
9325       /* ??? Note that this is not correct for C4X float formats.  There,
9326          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9327          negative exponent.  */
9328       return real_zerop (init)
9329         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
9330
9331     case FIXED_CST:
9332       return fixed_zerop (init);
9333
9334     case COMPLEX_CST:
9335       return integer_zerop (init)
9336         || (real_zerop (init)
9337             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
9338             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
9339
9340     case VECTOR_CST:
9341       for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
9342         if (!initializer_zerop (TREE_VALUE (elt)))
9343           return false;
9344       return true;
9345
9346     case CONSTRUCTOR:
9347       {
9348         unsigned HOST_WIDE_INT idx;
9349
9350         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
9351           if (!initializer_zerop (elt))
9352             return false;
9353         return true;
9354       }
9355
9356     default:
9357       return false;
9358     }
9359 }
9360
9361 /* Build an empty statement at location LOC.  */
9362
9363 tree
9364 build_empty_stmt (location_t loc)
9365 {
9366   tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
9367   SET_EXPR_LOCATION (t, loc);
9368   return t;
9369 }
9370
9371
9372 /* Build an OpenMP clause with code CODE.  LOC is the location of the
9373    clause.  */
9374
9375 tree
9376 build_omp_clause (location_t loc, enum omp_clause_code code)
9377 {
9378   tree t;
9379   int size, length;
9380
9381   length = omp_clause_num_ops[code];
9382   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
9383
9384   t = GGC_NEWVAR (union tree_node, size);
9385   memset (t, 0, size);
9386   TREE_SET_CODE (t, OMP_CLAUSE);
9387   OMP_CLAUSE_SET_CODE (t, code);
9388   OMP_CLAUSE_LOCATION (t) = loc;
9389
9390 #ifdef GATHER_STATISTICS
9391   tree_node_counts[(int) omp_clause_kind]++;
9392   tree_node_sizes[(int) omp_clause_kind] += size;
9393 #endif
9394
9395   return t;
9396 }
9397
9398 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
9399    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9400    Except for the CODE and operand count field, other storage for the
9401    object is initialized to zeros.  */
9402
9403 tree
9404 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
9405 {
9406   tree t;
9407   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
9408
9409   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
9410   gcc_assert (len >= 1);
9411
9412 #ifdef GATHER_STATISTICS
9413   tree_node_counts[(int) e_kind]++;
9414   tree_node_sizes[(int) e_kind] += length;
9415 #endif
9416
9417   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
9418
9419   memset (t, 0, length);
9420
9421   TREE_SET_CODE (t, code);
9422
9423   /* Can't use TREE_OPERAND to store the length because if checking is
9424      enabled, it will try to check the length before we store it.  :-P  */
9425   t->exp.operands[0] = build_int_cst (sizetype, len);
9426
9427   return t;
9428 }
9429
9430
9431 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE
9432    and FN and a null static chain slot.  ARGLIST is a TREE_LIST of the
9433    arguments.  */
9434
9435 tree
9436 build_call_list (tree return_type, tree fn, tree arglist)
9437 {
9438   tree t;
9439   int i;
9440
9441   t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
9442   TREE_TYPE (t) = return_type;
9443   CALL_EXPR_FN (t) = fn;
9444   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9445   for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
9446     CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
9447   process_call_operands (t);
9448   return t;
9449 }
9450
9451 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9452    FN and a null static chain slot.  NARGS is the number of call arguments
9453    which are specified as "..." arguments.  */
9454
9455 tree
9456 build_call_nary (tree return_type, tree fn, int nargs, ...)
9457 {
9458   tree ret;
9459   va_list args;
9460   va_start (args, nargs);
9461   ret = build_call_valist (return_type, fn, nargs, args);
9462   va_end (args);
9463   return ret;
9464 }
9465
9466 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9467    FN and a null static chain slot.  NARGS is the number of call arguments
9468    which are specified as a va_list ARGS.  */
9469
9470 tree
9471 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
9472 {
9473   tree t;
9474   int i;
9475
9476   t = build_vl_exp (CALL_EXPR, nargs + 3);
9477   TREE_TYPE (t) = return_type;
9478   CALL_EXPR_FN (t) = fn;
9479   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9480   for (i = 0; i < nargs; i++)
9481     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
9482   process_call_operands (t);
9483   return t;
9484 }
9485
9486 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9487    FN and a null static chain slot.  NARGS is the number of call arguments
9488    which are specified as a tree array ARGS.  */
9489
9490 tree
9491 build_call_array_loc (location_t loc, tree return_type, tree fn,
9492                       int nargs, const tree *args)
9493 {
9494   tree t;
9495   int i;
9496
9497   t = build_vl_exp (CALL_EXPR, nargs + 3);
9498   TREE_TYPE (t) = return_type;
9499   CALL_EXPR_FN (t) = fn;
9500   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9501   for (i = 0; i < nargs; i++)
9502     CALL_EXPR_ARG (t, i) = args[i];
9503   process_call_operands (t);
9504   SET_EXPR_LOCATION (t, loc);
9505   return t;
9506 }
9507
9508 /* Like build_call_array, but takes a VEC.  */
9509
9510 tree
9511 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
9512 {
9513   tree ret, t;
9514   unsigned int ix;
9515
9516   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
9517   TREE_TYPE (ret) = return_type;
9518   CALL_EXPR_FN (ret) = fn;
9519   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
9520   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
9521     CALL_EXPR_ARG (ret, ix) = t;
9522   process_call_operands (ret);
9523   return ret;
9524 }
9525
9526
9527 /* Returns true if it is possible to prove that the index of
9528    an array access REF (an ARRAY_REF expression) falls into the
9529    array bounds.  */
9530
9531 bool
9532 in_array_bounds_p (tree ref)
9533 {
9534   tree idx = TREE_OPERAND (ref, 1);
9535   tree min, max;
9536
9537   if (TREE_CODE (idx) != INTEGER_CST)
9538     return false;
9539
9540   min = array_ref_low_bound (ref);
9541   max = array_ref_up_bound (ref);
9542   if (!min
9543       || !max
9544       || TREE_CODE (min) != INTEGER_CST
9545       || TREE_CODE (max) != INTEGER_CST)
9546     return false;
9547
9548   if (tree_int_cst_lt (idx, min)
9549       || tree_int_cst_lt (max, idx))
9550     return false;
9551
9552   return true;
9553 }
9554
9555 /* Returns true if it is possible to prove that the range of
9556    an array access REF (an ARRAY_RANGE_REF expression) falls
9557    into the array bounds.  */
9558
9559 bool
9560 range_in_array_bounds_p (tree ref)
9561 {
9562   tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
9563   tree range_min, range_max, min, max;
9564
9565   range_min = TYPE_MIN_VALUE (domain_type);
9566   range_max = TYPE_MAX_VALUE (domain_type);
9567   if (!range_min
9568       || !range_max
9569       || TREE_CODE (range_min) != INTEGER_CST
9570       || TREE_CODE (range_max) != INTEGER_CST)
9571     return false;
9572
9573   min = array_ref_low_bound (ref);
9574   max = array_ref_up_bound (ref);
9575   if (!min
9576       || !max
9577       || TREE_CODE (min) != INTEGER_CST
9578       || TREE_CODE (max) != INTEGER_CST)
9579     return false;
9580
9581   if (tree_int_cst_lt (range_min, min)
9582       || tree_int_cst_lt (max, range_max))
9583     return false;
9584
9585   return true;
9586 }
9587
9588 /* Return true if T (assumed to be a DECL) must be assigned a memory
9589    location.  */
9590
9591 bool
9592 needs_to_live_in_memory (const_tree t)
9593 {
9594   if (TREE_CODE (t) == SSA_NAME)
9595     t = SSA_NAME_VAR (t);
9596
9597   return (TREE_ADDRESSABLE (t)
9598           || is_global_var (t)
9599           || (TREE_CODE (t) == RESULT_DECL
9600               && aggregate_value_p (t, current_function_decl)));
9601 }
9602
9603 /* There are situations in which a language considers record types
9604    compatible which have different field lists.  Decide if two fields
9605    are compatible.  It is assumed that the parent records are compatible.  */
9606
9607 bool
9608 fields_compatible_p (const_tree f1, const_tree f2)
9609 {
9610   if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
9611                         DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
9612     return false;
9613
9614   if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
9615                         DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
9616     return false;
9617
9618   if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
9619     return false;
9620
9621   return true;
9622 }
9623
9624 /* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
9625
9626 tree
9627 find_compatible_field (tree record, tree orig_field)
9628 {
9629   tree f;
9630
9631   for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
9632     if (TREE_CODE (f) == FIELD_DECL
9633         && fields_compatible_p (f, orig_field))
9634       return f;
9635
9636   /* ??? Why isn't this on the main fields list?  */
9637   f = TYPE_VFIELD (record);
9638   if (f && TREE_CODE (f) == FIELD_DECL
9639       && fields_compatible_p (f, orig_field))
9640     return f;
9641
9642   /* ??? We should abort here, but Java appears to do Bad Things
9643      with inherited fields.  */
9644   return orig_field;
9645 }
9646
9647 /* Return value of a constant X and sign-extend it.  */
9648
9649 HOST_WIDE_INT
9650 int_cst_value (const_tree x)
9651 {
9652   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9653   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
9654
9655   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9656   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9657               || TREE_INT_CST_HIGH (x) == -1);
9658
9659   if (bits < HOST_BITS_PER_WIDE_INT)
9660     {
9661       bool negative = ((val >> (bits - 1)) & 1) != 0;
9662       if (negative)
9663         val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
9664       else
9665         val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
9666     }
9667
9668   return val;
9669 }
9670
9671 /* Return value of a constant X and sign-extend it.  */
9672
9673 HOST_WIDEST_INT
9674 widest_int_cst_value (const_tree x)
9675 {
9676   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9677   unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
9678
9679 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9680   gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
9681   val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
9682           << HOST_BITS_PER_WIDE_INT);
9683 #else
9684   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9685   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9686               || TREE_INT_CST_HIGH (x) == -1);
9687 #endif
9688
9689   if (bits < HOST_BITS_PER_WIDEST_INT)
9690     {
9691       bool negative = ((val >> (bits - 1)) & 1) != 0;
9692       if (negative)
9693         val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
9694       else
9695         val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
9696     }
9697
9698   return val;
9699 }
9700
9701 /* If TYPE is an integral type, return an equivalent type which is
9702     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
9703     return TYPE itself.  */
9704
9705 tree
9706 signed_or_unsigned_type_for (int unsignedp, tree type)
9707 {
9708   tree t = type;
9709   if (POINTER_TYPE_P (type))
9710     {
9711       /* If the pointer points to the normal address space, use the
9712          size_type_node.  Otherwise use an appropriate size for the pointer
9713          based on the named address space it points to.  */
9714       if (!TYPE_ADDR_SPACE (TREE_TYPE (t)))
9715         t = size_type_node;
9716       else
9717         return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9718     }
9719
9720   if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
9721     return t;
9722
9723   return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9724 }
9725
9726 /* Returns unsigned variant of TYPE.  */
9727
9728 tree
9729 unsigned_type_for (tree type)
9730 {
9731   return signed_or_unsigned_type_for (1, type);
9732 }
9733
9734 /* Returns signed variant of TYPE.  */
9735
9736 tree
9737 signed_type_for (tree type)
9738 {
9739   return signed_or_unsigned_type_for (0, type);
9740 }
9741
9742 /* Returns the largest value obtainable by casting something in INNER type to
9743    OUTER type.  */
9744
9745 tree
9746 upper_bound_in_type (tree outer, tree inner)
9747 {
9748   unsigned HOST_WIDE_INT lo, hi;
9749   unsigned int det = 0;
9750   unsigned oprec = TYPE_PRECISION (outer);
9751   unsigned iprec = TYPE_PRECISION (inner);
9752   unsigned prec;
9753
9754   /* Compute a unique number for every combination.  */
9755   det |= (oprec > iprec) ? 4 : 0;
9756   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
9757   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
9758
9759   /* Determine the exponent to use.  */
9760   switch (det)
9761     {
9762     case 0:
9763     case 1:
9764       /* oprec <= iprec, outer: signed, inner: don't care.  */
9765       prec = oprec - 1;
9766       break;
9767     case 2:
9768     case 3:
9769       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
9770       prec = oprec;
9771       break;
9772     case 4:
9773       /* oprec > iprec, outer: signed, inner: signed.  */
9774       prec = iprec - 1;
9775       break;
9776     case 5:
9777       /* oprec > iprec, outer: signed, inner: unsigned.  */
9778       prec = iprec;
9779       break;
9780     case 6:
9781       /* oprec > iprec, outer: unsigned, inner: signed.  */
9782       prec = oprec;
9783       break;
9784     case 7:
9785       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
9786       prec = iprec;
9787       break;
9788     default:
9789       gcc_unreachable ();
9790     }
9791
9792   /* Compute 2^^prec - 1.  */
9793   if (prec <= HOST_BITS_PER_WIDE_INT)
9794     {
9795       hi = 0;
9796       lo = ((~(unsigned HOST_WIDE_INT) 0)
9797             >> (HOST_BITS_PER_WIDE_INT - prec));
9798     }
9799   else
9800     {
9801       hi = ((~(unsigned HOST_WIDE_INT) 0)
9802             >> (2 * HOST_BITS_PER_WIDE_INT - prec));
9803       lo = ~(unsigned HOST_WIDE_INT) 0;
9804     }
9805
9806   return build_int_cst_wide (outer, lo, hi);
9807 }
9808
9809 /* Returns the smallest value obtainable by casting something in INNER type to
9810    OUTER type.  */
9811
9812 tree
9813 lower_bound_in_type (tree outer, tree inner)
9814 {
9815   unsigned HOST_WIDE_INT lo, hi;
9816   unsigned oprec = TYPE_PRECISION (outer);
9817   unsigned iprec = TYPE_PRECISION (inner);
9818
9819   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
9820      and obtain 0.  */
9821   if (TYPE_UNSIGNED (outer)
9822       /* If we are widening something of an unsigned type, OUTER type
9823          contains all values of INNER type.  In particular, both INNER
9824          and OUTER types have zero in common.  */
9825       || (oprec > iprec && TYPE_UNSIGNED (inner)))
9826     lo = hi = 0;
9827   else
9828     {
9829       /* If we are widening a signed type to another signed type, we
9830          want to obtain -2^^(iprec-1).  If we are keeping the
9831          precision or narrowing to a signed type, we want to obtain
9832          -2^(oprec-1).  */
9833       unsigned prec = oprec > iprec ? iprec : oprec;
9834
9835       if (prec <= HOST_BITS_PER_WIDE_INT)
9836         {
9837           hi = ~(unsigned HOST_WIDE_INT) 0;
9838           lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
9839         }
9840       else
9841         {
9842           hi = ((~(unsigned HOST_WIDE_INT) 0)
9843                 << (prec - HOST_BITS_PER_WIDE_INT - 1));
9844           lo = 0;
9845         }
9846     }
9847
9848   return build_int_cst_wide (outer, lo, hi);
9849 }
9850
9851 /* Return nonzero if two operands that are suitable for PHI nodes are
9852    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
9853    SSA_NAME or invariant.  Note that this is strictly an optimization.
9854    That is, callers of this function can directly call operand_equal_p
9855    and get the same result, only slower.  */
9856
9857 int
9858 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
9859 {
9860   if (arg0 == arg1)
9861     return 1;
9862   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
9863     return 0;
9864   return operand_equal_p (arg0, arg1, 0);
9865 }
9866
9867 /* Returns number of zeros at the end of binary representation of X.
9868
9869    ??? Use ffs if available?  */
9870
9871 tree
9872 num_ending_zeros (const_tree x)
9873 {
9874   unsigned HOST_WIDE_INT fr, nfr;
9875   unsigned num, abits;
9876   tree type = TREE_TYPE (x);
9877
9878   if (TREE_INT_CST_LOW (x) == 0)
9879     {
9880       num = HOST_BITS_PER_WIDE_INT;
9881       fr = TREE_INT_CST_HIGH (x);
9882     }
9883   else
9884     {
9885       num = 0;
9886       fr = TREE_INT_CST_LOW (x);
9887     }
9888
9889   for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
9890     {
9891       nfr = fr >> abits;
9892       if (nfr << abits == fr)
9893         {
9894           num += abits;
9895           fr = nfr;
9896         }
9897     }
9898
9899   if (num > TYPE_PRECISION (type))
9900     num = TYPE_PRECISION (type);
9901
9902   return build_int_cst_type (type, num);
9903 }
9904
9905
9906 #define WALK_SUBTREE(NODE)                              \
9907   do                                                    \
9908     {                                                   \
9909       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
9910       if (result)                                       \
9911         return result;                                  \
9912     }                                                   \
9913   while (0)
9914
9915 /* This is a subroutine of walk_tree that walks field of TYPE that are to
9916    be walked whenever a type is seen in the tree.  Rest of operands and return
9917    value are as for walk_tree.  */
9918
9919 static tree
9920 walk_type_fields (tree type, walk_tree_fn func, void *data,
9921                   struct pointer_set_t *pset, walk_tree_lh lh)
9922 {
9923   tree result = NULL_TREE;
9924
9925   switch (TREE_CODE (type))
9926     {
9927     case POINTER_TYPE:
9928     case REFERENCE_TYPE:
9929       /* We have to worry about mutually recursive pointers.  These can't
9930          be written in C.  They can in Ada.  It's pathological, but
9931          there's an ACATS test (c38102a) that checks it.  Deal with this
9932          by checking if we're pointing to another pointer, that one
9933          points to another pointer, that one does too, and we have no htab.
9934          If so, get a hash table.  We check three levels deep to avoid
9935          the cost of the hash table if we don't need one.  */
9936       if (POINTER_TYPE_P (TREE_TYPE (type))
9937           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
9938           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
9939           && !pset)
9940         {
9941           result = walk_tree_without_duplicates (&TREE_TYPE (type),
9942                                                  func, data);
9943           if (result)
9944             return result;
9945
9946           break;
9947         }
9948
9949       /* ... fall through ... */
9950
9951     case COMPLEX_TYPE:
9952       WALK_SUBTREE (TREE_TYPE (type));
9953       break;
9954
9955     case METHOD_TYPE:
9956       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
9957
9958       /* Fall through.  */
9959
9960     case FUNCTION_TYPE:
9961       WALK_SUBTREE (TREE_TYPE (type));
9962       {
9963         tree arg;
9964
9965         /* We never want to walk into default arguments.  */
9966         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
9967           WALK_SUBTREE (TREE_VALUE (arg));
9968       }
9969       break;
9970
9971     case ARRAY_TYPE:
9972       /* Don't follow this nodes's type if a pointer for fear that
9973          we'll have infinite recursion.  If we have a PSET, then we
9974          need not fear.  */
9975       if (pset
9976           || (!POINTER_TYPE_P (TREE_TYPE (type))
9977               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
9978         WALK_SUBTREE (TREE_TYPE (type));
9979       WALK_SUBTREE (TYPE_DOMAIN (type));
9980       break;
9981
9982     case OFFSET_TYPE:
9983       WALK_SUBTREE (TREE_TYPE (type));
9984       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
9985       break;
9986
9987     default:
9988       break;
9989     }
9990
9991   return NULL_TREE;
9992 }
9993
9994 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
9995    called with the DATA and the address of each sub-tree.  If FUNC returns a
9996    non-NULL value, the traversal is stopped, and the value returned by FUNC
9997    is returned.  If PSET is non-NULL it is used to record the nodes visited,
9998    and to avoid visiting a node more than once.  */
9999
10000 tree
10001 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10002              struct pointer_set_t *pset, walk_tree_lh lh)
10003 {
10004   enum tree_code code;
10005   int walk_subtrees;
10006   tree result;
10007
10008 #define WALK_SUBTREE_TAIL(NODE)                         \
10009   do                                                    \
10010     {                                                   \
10011        tp = & (NODE);                                   \
10012        goto tail_recurse;                               \
10013     }                                                   \
10014   while (0)
10015
10016  tail_recurse:
10017   /* Skip empty subtrees.  */
10018   if (!*tp)
10019     return NULL_TREE;
10020
10021   /* Don't walk the same tree twice, if the user has requested
10022      that we avoid doing so.  */
10023   if (pset && pointer_set_insert (pset, *tp))
10024     return NULL_TREE;
10025
10026   /* Call the function.  */
10027   walk_subtrees = 1;
10028   result = (*func) (tp, &walk_subtrees, data);
10029
10030   /* If we found something, return it.  */
10031   if (result)
10032     return result;
10033
10034   code = TREE_CODE (*tp);
10035
10036   /* Even if we didn't, FUNC may have decided that there was nothing
10037      interesting below this point in the tree.  */
10038   if (!walk_subtrees)
10039     {
10040       /* But we still need to check our siblings.  */
10041       if (code == TREE_LIST)
10042         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10043       else if (code == OMP_CLAUSE)
10044         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10045       else
10046         return NULL_TREE;
10047     }
10048
10049   if (lh)
10050     {
10051       result = (*lh) (tp, &walk_subtrees, func, data, pset);
10052       if (result || !walk_subtrees)
10053         return result;
10054     }
10055
10056   switch (code)
10057     {
10058     case ERROR_MARK:
10059     case IDENTIFIER_NODE:
10060     case INTEGER_CST:
10061     case REAL_CST:
10062     case FIXED_CST:
10063     case VECTOR_CST:
10064     case STRING_CST:
10065     case BLOCK:
10066     case PLACEHOLDER_EXPR:
10067     case SSA_NAME:
10068     case FIELD_DECL:
10069     case RESULT_DECL:
10070       /* None of these have subtrees other than those already walked
10071          above.  */
10072       break;
10073
10074     case TREE_LIST:
10075       WALK_SUBTREE (TREE_VALUE (*tp));
10076       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10077       break;
10078
10079     case TREE_VEC:
10080       {
10081         int len = TREE_VEC_LENGTH (*tp);
10082
10083         if (len == 0)
10084           break;
10085
10086         /* Walk all elements but the first.  */
10087         while (--len)
10088           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
10089
10090         /* Now walk the first one as a tail call.  */
10091         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
10092       }
10093
10094     case COMPLEX_CST:
10095       WALK_SUBTREE (TREE_REALPART (*tp));
10096       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
10097
10098     case CONSTRUCTOR:
10099       {
10100         unsigned HOST_WIDE_INT idx;
10101         constructor_elt *ce;
10102
10103         for (idx = 0;
10104              VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
10105              idx++)
10106           WALK_SUBTREE (ce->value);
10107       }
10108       break;
10109
10110     case SAVE_EXPR:
10111       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
10112
10113     case BIND_EXPR:
10114       {
10115         tree decl;
10116         for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
10117           {
10118             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
10119                into declarations that are just mentioned, rather than
10120                declared; they don't really belong to this part of the tree.
10121                And, we can see cycles: the initializer for a declaration
10122                can refer to the declaration itself.  */
10123             WALK_SUBTREE (DECL_INITIAL (decl));
10124             WALK_SUBTREE (DECL_SIZE (decl));
10125             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
10126           }
10127         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
10128       }
10129
10130     case STATEMENT_LIST:
10131       {
10132         tree_stmt_iterator i;
10133         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
10134           WALK_SUBTREE (*tsi_stmt_ptr (i));
10135       }
10136       break;
10137
10138     case OMP_CLAUSE:
10139       switch (OMP_CLAUSE_CODE (*tp))
10140         {
10141         case OMP_CLAUSE_PRIVATE:
10142         case OMP_CLAUSE_SHARED:
10143         case OMP_CLAUSE_FIRSTPRIVATE:
10144         case OMP_CLAUSE_COPYIN:
10145         case OMP_CLAUSE_COPYPRIVATE:
10146         case OMP_CLAUSE_IF:
10147         case OMP_CLAUSE_NUM_THREADS:
10148         case OMP_CLAUSE_SCHEDULE:
10149           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
10150           /* FALLTHRU */
10151
10152         case OMP_CLAUSE_NOWAIT:
10153         case OMP_CLAUSE_ORDERED:
10154         case OMP_CLAUSE_DEFAULT:
10155         case OMP_CLAUSE_UNTIED:
10156           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10157
10158         case OMP_CLAUSE_LASTPRIVATE:
10159           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
10160           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
10161           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10162
10163         case OMP_CLAUSE_COLLAPSE:
10164           {
10165             int i;
10166             for (i = 0; i < 3; i++)
10167               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10168             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10169           }
10170
10171         case OMP_CLAUSE_REDUCTION:
10172           {
10173             int i;
10174             for (i = 0; i < 4; i++)
10175               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10176             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10177           }
10178
10179         default:
10180           gcc_unreachable ();
10181         }
10182       break;
10183
10184     case TARGET_EXPR:
10185       {
10186         int i, len;
10187
10188         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10189            But, we only want to walk once.  */
10190         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
10191         for (i = 0; i < len; ++i)
10192           WALK_SUBTREE (TREE_OPERAND (*tp, i));
10193         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
10194       }
10195
10196     case DECL_EXPR:
10197       /* If this is a TYPE_DECL, walk into the fields of the type that it's
10198          defining.  We only want to walk into these fields of a type in this
10199          case and not in the general case of a mere reference to the type.
10200
10201          The criterion is as follows: if the field can be an expression, it
10202          must be walked only here.  This should be in keeping with the fields
10203          that are directly gimplified in gimplify_type_sizes in order for the
10204          mark/copy-if-shared/unmark machinery of the gimplifier to work with
10205          variable-sized types.
10206
10207          Note that DECLs get walked as part of processing the BIND_EXPR.  */
10208       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
10209         {
10210           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
10211           if (TREE_CODE (*type_p) == ERROR_MARK)
10212             return NULL_TREE;
10213
10214           /* Call the function for the type.  See if it returns anything or
10215              doesn't want us to continue.  If we are to continue, walk both
10216              the normal fields and those for the declaration case.  */
10217           result = (*func) (type_p, &walk_subtrees, data);
10218           if (result || !walk_subtrees)
10219             return result;
10220
10221           result = walk_type_fields (*type_p, func, data, pset, lh);
10222           if (result)
10223             return result;
10224
10225           /* If this is a record type, also walk the fields.  */
10226           if (RECORD_OR_UNION_TYPE_P (*type_p))
10227             {
10228               tree field;
10229
10230               for (field = TYPE_FIELDS (*type_p); field;
10231                    field = TREE_CHAIN (field))
10232                 {
10233                   /* We'd like to look at the type of the field, but we can
10234                      easily get infinite recursion.  So assume it's pointed
10235                      to elsewhere in the tree.  Also, ignore things that
10236                      aren't fields.  */
10237                   if (TREE_CODE (field) != FIELD_DECL)
10238                     continue;
10239
10240                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
10241                   WALK_SUBTREE (DECL_SIZE (field));
10242                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
10243                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10244                     WALK_SUBTREE (DECL_QUALIFIER (field));
10245                 }
10246             }
10247
10248           /* Same for scalar types.  */
10249           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
10250                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
10251                    || TREE_CODE (*type_p) == INTEGER_TYPE
10252                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
10253                    || TREE_CODE (*type_p) == REAL_TYPE)
10254             {
10255               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
10256               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
10257             }
10258
10259           WALK_SUBTREE (TYPE_SIZE (*type_p));
10260           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
10261         }
10262       /* FALLTHRU */
10263
10264     default:
10265       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
10266         {
10267           int i, len;
10268
10269           /* Walk over all the sub-trees of this operand.  */
10270           len = TREE_OPERAND_LENGTH (*tp);
10271
10272           /* Go through the subtrees.  We need to do this in forward order so
10273              that the scope of a FOR_EXPR is handled properly.  */
10274           if (len)
10275             {
10276               for (i = 0; i < len - 1; ++i)
10277                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
10278               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
10279             }
10280         }
10281       /* If this is a type, walk the needed fields in the type.  */
10282       else if (TYPE_P (*tp))
10283         return walk_type_fields (*tp, func, data, pset, lh);
10284       break;
10285     }
10286
10287   /* We didn't find what we were looking for.  */
10288   return NULL_TREE;
10289
10290 #undef WALK_SUBTREE_TAIL
10291 }
10292 #undef WALK_SUBTREE
10293
10294 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
10295
10296 tree
10297 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
10298                                 walk_tree_lh lh)
10299 {
10300   tree result;
10301   struct pointer_set_t *pset;
10302
10303   pset = pointer_set_create ();
10304   result = walk_tree_1 (tp, func, data, pset, lh);
10305   pointer_set_destroy (pset);
10306   return result;
10307 }
10308
10309
10310 tree *
10311 tree_block (tree t)
10312 {
10313   char const c = TREE_CODE_CLASS (TREE_CODE (t));
10314
10315   if (IS_EXPR_CODE_CLASS (c))
10316     return &t->exp.block;
10317   gcc_unreachable ();
10318   return NULL;
10319 }
10320
10321 /* Build and return a TREE_LIST of arguments in the CALL_EXPR exp.
10322    FIXME: don't use this function.  It exists for compatibility with
10323    the old representation of CALL_EXPRs where a list was used to hold the
10324    arguments.  Places that currently extract the arglist from a CALL_EXPR
10325    ought to be rewritten to use the CALL_EXPR itself.  */
10326 tree
10327 call_expr_arglist (tree exp)
10328 {
10329   tree arglist = NULL_TREE;
10330   int i;
10331   for (i = call_expr_nargs (exp) - 1; i >= 0; i--)
10332     arglist = tree_cons (NULL_TREE, CALL_EXPR_ARG (exp, i), arglist);
10333   return arglist;
10334 }
10335
10336
10337 /* Create a nameless artificial label and put it in the current
10338    function context.  The label has a location of LOC.  Returns the
10339    newly created label.  */
10340
10341 tree
10342 create_artificial_label (location_t loc)
10343 {
10344   tree lab = build_decl (loc,
10345                          LABEL_DECL, NULL_TREE, void_type_node);
10346
10347   DECL_ARTIFICIAL (lab) = 1;
10348   DECL_IGNORED_P (lab) = 1;
10349   DECL_CONTEXT (lab) = current_function_decl;
10350   return lab;
10351 }
10352
10353 /*  Given a tree, try to return a useful variable name that we can use
10354     to prefix a temporary that is being assigned the value of the tree.
10355     I.E. given  <temp> = &A, return A.  */
10356
10357 const char *
10358 get_name (tree t)
10359 {
10360   tree stripped_decl;
10361
10362   stripped_decl = t;
10363   STRIP_NOPS (stripped_decl);
10364   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
10365     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
10366   else
10367     {
10368       switch (TREE_CODE (stripped_decl))
10369         {
10370         case ADDR_EXPR:
10371           return get_name (TREE_OPERAND (stripped_decl, 0));
10372         default:
10373           return NULL;
10374         }
10375     }
10376 }
10377
10378 /* Return true if TYPE has a variable argument list.  */
10379
10380 bool
10381 stdarg_p (tree fntype)
10382 {
10383   function_args_iterator args_iter;
10384   tree n = NULL_TREE, t;
10385
10386   if (!fntype)
10387     return false;
10388
10389   FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
10390     {
10391       n = t;
10392     }
10393
10394   return n != NULL_TREE && n != void_type_node;
10395 }
10396
10397 /* Return true if TYPE has a prototype.  */
10398
10399 bool
10400 prototype_p (tree fntype)
10401 {
10402   tree t;
10403
10404   gcc_assert (fntype != NULL_TREE);
10405
10406   t = TYPE_ARG_TYPES (fntype);
10407   return (t != NULL_TREE);
10408 }
10409
10410 /* If BLOCK is inlined from an __attribute__((__artificial__))
10411    routine, return pointer to location from where it has been
10412    called.  */
10413 location_t *
10414 block_nonartificial_location (tree block)
10415 {
10416   location_t *ret = NULL;
10417
10418   while (block && TREE_CODE (block) == BLOCK
10419          && BLOCK_ABSTRACT_ORIGIN (block))
10420     {
10421       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
10422
10423       while (TREE_CODE (ao) == BLOCK
10424              && BLOCK_ABSTRACT_ORIGIN (ao)
10425              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
10426         ao = BLOCK_ABSTRACT_ORIGIN (ao);
10427
10428       if (TREE_CODE (ao) == FUNCTION_DECL)
10429         {
10430           /* If AO is an artificial inline, point RET to the
10431              call site locus at which it has been inlined and continue
10432              the loop, in case AO's caller is also an artificial
10433              inline.  */
10434           if (DECL_DECLARED_INLINE_P (ao)
10435               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
10436             ret = &BLOCK_SOURCE_LOCATION (block);
10437           else
10438             break;
10439         }
10440       else if (TREE_CODE (ao) != BLOCK)
10441         break;
10442
10443       block = BLOCK_SUPERCONTEXT (block);
10444     }
10445   return ret;
10446 }
10447
10448
10449 /* If EXP is inlined from an __attribute__((__artificial__))
10450    function, return the location of the original call expression.  */
10451
10452 location_t
10453 tree_nonartificial_location (tree exp)
10454 {
10455   location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
10456
10457   if (loc)
10458     return *loc;
10459   else
10460     return EXPR_LOCATION (exp);
10461 }
10462
10463
10464 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10465    nodes.  */
10466
10467 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
10468
10469 static hashval_t
10470 cl_option_hash_hash (const void *x)
10471 {
10472   const_tree const t = (const_tree) x;
10473   const char *p;
10474   size_t i;
10475   size_t len = 0;
10476   hashval_t hash = 0;
10477
10478   if (TREE_CODE (t) == OPTIMIZATION_NODE)
10479     {
10480       p = (const char *)TREE_OPTIMIZATION (t);
10481       len = sizeof (struct cl_optimization);
10482     }
10483
10484   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
10485     {
10486       p = (const char *)TREE_TARGET_OPTION (t);
10487       len = sizeof (struct cl_target_option);
10488     }
10489
10490   else
10491     gcc_unreachable ();
10492
10493   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10494      something else.  */
10495   for (i = 0; i < len; i++)
10496     if (p[i])
10497       hash = (hash << 4) ^ ((i << 2) | p[i]);
10498
10499   return hash;
10500 }
10501
10502 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
10503    TARGET_OPTION tree node) is the same as that given by *Y, which is the
10504    same.  */
10505
10506 static int
10507 cl_option_hash_eq (const void *x, const void *y)
10508 {
10509   const_tree const xt = (const_tree) x;
10510   const_tree const yt = (const_tree) y;
10511   const char *xp;
10512   const char *yp;
10513   size_t len;
10514
10515   if (TREE_CODE (xt) != TREE_CODE (yt))
10516     return 0;
10517
10518   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
10519     {
10520       xp = (const char *)TREE_OPTIMIZATION (xt);
10521       yp = (const char *)TREE_OPTIMIZATION (yt);
10522       len = sizeof (struct cl_optimization);
10523     }
10524
10525   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
10526     {
10527       xp = (const char *)TREE_TARGET_OPTION (xt);
10528       yp = (const char *)TREE_TARGET_OPTION (yt);
10529       len = sizeof (struct cl_target_option);
10530     }
10531
10532   else
10533     gcc_unreachable ();
10534
10535   return (memcmp (xp, yp, len) == 0);
10536 }
10537
10538 /* Build an OPTIMIZATION_NODE based on the current options.  */
10539
10540 tree
10541 build_optimization_node (void)
10542 {
10543   tree t;
10544   void **slot;
10545
10546   /* Use the cache of optimization nodes.  */
10547
10548   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node));
10549
10550   slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
10551   t = (tree) *slot;
10552   if (!t)
10553     {
10554       /* Insert this one into the hash table.  */
10555       t = cl_optimization_node;
10556       *slot = t;
10557
10558       /* Make a new node for next time round.  */
10559       cl_optimization_node = make_node (OPTIMIZATION_NODE);
10560     }
10561
10562   return t;
10563 }
10564
10565 /* Build a TARGET_OPTION_NODE based on the current options.  */
10566
10567 tree
10568 build_target_option_node (void)
10569 {
10570   tree t;
10571   void **slot;
10572
10573   /* Use the cache of optimization nodes.  */
10574
10575   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node));
10576
10577   slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
10578   t = (tree) *slot;
10579   if (!t)
10580     {
10581       /* Insert this one into the hash table.  */
10582       t = cl_target_option_node;
10583       *slot = t;
10584
10585       /* Make a new node for next time round.  */
10586       cl_target_option_node = make_node (TARGET_OPTION_NODE);
10587     }
10588
10589   return t;
10590 }
10591
10592 /* Determine the "ultimate origin" of a block.  The block may be an inlined
10593    instance of an inlined instance of a block which is local to an inline
10594    function, so we have to trace all of the way back through the origin chain
10595    to find out what sort of node actually served as the original seed for the
10596    given block.  */
10597
10598 tree
10599 block_ultimate_origin (const_tree block)
10600 {
10601   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
10602
10603   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10604      nodes in the function to point to themselves; ignore that if
10605      we're trying to output the abstract instance of this function.  */
10606   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
10607     return NULL_TREE;
10608
10609   if (immediate_origin == NULL_TREE)
10610     return NULL_TREE;
10611   else
10612     {
10613       tree ret_val;
10614       tree lookahead = immediate_origin;
10615
10616       do
10617         {
10618           ret_val = lookahead;
10619           lookahead = (TREE_CODE (ret_val) == BLOCK
10620                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
10621         }
10622       while (lookahead != NULL && lookahead != ret_val);
10623
10624       /* The block's abstract origin chain may not be the *ultimate* origin of
10625          the block. It could lead to a DECL that has an abstract origin set.
10626          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10627          will give us if it has one).  Note that DECL's abstract origins are
10628          supposed to be the most distant ancestor (or so decl_ultimate_origin
10629          claims), so we don't need to loop following the DECL origins.  */
10630       if (DECL_P (ret_val))
10631         return DECL_ORIGIN (ret_val);
10632
10633       return ret_val;
10634     }
10635 }
10636
10637 /* Return true if T1 and T2 are equivalent lists.  */
10638
10639 bool
10640 list_equal_p (const_tree t1, const_tree t2)
10641 {
10642   for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
10643     if (TREE_VALUE (t1) != TREE_VALUE (t2))
10644       return false;
10645   return !t1 && !t2;
10646 }
10647
10648 /* Return true iff conversion in EXP generates no instruction.  Mark
10649    it inline so that we fully inline into the stripping functions even
10650    though we have two uses of this function.  */
10651
10652 static inline bool
10653 tree_nop_conversion (const_tree exp)
10654 {
10655   tree outer_type, inner_type;
10656
10657   if (!CONVERT_EXPR_P (exp)
10658       && TREE_CODE (exp) != NON_LVALUE_EXPR)
10659     return false;
10660   if (TREE_OPERAND (exp, 0) == error_mark_node)
10661     return false;
10662
10663   outer_type = TREE_TYPE (exp);
10664   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10665
10666   if (!inner_type)
10667     return false;
10668
10669   /* Use precision rather then machine mode when we can, which gives
10670      the correct answer even for submode (bit-field) types.  */
10671   if ((INTEGRAL_TYPE_P (outer_type)
10672        || POINTER_TYPE_P (outer_type)
10673        || TREE_CODE (outer_type) == OFFSET_TYPE)
10674       && (INTEGRAL_TYPE_P (inner_type)
10675           || POINTER_TYPE_P (inner_type)
10676           || TREE_CODE (inner_type) == OFFSET_TYPE))
10677     return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
10678
10679   /* Otherwise fall back on comparing machine modes (e.g. for
10680      aggregate types, floats).  */
10681   return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
10682 }
10683
10684 /* Return true iff conversion in EXP generates no instruction.  Don't
10685    consider conversions changing the signedness.  */
10686
10687 static bool
10688 tree_sign_nop_conversion (const_tree exp)
10689 {
10690   tree outer_type, inner_type;
10691
10692   if (!tree_nop_conversion (exp))
10693     return false;
10694
10695   outer_type = TREE_TYPE (exp);
10696   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10697
10698   return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
10699           && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
10700 }
10701
10702 /* Strip conversions from EXP according to tree_nop_conversion and
10703    return the resulting expression.  */
10704
10705 tree
10706 tree_strip_nop_conversions (tree exp)
10707 {
10708   while (tree_nop_conversion (exp))
10709     exp = TREE_OPERAND (exp, 0);
10710   return exp;
10711 }
10712
10713 /* Strip conversions from EXP according to tree_sign_nop_conversion
10714    and return the resulting expression.  */
10715
10716 tree
10717 tree_strip_sign_nop_conversions (tree exp)
10718 {
10719   while (tree_sign_nop_conversion (exp))
10720     exp = TREE_OPERAND (exp, 0);
10721   return exp;
10722 }
10723
10724 static GTY(()) tree gcc_eh_personality_decl;
10725
10726 /* Return the GCC personality function decl.  */
10727
10728 tree
10729 lhd_gcc_personality (void)
10730 {
10731   if (!gcc_eh_personality_decl)
10732     gcc_eh_personality_decl
10733       = build_personality_function (USING_SJLJ_EXCEPTIONS
10734                                     ? "__gcc_personality_sj0"
10735                                     : "__gcc_personality_v0");
10736
10737   return gcc_eh_personality_decl;
10738 }
10739
10740 #include "gt-tree.h"