gcc/tree.c

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