gcc/tree.c

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