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