gcc/tree.c

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