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