gcc/tree.c

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