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 /* Return the pointer-type relevant for TBAA purposes from the
3917    gimple memory reference tree T.  This is the type to be used for
3918    the offset operand of MEM_REF or TARGET_MEM_REF replacements of T.  */
3919
3920 tree
3921 reference_alias_ptr_type (const_tree t)
3922 {
3923   const_tree base = t;
3924   while (handled_component_p (base))
3925     base = TREE_OPERAND (base, 0);
3926   if (TREE_CODE (base) == MEM_REF)
3927     return TREE_TYPE (TREE_OPERAND (base, 1));
3928   else if (TREE_CODE (base) == TARGET_MEM_REF
3929            || TREE_CODE (base) == MISALIGNED_INDIRECT_REF)
3930     return NULL_TREE;
3931   else
3932     return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (base)));
3933 }
3934
3935 /* Similar except don't specify the TREE_TYPE
3936    and leave the TREE_SIDE_EFFECTS as 0.
3937    It is permissible for arguments to be null,
3938    or even garbage if their values do not matter.  */
3939
3940 tree
3941 build_nt (enum tree_code code, ...)
3942 {
3943   tree t;
3944   int length;
3945   int i;
3946   va_list p;
3947
3948   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3949
3950   va_start (p, code);
3951
3952   t = make_node (code);
3953   length = TREE_CODE_LENGTH (code);
3954
3955   for (i = 0; i < length; i++)
3956     TREE_OPERAND (t, i) = va_arg (p, tree);
3957
3958   va_end (p);
3959   return t;
3960 }
3961
3962 /* Similar to build_nt, but for creating a CALL_EXPR object with a
3963    tree VEC.  */
3964
3965 tree
3966 build_nt_call_vec (tree fn, VEC(tree,gc) *args)
3967 {
3968   tree ret, t;
3969   unsigned int ix;
3970
3971   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
3972   CALL_EXPR_FN (ret) = fn;
3973   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3974   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
3975     CALL_EXPR_ARG (ret, ix) = t;
3976   return ret;
3977 }
3978 \f
3979 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3980    We do NOT enter this node in any sort of symbol table.
3981
3982    LOC is the location of the decl.
3983
3984    layout_decl is used to set up the decl's storage layout.
3985    Other slots are initialized to 0 or null pointers.  */
3986
3987 tree
3988 build_decl_stat (location_t loc, enum tree_code code, tree name,
3989                  tree type MEM_STAT_DECL)
3990 {
3991   tree t;
3992
3993   t = make_node_stat (code PASS_MEM_STAT);
3994   DECL_SOURCE_LOCATION (t) = loc;
3995
3996 /*  if (type == error_mark_node)
3997     type = integer_type_node; */
3998 /* That is not done, deliberately, so that having error_mark_node
3999    as the type can suppress useless errors in the use of this variable.  */
4000
4001   DECL_NAME (t) = name;
4002   TREE_TYPE (t) = type;
4003
4004   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4005     layout_decl (t, 0);
4006
4007   return t;
4008 }
4009
4010 /* Builds and returns function declaration with NAME and TYPE.  */
4011
4012 tree
4013 build_fn_decl (const char *name, tree type)
4014 {
4015   tree id = get_identifier (name);
4016   tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4017
4018   DECL_EXTERNAL (decl) = 1;
4019   TREE_PUBLIC (decl) = 1;
4020   DECL_ARTIFICIAL (decl) = 1;
4021   TREE_NOTHROW (decl) = 1;
4022
4023   return decl;
4024 }
4025
4026 \f
4027 /* BLOCK nodes are used to represent the structure of binding contours
4028    and declarations, once those contours have been exited and their contents
4029    compiled.  This information is used for outputting debugging info.  */
4030
4031 tree
4032 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4033 {
4034   tree block = make_node (BLOCK);
4035
4036   BLOCK_VARS (block) = vars;
4037   BLOCK_SUBBLOCKS (block) = subblocks;
4038   BLOCK_SUPERCONTEXT (block) = supercontext;
4039   BLOCK_CHAIN (block) = chain;
4040   return block;
4041 }
4042
4043 \f
4044 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4045
4046    LOC is the location to use in tree T.  */
4047
4048 void
4049 protected_set_expr_location (tree t, location_t loc)
4050 {
4051   if (t && CAN_HAVE_LOCATION_P (t))
4052     SET_EXPR_LOCATION (t, loc);
4053 }
4054 \f
4055 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4056    is ATTRIBUTE.  */
4057
4058 tree
4059 build_decl_attribute_variant (tree ddecl, tree attribute)
4060 {
4061   DECL_ATTRIBUTES (ddecl) = attribute;
4062   return ddecl;
4063 }
4064
4065 /* Borrowed from hashtab.c iterative_hash implementation.  */
4066 #define mix(a,b,c) \
4067 { \
4068   a -= b; a -= c; a ^= (c>>13); \
4069   b -= c; b -= a; b ^= (a<< 8); \
4070   c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4071   a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4072   b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4073   c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4074   a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4075   b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4076   c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4077 }
4078
4079
4080 /* Produce good hash value combining VAL and VAL2.  */
4081 hashval_t
4082 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
4083 {
4084   /* the golden ratio; an arbitrary value.  */
4085   hashval_t a = 0x9e3779b9;
4086
4087   mix (a, val, val2);
4088   return val2;
4089 }
4090
4091 /* Produce good hash value combining VAL and VAL2.  */
4092 hashval_t
4093 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4094 {
4095   if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4096     return iterative_hash_hashval_t (val, val2);
4097   else
4098     {
4099       hashval_t a = (hashval_t) val;
4100       /* Avoid warnings about shifting of more than the width of the type on
4101          hosts that won't execute this path.  */
4102       int zero = 0;
4103       hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4104       mix (a, b, val2);
4105       if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4106         {
4107           hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4108           hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4109           mix (a, b, val2);
4110         }
4111       return val2;
4112     }
4113 }
4114
4115 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4116    is ATTRIBUTE and its qualifiers are QUALS.
4117
4118    Record such modified types already made so we don't make duplicates.  */
4119
4120 tree
4121 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4122 {
4123   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4124     {
4125       hashval_t hashcode = 0;
4126       tree ntype;
4127       enum tree_code code = TREE_CODE (ttype);
4128
4129       /* Building a distinct copy of a tagged type is inappropriate; it
4130          causes breakage in code that expects there to be a one-to-one
4131          relationship between a struct and its fields.
4132          build_duplicate_type is another solution (as used in
4133          handle_transparent_union_attribute), but that doesn't play well
4134          with the stronger C++ type identity model.  */
4135       if (TREE_CODE (ttype) == RECORD_TYPE
4136           || TREE_CODE (ttype) == UNION_TYPE
4137           || TREE_CODE (ttype) == QUAL_UNION_TYPE
4138           || TREE_CODE (ttype) == ENUMERAL_TYPE)
4139         {
4140           warning (OPT_Wattributes,
4141                    "ignoring attributes applied to %qT after definition",
4142                    TYPE_MAIN_VARIANT (ttype));
4143           return build_qualified_type (ttype, quals);
4144         }
4145
4146       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4147       ntype = build_distinct_type_copy (ttype);
4148
4149       TYPE_ATTRIBUTES (ntype) = attribute;
4150
4151       hashcode = iterative_hash_object (code, hashcode);
4152       if (TREE_TYPE (ntype))
4153         hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4154                                           hashcode);
4155       hashcode = attribute_hash_list (attribute, hashcode);
4156
4157       switch (TREE_CODE (ntype))
4158         {
4159         case FUNCTION_TYPE:
4160           hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4161           break;
4162         case ARRAY_TYPE:
4163           if (TYPE_DOMAIN (ntype))
4164             hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4165                                               hashcode);
4166           break;
4167         case INTEGER_TYPE:
4168           hashcode = iterative_hash_object
4169             (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4170           hashcode = iterative_hash_object
4171             (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4172           break;
4173         case REAL_TYPE:
4174         case FIXED_POINT_TYPE:
4175           {
4176             unsigned int precision = TYPE_PRECISION (ntype);
4177             hashcode = iterative_hash_object (precision, hashcode);
4178           }
4179           break;
4180         default:
4181           break;
4182         }
4183
4184       ntype = type_hash_canon (hashcode, ntype);
4185
4186       /* If the target-dependent attributes make NTYPE different from
4187          its canonical type, we will need to use structural equality
4188          checks for this type. */
4189       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4190           || !targetm.comp_type_attributes (ntype, ttype))
4191         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4192       else if (TYPE_CANONICAL (ntype) == ntype)
4193         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4194
4195       ttype = build_qualified_type (ntype, quals);
4196     }
4197   else if (TYPE_QUALS (ttype) != quals)
4198     ttype = build_qualified_type (ttype, quals);
4199
4200   return ttype;
4201 }
4202
4203
4204 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4205    is ATTRIBUTE.
4206
4207    Record such modified types already made so we don't make duplicates.  */
4208
4209 tree
4210 build_type_attribute_variant (tree ttype, tree attribute)
4211 {
4212   return build_type_attribute_qual_variant (ttype, attribute,
4213                                             TYPE_QUALS (ttype));
4214 }
4215
4216
4217 /* Reset the expression *EXPR_P, a size or position.
4218
4219    ??? We could reset all non-constant sizes or positions.  But it's cheap
4220    enough to not do so and refrain from adding workarounds to dwarf2out.c.
4221
4222    We need to reset self-referential sizes or positions because they cannot
4223    be gimplified and thus can contain a CALL_EXPR after the gimplification
4224    is finished, which will run afoul of LTO streaming.  And they need to be
4225    reset to something essentially dummy but not constant, so as to preserve
4226    the properties of the object they are attached to.  */
4227
4228 static inline void
4229 free_lang_data_in_one_sizepos (tree *expr_p)
4230 {
4231   tree expr = *expr_p;
4232   if (CONTAINS_PLACEHOLDER_P (expr))
4233     *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
4234 }
4235
4236
4237 /* Reset all the fields in a binfo node BINFO.  We only keep
4238    BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref.  */
4239
4240 static void
4241 free_lang_data_in_binfo (tree binfo)
4242 {
4243   unsigned i;
4244   tree t;
4245
4246   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4247
4248   BINFO_VTABLE (binfo) = NULL_TREE;
4249   BINFO_BASE_ACCESSES (binfo) = NULL;
4250   BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4251   BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4252
4253   for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (binfo), i, t); i++)
4254     free_lang_data_in_binfo (t);
4255 }
4256
4257
4258 /* Reset all language specific information still present in TYPE.  */
4259
4260 static void
4261 free_lang_data_in_type (tree type)
4262 {
4263   gcc_assert (TYPE_P (type));
4264
4265   /* Give the FE a chance to remove its own data first.  */
4266   lang_hooks.free_lang_data (type);
4267
4268   TREE_LANG_FLAG_0 (type) = 0;
4269   TREE_LANG_FLAG_1 (type) = 0;
4270   TREE_LANG_FLAG_2 (type) = 0;
4271   TREE_LANG_FLAG_3 (type) = 0;
4272   TREE_LANG_FLAG_4 (type) = 0;
4273   TREE_LANG_FLAG_5 (type) = 0;
4274   TREE_LANG_FLAG_6 (type) = 0;
4275
4276   if (TREE_CODE (type) == FUNCTION_TYPE)
4277     {
4278       /* Remove the const and volatile qualifiers from arguments.  The
4279          C++ front end removes them, but the C front end does not,
4280          leading to false ODR violation errors when merging two
4281          instances of the same function signature compiled by
4282          different front ends.  */
4283       tree p;
4284
4285       for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4286         {
4287           tree arg_type = TREE_VALUE (p);
4288
4289           if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4290             {
4291               int quals = TYPE_QUALS (arg_type)
4292                           & ~TYPE_QUAL_CONST
4293                           & ~TYPE_QUAL_VOLATILE;
4294               TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4295               free_lang_data_in_type (TREE_VALUE (p));
4296             }
4297         }
4298     }
4299
4300   /* Remove members that are not actually FIELD_DECLs from the field
4301      list of an aggregate.  These occur in C++.  */
4302   if (RECORD_OR_UNION_TYPE_P (type))
4303     {
4304       tree prev, member;
4305
4306       /* Note that TYPE_FIELDS can be shared across distinct
4307          TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
4308          to be removed, we cannot set its TREE_CHAIN to NULL.
4309          Otherwise, we would not be able to find all the other fields
4310          in the other instances of this TREE_TYPE.
4311
4312          This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
4313       prev = NULL_TREE;
4314       member = TYPE_FIELDS (type);
4315       while (member)
4316         {
4317           if (TREE_CODE (member) == FIELD_DECL)
4318             {
4319               if (prev)
4320                 TREE_CHAIN (prev) = member;
4321               else
4322                 TYPE_FIELDS (type) = member;
4323               prev = member;
4324             }
4325
4326           member = TREE_CHAIN (member);
4327         }
4328
4329       if (prev)
4330         TREE_CHAIN (prev) = NULL_TREE;
4331       else
4332         TYPE_FIELDS (type) = NULL_TREE;
4333
4334       TYPE_METHODS (type) = NULL_TREE;
4335       if (TYPE_BINFO (type))
4336         free_lang_data_in_binfo (TYPE_BINFO (type));
4337     }
4338   else
4339     {
4340       /* For non-aggregate types, clear out the language slot (which
4341          overloads TYPE_BINFO).  */
4342       TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4343
4344       if (INTEGRAL_TYPE_P (type)
4345           || SCALAR_FLOAT_TYPE_P (type)
4346           || FIXED_POINT_TYPE_P (type))
4347         {
4348           free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
4349           free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
4350         }
4351     }
4352
4353   free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
4354   free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
4355
4356   if (debug_info_level < DINFO_LEVEL_TERSE
4357       || (TYPE_CONTEXT (type)
4358           && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
4359           && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL))
4360     TYPE_CONTEXT (type) = NULL_TREE;
4361
4362   if (debug_info_level < DINFO_LEVEL_TERSE)
4363     TYPE_STUB_DECL (type) = NULL_TREE;
4364 }
4365
4366
4367 /* Return true if DECL may need an assembler name to be set.  */
4368
4369 static inline bool
4370 need_assembler_name_p (tree decl)
4371 {
4372   /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
4373   if (TREE_CODE (decl) != FUNCTION_DECL
4374       && TREE_CODE (decl) != VAR_DECL)
4375     return false;
4376
4377   /* If DECL already has its assembler name set, it does not need a
4378      new one.  */
4379   if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4380       || DECL_ASSEMBLER_NAME_SET_P (decl))
4381     return false;
4382
4383   /* Abstract decls do not need an assembler name.  */
4384   if (DECL_ABSTRACT (decl))
4385     return false;
4386
4387   /* For VAR_DECLs, only static, public and external symbols need an
4388      assembler name.  */
4389   if (TREE_CODE (decl) == VAR_DECL
4390       && !TREE_STATIC (decl)
4391       && !TREE_PUBLIC (decl)
4392       && !DECL_EXTERNAL (decl))
4393     return false;
4394
4395   if (TREE_CODE (decl) == FUNCTION_DECL)
4396     {
4397       /* Do not set assembler name on builtins.  Allow RTL expansion to
4398          decide whether to expand inline or via a regular call.  */
4399       if (DECL_BUILT_IN (decl)
4400           && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4401         return false;
4402
4403       /* Functions represented in the callgraph need an assembler name.  */
4404       if (cgraph_get_node (decl) != NULL)
4405         return true;
4406
4407       /* Unused and not public functions don't need an assembler name.  */
4408       if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
4409         return false;
4410     }
4411
4412   return true;
4413 }
4414
4415
4416 /* Remove all the non-variable decls from BLOCK.  LOCALS is the set of
4417    variables in DECL_STRUCT_FUNCTION (FN)->local_decls.  Every decl
4418    in BLOCK that is not in LOCALS is removed.  */
4419
4420 static void
4421 free_lang_data_in_block (tree fn, tree block, struct pointer_set_t *locals)
4422 {
4423   tree *tp, t;
4424
4425   tp = &BLOCK_VARS (block);
4426   while (*tp)
4427     {
4428       if (!pointer_set_contains (locals, *tp))
4429         *tp = TREE_CHAIN (*tp);
4430       else
4431         tp = &TREE_CHAIN (*tp);
4432     }
4433
4434   for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
4435     free_lang_data_in_block (fn, t, locals);
4436 }
4437
4438
4439 /* Reset all language specific information still present in symbol
4440    DECL.  */
4441
4442 static void
4443 free_lang_data_in_decl (tree decl)
4444 {
4445   gcc_assert (DECL_P (decl));
4446
4447   /* Give the FE a chance to remove its own data first.  */
4448   lang_hooks.free_lang_data (decl);
4449
4450   TREE_LANG_FLAG_0 (decl) = 0;
4451   TREE_LANG_FLAG_1 (decl) = 0;
4452   TREE_LANG_FLAG_2 (decl) = 0;
4453   TREE_LANG_FLAG_3 (decl) = 0;
4454   TREE_LANG_FLAG_4 (decl) = 0;
4455   TREE_LANG_FLAG_5 (decl) = 0;
4456   TREE_LANG_FLAG_6 (decl) = 0;
4457
4458   /* Identifiers need not have a type.  */
4459   if (DECL_NAME (decl))
4460     TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
4461
4462   /* Ignore any intervening types, because we are going to clear their
4463      TYPE_CONTEXT fields.  */
4464   if (TREE_CODE (decl) != FIELD_DECL
4465       && TREE_CODE (decl) != FUNCTION_DECL)
4466     DECL_CONTEXT (decl) = decl_function_context (decl);
4467
4468   if (DECL_CONTEXT (decl)
4469       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
4470     DECL_CONTEXT (decl) = NULL_TREE;
4471
4472  if (TREE_CODE (decl) == VAR_DECL)
4473    {
4474      tree context = DECL_CONTEXT (decl);
4475
4476      if (context)
4477        {
4478          enum tree_code code = TREE_CODE (context);
4479          if (code == FUNCTION_DECL && DECL_ABSTRACT (context))
4480            {
4481              /* Do not clear the decl context here, that will promote
4482                 all vars to global ones.  */
4483              DECL_INITIAL (decl) = NULL_TREE;
4484            }
4485
4486          if (TREE_STATIC (decl))
4487            DECL_CONTEXT (decl) = NULL_TREE;
4488        }
4489    }
4490
4491   free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
4492   free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
4493   if (TREE_CODE (decl) == FIELD_DECL)
4494     free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
4495
4496  /* DECL_FCONTEXT is only used for debug info generation.  */
4497  if (TREE_CODE (decl) == FIELD_DECL
4498      && debug_info_level < DINFO_LEVEL_TERSE)
4499    DECL_FCONTEXT (decl) = NULL_TREE;
4500
4501  if (TREE_CODE (decl) == FUNCTION_DECL)
4502     {
4503       if (gimple_has_body_p (decl))
4504         {
4505           tree t;
4506           struct pointer_set_t *locals;
4507
4508           /* If DECL has a gimple body, then the context for its
4509              arguments must be DECL.  Otherwise, it doesn't really
4510              matter, as we will not be emitting any code for DECL.  In
4511              general, there may be other instances of DECL created by
4512              the front end and since PARM_DECLs are generally shared,
4513              their DECL_CONTEXT changes as the replicas of DECL are
4514              created.  The only time where DECL_CONTEXT is important
4515              is for the FUNCTION_DECLs that have a gimple body (since
4516              the PARM_DECL will be used in the function's body).  */
4517           for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
4518             DECL_CONTEXT (t) = decl;
4519
4520           /* Collect all the symbols declared in DECL.  */
4521           locals = pointer_set_create ();
4522           t = DECL_STRUCT_FUNCTION (decl)->local_decls;
4523           for (; t; t = TREE_CHAIN (t))
4524             {
4525               pointer_set_insert (locals, TREE_VALUE (t));
4526
4527               /* All the local symbols should have DECL as their
4528                  context.  */
4529               DECL_CONTEXT (TREE_VALUE (t)) = decl;
4530             }
4531
4532           /* Get rid of any decl not in local_decls.  */
4533           free_lang_data_in_block (decl, DECL_INITIAL (decl), locals);
4534
4535           pointer_set_destroy (locals);
4536         }
4537
4538       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4539          At this point, it is not needed anymore.  */
4540       DECL_SAVED_TREE (decl) = NULL_TREE;
4541     }
4542   else if (TREE_CODE (decl) == VAR_DECL)
4543     {
4544       tree expr = DECL_DEBUG_EXPR (decl);
4545       if (expr
4546           && TREE_CODE (expr) == VAR_DECL
4547           && !TREE_STATIC (expr) && !DECL_EXTERNAL (expr))
4548         SET_DECL_DEBUG_EXPR (decl, NULL_TREE);
4549
4550       if (DECL_EXTERNAL (decl)
4551           && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
4552         DECL_INITIAL (decl) = NULL_TREE;
4553     }
4554   else if (TREE_CODE (decl) == TYPE_DECL)
4555     {
4556       DECL_INITIAL (decl) = NULL_TREE;
4557
4558       /* DECL_CONTEXT is overloaded as DECL_FIELD_CONTEXT for
4559          FIELD_DECLs, which should be preserved.  Otherwise,
4560          we shouldn't be concerned with source-level lexical
4561          nesting beyond this point. */
4562       DECL_CONTEXT (decl) = NULL_TREE;
4563     }
4564 }
4565
4566
4567 /* Data used when collecting DECLs and TYPEs for language data removal.  */
4568
4569 struct free_lang_data_d
4570 {
4571   /* Worklist to avoid excessive recursion.  */
4572   VEC(tree,heap) *worklist;
4573
4574   /* Set of traversed objects.  Used to avoid duplicate visits.  */
4575   struct pointer_set_t *pset;
4576
4577   /* Array of symbols to process with free_lang_data_in_decl.  */
4578   VEC(tree,heap) *decls;
4579
4580   /* Array of types to process with free_lang_data_in_type.  */
4581   VEC(tree,heap) *types;
4582 };
4583
4584
4585 /* Save all language fields needed to generate proper debug information
4586    for DECL.  This saves most fields cleared out by free_lang_data_in_decl.  */
4587
4588 static void
4589 save_debug_info_for_decl (tree t)
4590 {
4591   /*struct saved_debug_info_d *sdi;*/
4592
4593   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
4594
4595   /* FIXME.  Partial implementation for saving debug info removed.  */
4596 }
4597
4598
4599 /* Save all language fields needed to generate proper debug information
4600    for TYPE.  This saves most fields cleared out by free_lang_data_in_type.  */
4601
4602 static void
4603 save_debug_info_for_type (tree t)
4604 {
4605   /*struct saved_debug_info_d *sdi;*/
4606
4607   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
4608
4609   /* FIXME.  Partial implementation for saving debug info removed.  */
4610 }
4611
4612
4613 /* Add type or decl T to one of the list of tree nodes that need their
4614    language data removed.  The lists are held inside FLD.  */
4615
4616 static void
4617 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
4618 {
4619   if (DECL_P (t))
4620     {
4621       VEC_safe_push (tree, heap, fld->decls, t);
4622       if (debug_info_level > DINFO_LEVEL_TERSE)
4623         save_debug_info_for_decl (t);
4624     }
4625   else if (TYPE_P (t))
4626     {
4627       VEC_safe_push (tree, heap, fld->types, t);
4628       if (debug_info_level > DINFO_LEVEL_TERSE)
4629         save_debug_info_for_type (t);
4630     }
4631   else
4632     gcc_unreachable ();
4633 }
4634
4635 /* Push tree node T into FLD->WORKLIST.  */
4636
4637 static inline void
4638 fld_worklist_push (tree t, struct free_lang_data_d *fld)
4639 {
4640   if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t))
4641     VEC_safe_push (tree, heap, fld->worklist, (t));
4642 }
4643
4644
4645 /* Operand callback helper for free_lang_data_in_node.  *TP is the
4646    subtree operand being considered.  */
4647
4648 static tree
4649 find_decls_types_r (tree *tp, int *ws, void *data)
4650 {
4651   tree t = *tp;
4652   struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
4653
4654   if (TREE_CODE (t) == TREE_LIST)
4655     return NULL_TREE;
4656
4657   /* Language specific nodes will be removed, so there is no need
4658      to gather anything under them.  */
4659   if (is_lang_specific (t))
4660     {
4661       *ws = 0;
4662       return NULL_TREE;
4663     }
4664
4665   if (DECL_P (t))
4666     {
4667       /* Note that walk_tree does not traverse every possible field in
4668          decls, so we have to do our own traversals here.  */
4669       add_tree_to_fld_list (t, fld);
4670
4671       fld_worklist_push (DECL_NAME (t), fld);
4672       fld_worklist_push (DECL_CONTEXT (t), fld);
4673       fld_worklist_push (DECL_SIZE (t), fld);
4674       fld_worklist_push (DECL_SIZE_UNIT (t), fld);
4675
4676       /* We are going to remove everything under DECL_INITIAL for
4677          TYPE_DECLs.  No point walking them.  */
4678       if (TREE_CODE (t) != TYPE_DECL)
4679         fld_worklist_push (DECL_INITIAL (t), fld);
4680
4681       fld_worklist_push (DECL_ATTRIBUTES (t), fld);
4682       fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
4683
4684       if (TREE_CODE (t) == FUNCTION_DECL)
4685         {
4686           fld_worklist_push (DECL_ARGUMENTS (t), fld);
4687           fld_worklist_push (DECL_RESULT (t), fld);
4688         }
4689       else if (TREE_CODE (t) == TYPE_DECL)
4690         {
4691           fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
4692           fld_worklist_push (DECL_VINDEX (t), fld);
4693         }
4694       else if (TREE_CODE (t) == FIELD_DECL)
4695         {
4696           fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
4697           fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
4698           fld_worklist_push (DECL_QUALIFIER (t), fld);
4699           fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
4700           fld_worklist_push (DECL_FCONTEXT (t), fld);
4701         }
4702       else if (TREE_CODE (t) == VAR_DECL)
4703         {
4704           fld_worklist_push (DECL_SECTION_NAME (t), fld);
4705           fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
4706         }
4707
4708       if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
4709           && DECL_HAS_VALUE_EXPR_P (t))
4710         fld_worklist_push (DECL_VALUE_EXPR (t), fld);
4711
4712       if (TREE_CODE (t) != FIELD_DECL)
4713         fld_worklist_push (TREE_CHAIN (t), fld);
4714       *ws = 0;
4715     }
4716   else if (TYPE_P (t))
4717     {
4718       /* Note that walk_tree does not traverse every possible field in
4719          types, so we have to do our own traversals here.  */
4720       add_tree_to_fld_list (t, fld);
4721
4722       if (!RECORD_OR_UNION_TYPE_P (t))
4723         fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
4724       fld_worklist_push (TYPE_SIZE (t), fld);
4725       fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
4726       fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
4727       fld_worklist_push (TYPE_POINTER_TO (t), fld);
4728       fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
4729       fld_worklist_push (TYPE_NAME (t), fld);
4730       fld_worklist_push (TYPE_MINVAL (t), fld);
4731       if (!RECORD_OR_UNION_TYPE_P (t))
4732         fld_worklist_push (TYPE_MAXVAL (t), fld);
4733       fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
4734       fld_worklist_push (TYPE_NEXT_VARIANT (t), fld);
4735       fld_worklist_push (TYPE_CONTEXT (t), fld);
4736       fld_worklist_push (TYPE_CANONICAL (t), fld);
4737
4738       if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
4739         {
4740           unsigned i;
4741           tree tem;
4742           for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)),
4743                                    i, tem); ++i)
4744             fld_worklist_push (TREE_TYPE (tem), fld);
4745           tem = BINFO_VIRTUALS (TYPE_BINFO (t));
4746           if (tem
4747               /* The Java FE overloads BINFO_VIRTUALS for its own purpose.  */
4748               && TREE_CODE (tem) == TREE_LIST)
4749             do
4750               {
4751                 fld_worklist_push (TREE_VALUE (tem), fld);
4752                 tem = TREE_CHAIN (tem);
4753               }
4754             while (tem);
4755         }
4756       if (RECORD_OR_UNION_TYPE_P (t))
4757         {
4758           tree tem;
4759           /* Push all TYPE_FIELDS - there can be interleaving interesting
4760              and non-interesting things.  */
4761           tem = TYPE_FIELDS (t);
4762           while (tem)
4763             {
4764               if (TREE_CODE (tem) == FIELD_DECL)
4765                 fld_worklist_push (tem, fld);
4766               tem = TREE_CHAIN (tem);
4767             }
4768         }
4769
4770       fld_worklist_push (TREE_CHAIN (t), fld);
4771       *ws = 0;
4772     }
4773   else if (TREE_CODE (t) == BLOCK)
4774     {
4775       tree tem;
4776       for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
4777         fld_worklist_push (tem, fld);
4778       for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
4779         fld_worklist_push (tem, fld);
4780       fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
4781     }
4782
4783   fld_worklist_push (TREE_TYPE (t), fld);
4784
4785   return NULL_TREE;
4786 }
4787
4788
4789 /* Find decls and types in T.  */
4790
4791 static void
4792 find_decls_types (tree t, struct free_lang_data_d *fld)
4793 {
4794   while (1)
4795     {
4796       if (!pointer_set_contains (fld->pset, t))
4797         walk_tree (&t, find_decls_types_r, fld, fld->pset);
4798       if (VEC_empty (tree, fld->worklist))
4799         break;
4800       t = VEC_pop (tree, fld->worklist);
4801     }
4802 }
4803
4804 /* Translate all the types in LIST with the corresponding runtime
4805    types.  */
4806
4807 static tree
4808 get_eh_types_for_runtime (tree list)
4809 {
4810   tree head, prev;
4811
4812   if (list == NULL_TREE)
4813     return NULL_TREE;
4814
4815   head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4816   prev = head;
4817   list = TREE_CHAIN (list);
4818   while (list)
4819     {
4820       tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4821       TREE_CHAIN (prev) = n;
4822       prev = TREE_CHAIN (prev);
4823       list = TREE_CHAIN (list);
4824     }
4825
4826   return head;
4827 }
4828
4829
4830 /* Find decls and types referenced in EH region R and store them in
4831    FLD->DECLS and FLD->TYPES.  */
4832
4833 static void
4834 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
4835 {
4836   switch (r->type)
4837     {
4838     case ERT_CLEANUP:
4839       break;
4840
4841     case ERT_TRY:
4842       {
4843         eh_catch c;
4844
4845         /* The types referenced in each catch must first be changed to the
4846            EH types used at runtime.  This removes references to FE types
4847            in the region.  */
4848         for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
4849           {
4850             c->type_list = get_eh_types_for_runtime (c->type_list);
4851             walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
4852           }
4853       }
4854       break;
4855
4856     case ERT_ALLOWED_EXCEPTIONS:
4857       r->u.allowed.type_list
4858         = get_eh_types_for_runtime (r->u.allowed.type_list);
4859       walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
4860       break;
4861
4862     case ERT_MUST_NOT_THROW:
4863       walk_tree (&r->u.must_not_throw.failure_decl,
4864                  find_decls_types_r, fld, fld->pset);
4865       break;
4866     }
4867 }
4868
4869
4870 /* Find decls and types referenced in cgraph node N and store them in
4871    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4872    look for *every* kind of DECL and TYPE node reachable from N,
4873    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4874    NAMESPACE_DECLs, etc).  */
4875
4876 static void
4877 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
4878 {
4879   basic_block bb;
4880   struct function *fn;
4881   tree t;
4882
4883   find_decls_types (n->decl, fld);
4884
4885   if (!gimple_has_body_p (n->decl))
4886     return;
4887
4888   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
4889
4890   fn = DECL_STRUCT_FUNCTION (n->decl);
4891
4892   /* Traverse locals. */
4893   for (t = fn->local_decls; t; t = TREE_CHAIN (t))
4894     find_decls_types (TREE_VALUE (t), fld);
4895
4896   /* Traverse EH regions in FN.  */
4897   {
4898     eh_region r;
4899     FOR_ALL_EH_REGION_FN (r, fn)
4900       find_decls_types_in_eh_region (r, fld);
4901   }
4902
4903   /* Traverse every statement in FN.  */
4904   FOR_EACH_BB_FN (bb, fn)
4905     {
4906       gimple_stmt_iterator si;
4907       unsigned i;
4908
4909       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4910         {
4911           gimple phi = gsi_stmt (si);
4912
4913           for (i = 0; i < gimple_phi_num_args (phi); i++)
4914             {
4915               tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
4916               find_decls_types (*arg_p, fld);
4917             }
4918         }
4919
4920       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
4921         {
4922           gimple stmt = gsi_stmt (si);
4923
4924           for (i = 0; i < gimple_num_ops (stmt); i++)
4925             {
4926               tree arg = gimple_op (stmt, i);
4927               find_decls_types (arg, fld);
4928             }
4929         }
4930     }
4931 }
4932
4933
4934 /* Find decls and types referenced in varpool node N and store them in
4935    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4936    look for *every* kind of DECL and TYPE node reachable from N,
4937    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4938    NAMESPACE_DECLs, etc).  */
4939
4940 static void
4941 find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
4942 {
4943   find_decls_types (v->decl, fld);
4944 }
4945
4946 /* If T needs an assembler name, have one created for it.  */
4947
4948 void
4949 assign_assembler_name_if_neeeded (tree t)
4950 {
4951   if (need_assembler_name_p (t))
4952     {
4953       /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
4954          diagnostics that use input_location to show locus
4955          information.  The problem here is that, at this point,
4956          input_location is generally anchored to the end of the file
4957          (since the parser is long gone), so we don't have a good
4958          position to pin it to.
4959
4960          To alleviate this problem, this uses the location of T's
4961          declaration.  Examples of this are
4962          testsuite/g++.dg/template/cond2.C and
4963          testsuite/g++.dg/template/pr35240.C.  */
4964       location_t saved_location = input_location;
4965       input_location = DECL_SOURCE_LOCATION (t);
4966
4967       decl_assembler_name (t);
4968
4969       input_location = saved_location;
4970     }
4971 }
4972
4973
4974 /* Free language specific information for every operand and expression
4975    in every node of the call graph.  This process operates in three stages:
4976
4977    1- Every callgraph node and varpool node is traversed looking for
4978       decls and types embedded in them.  This is a more exhaustive
4979       search than that done by find_referenced_vars, because it will
4980       also collect individual fields, decls embedded in types, etc.
4981
4982    2- All the decls found are sent to free_lang_data_in_decl.
4983
4984    3- All the types found are sent to free_lang_data_in_type.
4985
4986    The ordering between decls and types is important because
4987    free_lang_data_in_decl sets assembler names, which includes
4988    mangling.  So types cannot be freed up until assembler names have
4989    been set up.  */
4990
4991 static void
4992 free_lang_data_in_cgraph (void)
4993 {
4994   struct cgraph_node *n;
4995   struct varpool_node *v;
4996   struct free_lang_data_d fld;
4997   tree t;
4998   unsigned i;
4999   alias_pair *p;
5000
5001   /* Initialize sets and arrays to store referenced decls and types.  */
5002   fld.pset = pointer_set_create ();
5003   fld.worklist = NULL;
5004   fld.decls = VEC_alloc (tree, heap, 100);
5005   fld.types = VEC_alloc (tree, heap, 100);
5006
5007   /* Find decls and types in the body of every function in the callgraph.  */
5008   for (n = cgraph_nodes; n; n = n->next)
5009     find_decls_types_in_node (n, &fld);
5010
5011   for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
5012     find_decls_types (p->decl, &fld);
5013
5014   /* Find decls and types in every varpool symbol.  */
5015   for (v = varpool_nodes_queue; v; v = v->next_needed)
5016     find_decls_types_in_var (v, &fld);
5017
5018   /* Set the assembler name on every decl found.  We need to do this
5019      now because free_lang_data_in_decl will invalidate data needed
5020      for mangling.  This breaks mangling on interdependent decls.  */
5021   for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
5022     assign_assembler_name_if_neeeded (t);
5023
5024   /* Traverse every decl found freeing its language data.  */
5025   for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
5026     free_lang_data_in_decl (t);
5027
5028   /* Traverse every type found freeing its language data.  */
5029   for (i = 0; VEC_iterate (tree, fld.types, i, t); i++)
5030     free_lang_data_in_type (t);
5031
5032   pointer_set_destroy (fld.pset);
5033   VEC_free (tree, heap, fld.worklist);
5034   VEC_free (tree, heap, fld.decls);
5035   VEC_free (tree, heap, fld.types);
5036 }
5037
5038
5039 /* Free resources that are used by FE but are not needed once they are done. */
5040
5041 static unsigned
5042 free_lang_data (void)
5043 {
5044   unsigned i;
5045
5046   /* If we are the LTO frontend we have freed lang-specific data already.  */
5047   if (in_lto_p
5048       || !flag_generate_lto)
5049     return 0;
5050
5051   /* Allocate and assign alias sets to the standard integer types
5052      while the slots are still in the way the frontends generated them.  */
5053   for (i = 0; i < itk_none; ++i)
5054     if (integer_types[i])
5055       TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
5056
5057   /* Traverse the IL resetting language specific information for
5058      operands, expressions, etc.  */
5059   free_lang_data_in_cgraph ();
5060
5061   /* Create gimple variants for common types.  */
5062   ptrdiff_type_node = integer_type_node;
5063   fileptr_type_node = ptr_type_node;
5064   if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE
5065       || (TYPE_MODE (boolean_type_node)
5066           != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0))
5067       || TYPE_PRECISION (boolean_type_node) != 1
5068       || !TYPE_UNSIGNED (boolean_type_node))
5069     {
5070       boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
5071       TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
5072       TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
5073       TYPE_PRECISION (boolean_type_node) = 1;
5074       boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
5075       boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
5076     }
5077
5078   /* Unify char_type_node with its properly signed variant.  */
5079   if (TYPE_UNSIGNED (char_type_node))
5080     unsigned_char_type_node = char_type_node;
5081   else
5082     signed_char_type_node = char_type_node;
5083
5084   /* Reset some langhooks.  Do not reset types_compatible_p, it may
5085      still be used indirectly via the get_alias_set langhook.  */
5086   lang_hooks.callgraph.analyze_expr = NULL;
5087   lang_hooks.dwarf_name = lhd_dwarf_name;
5088   lang_hooks.decl_printable_name = gimple_decl_printable_name;
5089   lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
5090
5091   /* Reset diagnostic machinery.  */
5092   diagnostic_starter (global_dc) = default_tree_diagnostic_starter;
5093   diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
5094   diagnostic_format_decoder (global_dc) = default_tree_printer;
5095
5096   return 0;
5097 }
5098
5099
5100 struct simple_ipa_opt_pass pass_ipa_free_lang_data =
5101 {
5102  {
5103   SIMPLE_IPA_PASS,
5104   "*free_lang_data",                    /* name */
5105   NULL,                                 /* gate */
5106   free_lang_data,                       /* execute */
5107   NULL,                                 /* sub */
5108   NULL,                                 /* next */
5109   0,                                    /* static_pass_number */
5110   TV_IPA_FREE_LANG_DATA,                /* tv_id */
5111   0,                                    /* properties_required */
5112   0,                                    /* properties_provided */
5113   0,                                    /* properties_destroyed */
5114   0,                                    /* todo_flags_start */
5115   TODO_ggc_collect                      /* todo_flags_finish */
5116  }
5117 };
5118
5119 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5120    or zero if not.
5121
5122    We try both `text' and `__text__', ATTR may be either one.  */
5123 /* ??? It might be a reasonable simplification to require ATTR to be only
5124    `text'.  One might then also require attribute lists to be stored in
5125    their canonicalized form.  */
5126
5127 static int
5128 is_attribute_with_length_p (const char *attr, int attr_len, const_tree ident)
5129 {
5130   int ident_len;
5131   const char *p;
5132
5133   if (TREE_CODE (ident) != IDENTIFIER_NODE)
5134     return 0;
5135
5136   p = IDENTIFIER_POINTER (ident);
5137   ident_len = IDENTIFIER_LENGTH (ident);
5138
5139   if (ident_len == attr_len
5140       && strcmp (attr, p) == 0)
5141     return 1;
5142
5143   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
5144   if (attr[0] == '_')
5145     {
5146       gcc_assert (attr[1] == '_');
5147       gcc_assert (attr[attr_len - 2] == '_');
5148       gcc_assert (attr[attr_len - 1] == '_');
5149       if (ident_len == attr_len - 4
5150           && strncmp (attr + 2, p, attr_len - 4) == 0)
5151         return 1;
5152     }
5153   else
5154     {
5155       if (ident_len == attr_len + 4
5156           && p[0] == '_' && p[1] == '_'
5157           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5158           && strncmp (attr, p + 2, attr_len) == 0)
5159         return 1;
5160     }
5161
5162   return 0;
5163 }
5164
5165 /* Return nonzero if IDENT is a valid name for attribute ATTR,
5166    or zero if not.
5167
5168    We try both `text' and `__text__', ATTR may be either one.  */
5169
5170 int
5171 is_attribute_p (const char *attr, const_tree ident)
5172 {
5173   return is_attribute_with_length_p (attr, strlen (attr), ident);
5174 }
5175
5176 /* Given an attribute name and a list of attributes, return a pointer to the
5177    attribute's list element if the attribute is part of the list, or NULL_TREE
5178    if not found.  If the attribute appears more than once, this only
5179    returns the first occurrence; the TREE_CHAIN of the return value should
5180    be passed back in if further occurrences are wanted.  */
5181
5182 tree
5183 lookup_attribute (const char *attr_name, tree list)
5184 {
5185   tree l;
5186   size_t attr_len = strlen (attr_name);
5187
5188   for (l = list; l; l = TREE_CHAIN (l))
5189     {
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         return l;
5193     }
5194   return NULL_TREE;
5195 }
5196
5197 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5198    modified list.  */
5199
5200 tree
5201 remove_attribute (const char *attr_name, tree list)
5202 {
5203   tree *p;
5204   size_t attr_len = strlen (attr_name);
5205
5206   for (p = &list; *p; )
5207     {
5208       tree l = *p;
5209       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5210       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5211         *p = TREE_CHAIN (l);
5212       else
5213         p = &TREE_CHAIN (l);
5214     }
5215
5216   return list;
5217 }
5218
5219 /* Return an attribute list that is the union of a1 and a2.  */
5220
5221 tree
5222 merge_attributes (tree a1, tree a2)
5223 {
5224   tree attributes;
5225
5226   /* Either one unset?  Take the set one.  */
5227
5228   if ((attributes = a1) == 0)
5229     attributes = a2;
5230
5231   /* One that completely contains the other?  Take it.  */
5232
5233   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5234     {
5235       if (attribute_list_contained (a2, a1))
5236         attributes = a2;
5237       else
5238         {
5239           /* Pick the longest list, and hang on the other list.  */
5240
5241           if (list_length (a1) < list_length (a2))
5242             attributes = a2, a2 = a1;
5243
5244           for (; a2 != 0; a2 = TREE_CHAIN (a2))
5245             {
5246               tree a;
5247               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5248                                          attributes);
5249                    a != NULL_TREE;
5250                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5251                                          TREE_CHAIN (a)))
5252                 {
5253                   if (TREE_VALUE (a) != NULL
5254                       && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
5255                       && TREE_VALUE (a2) != NULL
5256                       && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
5257                     {
5258                       if (simple_cst_list_equal (TREE_VALUE (a),
5259                                                  TREE_VALUE (a2)) == 1)
5260                         break;
5261                     }
5262                   else if (simple_cst_equal (TREE_VALUE (a),
5263                                              TREE_VALUE (a2)) == 1)
5264                     break;
5265                 }
5266               if (a == NULL_TREE)
5267                 {
5268                   a1 = copy_node (a2);
5269                   TREE_CHAIN (a1) = attributes;
5270                   attributes = a1;
5271                 }
5272             }
5273         }
5274     }
5275   return attributes;
5276 }
5277
5278 /* Given types T1 and T2, merge their attributes and return
5279   the result.  */
5280
5281 tree
5282 merge_type_attributes (tree t1, tree t2)
5283 {
5284   return merge_attributes (TYPE_ATTRIBUTES (t1),
5285                            TYPE_ATTRIBUTES (t2));
5286 }
5287
5288 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5289    the result.  */
5290
5291 tree
5292 merge_decl_attributes (tree olddecl, tree newdecl)
5293 {
5294   return merge_attributes (DECL_ATTRIBUTES (olddecl),
5295                            DECL_ATTRIBUTES (newdecl));
5296 }
5297
5298 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5299
5300 /* Specialization of merge_decl_attributes for various Windows targets.
5301
5302    This handles the following situation:
5303
5304      __declspec (dllimport) int foo;
5305      int foo;
5306
5307    The second instance of `foo' nullifies the dllimport.  */
5308
5309 tree
5310 merge_dllimport_decl_attributes (tree old, tree new_tree)
5311 {
5312   tree a;
5313   int delete_dllimport_p = 1;
5314
5315   /* What we need to do here is remove from `old' dllimport if it doesn't
5316      appear in `new'.  dllimport behaves like extern: if a declaration is
5317      marked dllimport and a definition appears later, then the object
5318      is not dllimport'd.  We also remove a `new' dllimport if the old list
5319      contains dllexport:  dllexport always overrides dllimport, regardless
5320      of the order of declaration.  */
5321   if (!VAR_OR_FUNCTION_DECL_P (new_tree))
5322     delete_dllimport_p = 0;
5323   else if (DECL_DLLIMPORT_P (new_tree)
5324            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
5325     {
5326       DECL_DLLIMPORT_P (new_tree) = 0;
5327       warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
5328               "dllimport ignored", new_tree);
5329     }
5330   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
5331     {
5332       /* Warn about overriding a symbol that has already been used, e.g.:
5333            extern int __attribute__ ((dllimport)) foo;
5334            int* bar () {return &foo;}
5335            int foo;
5336       */
5337       if (TREE_USED (old))
5338         {
5339           warning (0, "%q+D redeclared without dllimport attribute "
5340                    "after being referenced with dll linkage", new_tree);
5341           /* If we have used a variable's address with dllimport linkage,
5342               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5343               decl may already have had TREE_CONSTANT computed.
5344               We still remove the attribute so that assembler code refers
5345               to '&foo rather than '_imp__foo'.  */
5346           if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
5347             DECL_DLLIMPORT_P (new_tree) = 1;
5348         }
5349
5350       /* Let an inline definition silently override the external reference,
5351          but otherwise warn about attribute inconsistency.  */
5352       else if (TREE_CODE (new_tree) == VAR_DECL
5353                || !DECL_DECLARED_INLINE_P (new_tree))
5354         warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
5355                   "previous dllimport ignored", new_tree);
5356     }
5357   else
5358     delete_dllimport_p = 0;
5359
5360   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
5361
5362   if (delete_dllimport_p)
5363     {
5364       tree prev, t;
5365       const size_t attr_len = strlen ("dllimport");
5366
5367       /* Scan the list for dllimport and delete it.  */
5368       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
5369         {
5370           if (is_attribute_with_length_p ("dllimport", attr_len,
5371                                           TREE_PURPOSE (t)))
5372             {
5373               if (prev == NULL_TREE)
5374                 a = TREE_CHAIN (a);
5375               else
5376                 TREE_CHAIN (prev) = TREE_CHAIN (t);
5377               break;
5378             }
5379         }
5380     }
5381
5382   return a;
5383 }
5384
5385 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5386    struct attribute_spec.handler.  */
5387
5388 tree
5389 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
5390                       bool *no_add_attrs)
5391 {
5392   tree node = *pnode;
5393   bool is_dllimport;
5394
5395   /* These attributes may apply to structure and union types being created,
5396      but otherwise should pass to the declaration involved.  */
5397   if (!DECL_P (node))
5398     {
5399       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
5400                    | (int) ATTR_FLAG_ARRAY_NEXT))
5401         {
5402           *no_add_attrs = true;
5403           return tree_cons (name, args, NULL_TREE);
5404         }
5405       if (TREE_CODE (node) == RECORD_TYPE
5406           || TREE_CODE (node) == UNION_TYPE)
5407         {
5408           node = TYPE_NAME (node);
5409           if (!node)
5410             return NULL_TREE;
5411         }
5412       else
5413         {
5414           warning (OPT_Wattributes, "%qE attribute ignored",
5415                    name);
5416           *no_add_attrs = true;
5417           return NULL_TREE;
5418         }
5419     }
5420
5421   if (TREE_CODE (node) != FUNCTION_DECL
5422       && TREE_CODE (node) != VAR_DECL
5423       && TREE_CODE (node) != TYPE_DECL)
5424     {
5425       *no_add_attrs = true;
5426       warning (OPT_Wattributes, "%qE attribute ignored",
5427                name);
5428       return NULL_TREE;
5429     }
5430
5431   if (TREE_CODE (node) == TYPE_DECL
5432       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
5433       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
5434     {
5435       *no_add_attrs = true;
5436       warning (OPT_Wattributes, "%qE attribute ignored",
5437                name);
5438       return NULL_TREE;
5439     }
5440
5441   is_dllimport = is_attribute_p ("dllimport", name);
5442
5443   /* Report error on dllimport ambiguities seen now before they cause
5444      any damage.  */
5445   if (is_dllimport)
5446     {
5447       /* Honor any target-specific overrides. */
5448       if (!targetm.valid_dllimport_attribute_p (node))
5449         *no_add_attrs = true;
5450
5451      else if (TREE_CODE (node) == FUNCTION_DECL
5452                 && DECL_DECLARED_INLINE_P (node))
5453         {
5454           warning (OPT_Wattributes, "inline function %q+D declared as "
5455                   " dllimport: attribute ignored", node);
5456           *no_add_attrs = true;
5457         }
5458       /* Like MS, treat definition of dllimported variables and
5459          non-inlined functions on declaration as syntax errors. */
5460      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
5461         {
5462           error ("function %q+D definition is marked dllimport", node);
5463           *no_add_attrs = true;
5464         }
5465
5466      else if (TREE_CODE (node) == VAR_DECL)
5467         {
5468           if (DECL_INITIAL (node))
5469             {
5470               error ("variable %q+D definition is marked dllimport",
5471                      node);
5472               *no_add_attrs = true;
5473             }
5474
5475           /* `extern' needn't be specified with dllimport.
5476              Specify `extern' now and hope for the best.  Sigh.  */
5477           DECL_EXTERNAL (node) = 1;
5478           /* Also, implicitly give dllimport'd variables declared within
5479              a function global scope, unless declared static.  */
5480           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
5481             TREE_PUBLIC (node) = 1;
5482         }
5483
5484       if (*no_add_attrs == false)
5485         DECL_DLLIMPORT_P (node) = 1;
5486     }
5487   else if (TREE_CODE (node) == FUNCTION_DECL
5488            && DECL_DECLARED_INLINE_P (node))
5489     /* An exported function, even if inline, must be emitted.  */
5490     DECL_EXTERNAL (node) = 0;
5491
5492   /*  Report error if symbol is not accessible at global scope.  */
5493   if (!TREE_PUBLIC (node)
5494       && (TREE_CODE (node) == VAR_DECL
5495           || TREE_CODE (node) == FUNCTION_DECL))
5496     {
5497       error ("external linkage required for symbol %q+D because of "
5498              "%qE attribute", node, name);
5499       *no_add_attrs = true;
5500     }
5501
5502   /* A dllexport'd entity must have default visibility so that other
5503      program units (shared libraries or the main executable) can see
5504      it.  A dllimport'd entity must have default visibility so that
5505      the linker knows that undefined references within this program
5506      unit can be resolved by the dynamic linker.  */
5507   if (!*no_add_attrs)
5508     {
5509       if (DECL_VISIBILITY_SPECIFIED (node)
5510           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
5511         error ("%qE implies default visibility, but %qD has already "
5512                "been declared with a different visibility",
5513                name, node);
5514       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
5515       DECL_VISIBILITY_SPECIFIED (node) = 1;
5516     }
5517
5518   return NULL_TREE;
5519 }
5520
5521 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
5522 \f
5523 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5524    of the various TYPE_QUAL values.  */
5525
5526 static void
5527 set_type_quals (tree type, int type_quals)
5528 {
5529   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
5530   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
5531   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
5532   TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
5533 }
5534
5535 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
5536
5537 bool
5538 check_qualified_type (const_tree cand, const_tree base, int type_quals)
5539 {
5540   return (TYPE_QUALS (cand) == type_quals
5541           && TYPE_NAME (cand) == TYPE_NAME (base)
5542           /* Apparently this is needed for Objective-C.  */
5543           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5544           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5545                                    TYPE_ATTRIBUTES (base)));
5546 }
5547
5548 /* Return a version of the TYPE, qualified as indicated by the
5549    TYPE_QUALS, if one exists.  If no qualified version exists yet,
5550    return NULL_TREE.  */
5551
5552 tree
5553 get_qualified_type (tree type, int type_quals)
5554 {
5555   tree t;
5556
5557   if (TYPE_QUALS (type) == type_quals)
5558     return type;
5559
5560   /* Search the chain of variants to see if there is already one there just
5561      like the one we need to have.  If so, use that existing one.  We must
5562      preserve the TYPE_NAME, since there is code that depends on this.  */
5563   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5564     if (check_qualified_type (t, type, type_quals))
5565       return t;
5566
5567   return NULL_TREE;
5568 }
5569
5570 /* Like get_qualified_type, but creates the type if it does not
5571    exist.  This function never returns NULL_TREE.  */
5572
5573 tree
5574 build_qualified_type (tree type, int type_quals)
5575 {
5576   tree t;
5577
5578   /* See if we already have the appropriate qualified variant.  */
5579   t = get_qualified_type (type, type_quals);
5580
5581   /* If not, build it.  */
5582   if (!t)
5583     {
5584       t = build_variant_type_copy (type);
5585       set_type_quals (t, type_quals);
5586
5587       if (TYPE_STRUCTURAL_EQUALITY_P (type))
5588         /* Propagate structural equality. */
5589         SET_TYPE_STRUCTURAL_EQUALITY (t);
5590       else if (TYPE_CANONICAL (type) != type)
5591         /* Build the underlying canonical type, since it is different
5592            from TYPE. */
5593         TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
5594                                                    type_quals);
5595       else
5596         /* T is its own canonical type. */
5597         TYPE_CANONICAL (t) = t;
5598
5599     }
5600
5601   return t;
5602 }
5603
5604 /* Create a new distinct copy of TYPE.  The new type is made its own
5605    MAIN_VARIANT. If TYPE requires structural equality checks, the
5606    resulting type requires structural equality checks; otherwise, its
5607    TYPE_CANONICAL points to itself. */
5608
5609 tree
5610 build_distinct_type_copy (tree type)
5611 {
5612   tree t = copy_node (type);
5613
5614   TYPE_POINTER_TO (t) = 0;
5615   TYPE_REFERENCE_TO (t) = 0;
5616
5617   /* Set the canonical type either to a new equivalence class, or
5618      propagate the need for structural equality checks. */
5619   if (TYPE_STRUCTURAL_EQUALITY_P (type))
5620     SET_TYPE_STRUCTURAL_EQUALITY (t);
5621   else
5622     TYPE_CANONICAL (t) = t;
5623
5624   /* Make it its own variant.  */
5625   TYPE_MAIN_VARIANT (t) = t;
5626   TYPE_NEXT_VARIANT (t) = 0;
5627
5628   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5629      whose TREE_TYPE is not t.  This can also happen in the Ada
5630      frontend when using subtypes.  */
5631
5632   return t;
5633 }
5634
5635 /* Create a new variant of TYPE, equivalent but distinct.  This is so
5636    the caller can modify it. TYPE_CANONICAL for the return type will
5637    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5638    are considered equal by the language itself (or that both types
5639    require structural equality checks). */
5640
5641 tree
5642 build_variant_type_copy (tree type)
5643 {
5644   tree t, m = TYPE_MAIN_VARIANT (type);
5645
5646   t = build_distinct_type_copy (type);
5647
5648   /* Since we're building a variant, assume that it is a non-semantic
5649      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5650   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
5651
5652   /* Add the new type to the chain of variants of TYPE.  */
5653   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
5654   TYPE_NEXT_VARIANT (m) = t;
5655   TYPE_MAIN_VARIANT (t) = m;
5656
5657   return t;
5658 }
5659 \f
5660 /* Return true if the from tree in both tree maps are equal.  */
5661
5662 int
5663 tree_map_base_eq (const void *va, const void *vb)
5664 {
5665   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
5666     *const b = (const struct tree_map_base *) vb;
5667   return (a->from == b->from);
5668 }
5669
5670 /* Hash a from tree in a tree_base_map.  */
5671
5672 unsigned int
5673 tree_map_base_hash (const void *item)
5674 {
5675   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
5676 }
5677
5678 /* Return true if this tree map structure is marked for garbage collection
5679    purposes.  We simply return true if the from tree is marked, so that this
5680    structure goes away when the from tree goes away.  */
5681
5682 int
5683 tree_map_base_marked_p (const void *p)
5684 {
5685   return ggc_marked_p (((const struct tree_map_base *) p)->from);
5686 }
5687
5688 /* Hash a from tree in a tree_map.  */
5689
5690 unsigned int
5691 tree_map_hash (const void *item)
5692 {
5693   return (((const struct tree_map *) item)->hash);
5694 }
5695
5696 /* Hash a from tree in a tree_decl_map.  */
5697
5698 unsigned int
5699 tree_decl_map_hash (const void *item)
5700 {
5701   return DECL_UID (((const struct tree_decl_map *) item)->base.from);
5702 }
5703
5704 /* Return the initialization priority for DECL.  */
5705
5706 priority_type
5707 decl_init_priority_lookup (tree decl)
5708 {
5709   struct tree_priority_map *h;
5710   struct tree_map_base in;
5711
5712   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5713   in.from = decl;
5714   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5715   return h ? h->init : DEFAULT_INIT_PRIORITY;
5716 }
5717
5718 /* Return the finalization priority for DECL.  */
5719
5720 priority_type
5721 decl_fini_priority_lookup (tree decl)
5722 {
5723   struct tree_priority_map *h;
5724   struct tree_map_base in;
5725
5726   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5727   in.from = decl;
5728   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5729   return h ? h->fini : DEFAULT_INIT_PRIORITY;
5730 }
5731
5732 /* Return the initialization and finalization priority information for
5733    DECL.  If there is no previous priority information, a freshly
5734    allocated structure is returned.  */
5735
5736 static struct tree_priority_map *
5737 decl_priority_info (tree decl)
5738 {
5739   struct tree_priority_map in;
5740   struct tree_priority_map *h;
5741   void **loc;
5742
5743   in.base.from = decl;
5744   loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
5745   h = (struct tree_priority_map *) *loc;
5746   if (!h)
5747     {
5748       h = ggc_alloc_cleared_tree_priority_map ();
5749       *loc = h;
5750       h->base.from = decl;
5751       h->init = DEFAULT_INIT_PRIORITY;
5752       h->fini = DEFAULT_INIT_PRIORITY;
5753     }
5754
5755   return h;
5756 }
5757
5758 /* Set the initialization priority for DECL to PRIORITY.  */
5759
5760 void
5761 decl_init_priority_insert (tree decl, priority_type priority)
5762 {
5763   struct tree_priority_map *h;
5764
5765   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5766   h = decl_priority_info (decl);
5767   h->init = priority;
5768 }
5769
5770 /* Set the finalization priority for DECL to PRIORITY.  */
5771
5772 void
5773 decl_fini_priority_insert (tree decl, priority_type priority)
5774 {
5775   struct tree_priority_map *h;
5776
5777   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5778   h = decl_priority_info (decl);
5779   h->fini = priority;
5780 }
5781
5782 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
5783
5784 static void
5785 print_debug_expr_statistics (void)
5786 {
5787   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5788            (long) htab_size (debug_expr_for_decl),
5789            (long) htab_elements (debug_expr_for_decl),
5790            htab_collisions (debug_expr_for_decl));
5791 }
5792
5793 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
5794
5795 static void
5796 print_value_expr_statistics (void)
5797 {
5798   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5799            (long) htab_size (value_expr_for_decl),
5800            (long) htab_elements (value_expr_for_decl),
5801            htab_collisions (value_expr_for_decl));
5802 }
5803
5804 /* Lookup a debug expression for FROM, and return it if we find one.  */
5805
5806 tree
5807 decl_debug_expr_lookup (tree from)
5808 {
5809   struct tree_decl_map *h, in;
5810   in.base.from = from;
5811
5812   h = (struct tree_decl_map *)
5813       htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from));
5814   if (h)
5815     return h->to;
5816   return NULL_TREE;
5817 }
5818
5819 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
5820
5821 void
5822 decl_debug_expr_insert (tree from, tree to)
5823 {
5824   struct tree_decl_map *h;
5825   void **loc;
5826
5827   h = ggc_alloc_tree_decl_map ();
5828   h->base.from = from;
5829   h->to = to;
5830   loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from),
5831                                   INSERT);
5832   *(struct tree_decl_map **) loc = h;
5833 }
5834
5835 /* Lookup a value expression for FROM, and return it if we find one.  */
5836
5837 tree
5838 decl_value_expr_lookup (tree from)
5839 {
5840   struct tree_decl_map *h, in;
5841   in.base.from = from;
5842
5843   h = (struct tree_decl_map *)
5844       htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from));
5845   if (h)
5846     return h->to;
5847   return NULL_TREE;
5848 }
5849
5850 /* Insert a mapping FROM->TO in the value expression hashtable.  */
5851
5852 void
5853 decl_value_expr_insert (tree from, tree to)
5854 {
5855   struct tree_decl_map *h;
5856   void **loc;
5857
5858   h = ggc_alloc_tree_decl_map ();
5859   h->base.from = from;
5860   h->to = to;
5861   loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from),
5862                                   INSERT);
5863   *(struct tree_decl_map **) loc = h;
5864 }
5865
5866 /* Hashing of types so that we don't make duplicates.
5867    The entry point is `type_hash_canon'.  */
5868
5869 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
5870    with types in the TREE_VALUE slots), by adding the hash codes
5871    of the individual types.  */
5872
5873 static unsigned int
5874 type_hash_list (const_tree list, hashval_t hashcode)
5875 {
5876   const_tree tail;
5877
5878   for (tail = list; tail; tail = TREE_CHAIN (tail))
5879     if (TREE_VALUE (tail) != error_mark_node)
5880       hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
5881                                         hashcode);
5882
5883   return hashcode;
5884 }
5885
5886 /* These are the Hashtable callback functions.  */
5887
5888 /* Returns true iff the types are equivalent.  */
5889
5890 static int
5891 type_hash_eq (const void *va, const void *vb)
5892 {
5893   const struct type_hash *const a = (const struct type_hash *) va,
5894     *const b = (const struct type_hash *) vb;
5895
5896   /* First test the things that are the same for all types.  */
5897   if (a->hash != b->hash
5898       || TREE_CODE (a->type) != TREE_CODE (b->type)
5899       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
5900       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
5901                                  TYPE_ATTRIBUTES (b->type))
5902       || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
5903       || TYPE_MODE (a->type) != TYPE_MODE (b->type)
5904       || (TREE_CODE (a->type) != COMPLEX_TYPE
5905           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
5906     return 0;
5907
5908   switch (TREE_CODE (a->type))
5909     {
5910     case VOID_TYPE:
5911     case COMPLEX_TYPE:
5912     case POINTER_TYPE:
5913     case REFERENCE_TYPE:
5914       return 1;
5915
5916     case VECTOR_TYPE:
5917       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
5918
5919     case ENUMERAL_TYPE:
5920       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
5921           && !(TYPE_VALUES (a->type)
5922                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
5923                && TYPE_VALUES (b->type)
5924                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
5925                && type_list_equal (TYPE_VALUES (a->type),
5926                                    TYPE_VALUES (b->type))))
5927         return 0;
5928
5929       /* ... fall through ... */
5930
5931     case INTEGER_TYPE:
5932     case REAL_TYPE:
5933     case BOOLEAN_TYPE:
5934       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
5935                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
5936                                       TYPE_MAX_VALUE (b->type)))
5937               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
5938                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
5939                                          TYPE_MIN_VALUE (b->type))));
5940
5941     case FIXED_POINT_TYPE:
5942       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
5943
5944     case OFFSET_TYPE:
5945       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
5946
5947     case METHOD_TYPE:
5948       return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
5949               && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5950                   || (TYPE_ARG_TYPES (a->type)
5951                       && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5952                       && TYPE_ARG_TYPES (b->type)
5953                       && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5954                       && type_list_equal (TYPE_ARG_TYPES (a->type),
5955                                           TYPE_ARG_TYPES (b->type)))));
5956
5957     case ARRAY_TYPE:
5958       return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
5959
5960     case RECORD_TYPE:
5961     case UNION_TYPE:
5962     case QUAL_UNION_TYPE:
5963       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
5964               || (TYPE_FIELDS (a->type)
5965                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
5966                   && TYPE_FIELDS (b->type)
5967                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
5968                   && type_list_equal (TYPE_FIELDS (a->type),
5969                                       TYPE_FIELDS (b->type))));
5970
5971     case FUNCTION_TYPE:
5972       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5973           || (TYPE_ARG_TYPES (a->type)
5974               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5975               && TYPE_ARG_TYPES (b->type)
5976               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5977               && type_list_equal (TYPE_ARG_TYPES (a->type),
5978                                   TYPE_ARG_TYPES (b->type))))
5979         break;
5980       return 0;
5981
5982     default:
5983       return 0;
5984     }
5985
5986   if (lang_hooks.types.type_hash_eq != NULL)
5987     return lang_hooks.types.type_hash_eq (a->type, b->type);
5988
5989   return 1;
5990 }
5991
5992 /* Return the cached hash value.  */
5993
5994 static hashval_t
5995 type_hash_hash (const void *item)
5996 {
5997   return ((const struct type_hash *) item)->hash;
5998 }
5999
6000 /* Look in the type hash table for a type isomorphic to TYPE.
6001    If one is found, return it.  Otherwise return 0.  */
6002
6003 tree
6004 type_hash_lookup (hashval_t hashcode, tree type)
6005 {
6006   struct type_hash *h, in;
6007
6008   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
6009      must call that routine before comparing TYPE_ALIGNs.  */
6010   layout_type (type);
6011
6012   in.hash = hashcode;
6013   in.type = type;
6014
6015   h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
6016                                                 hashcode);
6017   if (h)
6018     return h->type;
6019   return NULL_TREE;
6020 }
6021
6022 /* Add an entry to the type-hash-table
6023    for a type TYPE whose hash code is HASHCODE.  */
6024
6025 void
6026 type_hash_add (hashval_t hashcode, tree type)
6027 {
6028   struct type_hash *h;
6029   void **loc;
6030
6031   h = ggc_alloc_type_hash ();
6032   h->hash = hashcode;
6033   h->type = type;
6034   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
6035   *loc = (void *)h;
6036 }
6037
6038 /* Given TYPE, and HASHCODE its hash code, return the canonical
6039    object for an identical type if one already exists.
6040    Otherwise, return TYPE, and record it as the canonical object.
6041
6042    To use this function, first create a type of the sort you want.
6043    Then compute its hash code from the fields of the type that
6044    make it different from other similar types.
6045    Then call this function and use the value.  */
6046
6047 tree
6048 type_hash_canon (unsigned int hashcode, tree type)
6049 {
6050   tree t1;
6051
6052   /* The hash table only contains main variants, so ensure that's what we're
6053      being passed.  */
6054   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
6055
6056   if (!lang_hooks.types.hash_types)
6057     return type;
6058
6059   /* See if the type is in the hash table already.  If so, return it.
6060      Otherwise, add the type.  */
6061   t1 = type_hash_lookup (hashcode, type);
6062   if (t1 != 0)
6063     {
6064 #ifdef GATHER_STATISTICS
6065       tree_node_counts[(int) t_kind]--;
6066       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
6067 #endif
6068       return t1;
6069     }
6070   else
6071     {
6072       type_hash_add (hashcode, type);
6073       return type;
6074     }
6075 }
6076
6077 /* See if the data pointed to by the type hash table is marked.  We consider
6078    it marked if the type is marked or if a debug type number or symbol
6079    table entry has been made for the type.  This reduces the amount of
6080    debugging output and eliminates that dependency of the debug output on
6081    the number of garbage collections.  */
6082
6083 static int
6084 type_hash_marked_p (const void *p)
6085 {
6086   const_tree const type = ((const struct type_hash *) p)->type;
6087
6088   return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
6089 }
6090
6091 static void
6092 print_type_hash_statistics (void)
6093 {
6094   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
6095            (long) htab_size (type_hash_table),
6096            (long) htab_elements (type_hash_table),
6097            htab_collisions (type_hash_table));
6098 }
6099
6100 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
6101    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6102    by adding the hash codes of the individual attributes.  */
6103
6104 static unsigned int
6105 attribute_hash_list (const_tree list, hashval_t hashcode)
6106 {
6107   const_tree tail;
6108
6109   for (tail = list; tail; tail = TREE_CHAIN (tail))
6110     /* ??? Do we want to add in TREE_VALUE too? */
6111     hashcode = iterative_hash_object
6112       (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
6113   return hashcode;
6114 }
6115
6116 /* Given two lists of attributes, return true if list l2 is
6117    equivalent to l1.  */
6118
6119 int
6120 attribute_list_equal (const_tree l1, const_tree l2)
6121 {
6122   return attribute_list_contained (l1, l2)
6123          && attribute_list_contained (l2, l1);
6124 }
6125
6126 /* Given two lists of attributes, return true if list L2 is
6127    completely contained within L1.  */
6128 /* ??? This would be faster if attribute names were stored in a canonicalized
6129    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6130    must be used to show these elements are equivalent (which they are).  */
6131 /* ??? It's not clear that attributes with arguments will always be handled
6132    correctly.  */
6133
6134 int
6135 attribute_list_contained (const_tree l1, const_tree l2)
6136 {
6137   const_tree t1, t2;
6138
6139   /* First check the obvious, maybe the lists are identical.  */
6140   if (l1 == l2)
6141     return 1;
6142
6143   /* Maybe the lists are similar.  */
6144   for (t1 = l1, t2 = l2;
6145        t1 != 0 && t2 != 0
6146         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
6147         && TREE_VALUE (t1) == TREE_VALUE (t2);
6148        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
6149
6150   /* Maybe the lists are equal.  */
6151   if (t1 == 0 && t2 == 0)
6152     return 1;
6153
6154   for (; t2 != 0; t2 = TREE_CHAIN (t2))
6155     {
6156       const_tree attr;
6157       /* This CONST_CAST is okay because lookup_attribute does not
6158          modify its argument and the return value is assigned to a
6159          const_tree.  */
6160       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6161                                     CONST_CAST_TREE(l1));
6162            attr != NULL_TREE;
6163            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6164                                     TREE_CHAIN (attr)))
6165         {
6166           if (TREE_VALUE (t2) != NULL
6167               && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
6168               && TREE_VALUE (attr) != NULL
6169               && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
6170             {
6171               if (simple_cst_list_equal (TREE_VALUE (t2),
6172                                          TREE_VALUE (attr)) == 1)
6173                 break;
6174             }
6175           else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
6176             break;
6177         }
6178
6179       if (attr == 0)
6180         return 0;
6181     }
6182
6183   return 1;
6184 }
6185
6186 /* Given two lists of types
6187    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6188    return 1 if the lists contain the same types in the same order.
6189    Also, the TREE_PURPOSEs must match.  */
6190
6191 int
6192 type_list_equal (const_tree l1, const_tree l2)
6193 {
6194   const_tree t1, t2;
6195
6196   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6197     if (TREE_VALUE (t1) != TREE_VALUE (t2)
6198         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6199             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6200                   && (TREE_TYPE (TREE_PURPOSE (t1))
6201                       == TREE_TYPE (TREE_PURPOSE (t2))))))
6202       return 0;
6203
6204   return t1 == t2;
6205 }
6206
6207 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6208    given by TYPE.  If the argument list accepts variable arguments,
6209    then this function counts only the ordinary arguments.  */
6210
6211 int
6212 type_num_arguments (const_tree type)
6213 {
6214   int i = 0;
6215   tree t;
6216
6217   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6218     /* If the function does not take a variable number of arguments,
6219        the last element in the list will have type `void'.  */
6220     if (VOID_TYPE_P (TREE_VALUE (t)))
6221       break;
6222     else
6223       ++i;
6224
6225   return i;
6226 }
6227
6228 /* Nonzero if integer constants T1 and T2
6229    represent the same constant value.  */
6230
6231 int
6232 tree_int_cst_equal (const_tree t1, const_tree t2)
6233 {
6234   if (t1 == t2)
6235     return 1;
6236
6237   if (t1 == 0 || t2 == 0)
6238     return 0;
6239
6240   if (TREE_CODE (t1) == INTEGER_CST
6241       && TREE_CODE (t2) == INTEGER_CST
6242       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6243       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
6244     return 1;
6245
6246   return 0;
6247 }
6248
6249 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6250    The precise way of comparison depends on their data type.  */
6251
6252 int
6253 tree_int_cst_lt (const_tree t1, const_tree t2)
6254 {
6255   if (t1 == t2)
6256     return 0;
6257
6258   if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
6259     {
6260       int t1_sgn = tree_int_cst_sgn (t1);
6261       int t2_sgn = tree_int_cst_sgn (t2);
6262
6263       if (t1_sgn < t2_sgn)
6264         return 1;
6265       else if (t1_sgn > t2_sgn)
6266         return 0;
6267       /* Otherwise, both are non-negative, so we compare them as
6268          unsigned just in case one of them would overflow a signed
6269          type.  */
6270     }
6271   else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
6272     return INT_CST_LT (t1, t2);
6273
6274   return INT_CST_LT_UNSIGNED (t1, t2);
6275 }
6276
6277 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
6278
6279 int
6280 tree_int_cst_compare (const_tree t1, const_tree t2)
6281 {
6282   if (tree_int_cst_lt (t1, t2))
6283     return -1;
6284   else if (tree_int_cst_lt (t2, t1))
6285     return 1;
6286   else
6287     return 0;
6288 }
6289
6290 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6291    the host.  If POS is zero, the value can be represented in a single
6292    HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
6293    be represented in a single unsigned HOST_WIDE_INT.  */
6294
6295 int
6296 host_integerp (const_tree t, int pos)
6297 {
6298   if (t == NULL_TREE)
6299     return 0;
6300
6301   return (TREE_CODE (t) == INTEGER_CST
6302           && ((TREE_INT_CST_HIGH (t) == 0
6303                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
6304               || (! pos && TREE_INT_CST_HIGH (t) == -1
6305                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
6306                   && (!TYPE_UNSIGNED (TREE_TYPE (t))
6307                       || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6308                           && TYPE_IS_SIZETYPE (TREE_TYPE (t)))))
6309               || (pos && TREE_INT_CST_HIGH (t) == 0)));
6310 }
6311
6312 /* Return the HOST_WIDE_INT least significant bits of T if it is an
6313    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
6314    be non-negative.  We must be able to satisfy the above conditions.  */
6315
6316 HOST_WIDE_INT
6317 tree_low_cst (const_tree t, int pos)
6318 {
6319   gcc_assert (host_integerp (t, pos));
6320   return TREE_INT_CST_LOW (t);
6321 }
6322
6323 /* Return the most significant bit of the integer constant T.  */
6324
6325 int
6326 tree_int_cst_msb (const_tree t)
6327 {
6328   int prec;
6329   HOST_WIDE_INT h;
6330   unsigned HOST_WIDE_INT l;
6331
6332   /* Note that using TYPE_PRECISION here is wrong.  We care about the
6333      actual bits, not the (arbitrary) range of the type.  */
6334   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
6335   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
6336                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
6337   return (l & 1) == 1;
6338 }
6339
6340 /* Return an indication of the sign of the integer constant T.
6341    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6342    Note that -1 will never be returned if T's type is unsigned.  */
6343
6344 int
6345 tree_int_cst_sgn (const_tree t)
6346 {
6347   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
6348     return 0;
6349   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
6350     return 1;
6351   else if (TREE_INT_CST_HIGH (t) < 0)
6352     return -1;
6353   else
6354     return 1;
6355 }
6356
6357 /* Return the minimum number of bits needed to represent VALUE in a
6358    signed or unsigned type, UNSIGNEDP says which.  */
6359
6360 unsigned int
6361 tree_int_cst_min_precision (tree value, bool unsignedp)
6362 {
6363   int log;
6364
6365   /* If the value is negative, compute its negative minus 1.  The latter
6366      adjustment is because the absolute value of the largest negative value
6367      is one larger than the largest positive value.  This is equivalent to
6368      a bit-wise negation, so use that operation instead.  */
6369
6370   if (tree_int_cst_sgn (value) < 0)
6371     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
6372
6373   /* Return the number of bits needed, taking into account the fact
6374      that we need one more bit for a signed than unsigned type.  */
6375
6376   if (integer_zerop (value))
6377     log = 0;
6378   else
6379     log = tree_floor_log2 (value);
6380
6381   return log + 1 + !unsignedp;
6382 }
6383
6384 /* Compare two constructor-element-type constants.  Return 1 if the lists
6385    are known to be equal; otherwise return 0.  */
6386
6387 int
6388 simple_cst_list_equal (const_tree l1, const_tree l2)
6389 {
6390   while (l1 != NULL_TREE && l2 != NULL_TREE)
6391     {
6392       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
6393         return 0;
6394
6395       l1 = TREE_CHAIN (l1);
6396       l2 = TREE_CHAIN (l2);
6397     }
6398
6399   return l1 == l2;
6400 }
6401
6402 /* Return truthvalue of whether T1 is the same tree structure as T2.
6403    Return 1 if they are the same.
6404    Return 0 if they are understandably different.
6405    Return -1 if either contains tree structure not understood by
6406    this function.  */
6407
6408 int
6409 simple_cst_equal (const_tree t1, const_tree t2)
6410 {
6411   enum tree_code code1, code2;
6412   int cmp;
6413   int i;
6414
6415   if (t1 == t2)
6416     return 1;
6417   if (t1 == 0 || t2 == 0)
6418     return 0;
6419
6420   code1 = TREE_CODE (t1);
6421   code2 = TREE_CODE (t2);
6422
6423   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
6424     {
6425       if (CONVERT_EXPR_CODE_P (code2)
6426           || code2 == NON_LVALUE_EXPR)
6427         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6428       else
6429         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
6430     }
6431
6432   else if (CONVERT_EXPR_CODE_P (code2)
6433            || code2 == NON_LVALUE_EXPR)
6434     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
6435
6436   if (code1 != code2)
6437     return 0;
6438
6439   switch (code1)
6440     {
6441     case INTEGER_CST:
6442       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6443               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
6444
6445     case REAL_CST:
6446       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
6447
6448     case FIXED_CST:
6449       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
6450
6451     case STRING_CST:
6452       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
6453               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
6454                          TREE_STRING_LENGTH (t1)));
6455
6456     case CONSTRUCTOR:
6457       {
6458         unsigned HOST_WIDE_INT idx;
6459         VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
6460         VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
6461
6462         if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
6463           return false;
6464
6465         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
6466           /* ??? Should we handle also fields here? */
6467           if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
6468                                  VEC_index (constructor_elt, v2, idx)->value))
6469             return false;
6470         return true;
6471       }
6472
6473     case SAVE_EXPR:
6474       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6475
6476     case CALL_EXPR:
6477       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
6478       if (cmp <= 0)
6479         return cmp;
6480       if (call_expr_nargs (t1) != call_expr_nargs (t2))
6481         return 0;
6482       {
6483         const_tree arg1, arg2;
6484         const_call_expr_arg_iterator iter1, iter2;
6485         for (arg1 = first_const_call_expr_arg (t1, &iter1),
6486                arg2 = first_const_call_expr_arg (t2, &iter2);
6487              arg1 && arg2;
6488              arg1 = next_const_call_expr_arg (&iter1),
6489                arg2 = next_const_call_expr_arg (&iter2))
6490           {
6491             cmp = simple_cst_equal (arg1, arg2);
6492             if (cmp <= 0)
6493               return cmp;
6494           }
6495         return arg1 == arg2;
6496       }
6497
6498     case TARGET_EXPR:
6499       /* Special case: if either target is an unallocated VAR_DECL,
6500          it means that it's going to be unified with whatever the
6501          TARGET_EXPR is really supposed to initialize, so treat it
6502          as being equivalent to anything.  */
6503       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
6504            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
6505            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
6506           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
6507               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
6508               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
6509         cmp = 1;
6510       else
6511         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6512
6513       if (cmp <= 0)
6514         return cmp;
6515
6516       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
6517
6518     case WITH_CLEANUP_EXPR:
6519       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6520       if (cmp <= 0)
6521         return cmp;
6522
6523       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
6524
6525     case COMPONENT_REF:
6526       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
6527         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6528
6529       return 0;
6530
6531     case VAR_DECL:
6532     case PARM_DECL:
6533     case CONST_DECL:
6534     case FUNCTION_DECL:
6535       return 0;
6536
6537     default:
6538       break;
6539     }
6540
6541   /* This general rule works for most tree codes.  All exceptions should be
6542      handled above.  If this is a language-specific tree code, we can't
6543      trust what might be in the operand, so say we don't know
6544      the situation.  */
6545   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
6546     return -1;
6547
6548   switch (TREE_CODE_CLASS (code1))
6549     {
6550     case tcc_unary:
6551     case tcc_binary:
6552     case tcc_comparison:
6553     case tcc_expression:
6554     case tcc_reference:
6555     case tcc_statement:
6556       cmp = 1;
6557       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
6558         {
6559           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
6560           if (cmp <= 0)
6561             return cmp;
6562         }
6563
6564       return cmp;
6565
6566     default:
6567       return -1;
6568     }
6569 }
6570
6571 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6572    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6573    than U, respectively.  */
6574
6575 int
6576 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
6577 {
6578   if (tree_int_cst_sgn (t) < 0)
6579     return -1;
6580   else if (TREE_INT_CST_HIGH (t) != 0)
6581     return 1;
6582   else if (TREE_INT_CST_LOW (t) == u)
6583     return 0;
6584   else if (TREE_INT_CST_LOW (t) < u)
6585     return -1;
6586   else
6587     return 1;
6588 }
6589
6590 /* Return true if CODE represents an associative tree code.  Otherwise
6591    return false.  */
6592 bool
6593 associative_tree_code (enum tree_code code)
6594 {
6595   switch (code)
6596     {
6597     case BIT_IOR_EXPR:
6598     case BIT_AND_EXPR:
6599     case BIT_XOR_EXPR:
6600     case PLUS_EXPR:
6601     case MULT_EXPR:
6602     case MIN_EXPR:
6603     case MAX_EXPR:
6604       return true;
6605
6606     default:
6607       break;
6608     }
6609   return false;
6610 }
6611
6612 /* Return true if CODE represents a commutative tree code.  Otherwise
6613    return false.  */
6614 bool
6615 commutative_tree_code (enum tree_code code)
6616 {
6617   switch (code)
6618     {
6619     case PLUS_EXPR:
6620     case MULT_EXPR:
6621     case MIN_EXPR:
6622     case MAX_EXPR:
6623     case BIT_IOR_EXPR:
6624     case BIT_XOR_EXPR:
6625     case BIT_AND_EXPR:
6626     case NE_EXPR:
6627     case EQ_EXPR:
6628     case UNORDERED_EXPR:
6629     case ORDERED_EXPR:
6630     case UNEQ_EXPR:
6631     case LTGT_EXPR:
6632     case TRUTH_AND_EXPR:
6633     case TRUTH_XOR_EXPR:
6634     case TRUTH_OR_EXPR:
6635       return true;
6636
6637     default:
6638       break;
6639     }
6640   return false;
6641 }
6642
6643 /* Return true if CODE represents a ternary tree code for which the
6644    first two operands are commutative.  Otherwise return false.  */
6645 bool
6646 commutative_ternary_tree_code (enum tree_code code)
6647 {
6648   switch (code)
6649     {
6650     case WIDEN_MULT_PLUS_EXPR:
6651     case WIDEN_MULT_MINUS_EXPR:
6652       return true;
6653
6654     default:
6655       break;
6656     }
6657   return false;
6658 }
6659
6660 /* Generate a hash value for an expression.  This can be used iteratively
6661    by passing a previous result as the VAL argument.
6662
6663    This function is intended to produce the same hash for expressions which
6664    would compare equal using operand_equal_p.  */
6665
6666 hashval_t
6667 iterative_hash_expr (const_tree t, hashval_t val)
6668 {
6669   int i;
6670   enum tree_code code;
6671   char tclass;
6672
6673   if (t == NULL_TREE)
6674     return iterative_hash_hashval_t (0, val);
6675
6676   code = TREE_CODE (t);
6677
6678   switch (code)
6679     {
6680     /* Alas, constants aren't shared, so we can't rely on pointer
6681        identity.  */
6682     case INTEGER_CST:
6683       val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
6684       return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
6685     case REAL_CST:
6686       {
6687         unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
6688
6689         return iterative_hash_hashval_t (val2, val);
6690       }
6691     case FIXED_CST:
6692       {
6693         unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
6694
6695         return iterative_hash_hashval_t (val2, val);
6696       }
6697     case STRING_CST:
6698       return iterative_hash (TREE_STRING_POINTER (t),
6699                              TREE_STRING_LENGTH (t), val);
6700     case COMPLEX_CST:
6701       val = iterative_hash_expr (TREE_REALPART (t), val);
6702       return iterative_hash_expr (TREE_IMAGPART (t), val);
6703     case VECTOR_CST:
6704       return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
6705     case SSA_NAME:
6706       /* We can just compare by pointer.  */
6707       return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
6708     case PLACEHOLDER_EXPR:
6709       /* The node itself doesn't matter.  */
6710       return val;
6711     case TREE_LIST:
6712       /* A list of expressions, for a CALL_EXPR or as the elements of a
6713          VECTOR_CST.  */
6714       for (; t; t = TREE_CHAIN (t))
6715         val = iterative_hash_expr (TREE_VALUE (t), val);
6716       return val;
6717     case CONSTRUCTOR:
6718       {
6719         unsigned HOST_WIDE_INT idx;
6720         tree field, value;
6721         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
6722           {
6723             val = iterative_hash_expr (field, val);
6724             val = iterative_hash_expr (value, val);
6725           }
6726         return val;
6727       }
6728     case FUNCTION_DECL:
6729       /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
6730          Otherwise nodes that compare equal according to operand_equal_p might
6731          get different hash codes.  However, don't do this for machine specific
6732          or front end builtins, since the function code is overloaded in those
6733          cases.  */
6734       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
6735           && built_in_decls[DECL_FUNCTION_CODE (t)])
6736         {
6737           t = built_in_decls[DECL_FUNCTION_CODE (t)];
6738           code = TREE_CODE (t);
6739         }
6740       /* FALL THROUGH */
6741     default:
6742       tclass = TREE_CODE_CLASS (code);
6743
6744       if (tclass == tcc_declaration)
6745         {
6746           /* DECL's have a unique ID */
6747           val = iterative_hash_host_wide_int (DECL_UID (t), val);
6748         }
6749       else
6750         {
6751           gcc_assert (IS_EXPR_CODE_CLASS (tclass));
6752
6753           val = iterative_hash_object (code, val);
6754
6755           /* Don't hash the type, that can lead to having nodes which
6756              compare equal according to operand_equal_p, but which
6757              have different hash codes.  */
6758           if (CONVERT_EXPR_CODE_P (code)
6759               || code == NON_LVALUE_EXPR)
6760             {
6761               /* Make sure to include signness in the hash computation.  */
6762               val += TYPE_UNSIGNED (TREE_TYPE (t));
6763               val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
6764             }
6765
6766           else if (commutative_tree_code (code))
6767             {
6768               /* It's a commutative expression.  We want to hash it the same
6769                  however it appears.  We do this by first hashing both operands
6770                  and then rehashing based on the order of their independent
6771                  hashes.  */
6772               hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
6773               hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
6774               hashval_t t;
6775
6776               if (one > two)
6777                 t = one, one = two, two = t;
6778
6779               val = iterative_hash_hashval_t (one, val);
6780               val = iterative_hash_hashval_t (two, val);
6781             }
6782           else
6783             for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
6784               val = iterative_hash_expr (TREE_OPERAND (t, i), val);
6785         }
6786       return val;
6787       break;
6788     }
6789 }
6790
6791 /* Generate a hash value for a pair of expressions.  This can be used
6792    iteratively by passing a previous result as the VAL argument.
6793
6794    The same hash value is always returned for a given pair of expressions,
6795    regardless of the order in which they are presented.  This is useful in
6796    hashing the operands of commutative functions.  */
6797
6798 hashval_t
6799 iterative_hash_exprs_commutative (const_tree t1,
6800                                   const_tree t2, hashval_t val)
6801 {
6802   hashval_t one = iterative_hash_expr (t1, 0);
6803   hashval_t two = iterative_hash_expr (t2, 0);
6804   hashval_t t;
6805
6806   if (one > two)
6807     t = one, one = two, two = t;
6808   val = iterative_hash_hashval_t (one, val);
6809   val = iterative_hash_hashval_t (two, val);
6810
6811   return val;
6812 }
6813 \f
6814 /* Constructors for pointer, array and function types.
6815    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
6816    constructed by language-dependent code, not here.)  */
6817
6818 /* Construct, lay out and return the type of pointers to TO_TYPE with
6819    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
6820    reference all of memory. If such a type has already been
6821    constructed, reuse it.  */
6822
6823 tree
6824 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
6825                              bool can_alias_all)
6826 {
6827   tree t;
6828
6829   if (to_type == error_mark_node)
6830     return error_mark_node;
6831
6832   /* If the pointed-to type has the may_alias attribute set, force
6833      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6834   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6835     can_alias_all = true;
6836
6837   /* In some cases, languages will have things that aren't a POINTER_TYPE
6838      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
6839      In that case, return that type without regard to the rest of our
6840      operands.
6841
6842      ??? This is a kludge, but consistent with the way this function has
6843      always operated and there doesn't seem to be a good way to avoid this
6844      at the moment.  */
6845   if (TYPE_POINTER_TO (to_type) != 0
6846       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
6847     return TYPE_POINTER_TO (to_type);
6848
6849   /* First, if we already have a type for pointers to TO_TYPE and it's
6850      the proper mode, use it.  */
6851   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
6852     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6853       return t;
6854
6855   t = make_node (POINTER_TYPE);
6856
6857   TREE_TYPE (t) = to_type;
6858   SET_TYPE_MODE (t, mode);
6859   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6860   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
6861   TYPE_POINTER_TO (to_type) = t;
6862
6863   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6864     SET_TYPE_STRUCTURAL_EQUALITY (t);
6865   else if (TYPE_CANONICAL (to_type) != to_type)
6866     TYPE_CANONICAL (t)
6867       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
6868                                      mode, can_alias_all);
6869
6870   /* Lay out the type.  This function has many callers that are concerned
6871      with expression-construction, and this simplifies them all.  */
6872   layout_type (t);
6873
6874   return t;
6875 }
6876
6877 /* By default build pointers in ptr_mode.  */
6878
6879 tree
6880 build_pointer_type (tree to_type)
6881 {
6882   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6883                                               : TYPE_ADDR_SPACE (to_type);
6884   enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6885   return build_pointer_type_for_mode (to_type, pointer_mode, false);
6886 }
6887
6888 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
6889
6890 tree
6891 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
6892                                bool can_alias_all)
6893 {
6894   tree t;
6895
6896   if (to_type == error_mark_node)
6897     return error_mark_node;
6898
6899   /* If the pointed-to type has the may_alias attribute set, force
6900      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6901   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6902     can_alias_all = true;
6903
6904   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
6905      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
6906      In that case, return that type without regard to the rest of our
6907      operands.
6908
6909      ??? This is a kludge, but consistent with the way this function has
6910      always operated and there doesn't seem to be a good way to avoid this
6911      at the moment.  */
6912   if (TYPE_REFERENCE_TO (to_type) != 0
6913       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
6914     return TYPE_REFERENCE_TO (to_type);
6915
6916   /* First, if we already have a type for pointers to TO_TYPE and it's
6917      the proper mode, use it.  */
6918   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
6919     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6920       return t;
6921
6922   t = make_node (REFERENCE_TYPE);
6923
6924   TREE_TYPE (t) = to_type;
6925   SET_TYPE_MODE (t, mode);
6926   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6927   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
6928   TYPE_REFERENCE_TO (to_type) = t;
6929
6930   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6931     SET_TYPE_STRUCTURAL_EQUALITY (t);
6932   else if (TYPE_CANONICAL (to_type) != to_type)
6933     TYPE_CANONICAL (t)
6934       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
6935                                        mode, can_alias_all);
6936
6937   layout_type (t);
6938
6939   return t;
6940 }
6941
6942
6943 /* Build the node for the type of references-to-TO_TYPE by default
6944    in ptr_mode.  */
6945
6946 tree
6947 build_reference_type (tree to_type)
6948 {
6949   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6950                                               : TYPE_ADDR_SPACE (to_type);
6951   enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6952   return build_reference_type_for_mode (to_type, pointer_mode, false);
6953 }
6954
6955 /* Build a type that is compatible with t but has no cv quals anywhere
6956    in its type, thus
6957
6958    const char *const *const *  ->  char ***.  */
6959
6960 tree
6961 build_type_no_quals (tree t)
6962 {
6963   switch (TREE_CODE (t))
6964     {
6965     case POINTER_TYPE:
6966       return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6967                                           TYPE_MODE (t),
6968                                           TYPE_REF_CAN_ALIAS_ALL (t));
6969     case REFERENCE_TYPE:
6970       return
6971         build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6972                                        TYPE_MODE (t),
6973                                        TYPE_REF_CAN_ALIAS_ALL (t));
6974     default:
6975       return TYPE_MAIN_VARIANT (t);
6976     }
6977 }
6978
6979 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
6980    MAXVAL should be the maximum value in the domain
6981    (one less than the length of the array).
6982
6983    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
6984    We don't enforce this limit, that is up to caller (e.g. language front end).
6985    The limit exists because the result is a signed type and we don't handle
6986    sizes that use more than one HOST_WIDE_INT.  */
6987
6988 tree
6989 build_index_type (tree maxval)
6990 {
6991   tree itype = make_node (INTEGER_TYPE);
6992
6993   TREE_TYPE (itype) = sizetype;
6994   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
6995   TYPE_MIN_VALUE (itype) = size_zero_node;
6996   TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
6997   SET_TYPE_MODE (itype, TYPE_MODE (sizetype));
6998   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
6999   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
7000   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
7001   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
7002
7003   if (host_integerp (maxval, 1))
7004     return type_hash_canon (tree_low_cst (maxval, 1), itype);
7005   else
7006     {
7007       /* Since we cannot hash this type, we need to compare it using
7008          structural equality checks. */
7009       SET_TYPE_STRUCTURAL_EQUALITY (itype);
7010       return itype;
7011     }
7012 }
7013
7014 #define MAX_INT_CACHED_PREC \
7015   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
7016 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
7017
7018 /* Builds a signed or unsigned integer type of precision PRECISION.
7019    Used for C bitfields whose precision does not match that of
7020    built-in target types.  */
7021 tree
7022 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
7023                                 int unsignedp)
7024 {
7025   tree itype, ret;
7026
7027   if (unsignedp)
7028     unsignedp = MAX_INT_CACHED_PREC + 1;
7029
7030   if (precision <= MAX_INT_CACHED_PREC)
7031     {
7032       itype = nonstandard_integer_type_cache[precision + unsignedp];
7033       if (itype)
7034         return itype;
7035     }
7036
7037   itype = make_node (INTEGER_TYPE);
7038   TYPE_PRECISION (itype) = precision;
7039
7040   if (unsignedp)
7041     fixup_unsigned_type (itype);
7042   else
7043     fixup_signed_type (itype);
7044
7045   ret = itype;
7046   if (host_integerp (TYPE_MAX_VALUE (itype), 1))
7047     ret = type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
7048   if (precision <= MAX_INT_CACHED_PREC && lang_hooks.types.hash_types)
7049     nonstandard_integer_type_cache[precision + unsignedp] = ret;
7050
7051   return ret;
7052 }
7053
7054 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
7055    ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
7056    high bound HIGHVAL.  If TYPE is NULL, sizetype is used.  */
7057
7058 tree
7059 build_range_type (tree type, tree lowval, tree highval)
7060 {
7061   tree itype = make_node (INTEGER_TYPE);
7062
7063   TREE_TYPE (itype) = type;
7064   if (type == NULL_TREE)
7065     type = sizetype;
7066
7067   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
7068   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
7069
7070   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
7071   SET_TYPE_MODE (itype, TYPE_MODE (type));
7072   TYPE_SIZE (itype) = TYPE_SIZE (type);
7073   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
7074   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
7075   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
7076
7077   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
7078     return type_hash_canon (tree_low_cst (highval, 0)
7079                             - tree_low_cst (lowval, 0),
7080                             itype);
7081   else
7082     return itype;
7083 }
7084
7085 /* Return true if the debug information for TYPE, a subtype, should be emitted
7086    as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
7087    high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
7088    debug info and doesn't reflect the source code.  */
7089
7090 bool
7091 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
7092 {
7093   tree base_type = TREE_TYPE (type), low, high;
7094
7095   /* Subrange types have a base type which is an integral type.  */
7096   if (!INTEGRAL_TYPE_P (base_type))
7097     return false;
7098
7099   /* Get the real bounds of the subtype.  */
7100   if (lang_hooks.types.get_subrange_bounds)
7101     lang_hooks.types.get_subrange_bounds (type, &low, &high);
7102   else
7103     {
7104       low = TYPE_MIN_VALUE (type);
7105       high = TYPE_MAX_VALUE (type);
7106     }
7107
7108   /* If the type and its base type have the same representation and the same
7109      name, then the type is not a subrange but a copy of the base type.  */
7110   if ((TREE_CODE (base_type) == INTEGER_TYPE
7111        || TREE_CODE (base_type) == BOOLEAN_TYPE)
7112       && int_size_in_bytes (type) == int_size_in_bytes (base_type)
7113       && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
7114       && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
7115     {
7116       tree type_name = TYPE_NAME (type);
7117       tree base_type_name = TYPE_NAME (base_type);
7118
7119       if (type_name && TREE_CODE (type_name) == TYPE_DECL)
7120         type_name = DECL_NAME (type_name);
7121
7122       if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
7123         base_type_name = DECL_NAME (base_type_name);
7124
7125       if (type_name == base_type_name)
7126         return false;
7127     }
7128
7129   if (lowval)
7130     *lowval = low;
7131   if (highval)
7132     *highval = high;
7133   return true;
7134 }
7135
7136 /* Just like build_index_type, but takes lowval and highval instead
7137    of just highval (maxval).  */
7138
7139 tree
7140 build_index_2_type (tree lowval, tree highval)
7141 {
7142   return build_range_type (sizetype, lowval, highval);
7143 }
7144
7145 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7146    and number of elements specified by the range of values of INDEX_TYPE.
7147    If such a type has already been constructed, reuse it.  */
7148
7149 tree
7150 build_array_type (tree elt_type, tree index_type)
7151 {
7152   tree t;
7153   hashval_t hashcode = 0;
7154
7155   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7156     {
7157       error ("arrays of functions are not meaningful");
7158       elt_type = integer_type_node;
7159     }
7160
7161   t = make_node (ARRAY_TYPE);
7162   TREE_TYPE (t) = elt_type;
7163   TYPE_DOMAIN (t) = index_type;
7164   TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7165   layout_type (t);
7166
7167   /* If the element type is incomplete at this point we get marked for
7168      structural equality.  Do not record these types in the canonical
7169      type hashtable.  */
7170   if (TYPE_STRUCTURAL_EQUALITY_P (t))
7171     return t;
7172
7173   hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
7174   if (index_type)
7175     hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
7176   t = type_hash_canon (hashcode, t);
7177
7178   if (TYPE_CANONICAL (t) == t)
7179     {
7180       if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7181           || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7182         SET_TYPE_STRUCTURAL_EQUALITY (t);
7183       else if (TYPE_CANONICAL (elt_type) != elt_type
7184                || (index_type && TYPE_CANONICAL (index_type) != index_type))
7185         TYPE_CANONICAL (t)
7186           = build_array_type (TYPE_CANONICAL (elt_type),
7187                               index_type ? TYPE_CANONICAL (index_type) : NULL);
7188     }
7189
7190   return t;
7191 }
7192
7193 /* Recursively examines the array elements of TYPE, until a non-array
7194    element type is found.  */
7195
7196 tree
7197 strip_array_types (tree type)
7198 {
7199   while (TREE_CODE (type) == ARRAY_TYPE)
7200     type = TREE_TYPE (type);
7201
7202   return type;
7203 }
7204
7205 /* Computes the canonical argument types from the argument type list
7206    ARGTYPES.
7207
7208    Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7209    on entry to this function, or if any of the ARGTYPES are
7210    structural.
7211
7212    Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7213    true on entry to this function, or if any of the ARGTYPES are
7214    non-canonical.
7215
7216    Returns a canonical argument list, which may be ARGTYPES when the
7217    canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7218    true) or would not differ from ARGTYPES.  */
7219
7220 static tree
7221 maybe_canonicalize_argtypes(tree argtypes,
7222                             bool *any_structural_p,
7223                             bool *any_noncanonical_p)
7224 {
7225   tree arg;
7226   bool any_noncanonical_argtypes_p = false;
7227
7228   for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7229     {
7230       if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7231         /* Fail gracefully by stating that the type is structural.  */
7232         *any_structural_p = true;
7233       else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7234         *any_structural_p = true;
7235       else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7236                || TREE_PURPOSE (arg))
7237         /* If the argument has a default argument, we consider it
7238            non-canonical even though the type itself is canonical.
7239            That way, different variants of function and method types
7240            with default arguments will all point to the variant with
7241            no defaults as their canonical type.  */
7242         any_noncanonical_argtypes_p = true;
7243     }
7244
7245   if (*any_structural_p)
7246     return argtypes;
7247
7248   if (any_noncanonical_argtypes_p)
7249     {
7250       /* Build the canonical list of argument types.  */
7251       tree canon_argtypes = NULL_TREE;
7252       bool is_void = false;
7253
7254       for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7255         {
7256           if (arg == void_list_node)
7257             is_void = true;
7258           else
7259             canon_argtypes = tree_cons (NULL_TREE,
7260                                         TYPE_CANONICAL (TREE_VALUE (arg)),
7261                                         canon_argtypes);
7262         }
7263
7264       canon_argtypes = nreverse (canon_argtypes);
7265       if (is_void)
7266         canon_argtypes = chainon (canon_argtypes, void_list_node);
7267
7268       /* There is a non-canonical type.  */
7269       *any_noncanonical_p = true;
7270       return canon_argtypes;
7271     }
7272
7273   /* The canonical argument types are the same as ARGTYPES.  */
7274   return argtypes;
7275 }
7276
7277 /* Construct, lay out and return
7278    the type of functions returning type VALUE_TYPE
7279    given arguments of types ARG_TYPES.
7280    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7281    are data type nodes for the arguments of the function.
7282    If such a type has already been constructed, reuse it.  */
7283
7284 tree
7285 build_function_type (tree value_type, tree arg_types)
7286 {
7287   tree t;
7288   hashval_t hashcode = 0;
7289   bool any_structural_p, any_noncanonical_p;
7290   tree canon_argtypes;
7291
7292   if (TREE_CODE (value_type) == FUNCTION_TYPE)
7293     {
7294       error ("function return type cannot be function");
7295       value_type = integer_type_node;
7296     }
7297
7298   /* Make a node of the sort we want.  */
7299   t = make_node (FUNCTION_TYPE);
7300   TREE_TYPE (t) = value_type;
7301   TYPE_ARG_TYPES (t) = arg_types;
7302
7303   /* If we already have such a type, use the old one.  */
7304   hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
7305   hashcode = type_hash_list (arg_types, hashcode);
7306   t = type_hash_canon (hashcode, t);
7307
7308   /* Set up the canonical type. */
7309   any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
7310   any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
7311   canon_argtypes = maybe_canonicalize_argtypes (arg_types,
7312                                                 &any_structural_p,
7313                                                 &any_noncanonical_p);
7314   if (any_structural_p)
7315     SET_TYPE_STRUCTURAL_EQUALITY (t);
7316   else if (any_noncanonical_p)
7317     TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
7318                                               canon_argtypes);
7319
7320   if (!COMPLETE_TYPE_P (t))
7321     layout_type (t);
7322   return t;
7323 }
7324
7325 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.  */
7326
7327 tree
7328 build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
7329 {
7330   tree new_type = NULL;
7331   tree args, new_args = NULL, t;
7332   tree new_reversed;
7333   int i = 0;
7334
7335   for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
7336        args = TREE_CHAIN (args), i++)
7337     if (!bitmap_bit_p (args_to_skip, i))
7338       new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
7339
7340   new_reversed = nreverse (new_args);
7341   if (args)
7342     {
7343       if (new_reversed)
7344         TREE_CHAIN (new_args) = void_list_node;
7345       else
7346         new_reversed = void_list_node;
7347     }
7348
7349   /* Use copy_node to preserve as much as possible from original type
7350      (debug info, attribute lists etc.)
7351      Exception is METHOD_TYPEs must have THIS argument.
7352      When we are asked to remove it, we need to build new FUNCTION_TYPE
7353      instead.  */
7354   if (TREE_CODE (orig_type) != METHOD_TYPE
7355       || !bitmap_bit_p (args_to_skip, 0))
7356     {
7357       new_type = copy_node (orig_type);
7358       TYPE_ARG_TYPES (new_type) = new_reversed;
7359     }
7360   else
7361     {
7362       new_type
7363         = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
7364                                                          new_reversed));
7365       TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
7366     }
7367
7368   /* This is a new type, not a copy of an old type.  Need to reassociate
7369      variants.  We can handle everything except the main variant lazily.  */
7370   t = TYPE_MAIN_VARIANT (orig_type);
7371   if (orig_type != t)
7372     {
7373       TYPE_MAIN_VARIANT (new_type) = t;
7374       TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
7375       TYPE_NEXT_VARIANT (t) = new_type;
7376     }
7377   else
7378     {
7379       TYPE_MAIN_VARIANT (new_type) = new_type;
7380       TYPE_NEXT_VARIANT (new_type) = NULL;
7381     }
7382   return new_type;
7383 }
7384
7385 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
7386
7387    Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7388    linked by TREE_CHAIN directly.  The caller is responsible for eliminating
7389    them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
7390
7391 tree
7392 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
7393 {
7394   tree new_decl = copy_node (orig_decl);
7395   tree new_type;
7396
7397   new_type = TREE_TYPE (orig_decl);
7398   if (prototype_p (new_type))
7399     new_type = build_function_type_skip_args (new_type, args_to_skip);
7400   TREE_TYPE (new_decl) = new_type;
7401
7402   /* For declarations setting DECL_VINDEX (i.e. methods)
7403      we expect first argument to be THIS pointer.   */
7404   if (bitmap_bit_p (args_to_skip, 0))
7405     DECL_VINDEX (new_decl) = NULL_TREE;
7406
7407   /* When signature changes, we need to clear builtin info.  */
7408   if (DECL_BUILT_IN (new_decl) && !bitmap_empty_p (args_to_skip))
7409     {
7410       DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
7411       DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
7412     }
7413   return new_decl;
7414 }
7415
7416 /* Build a function type.  The RETURN_TYPE is the type returned by the
7417    function.  If VAARGS is set, no void_type_node is appended to the
7418    the list.  ARGP must be always be terminated be a NULL_TREE.  */
7419
7420 static tree
7421 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
7422 {
7423   tree t, args, last;
7424
7425   t = va_arg (argp, tree);
7426   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
7427     args = tree_cons (NULL_TREE, t, args);
7428
7429   if (vaargs)
7430     {
7431       last = args;
7432       if (args != NULL_TREE)
7433         args = nreverse (args);
7434       gcc_assert (last != void_list_node);
7435     }
7436   else if (args == NULL_TREE)
7437     args = void_list_node;
7438   else
7439     {
7440       last = args;
7441       args = nreverse (args);
7442       TREE_CHAIN (last) = void_list_node;
7443     }
7444   args = build_function_type (return_type, args);
7445
7446   return args;
7447 }
7448
7449 /* Build a function type.  The RETURN_TYPE is the type returned by the
7450    function.  If additional arguments are provided, they are
7451    additional argument types.  The list of argument types must always
7452    be terminated by NULL_TREE.  */
7453
7454 tree
7455 build_function_type_list (tree return_type, ...)
7456 {
7457   tree args;
7458   va_list p;
7459
7460   va_start (p, return_type);
7461   args = build_function_type_list_1 (false, return_type, p);
7462   va_end (p);
7463   return args;
7464 }
7465
7466 /* Build a variable argument function type.  The RETURN_TYPE is the
7467    type returned by the function.  If additional arguments are provided,
7468    they are additional argument types.  The list of argument types must
7469    always be terminated by NULL_TREE.  */
7470
7471 tree
7472 build_varargs_function_type_list (tree return_type, ...)
7473 {
7474   tree args;
7475   va_list p;
7476
7477   va_start (p, return_type);
7478   args = build_function_type_list_1 (true, return_type, p);
7479   va_end (p);
7480
7481   return args;
7482 }
7483
7484 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
7485    and ARGTYPES (a TREE_LIST) are the return type and arguments types
7486    for the method.  An implicit additional parameter (of type
7487    pointer-to-BASETYPE) is added to the ARGTYPES.  */
7488
7489 tree
7490 build_method_type_directly (tree basetype,
7491                             tree rettype,
7492                             tree argtypes)
7493 {
7494   tree t;
7495   tree ptype;
7496   int hashcode = 0;
7497   bool any_structural_p, any_noncanonical_p;
7498   tree canon_argtypes;
7499
7500   /* Make a node of the sort we want.  */
7501   t = make_node (METHOD_TYPE);
7502
7503   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7504   TREE_TYPE (t) = rettype;
7505   ptype = build_pointer_type (basetype);
7506
7507   /* The actual arglist for this function includes a "hidden" argument
7508      which is "this".  Put it into the list of argument types.  */
7509   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
7510   TYPE_ARG_TYPES (t) = argtypes;
7511
7512   /* If we already have such a type, use the old one.  */
7513   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7514   hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
7515   hashcode = type_hash_list (argtypes, hashcode);
7516   t = type_hash_canon (hashcode, t);
7517
7518   /* Set up the canonical type. */
7519   any_structural_p
7520     = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7521        || TYPE_STRUCTURAL_EQUALITY_P (rettype));
7522   any_noncanonical_p
7523     = (TYPE_CANONICAL (basetype) != basetype
7524        || TYPE_CANONICAL (rettype) != rettype);
7525   canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
7526                                                 &any_structural_p,
7527                                                 &any_noncanonical_p);
7528   if (any_structural_p)
7529     SET_TYPE_STRUCTURAL_EQUALITY (t);
7530   else if (any_noncanonical_p)
7531     TYPE_CANONICAL (t)
7532       = build_method_type_directly (TYPE_CANONICAL (basetype),
7533                                     TYPE_CANONICAL (rettype),
7534                                     canon_argtypes);
7535   if (!COMPLETE_TYPE_P (t))
7536     layout_type (t);
7537
7538   return t;
7539 }
7540
7541 /* Construct, lay out and return the type of methods belonging to class
7542    BASETYPE and whose arguments and values are described by TYPE.
7543    If that type exists already, reuse it.
7544    TYPE must be a FUNCTION_TYPE node.  */
7545
7546 tree
7547 build_method_type (tree basetype, tree type)
7548 {
7549   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
7550
7551   return build_method_type_directly (basetype,
7552                                      TREE_TYPE (type),
7553                                      TYPE_ARG_TYPES (type));
7554 }
7555
7556 /* Construct, lay out and return the type of offsets to a value
7557    of type TYPE, within an object of type BASETYPE.
7558    If a suitable offset type exists already, reuse it.  */
7559
7560 tree
7561 build_offset_type (tree basetype, tree type)
7562 {
7563   tree t;
7564   hashval_t hashcode = 0;
7565
7566   /* Make a node of the sort we want.  */
7567   t = make_node (OFFSET_TYPE);
7568
7569   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7570   TREE_TYPE (t) = type;
7571
7572   /* If we already have such a type, use the old one.  */
7573   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7574   hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
7575   t = type_hash_canon (hashcode, t);
7576
7577   if (!COMPLETE_TYPE_P (t))
7578     layout_type (t);
7579
7580   if (TYPE_CANONICAL (t) == t)
7581     {
7582       if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7583           || TYPE_STRUCTURAL_EQUALITY_P (type))
7584         SET_TYPE_STRUCTURAL_EQUALITY (t);
7585       else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
7586                || TYPE_CANONICAL (type) != type)
7587         TYPE_CANONICAL (t)
7588           = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
7589                                TYPE_CANONICAL (type));
7590     }
7591
7592   return t;
7593 }
7594
7595 /* Create a complex type whose components are COMPONENT_TYPE.  */
7596
7597 tree
7598 build_complex_type (tree component_type)
7599 {
7600   tree t;
7601   hashval_t hashcode;
7602
7603   gcc_assert (INTEGRAL_TYPE_P (component_type)
7604               || SCALAR_FLOAT_TYPE_P (component_type)
7605               || FIXED_POINT_TYPE_P (component_type));
7606
7607   /* Make a node of the sort we want.  */
7608   t = make_node (COMPLEX_TYPE);
7609
7610   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
7611
7612   /* If we already have such a type, use the old one.  */
7613   hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
7614   t = type_hash_canon (hashcode, t);
7615
7616   if (!COMPLETE_TYPE_P (t))
7617     layout_type (t);
7618
7619   if (TYPE_CANONICAL (t) == t)
7620     {
7621       if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
7622         SET_TYPE_STRUCTURAL_EQUALITY (t);
7623       else if (TYPE_CANONICAL (component_type) != component_type)
7624         TYPE_CANONICAL (t)
7625           = build_complex_type (TYPE_CANONICAL (component_type));
7626     }
7627
7628   /* We need to create a name, since complex is a fundamental type.  */
7629   if (! TYPE_NAME (t))
7630     {
7631       const char *name;
7632       if (component_type == char_type_node)
7633         name = "complex char";
7634       else if (component_type == signed_char_type_node)
7635         name = "complex signed char";
7636       else if (component_type == unsigned_char_type_node)
7637         name = "complex unsigned char";
7638       else if (component_type == short_integer_type_node)
7639         name = "complex short int";
7640       else if (component_type == short_unsigned_type_node)
7641         name = "complex short unsigned int";
7642       else if (component_type == integer_type_node)
7643         name = "complex int";
7644       else if (component_type == unsigned_type_node)
7645         name = "complex unsigned int";
7646       else if (component_type == long_integer_type_node)
7647         name = "complex long int";
7648       else if (component_type == long_unsigned_type_node)
7649         name = "complex long unsigned int";
7650       else if (component_type == long_long_integer_type_node)
7651         name = "complex long long int";
7652       else if (component_type == long_long_unsigned_type_node)
7653         name = "complex long long unsigned int";
7654       else
7655         name = 0;
7656
7657       if (name != 0)
7658         TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
7659                                     get_identifier (name), t);
7660     }
7661
7662   return build_qualified_type (t, TYPE_QUALS (component_type));
7663 }
7664
7665 /* If TYPE is a real or complex floating-point type and the target
7666    does not directly support arithmetic on TYPE then return the wider
7667    type to be used for arithmetic on TYPE.  Otherwise, return
7668    NULL_TREE.  */
7669
7670 tree
7671 excess_precision_type (tree type)
7672 {
7673   if (flag_excess_precision != EXCESS_PRECISION_FAST)
7674     {
7675       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
7676       switch (TREE_CODE (type))
7677         {
7678         case REAL_TYPE:
7679           switch (flt_eval_method)
7680             {
7681             case 1:
7682               if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
7683                 return double_type_node;
7684               break;
7685             case 2:
7686               if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
7687                   || TYPE_MODE (type) == TYPE_MODE (double_type_node))
7688                 return long_double_type_node;
7689               break;
7690             default:
7691               gcc_unreachable ();
7692             }
7693           break;
7694         case COMPLEX_TYPE:
7695           if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
7696             return NULL_TREE;
7697           switch (flt_eval_method)
7698             {
7699             case 1:
7700               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
7701                 return complex_double_type_node;
7702               break;
7703             case 2:
7704               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
7705                   || (TYPE_MODE (TREE_TYPE (type))
7706                       == TYPE_MODE (double_type_node)))
7707                 return complex_long_double_type_node;
7708               break;
7709             default:
7710               gcc_unreachable ();
7711             }
7712           break;
7713         default:
7714           break;
7715         }
7716     }
7717   return NULL_TREE;
7718 }
7719 \f
7720 /* Return OP, stripped of any conversions to wider types as much as is safe.
7721    Converting the value back to OP's type makes a value equivalent to OP.
7722
7723    If FOR_TYPE is nonzero, we return a value which, if converted to
7724    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
7725
7726    OP must have integer, real or enumeral type.  Pointers are not allowed!
7727
7728    There are some cases where the obvious value we could return
7729    would regenerate to OP if converted to OP's type,
7730    but would not extend like OP to wider types.
7731    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
7732    For example, if OP is (unsigned short)(signed char)-1,
7733    we avoid returning (signed char)-1 if FOR_TYPE is int,
7734    even though extending that to an unsigned short would regenerate OP,
7735    since the result of extending (signed char)-1 to (int)
7736    is different from (int) OP.  */
7737
7738 tree
7739 get_unwidened (tree op, tree for_type)
7740 {
7741   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
7742   tree type = TREE_TYPE (op);
7743   unsigned final_prec
7744     = TYPE_PRECISION (for_type != 0 ? for_type : type);
7745   int uns
7746     = (for_type != 0 && for_type != type
7747        && final_prec > TYPE_PRECISION (type)
7748        && TYPE_UNSIGNED (type));
7749   tree win = op;
7750
7751   while (CONVERT_EXPR_P (op))
7752     {
7753       int bitschange;
7754
7755       /* TYPE_PRECISION on vector types has different meaning
7756          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
7757          so avoid them here.  */
7758       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
7759         break;
7760
7761       bitschange = TYPE_PRECISION (TREE_TYPE (op))
7762                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
7763
7764       /* Truncations are many-one so cannot be removed.
7765          Unless we are later going to truncate down even farther.  */
7766       if (bitschange < 0
7767           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
7768         break;
7769
7770       /* See what's inside this conversion.  If we decide to strip it,
7771          we will set WIN.  */
7772       op = TREE_OPERAND (op, 0);
7773
7774       /* If we have not stripped any zero-extensions (uns is 0),
7775          we can strip any kind of extension.
7776          If we have previously stripped a zero-extension,
7777          only zero-extensions can safely be stripped.
7778          Any extension can be stripped if the bits it would produce
7779          are all going to be discarded later by truncating to FOR_TYPE.  */
7780
7781       if (bitschange > 0)
7782         {
7783           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
7784             win = op;
7785           /* TYPE_UNSIGNED says whether this is a zero-extension.
7786              Let's avoid computing it if it does not affect WIN
7787              and if UNS will not be needed again.  */
7788           if ((uns
7789                || CONVERT_EXPR_P (op))
7790               && TYPE_UNSIGNED (TREE_TYPE (op)))
7791             {
7792               uns = 1;
7793               win = op;
7794             }
7795         }
7796     }
7797
7798   /* If we finally reach a constant see if it fits in for_type and
7799      in that case convert it.  */
7800   if (for_type
7801       && TREE_CODE (win) == INTEGER_CST
7802       && TREE_TYPE (win) != for_type
7803       && int_fits_type_p (win, for_type))
7804     win = fold_convert (for_type, win);
7805
7806   return win;
7807 }
7808 \f
7809 /* Return OP or a simpler expression for a narrower value
7810    which can be sign-extended or zero-extended to give back OP.
7811    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
7812    or 0 if the value should be sign-extended.  */
7813
7814 tree
7815 get_narrower (tree op, int *unsignedp_ptr)
7816 {
7817   int uns = 0;
7818   int first = 1;
7819   tree win = op;
7820   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
7821
7822   while (TREE_CODE (op) == NOP_EXPR)
7823     {
7824       int bitschange
7825         = (TYPE_PRECISION (TREE_TYPE (op))
7826            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
7827
7828       /* Truncations are many-one so cannot be removed.  */
7829       if (bitschange < 0)
7830         break;
7831
7832       /* See what's inside this conversion.  If we decide to strip it,
7833          we will set WIN.  */
7834
7835       if (bitschange > 0)
7836         {
7837           op = TREE_OPERAND (op, 0);
7838           /* An extension: the outermost one can be stripped,
7839              but remember whether it is zero or sign extension.  */
7840           if (first)
7841             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7842           /* Otherwise, if a sign extension has been stripped,
7843              only sign extensions can now be stripped;
7844              if a zero extension has been stripped, only zero-extensions.  */
7845           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
7846             break;
7847           first = 0;
7848         }
7849       else /* bitschange == 0 */
7850         {
7851           /* A change in nominal type can always be stripped, but we must
7852              preserve the unsignedness.  */
7853           if (first)
7854             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7855           first = 0;
7856           op = TREE_OPERAND (op, 0);
7857           /* Keep trying to narrow, but don't assign op to win if it
7858              would turn an integral type into something else.  */
7859           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
7860             continue;
7861         }
7862
7863       win = op;
7864     }
7865
7866   if (TREE_CODE (op) == COMPONENT_REF
7867       /* Since type_for_size always gives an integer type.  */
7868       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
7869       && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
7870       /* Ensure field is laid out already.  */
7871       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
7872       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
7873     {
7874       unsigned HOST_WIDE_INT innerprec
7875         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
7876       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
7877                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
7878       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
7879
7880       /* We can get this structure field in a narrower type that fits it,
7881          but the resulting extension to its nominal type (a fullword type)
7882          must satisfy the same conditions as for other extensions.
7883
7884          Do this only for fields that are aligned (not bit-fields),
7885          because when bit-field insns will be used there is no
7886          advantage in doing this.  */
7887
7888       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
7889           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
7890           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
7891           && type != 0)
7892         {
7893           if (first)
7894             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
7895           win = fold_convert (type, op);
7896         }
7897     }
7898
7899   *unsignedp_ptr = uns;
7900   return win;
7901 }
7902 \f
7903 /* Nonzero if integer constant C has a value that is permissible
7904    for type TYPE (an INTEGER_TYPE).  */
7905
7906 int
7907 int_fits_type_p (const_tree c, const_tree type)
7908 {
7909   tree type_low_bound, type_high_bound;
7910   bool ok_for_low_bound, ok_for_high_bound, unsc;
7911   double_int dc, dd;
7912
7913   dc = tree_to_double_int (c);
7914   unsc = TYPE_UNSIGNED (TREE_TYPE (c));
7915
7916   if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE
7917       && TYPE_IS_SIZETYPE (TREE_TYPE (c))
7918       && unsc)
7919     /* So c is an unsigned integer whose type is sizetype and type is not.
7920        sizetype'd integers are sign extended even though they are
7921        unsigned. If the integer value fits in the lower end word of c,
7922        and if the higher end word has all its bits set to 1, that
7923        means the higher end bits are set to 1 only for sign extension.
7924        So let's convert c into an equivalent zero extended unsigned
7925        integer.  */
7926     dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c)));
7927
7928 retry:
7929   type_low_bound = TYPE_MIN_VALUE (type);
7930   type_high_bound = TYPE_MAX_VALUE (type);
7931
7932   /* If at least one bound of the type is a constant integer, we can check
7933      ourselves and maybe make a decision. If no such decision is possible, but
7934      this type is a subtype, try checking against that.  Otherwise, use
7935      fit_double_type, which checks against the precision.
7936
7937      Compute the status for each possibly constant bound, and return if we see
7938      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
7939      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
7940      for "constant known to fit".  */
7941
7942   /* Check if c >= type_low_bound.  */
7943   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
7944     {
7945       dd = tree_to_double_int (type_low_bound);
7946       if (TREE_CODE (type) == INTEGER_TYPE
7947           && TYPE_IS_SIZETYPE (type)
7948           && TYPE_UNSIGNED (type))
7949         dd = double_int_zext (dd, TYPE_PRECISION (type));
7950       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
7951         {
7952           int c_neg = (!unsc && double_int_negative_p (dc));
7953           int t_neg = (unsc && double_int_negative_p (dd));
7954
7955           if (c_neg && !t_neg)
7956             return 0;
7957           if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0)
7958             return 0;
7959         }
7960       else if (double_int_cmp (dc, dd, unsc) < 0)
7961         return 0;
7962       ok_for_low_bound = true;
7963     }
7964   else
7965     ok_for_low_bound = false;
7966
7967   /* Check if c <= type_high_bound.  */
7968   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
7969     {
7970       dd = tree_to_double_int (type_high_bound);
7971       if (TREE_CODE (type) == INTEGER_TYPE
7972           && TYPE_IS_SIZETYPE (type)
7973           && TYPE_UNSIGNED (type))
7974         dd = double_int_zext (dd, TYPE_PRECISION (type));
7975       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
7976         {
7977           int c_neg = (!unsc && double_int_negative_p (dc));
7978           int t_neg = (unsc && double_int_negative_p (dd));
7979
7980           if (t_neg && !c_neg)
7981             return 0;
7982           if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0)
7983             return 0;
7984         }
7985       else if (double_int_cmp (dc, dd, unsc) > 0)
7986         return 0;
7987       ok_for_high_bound = true;
7988     }
7989   else
7990     ok_for_high_bound = false;
7991
7992   /* If the constant fits both bounds, the result is known.  */
7993   if (ok_for_low_bound && ok_for_high_bound)
7994     return 1;
7995
7996   /* Perform some generic filtering which may allow making a decision
7997      even if the bounds are not constant.  First, negative integers
7998      never fit in unsigned types, */
7999   if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc))
8000     return 0;
8001
8002   /* Second, narrower types always fit in wider ones.  */
8003   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
8004     return 1;
8005
8006   /* Third, unsigned integers with top bit set never fit signed types.  */
8007   if (! TYPE_UNSIGNED (type) && unsc)
8008     {
8009       int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1;
8010       if (prec < HOST_BITS_PER_WIDE_INT)
8011         {
8012           if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
8013             return 0;
8014         }
8015       else if (((((unsigned HOST_WIDE_INT) 1)
8016                  << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
8017         return 0;
8018     }
8019
8020   /* If we haven't been able to decide at this point, there nothing more we
8021      can check ourselves here.  Look at the base type if we have one and it
8022      has the same precision.  */
8023   if (TREE_CODE (type) == INTEGER_TYPE
8024       && TREE_TYPE (type) != 0
8025       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
8026     {
8027       type = TREE_TYPE (type);
8028       goto retry;
8029     }
8030
8031   /* Or to fit_double_type, if nothing else.  */
8032   return !fit_double_type (dc.low, dc.high, &dc.low, &dc.high, type);
8033 }
8034
8035 /* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
8036    bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
8037    represented (assuming two's-complement arithmetic) within the bit
8038    precision of the type are returned instead.  */
8039
8040 void
8041 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
8042 {
8043   if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
8044       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
8045     mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
8046                         TYPE_UNSIGNED (type));
8047   else
8048     {
8049       if (TYPE_UNSIGNED (type))
8050         mpz_set_ui (min, 0);
8051       else
8052         {
8053           double_int mn;
8054           mn = double_int_mask (TYPE_PRECISION (type) - 1);
8055           mn = double_int_sext (double_int_add (mn, double_int_one),
8056                                 TYPE_PRECISION (type));
8057           mpz_set_double_int (min, mn, false);
8058         }
8059     }
8060
8061   if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
8062       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
8063     mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
8064                         TYPE_UNSIGNED (type));
8065   else
8066     {
8067       if (TYPE_UNSIGNED (type))
8068         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)),
8069                             true);
8070       else
8071         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1),
8072                             true);
8073     }
8074 }
8075
8076 /* Return true if VAR is an automatic variable defined in function FN.  */
8077
8078 bool
8079 auto_var_in_fn_p (const_tree var, const_tree fn)
8080 {
8081   return (DECL_P (var) && DECL_CONTEXT (var) == fn
8082           && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
8083                 || TREE_CODE (var) == PARM_DECL)
8084                && ! TREE_STATIC (var))
8085               || TREE_CODE (var) == LABEL_DECL
8086               || TREE_CODE (var) == RESULT_DECL));
8087 }
8088
8089 /* Subprogram of following function.  Called by walk_tree.
8090
8091    Return *TP if it is an automatic variable or parameter of the
8092    function passed in as DATA.  */
8093
8094 static tree
8095 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
8096 {
8097   tree fn = (tree) data;
8098
8099   if (TYPE_P (*tp))
8100     *walk_subtrees = 0;
8101
8102   else if (DECL_P (*tp)
8103            && auto_var_in_fn_p (*tp, fn))
8104     return *tp;
8105
8106   return NULL_TREE;
8107 }
8108
8109 /* Returns true if T is, contains, or refers to a type with variable
8110    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
8111    arguments, but not the return type.  If FN is nonzero, only return
8112    true if a modifier of the type or position of FN is a variable or
8113    parameter inside FN.
8114
8115    This concept is more general than that of C99 'variably modified types':
8116    in C99, a struct type is never variably modified because a VLA may not
8117    appear as a structure member.  However, in GNU C code like:
8118
8119      struct S { int i[f()]; };
8120
8121    is valid, and other languages may define similar constructs.  */
8122
8123 bool
8124 variably_modified_type_p (tree type, tree fn)
8125 {
8126   tree t;
8127
8128 /* Test if T is either variable (if FN is zero) or an expression containing
8129    a variable in FN.  */
8130 #define RETURN_TRUE_IF_VAR(T)                                           \
8131   do { tree _t = (T);                                                   \
8132     if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
8133         && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
8134       return true;  } while (0)
8135
8136   if (type == error_mark_node)
8137     return false;
8138
8139   /* If TYPE itself has variable size, it is variably modified.  */
8140   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8141   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8142
8143   switch (TREE_CODE (type))
8144     {
8145     case POINTER_TYPE:
8146     case REFERENCE_TYPE:
8147     case VECTOR_TYPE:
8148       if (variably_modified_type_p (TREE_TYPE (type), fn))
8149         return true;
8150       break;
8151
8152     case FUNCTION_TYPE:
8153     case METHOD_TYPE:
8154       /* If TYPE is a function type, it is variably modified if the
8155          return type is variably modified.  */
8156       if (variably_modified_type_p (TREE_TYPE (type), fn))
8157           return true;
8158       break;
8159
8160     case INTEGER_TYPE:
8161     case REAL_TYPE:
8162     case FIXED_POINT_TYPE:
8163     case ENUMERAL_TYPE:
8164     case BOOLEAN_TYPE:
8165       /* Scalar types are variably modified if their end points
8166          aren't constant.  */
8167       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8168       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8169       break;
8170
8171     case RECORD_TYPE:
8172     case UNION_TYPE:
8173     case QUAL_UNION_TYPE:
8174       /* We can't see if any of the fields are variably-modified by the
8175          definition we normally use, since that would produce infinite
8176          recursion via pointers.  */
8177       /* This is variably modified if some field's type is.  */
8178       for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
8179         if (TREE_CODE (t) == FIELD_DECL)
8180           {
8181             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8182             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8183             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8184
8185             if (TREE_CODE (type) == QUAL_UNION_TYPE)
8186               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8187           }
8188         break;
8189
8190     case ARRAY_TYPE:
8191       /* Do not call ourselves to avoid infinite recursion.  This is
8192          variably modified if the element type is.  */
8193       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8194       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8195       break;
8196
8197     default:
8198       break;
8199     }
8200
8201   /* The current language may have other cases to check, but in general,
8202      all other types are not variably modified.  */
8203   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8204
8205 #undef RETURN_TRUE_IF_VAR
8206 }
8207
8208 /* Given a DECL or TYPE, return the scope in which it was declared, or
8209    NULL_TREE if there is no containing scope.  */
8210
8211 tree
8212 get_containing_scope (const_tree t)
8213 {
8214   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8215 }
8216
8217 /* Return the innermost context enclosing DECL that is
8218    a FUNCTION_DECL, or zero if none.  */
8219
8220 tree
8221 decl_function_context (const_tree decl)
8222 {
8223   tree context;
8224
8225   if (TREE_CODE (decl) == ERROR_MARK)
8226     return 0;
8227
8228   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8229      where we look up the function at runtime.  Such functions always take
8230      a first argument of type 'pointer to real context'.
8231
8232      C++ should really be fixed to use DECL_CONTEXT for the real context,
8233      and use something else for the "virtual context".  */
8234   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8235     context
8236       = TYPE_MAIN_VARIANT
8237         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8238   else
8239     context = DECL_CONTEXT (decl);
8240
8241   while (context && TREE_CODE (context) != FUNCTION_DECL)
8242     {
8243       if (TREE_CODE (context) == BLOCK)
8244         context = BLOCK_SUPERCONTEXT (context);
8245       else
8246         context = get_containing_scope (context);
8247     }
8248
8249   return context;
8250 }
8251
8252 /* Return the innermost context enclosing DECL that is
8253    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8254    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
8255
8256 tree
8257 decl_type_context (const_tree decl)
8258 {
8259   tree context = DECL_CONTEXT (decl);
8260
8261   while (context)
8262     switch (TREE_CODE (context))
8263       {
8264       case NAMESPACE_DECL:
8265       case TRANSLATION_UNIT_DECL:
8266         return NULL_TREE;
8267
8268       case RECORD_TYPE:
8269       case UNION_TYPE:
8270       case QUAL_UNION_TYPE:
8271         return context;
8272
8273       case TYPE_DECL:
8274       case FUNCTION_DECL:
8275         context = DECL_CONTEXT (context);
8276         break;
8277
8278       case BLOCK:
8279         context = BLOCK_SUPERCONTEXT (context);
8280         break;
8281
8282       default:
8283         gcc_unreachable ();
8284       }
8285
8286   return NULL_TREE;
8287 }
8288
8289 /* CALL is a CALL_EXPR.  Return the declaration for the function
8290    called, or NULL_TREE if the called function cannot be
8291    determined.  */
8292
8293 tree
8294 get_callee_fndecl (const_tree call)
8295 {
8296   tree addr;
8297
8298   if (call == error_mark_node)
8299     return error_mark_node;
8300
8301   /* It's invalid to call this function with anything but a
8302      CALL_EXPR.  */
8303   gcc_assert (TREE_CODE (call) == CALL_EXPR);
8304
8305   /* The first operand to the CALL is the address of the function
8306      called.  */
8307   addr = CALL_EXPR_FN (call);
8308
8309   STRIP_NOPS (addr);
8310
8311   /* If this is a readonly function pointer, extract its initial value.  */
8312   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8313       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8314       && DECL_INITIAL (addr))
8315     addr = DECL_INITIAL (addr);
8316
8317   /* If the address is just `&f' for some function `f', then we know
8318      that `f' is being called.  */
8319   if (TREE_CODE (addr) == ADDR_EXPR
8320       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8321     return TREE_OPERAND (addr, 0);
8322
8323   /* We couldn't figure out what was being called.  */
8324   return NULL_TREE;
8325 }
8326
8327 /* Print debugging information about tree nodes generated during the compile,
8328    and any language-specific information.  */
8329
8330 void
8331 dump_tree_statistics (void)
8332 {
8333 #ifdef GATHER_STATISTICS
8334   int i;
8335   int total_nodes, total_bytes;
8336 #endif
8337
8338   fprintf (stderr, "\n??? tree nodes created\n\n");
8339 #ifdef GATHER_STATISTICS
8340   fprintf (stderr, "Kind                   Nodes      Bytes\n");
8341   fprintf (stderr, "---------------------------------------\n");
8342   total_nodes = total_bytes = 0;
8343   for (i = 0; i < (int) all_kinds; i++)
8344     {
8345       fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8346                tree_node_counts[i], tree_node_sizes[i]);
8347       total_nodes += tree_node_counts[i];
8348       total_bytes += tree_node_sizes[i];
8349     }
8350   fprintf (stderr, "---------------------------------------\n");
8351   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8352   fprintf (stderr, "---------------------------------------\n");
8353   ssanames_print_statistics ();
8354   phinodes_print_statistics ();
8355 #else
8356   fprintf (stderr, "(No per-node statistics)\n");
8357 #endif
8358   print_type_hash_statistics ();
8359   print_debug_expr_statistics ();
8360   print_value_expr_statistics ();
8361   lang_hooks.print_statistics ();
8362 }
8363 \f
8364 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8365
8366 /* Generate a crc32 of a string.  */
8367
8368 unsigned
8369 crc32_string (unsigned chksum, const char *string)
8370 {
8371   do
8372     {
8373       unsigned value = *string << 24;
8374       unsigned ix;
8375
8376       for (ix = 8; ix--; value <<= 1)
8377         {
8378           unsigned feedback;
8379
8380           feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
8381           chksum <<= 1;
8382           chksum ^= feedback;
8383         }
8384     }
8385   while (*string++);
8386   return chksum;
8387 }
8388
8389 /* P is a string that will be used in a symbol.  Mask out any characters
8390    that are not valid in that context.  */
8391
8392 void
8393 clean_symbol_name (char *p)
8394 {
8395   for (; *p; p++)
8396     if (! (ISALNUM (*p)
8397 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
8398             || *p == '$'
8399 #endif
8400 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
8401             || *p == '.'
8402 #endif
8403            ))
8404       *p = '_';
8405 }
8406
8407 /* Generate a name for a special-purpose function function.
8408    The generated name may need to be unique across the whole link.
8409    TYPE is some string to identify the purpose of this function to the
8410    linker or collect2; it must start with an uppercase letter,
8411    one of:
8412    I - for constructors
8413    D - for destructors
8414    N - for C++ anonymous namespaces
8415    F - for DWARF unwind frame information.  */
8416
8417 tree
8418 get_file_function_name (const char *type)
8419 {
8420   char *buf;
8421   const char *p;
8422   char *q;
8423
8424   /* If we already have a name we know to be unique, just use that.  */
8425   if (first_global_object_name)
8426     p = q = ASTRDUP (first_global_object_name);
8427   /* If the target is handling the constructors/destructors, they
8428      will be local to this file and the name is only necessary for
8429      debugging purposes.  */
8430   else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
8431     {
8432       const char *file = main_input_filename;
8433       if (! file)
8434         file = input_filename;
8435       /* Just use the file's basename, because the full pathname
8436          might be quite long.  */
8437       p = strrchr (file, '/');
8438       if (p)
8439         p++;
8440       else
8441         p = file;
8442       p = q = ASTRDUP (p);
8443     }
8444   else
8445     {
8446       /* Otherwise, the name must be unique across the entire link.
8447          We don't have anything that we know to be unique to this translation
8448          unit, so use what we do have and throw in some randomness.  */
8449       unsigned len;
8450       const char *name = weak_global_object_name;
8451       const char *file = main_input_filename;
8452
8453       if (! name)
8454         name = "";
8455       if (! file)
8456         file = input_filename;
8457
8458       len = strlen (file);
8459       q = (char *) alloca (9 * 2 + len + 1);
8460       memcpy (q, file, len + 1);
8461
8462       sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
8463                crc32_string (0, get_random_seed (false)));
8464
8465       p = q;
8466     }
8467
8468   clean_symbol_name (q);
8469   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
8470                          + strlen (type));
8471
8472   /* Set up the name of the file-level functions we may need.
8473      Use a global object (which is already required to be unique over
8474      the program) rather than the file name (which imposes extra
8475      constraints).  */
8476   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
8477
8478   return get_identifier (buf);
8479 }
8480 \f
8481 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8482
8483 /* Complain that the tree code of NODE does not match the expected 0
8484    terminated list of trailing codes. The trailing code list can be
8485    empty, for a more vague error message.  FILE, LINE, and FUNCTION
8486    are of the caller.  */
8487
8488 void
8489 tree_check_failed (const_tree node, const char *file,
8490                    int line, const char *function, ...)
8491 {
8492   va_list args;
8493   const char *buffer;
8494   unsigned length = 0;
8495   int code;
8496
8497   va_start (args, function);
8498   while ((code = va_arg (args, int)))
8499     length += 4 + strlen (tree_code_name[code]);
8500   va_end (args);
8501   if (length)
8502     {
8503       char *tmp;
8504       va_start (args, function);
8505       length += strlen ("expected ");
8506       buffer = tmp = (char *) alloca (length);
8507       length = 0;
8508       while ((code = va_arg (args, int)))
8509         {
8510           const char *prefix = length ? " or " : "expected ";
8511
8512           strcpy (tmp + length, prefix);
8513           length += strlen (prefix);
8514           strcpy (tmp + length, tree_code_name[code]);
8515           length += strlen (tree_code_name[code]);
8516         }
8517       va_end (args);
8518     }
8519   else
8520     buffer = "unexpected node";
8521
8522   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8523                   buffer, tree_code_name[TREE_CODE (node)],
8524                   function, trim_filename (file), line);
8525 }
8526
8527 /* Complain that the tree code of NODE does match the expected 0
8528    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8529    the caller.  */
8530
8531 void
8532 tree_not_check_failed (const_tree node, const char *file,
8533                        int line, const char *function, ...)
8534 {
8535   va_list args;
8536   char *buffer;
8537   unsigned length = 0;
8538   int code;
8539
8540   va_start (args, function);
8541   while ((code = va_arg (args, int)))
8542     length += 4 + strlen (tree_code_name[code]);
8543   va_end (args);
8544   va_start (args, function);
8545   buffer = (char *) alloca (length);
8546   length = 0;
8547   while ((code = va_arg (args, int)))
8548     {
8549       if (length)
8550         {
8551           strcpy (buffer + length, " or ");
8552           length += 4;
8553         }
8554       strcpy (buffer + length, tree_code_name[code]);
8555       length += strlen (tree_code_name[code]);
8556     }
8557   va_end (args);
8558
8559   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8560                   buffer, tree_code_name[TREE_CODE (node)],
8561                   function, trim_filename (file), line);
8562 }
8563
8564 /* Similar to tree_check_failed, except that we check for a class of tree
8565    code, given in CL.  */
8566
8567 void
8568 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
8569                          const char *file, int line, const char *function)
8570 {
8571   internal_error
8572     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8573      TREE_CODE_CLASS_STRING (cl),
8574      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8575      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8576 }
8577
8578 /* Similar to tree_check_failed, except that instead of specifying a
8579    dozen codes, use the knowledge that they're all sequential.  */
8580
8581 void
8582 tree_range_check_failed (const_tree node, const char *file, int line,
8583                          const char *function, enum tree_code c1,
8584                          enum tree_code c2)
8585 {
8586   char *buffer;
8587   unsigned length = 0;
8588   unsigned int c;
8589
8590   for (c = c1; c <= c2; ++c)
8591     length += 4 + strlen (tree_code_name[c]);
8592
8593   length += strlen ("expected ");
8594   buffer = (char *) alloca (length);
8595   length = 0;
8596
8597   for (c = c1; c <= c2; ++c)
8598     {
8599       const char *prefix = length ? " or " : "expected ";
8600
8601       strcpy (buffer + length, prefix);
8602       length += strlen (prefix);
8603       strcpy (buffer + length, tree_code_name[c]);
8604       length += strlen (tree_code_name[c]);
8605     }
8606
8607   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8608                   buffer, tree_code_name[TREE_CODE (node)],
8609                   function, trim_filename (file), line);
8610 }
8611
8612
8613 /* Similar to tree_check_failed, except that we check that a tree does
8614    not have the specified code, given in CL.  */
8615
8616 void
8617 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
8618                              const char *file, int line, const char *function)
8619 {
8620   internal_error
8621     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8622      TREE_CODE_CLASS_STRING (cl),
8623      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8624      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8625 }
8626
8627
8628 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
8629
8630 void
8631 omp_clause_check_failed (const_tree node, const char *file, int line,
8632                          const char *function, enum omp_clause_code code)
8633 {
8634   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8635                   omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
8636                   function, trim_filename (file), line);
8637 }
8638
8639
8640 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
8641
8642 void
8643 omp_clause_range_check_failed (const_tree node, const char *file, int line,
8644                                const char *function, enum omp_clause_code c1,
8645                                enum omp_clause_code c2)
8646 {
8647   char *buffer;
8648   unsigned length = 0;
8649   unsigned int c;
8650
8651   for (c = c1; c <= c2; ++c)
8652     length += 4 + strlen (omp_clause_code_name[c]);
8653
8654   length += strlen ("expected ");
8655   buffer = (char *) alloca (length);
8656   length = 0;
8657
8658   for (c = c1; c <= c2; ++c)
8659     {
8660       const char *prefix = length ? " or " : "expected ";
8661
8662       strcpy (buffer + length, prefix);
8663       length += strlen (prefix);
8664       strcpy (buffer + length, omp_clause_code_name[c]);
8665       length += strlen (omp_clause_code_name[c]);
8666     }
8667
8668   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8669                   buffer, omp_clause_code_name[TREE_CODE (node)],
8670                   function, trim_filename (file), line);
8671 }
8672
8673
8674 #undef DEFTREESTRUCT
8675 #define DEFTREESTRUCT(VAL, NAME) NAME,
8676
8677 static const char *ts_enum_names[] = {
8678 #include "treestruct.def"
8679 };
8680 #undef DEFTREESTRUCT
8681
8682 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8683
8684 /* Similar to tree_class_check_failed, except that we check for
8685    whether CODE contains the tree structure identified by EN.  */
8686
8687 void
8688 tree_contains_struct_check_failed (const_tree node,
8689                                    const enum tree_node_structure_enum en,
8690                                    const char *file, int line,
8691                                    const char *function)
8692 {
8693   internal_error
8694     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8695      TS_ENUM_NAME(en),
8696      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8697 }
8698
8699
8700 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
8701    (dynamically sized) vector.  */
8702
8703 void
8704 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
8705                            const char *function)
8706 {
8707   internal_error
8708     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8709      idx + 1, len, function, trim_filename (file), line);
8710 }
8711
8712 /* Similar to above, except that the check is for the bounds of the operand
8713    vector of an expression node EXP.  */
8714
8715 void
8716 tree_operand_check_failed (int idx, const_tree exp, const char *file,
8717                            int line, const char *function)
8718 {
8719   int code = TREE_CODE (exp);
8720   internal_error
8721     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8722      idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
8723      function, trim_filename (file), line);
8724 }
8725
8726 /* Similar to above, except that the check is for the number of
8727    operands of an OMP_CLAUSE node.  */
8728
8729 void
8730 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
8731                                  int line, const char *function)
8732 {
8733   internal_error
8734     ("tree check: accessed operand %d of omp_clause %s with %d operands "
8735      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
8736      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
8737      trim_filename (file), line);
8738 }
8739 #endif /* ENABLE_TREE_CHECKING */
8740 \f
8741 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8742    and mapped to the machine mode MODE.  Initialize its fields and build
8743    the information necessary for debugging output.  */
8744
8745 static tree
8746 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
8747 {
8748   tree t;
8749   hashval_t hashcode = 0;
8750
8751   t = make_node (VECTOR_TYPE);
8752   TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
8753   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
8754   SET_TYPE_MODE (t, mode);
8755
8756   if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
8757     SET_TYPE_STRUCTURAL_EQUALITY (t);
8758   else if (TYPE_CANONICAL (innertype) != innertype
8759            || mode != VOIDmode)
8760     TYPE_CANONICAL (t)
8761       = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
8762
8763   layout_type (t);
8764
8765   {
8766     tree index = build_int_cst (NULL_TREE, nunits - 1);
8767     tree array = build_array_type (TYPE_MAIN_VARIANT (innertype),
8768                                    build_index_type (index));
8769     tree rt = make_node (RECORD_TYPE);
8770
8771     TYPE_FIELDS (rt) = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
8772                                    get_identifier ("f"), array);
8773     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
8774     layout_type (rt);
8775     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
8776     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
8777        the representation type, and we want to find that die when looking up
8778        the vector type.  This is most easily achieved by making the TYPE_UID
8779        numbers equal.  */
8780     TYPE_UID (rt) = TYPE_UID (t);
8781   }
8782
8783   hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
8784   hashcode = iterative_hash_host_wide_int (nunits, hashcode);
8785   hashcode = iterative_hash_host_wide_int (mode, hashcode);
8786   hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
8787   t = type_hash_canon (hashcode, t);
8788
8789   /* We have built a main variant, based on the main variant of the
8790      inner type. Use it to build the variant we return.  */
8791   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
8792       && TREE_TYPE (t) != innertype)
8793     return build_type_attribute_qual_variant (t,
8794                                               TYPE_ATTRIBUTES (innertype),
8795                                               TYPE_QUALS (innertype));
8796
8797   return t;
8798 }
8799
8800 static tree
8801 make_or_reuse_type (unsigned size, int unsignedp)
8802 {
8803   if (size == INT_TYPE_SIZE)
8804     return unsignedp ? unsigned_type_node : integer_type_node;
8805   if (size == CHAR_TYPE_SIZE)
8806     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
8807   if (size == SHORT_TYPE_SIZE)
8808     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
8809   if (size == LONG_TYPE_SIZE)
8810     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
8811   if (size == LONG_LONG_TYPE_SIZE)
8812     return (unsignedp ? long_long_unsigned_type_node
8813             : long_long_integer_type_node);
8814   if (size == 128 && int128_integer_type_node)
8815     return (unsignedp ? int128_unsigned_type_node
8816             : int128_integer_type_node);
8817
8818   if (unsignedp)
8819     return make_unsigned_type (size);
8820   else
8821     return make_signed_type (size);
8822 }
8823
8824 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
8825
8826 static tree
8827 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
8828 {
8829   if (satp)
8830     {
8831       if (size == SHORT_FRACT_TYPE_SIZE)
8832         return unsignedp ? sat_unsigned_short_fract_type_node
8833                          : sat_short_fract_type_node;
8834       if (size == FRACT_TYPE_SIZE)
8835         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
8836       if (size == LONG_FRACT_TYPE_SIZE)
8837         return unsignedp ? sat_unsigned_long_fract_type_node
8838                          : sat_long_fract_type_node;
8839       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8840         return unsignedp ? sat_unsigned_long_long_fract_type_node
8841                          : sat_long_long_fract_type_node;
8842     }
8843   else
8844     {
8845       if (size == SHORT_FRACT_TYPE_SIZE)
8846         return unsignedp ? unsigned_short_fract_type_node
8847                          : short_fract_type_node;
8848       if (size == FRACT_TYPE_SIZE)
8849         return unsignedp ? unsigned_fract_type_node : fract_type_node;
8850       if (size == LONG_FRACT_TYPE_SIZE)
8851         return unsignedp ? unsigned_long_fract_type_node
8852                          : long_fract_type_node;
8853       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8854         return unsignedp ? unsigned_long_long_fract_type_node
8855                          : long_long_fract_type_node;
8856     }
8857
8858   return make_fract_type (size, unsignedp, satp);
8859 }
8860
8861 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
8862
8863 static tree
8864 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
8865 {
8866   if (satp)
8867     {
8868       if (size == SHORT_ACCUM_TYPE_SIZE)
8869         return unsignedp ? sat_unsigned_short_accum_type_node
8870                          : sat_short_accum_type_node;
8871       if (size == ACCUM_TYPE_SIZE)
8872         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
8873       if (size == LONG_ACCUM_TYPE_SIZE)
8874         return unsignedp ? sat_unsigned_long_accum_type_node
8875                          : sat_long_accum_type_node;
8876       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8877         return unsignedp ? sat_unsigned_long_long_accum_type_node
8878                          : sat_long_long_accum_type_node;
8879     }
8880   else
8881     {
8882       if (size == SHORT_ACCUM_TYPE_SIZE)
8883         return unsignedp ? unsigned_short_accum_type_node
8884                          : short_accum_type_node;
8885       if (size == ACCUM_TYPE_SIZE)
8886         return unsignedp ? unsigned_accum_type_node : accum_type_node;
8887       if (size == LONG_ACCUM_TYPE_SIZE)
8888         return unsignedp ? unsigned_long_accum_type_node
8889                          : long_accum_type_node;
8890       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8891         return unsignedp ? unsigned_long_long_accum_type_node
8892                          : long_long_accum_type_node;
8893     }
8894
8895   return make_accum_type (size, unsignedp, satp);
8896 }
8897
8898 /* Create nodes for all integer types (and error_mark_node) using the sizes
8899    of C datatypes.  The caller should call set_sizetype soon after calling
8900    this function to select one of the types as sizetype.  */
8901
8902 void
8903 build_common_tree_nodes (bool signed_char)
8904 {
8905   error_mark_node = make_node (ERROR_MARK);
8906   TREE_TYPE (error_mark_node) = error_mark_node;
8907
8908   initialize_sizetypes ();
8909
8910   /* Define both `signed char' and `unsigned char'.  */
8911   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
8912   TYPE_STRING_FLAG (signed_char_type_node) = 1;
8913   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
8914   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
8915
8916   /* Define `char', which is like either `signed char' or `unsigned char'
8917      but not the same as either.  */
8918   char_type_node
8919     = (signed_char
8920        ? make_signed_type (CHAR_TYPE_SIZE)
8921        : make_unsigned_type (CHAR_TYPE_SIZE));
8922   TYPE_STRING_FLAG (char_type_node) = 1;
8923
8924   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
8925   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
8926   integer_type_node = make_signed_type (INT_TYPE_SIZE);
8927   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
8928   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
8929   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
8930   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
8931   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
8932 #if HOST_BITS_PER_WIDE_INT >= 64
8933     /* TODO: This isn't correct, but as logic depends at the moment on
8934        host's instead of target's wide-integer.
8935        If there is a target not supporting TImode, but has an 128-bit
8936        integer-scalar register, this target check needs to be adjusted. */
8937     if (targetm.scalar_mode_supported_p (TImode))
8938       {
8939         int128_integer_type_node = make_signed_type (128);
8940         int128_unsigned_type_node = make_unsigned_type (128);
8941       }
8942 #endif
8943   /* Define a boolean type.  This type only represents boolean values but
8944      may be larger than char depending on the value of BOOL_TYPE_SIZE.
8945      Front ends which want to override this size (i.e. Java) can redefine
8946      boolean_type_node before calling build_common_tree_nodes_2.  */
8947   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
8948   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
8949   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
8950   TYPE_PRECISION (boolean_type_node) = 1;
8951
8952   /* Fill in the rest of the sized types.  Reuse existing type nodes
8953      when possible.  */
8954   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
8955   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
8956   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
8957   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
8958   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
8959
8960   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
8961   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
8962   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
8963   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
8964   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
8965
8966   access_public_node = get_identifier ("public");
8967   access_protected_node = get_identifier ("protected");
8968   access_private_node = get_identifier ("private");
8969 }
8970
8971 /* Call this function after calling build_common_tree_nodes and set_sizetype.
8972    It will create several other common tree nodes.  */
8973
8974 void
8975 build_common_tree_nodes_2 (int short_double)
8976 {
8977   /* Define these next since types below may used them.  */
8978   integer_zero_node = build_int_cst (NULL_TREE, 0);
8979   integer_one_node = build_int_cst (NULL_TREE, 1);
8980   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
8981
8982   size_zero_node = size_int (0);
8983   size_one_node = size_int (1);
8984   bitsize_zero_node = bitsize_int (0);
8985   bitsize_one_node = bitsize_int (1);
8986   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
8987
8988   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
8989   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
8990
8991   void_type_node = make_node (VOID_TYPE);
8992   layout_type (void_type_node);
8993
8994   /* We are not going to have real types in C with less than byte alignment,
8995      so we might as well not have any types that claim to have it.  */
8996   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
8997   TYPE_USER_ALIGN (void_type_node) = 0;
8998
8999   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
9000   layout_type (TREE_TYPE (null_pointer_node));
9001
9002   ptr_type_node = build_pointer_type (void_type_node);
9003   const_ptr_type_node
9004     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
9005   fileptr_type_node = ptr_type_node;
9006
9007   float_type_node = make_node (REAL_TYPE);
9008   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
9009   layout_type (float_type_node);
9010
9011   double_type_node = make_node (REAL_TYPE);
9012   if (short_double)
9013     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
9014   else
9015     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
9016   layout_type (double_type_node);
9017
9018   long_double_type_node = make_node (REAL_TYPE);
9019   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
9020   layout_type (long_double_type_node);
9021
9022   float_ptr_type_node = build_pointer_type (float_type_node);
9023   double_ptr_type_node = build_pointer_type (double_type_node);
9024   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
9025   integer_ptr_type_node = build_pointer_type (integer_type_node);
9026
9027   /* Fixed size integer types.  */
9028   uint32_type_node = build_nonstandard_integer_type (32, true);
9029   uint64_type_node = build_nonstandard_integer_type (64, true);
9030
9031   /* Decimal float types. */
9032   dfloat32_type_node = make_node (REAL_TYPE);
9033   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
9034   layout_type (dfloat32_type_node);
9035   SET_TYPE_MODE (dfloat32_type_node, SDmode);
9036   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
9037
9038   dfloat64_type_node = make_node (REAL_TYPE);
9039   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
9040   layout_type (dfloat64_type_node);
9041   SET_TYPE_MODE (dfloat64_type_node, DDmode);
9042   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
9043
9044   dfloat128_type_node = make_node (REAL_TYPE);
9045   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
9046   layout_type (dfloat128_type_node);
9047   SET_TYPE_MODE (dfloat128_type_node, TDmode);
9048   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
9049
9050   complex_integer_type_node = build_complex_type (integer_type_node);
9051   complex_float_type_node = build_complex_type (float_type_node);
9052   complex_double_type_node = build_complex_type (double_type_node);
9053   complex_long_double_type_node = build_complex_type (long_double_type_node);
9054
9055 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
9056 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
9057   sat_ ## KIND ## _type_node = \
9058     make_sat_signed_ ## KIND ## _type (SIZE); \
9059   sat_unsigned_ ## KIND ## _type_node = \
9060     make_sat_unsigned_ ## KIND ## _type (SIZE); \
9061   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9062   unsigned_ ## KIND ## _type_node = \
9063     make_unsigned_ ## KIND ## _type (SIZE);
9064
9065 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
9066   sat_ ## WIDTH ## KIND ## _type_node = \
9067     make_sat_signed_ ## KIND ## _type (SIZE); \
9068   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
9069     make_sat_unsigned_ ## KIND ## _type (SIZE); \
9070   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
9071   unsigned_ ## WIDTH ## KIND ## _type_node = \
9072     make_unsigned_ ## KIND ## _type (SIZE);
9073
9074 /* Make fixed-point type nodes based on four different widths.  */
9075 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
9076   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
9077   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
9078   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
9079   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
9080
9081 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
9082 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
9083   NAME ## _type_node = \
9084     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
9085   u ## NAME ## _type_node = \
9086     make_or_reuse_unsigned_ ## KIND ## _type \
9087       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
9088   sat_ ## NAME ## _type_node = \
9089     make_or_reuse_sat_signed_ ## KIND ## _type \
9090       (GET_MODE_BITSIZE (MODE ## mode)); \
9091   sat_u ## NAME ## _type_node = \
9092     make_or_reuse_sat_unsigned_ ## KIND ## _type \
9093       (GET_MODE_BITSIZE (U ## MODE ## mode));
9094
9095   /* Fixed-point type and mode nodes.  */
9096   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
9097   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
9098   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
9099   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
9100   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
9101   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
9102   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
9103   MAKE_FIXED_MODE_NODE (accum, ha, HA)
9104   MAKE_FIXED_MODE_NODE (accum, sa, SA)
9105   MAKE_FIXED_MODE_NODE (accum, da, DA)
9106   MAKE_FIXED_MODE_NODE (accum, ta, TA)
9107
9108   {
9109     tree t = targetm.build_builtin_va_list ();
9110
9111     /* Many back-ends define record types without setting TYPE_NAME.
9112        If we copied the record type here, we'd keep the original
9113        record type without a name.  This breaks name mangling.  So,
9114        don't copy record types and let c_common_nodes_and_builtins()
9115        declare the type to be __builtin_va_list.  */
9116     if (TREE_CODE (t) != RECORD_TYPE)
9117       t = build_variant_type_copy (t);
9118
9119     va_list_type_node = t;
9120   }
9121 }
9122
9123 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
9124
9125 static void
9126 local_define_builtin (const char *name, tree type, enum built_in_function code,
9127                       const char *library_name, int ecf_flags)
9128 {
9129   tree decl;
9130
9131   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
9132                                library_name, NULL_TREE);
9133   if (ecf_flags & ECF_CONST)
9134     TREE_READONLY (decl) = 1;
9135   if (ecf_flags & ECF_PURE)
9136     DECL_PURE_P (decl) = 1;
9137   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
9138     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
9139   if (ecf_flags & ECF_NORETURN)
9140     TREE_THIS_VOLATILE (decl) = 1;
9141   if (ecf_flags & ECF_NOTHROW)
9142     TREE_NOTHROW (decl) = 1;
9143   if (ecf_flags & ECF_MALLOC)
9144     DECL_IS_MALLOC (decl) = 1;
9145
9146   built_in_decls[code] = decl;
9147   implicit_built_in_decls[code] = decl;
9148 }
9149
9150 /* Call this function after instantiating all builtins that the language
9151    front end cares about.  This will build the rest of the builtins that
9152    are relied upon by the tree optimizers and the middle-end.  */
9153
9154 void
9155 build_common_builtin_nodes (void)
9156 {
9157   tree tmp, tmp2, ftype;
9158
9159   if (built_in_decls[BUILT_IN_MEMCPY] == NULL
9160       || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9161     {
9162       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9163       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9164       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9165       ftype = build_function_type (ptr_type_node, tmp);
9166
9167       if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
9168         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9169                               "memcpy", ECF_NOTHROW);
9170       if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9171         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9172                               "memmove", ECF_NOTHROW);
9173     }
9174
9175   if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
9176     {
9177       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9178       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9179       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9180       ftype = build_function_type (integer_type_node, tmp);
9181       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9182                             "memcmp", ECF_PURE | ECF_NOTHROW);
9183     }
9184
9185   if (built_in_decls[BUILT_IN_MEMSET] == NULL)
9186     {
9187       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9188       tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9189       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9190       ftype = build_function_type (ptr_type_node, tmp);
9191       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9192                             "memset", ECF_NOTHROW);
9193     }
9194
9195   if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
9196     {
9197       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9198       ftype = build_function_type (ptr_type_node, tmp);
9199       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
9200                             "alloca", ECF_MALLOC | ECF_NOTHROW);
9201     }
9202
9203   /* If we're checking the stack, `alloca' can throw.  */
9204   if (flag_stack_check)
9205     TREE_NOTHROW (built_in_decls[BUILT_IN_ALLOCA]) = 0;
9206
9207   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9208   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9209   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9210   ftype = build_function_type (void_type_node, tmp);
9211   local_define_builtin ("__builtin_init_trampoline", ftype,
9212                         BUILT_IN_INIT_TRAMPOLINE,
9213                         "__builtin_init_trampoline", ECF_NOTHROW);
9214
9215   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9216   ftype = build_function_type (ptr_type_node, tmp);
9217   local_define_builtin ("__builtin_adjust_trampoline", ftype,
9218                         BUILT_IN_ADJUST_TRAMPOLINE,
9219                         "__builtin_adjust_trampoline",
9220                         ECF_CONST | ECF_NOTHROW);
9221
9222   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9223   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9224   ftype = build_function_type (void_type_node, tmp);
9225   local_define_builtin ("__builtin_nonlocal_goto", ftype,
9226                         BUILT_IN_NONLOCAL_GOTO,
9227                         "__builtin_nonlocal_goto",
9228                         ECF_NORETURN | ECF_NOTHROW);
9229
9230   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9231   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9232   ftype = build_function_type (void_type_node, tmp);
9233   local_define_builtin ("__builtin_setjmp_setup", ftype,
9234                         BUILT_IN_SETJMP_SETUP,
9235                         "__builtin_setjmp_setup", ECF_NOTHROW);
9236
9237   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9238   ftype = build_function_type (ptr_type_node, tmp);
9239   local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
9240                         BUILT_IN_SETJMP_DISPATCHER,
9241                         "__builtin_setjmp_dispatcher",
9242                         ECF_PURE | ECF_NOTHROW);
9243
9244   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9245   ftype = build_function_type (void_type_node, tmp);
9246   local_define_builtin ("__builtin_setjmp_receiver", ftype,
9247                         BUILT_IN_SETJMP_RECEIVER,
9248                         "__builtin_setjmp_receiver", ECF_NOTHROW);
9249
9250   ftype = build_function_type (ptr_type_node, void_list_node);
9251   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
9252                         "__builtin_stack_save", ECF_NOTHROW);
9253
9254   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9255   ftype = build_function_type (void_type_node, tmp);
9256   local_define_builtin ("__builtin_stack_restore", ftype,
9257                         BUILT_IN_STACK_RESTORE,
9258                         "__builtin_stack_restore", ECF_NOTHROW);
9259
9260   ftype = build_function_type (void_type_node, void_list_node);
9261   local_define_builtin ("__builtin_profile_func_enter", ftype,
9262                         BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
9263   local_define_builtin ("__builtin_profile_func_exit", ftype,
9264                         BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
9265
9266   /* If there's a possibility that we might use the ARM EABI, build the
9267     alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
9268   if (targetm.arm_eabi_unwinder)
9269     {
9270       ftype = build_function_type (void_type_node, void_list_node);
9271       local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
9272                             BUILT_IN_CXA_END_CLEANUP,
9273                             "__cxa_end_cleanup", ECF_NORETURN);
9274     }
9275
9276   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9277   ftype = build_function_type (void_type_node, tmp);
9278   local_define_builtin ("__builtin_unwind_resume", ftype,
9279                         BUILT_IN_UNWIND_RESUME,
9280                         (USING_SJLJ_EXCEPTIONS
9281                          ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9282                         ECF_NORETURN);
9283
9284   /* The exception object and filter values from the runtime.  The argument
9285      must be zero before exception lowering, i.e. from the front end.  After
9286      exception lowering, it will be the region number for the exception
9287      landing pad.  These functions are PURE instead of CONST to prevent
9288      them from being hoisted past the exception edge that will initialize
9289      its value in the landing pad.  */
9290   tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9291   ftype = build_function_type (ptr_type_node, tmp);
9292   local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
9293                         "__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW);
9294
9295   tmp2 = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
9296   ftype = build_function_type (tmp2, tmp);
9297   local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
9298                         "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW);
9299
9300   tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9301   tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9302   ftype = build_function_type (void_type_node, tmp);
9303   local_define_builtin ("__builtin_eh_copy_values", ftype,
9304                         BUILT_IN_EH_COPY_VALUES,
9305                         "__builtin_eh_copy_values", ECF_NOTHROW);
9306
9307   /* Complex multiplication and division.  These are handled as builtins
9308      rather than optabs because emit_library_call_value doesn't support
9309      complex.  Further, we can do slightly better with folding these
9310      beasties if the real and complex parts of the arguments are separate.  */
9311   {
9312     int mode;
9313
9314     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
9315       {
9316         char mode_name_buf[4], *q;
9317         const char *p;
9318         enum built_in_function mcode, dcode;
9319         tree type, inner_type;
9320
9321         type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
9322         if (type == NULL)
9323           continue;
9324         inner_type = TREE_TYPE (type);
9325
9326         tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
9327         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9328         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9329         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9330         ftype = build_function_type (type, tmp);
9331
9332         mcode = ((enum built_in_function)
9333                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9334         dcode = ((enum built_in_function)
9335                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9336
9337         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
9338           *q = TOLOWER (*p);
9339         *q = '\0';
9340
9341         built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
9342         local_define_builtin (built_in_names[mcode], ftype, mcode,
9343                               built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
9344
9345         built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
9346         local_define_builtin (built_in_names[dcode], ftype, dcode,
9347                               built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
9348       }
9349   }
9350 }
9351
9352 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
9353    better way.
9354
9355    If we requested a pointer to a vector, build up the pointers that
9356    we stripped off while looking for the inner type.  Similarly for
9357    return values from functions.
9358
9359    The argument TYPE is the top of the chain, and BOTTOM is the
9360    new type which we will point to.  */
9361
9362 tree
9363 reconstruct_complex_type (tree type, tree bottom)
9364 {
9365   tree inner, outer;
9366
9367   if (TREE_CODE (type) == POINTER_TYPE)
9368     {
9369       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9370       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
9371                                            TYPE_REF_CAN_ALIAS_ALL (type));
9372     }
9373   else if (TREE_CODE (type) == REFERENCE_TYPE)
9374     {
9375       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9376       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
9377                                              TYPE_REF_CAN_ALIAS_ALL (type));
9378     }
9379   else if (TREE_CODE (type) == ARRAY_TYPE)
9380     {
9381       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9382       outer = build_array_type (inner, TYPE_DOMAIN (type));
9383     }
9384   else if (TREE_CODE (type) == FUNCTION_TYPE)
9385     {
9386       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9387       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
9388     }
9389   else if (TREE_CODE (type) == METHOD_TYPE)
9390     {
9391       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9392       /* The build_method_type_directly() routine prepends 'this' to argument list,
9393          so we must compensate by getting rid of it.  */
9394       outer
9395         = build_method_type_directly
9396             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
9397              inner,
9398              TREE_CHAIN (TYPE_ARG_TYPES (type)));
9399     }
9400   else if (TREE_CODE (type) == OFFSET_TYPE)
9401     {
9402       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9403       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
9404     }
9405   else
9406     return bottom;
9407
9408   return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
9409                                             TYPE_QUALS (type));
9410 }
9411
9412 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9413    the inner type.  */
9414 tree
9415 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
9416 {
9417   int nunits;
9418
9419   switch (GET_MODE_CLASS (mode))
9420     {
9421     case MODE_VECTOR_INT:
9422     case MODE_VECTOR_FLOAT:
9423     case MODE_VECTOR_FRACT:
9424     case MODE_VECTOR_UFRACT:
9425     case MODE_VECTOR_ACCUM:
9426     case MODE_VECTOR_UACCUM:
9427       nunits = GET_MODE_NUNITS (mode);
9428       break;
9429
9430     case MODE_INT:
9431       /* Check that there are no leftover bits.  */
9432       gcc_assert (GET_MODE_BITSIZE (mode)
9433                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
9434
9435       nunits = GET_MODE_BITSIZE (mode)
9436                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
9437       break;
9438
9439     default:
9440       gcc_unreachable ();
9441     }
9442
9443   return make_vector_type (innertype, nunits, mode);
9444 }
9445
9446 /* Similarly, but takes the inner type and number of units, which must be
9447    a power of two.  */
9448
9449 tree
9450 build_vector_type (tree innertype, int nunits)
9451 {
9452   return make_vector_type (innertype, nunits, VOIDmode);
9453 }
9454
9455 /* Similarly, but takes the inner type and number of units, which must be
9456    a power of two.  */
9457
9458 tree
9459 build_opaque_vector_type (tree innertype, int nunits)
9460 {
9461   tree t;
9462   innertype = build_distinct_type_copy (innertype);
9463   t = make_vector_type (innertype, nunits, VOIDmode);
9464   TYPE_VECTOR_OPAQUE (t) = true;
9465   return t;
9466 }
9467
9468
9469 /* Given an initializer INIT, return TRUE if INIT is zero or some
9470    aggregate of zeros.  Otherwise return FALSE.  */
9471 bool
9472 initializer_zerop (const_tree init)
9473 {
9474   tree elt;
9475
9476   STRIP_NOPS (init);
9477
9478   switch (TREE_CODE (init))
9479     {
9480     case INTEGER_CST:
9481       return integer_zerop (init);
9482
9483     case REAL_CST:
9484       /* ??? Note that this is not correct for C4X float formats.  There,
9485          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9486          negative exponent.  */
9487       return real_zerop (init)
9488         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
9489
9490     case FIXED_CST:
9491       return fixed_zerop (init);
9492
9493     case COMPLEX_CST:
9494       return integer_zerop (init)
9495         || (real_zerop (init)
9496             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
9497             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
9498
9499     case VECTOR_CST:
9500       for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
9501         if (!initializer_zerop (TREE_VALUE (elt)))
9502           return false;
9503       return true;
9504
9505     case CONSTRUCTOR:
9506       {
9507         unsigned HOST_WIDE_INT idx;
9508
9509         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
9510           if (!initializer_zerop (elt))
9511             return false;
9512         return true;
9513       }
9514
9515     case STRING_CST:
9516       {
9517         int i;
9518
9519         /* We need to loop through all elements to handle cases like
9520            "\0" and "\0foobar".  */
9521         for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
9522           if (TREE_STRING_POINTER (init)[i] != '\0')
9523             return false;
9524
9525         return true;
9526       }
9527
9528     default:
9529       return false;
9530     }
9531 }
9532
9533 /* Build an empty statement at location LOC.  */
9534
9535 tree
9536 build_empty_stmt (location_t loc)
9537 {
9538   tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
9539   SET_EXPR_LOCATION (t, loc);
9540   return t;
9541 }
9542
9543
9544 /* Build an OpenMP clause with code CODE.  LOC is the location of the
9545    clause.  */
9546
9547 tree
9548 build_omp_clause (location_t loc, enum omp_clause_code code)
9549 {
9550   tree t;
9551   int size, length;
9552
9553   length = omp_clause_num_ops[code];
9554   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
9555
9556   t = ggc_alloc_tree_node (size);
9557   memset (t, 0, size);
9558   TREE_SET_CODE (t, OMP_CLAUSE);
9559   OMP_CLAUSE_SET_CODE (t, code);
9560   OMP_CLAUSE_LOCATION (t) = loc;
9561
9562 #ifdef GATHER_STATISTICS
9563   tree_node_counts[(int) omp_clause_kind]++;
9564   tree_node_sizes[(int) omp_clause_kind] += size;
9565 #endif
9566
9567   return t;
9568 }
9569
9570 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
9571    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9572    Except for the CODE and operand count field, other storage for the
9573    object is initialized to zeros.  */
9574
9575 tree
9576 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
9577 {
9578   tree t;
9579   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
9580
9581   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
9582   gcc_assert (len >= 1);
9583
9584 #ifdef GATHER_STATISTICS
9585   tree_node_counts[(int) e_kind]++;
9586   tree_node_sizes[(int) e_kind] += length;
9587 #endif
9588
9589   t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT);
9590
9591   TREE_SET_CODE (t, code);
9592
9593   /* Can't use TREE_OPERAND to store the length because if checking is
9594      enabled, it will try to check the length before we store it.  :-P  */
9595   t->exp.operands[0] = build_int_cst (sizetype, len);
9596
9597   return t;
9598 }
9599
9600 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9601    FN and a null static chain slot.  NARGS is the number of call arguments
9602    which are specified as "..." arguments.  */
9603
9604 tree
9605 build_call_nary (tree return_type, tree fn, int nargs, ...)
9606 {
9607   tree ret;
9608   va_list args;
9609   va_start (args, nargs);
9610   ret = build_call_valist (return_type, fn, nargs, args);
9611   va_end (args);
9612   return ret;
9613 }
9614
9615 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9616    FN and a null static chain slot.  NARGS is the number of call arguments
9617    which are specified as a va_list ARGS.  */
9618
9619 tree
9620 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
9621 {
9622   tree t;
9623   int i;
9624
9625   t = build_vl_exp (CALL_EXPR, nargs + 3);
9626   TREE_TYPE (t) = return_type;
9627   CALL_EXPR_FN (t) = fn;
9628   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9629   for (i = 0; i < nargs; i++)
9630     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
9631   process_call_operands (t);
9632   return t;
9633 }
9634
9635 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9636    FN and a null static chain slot.  NARGS is the number of call arguments
9637    which are specified as a tree array ARGS.  */
9638
9639 tree
9640 build_call_array_loc (location_t loc, tree return_type, tree fn,
9641                       int nargs, const tree *args)
9642 {
9643   tree t;
9644   int i;
9645
9646   t = build_vl_exp (CALL_EXPR, nargs + 3);
9647   TREE_TYPE (t) = return_type;
9648   CALL_EXPR_FN (t) = fn;
9649   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9650   for (i = 0; i < nargs; i++)
9651     CALL_EXPR_ARG (t, i) = args[i];
9652   process_call_operands (t);
9653   SET_EXPR_LOCATION (t, loc);
9654   return t;
9655 }
9656
9657 /* Like build_call_array, but takes a VEC.  */
9658
9659 tree
9660 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
9661 {
9662   tree ret, t;
9663   unsigned int ix;
9664
9665   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
9666   TREE_TYPE (ret) = return_type;
9667   CALL_EXPR_FN (ret) = fn;
9668   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
9669   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
9670     CALL_EXPR_ARG (ret, ix) = t;
9671   process_call_operands (ret);
9672   return ret;
9673 }
9674
9675
9676 /* Returns true if it is possible to prove that the index of
9677    an array access REF (an ARRAY_REF expression) falls into the
9678    array bounds.  */
9679
9680 bool
9681 in_array_bounds_p (tree ref)
9682 {
9683   tree idx = TREE_OPERAND (ref, 1);
9684   tree min, max;
9685
9686   if (TREE_CODE (idx) != INTEGER_CST)
9687     return false;
9688
9689   min = array_ref_low_bound (ref);
9690   max = array_ref_up_bound (ref);
9691   if (!min
9692       || !max
9693       || TREE_CODE (min) != INTEGER_CST
9694       || TREE_CODE (max) != INTEGER_CST)
9695     return false;
9696
9697   if (tree_int_cst_lt (idx, min)
9698       || tree_int_cst_lt (max, idx))
9699     return false;
9700
9701   return true;
9702 }
9703
9704 /* Returns true if it is possible to prove that the range of
9705    an array access REF (an ARRAY_RANGE_REF expression) falls
9706    into the array bounds.  */
9707
9708 bool
9709 range_in_array_bounds_p (tree ref)
9710 {
9711   tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
9712   tree range_min, range_max, min, max;
9713
9714   range_min = TYPE_MIN_VALUE (domain_type);
9715   range_max = TYPE_MAX_VALUE (domain_type);
9716   if (!range_min
9717       || !range_max
9718       || TREE_CODE (range_min) != INTEGER_CST
9719       || TREE_CODE (range_max) != INTEGER_CST)
9720     return false;
9721
9722   min = array_ref_low_bound (ref);
9723   max = array_ref_up_bound (ref);
9724   if (!min
9725       || !max
9726       || TREE_CODE (min) != INTEGER_CST
9727       || TREE_CODE (max) != INTEGER_CST)
9728     return false;
9729
9730   if (tree_int_cst_lt (range_min, min)
9731       || tree_int_cst_lt (max, range_max))
9732     return false;
9733
9734   return true;
9735 }
9736
9737 /* Return true if T (assumed to be a DECL) must be assigned a memory
9738    location.  */
9739
9740 bool
9741 needs_to_live_in_memory (const_tree t)
9742 {
9743   if (TREE_CODE (t) == SSA_NAME)
9744     t = SSA_NAME_VAR (t);
9745
9746   return (TREE_ADDRESSABLE (t)
9747           || is_global_var (t)
9748           || (TREE_CODE (t) == RESULT_DECL
9749               && aggregate_value_p (t, current_function_decl)));
9750 }
9751
9752 /* There are situations in which a language considers record types
9753    compatible which have different field lists.  Decide if two fields
9754    are compatible.  It is assumed that the parent records are compatible.  */
9755
9756 bool
9757 fields_compatible_p (const_tree f1, const_tree f2)
9758 {
9759   if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
9760                         DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
9761     return false;
9762
9763   if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
9764                         DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
9765     return false;
9766
9767   if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
9768     return false;
9769
9770   return true;
9771 }
9772
9773 /* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
9774
9775 tree
9776 find_compatible_field (tree record, tree orig_field)
9777 {
9778   tree f;
9779
9780   for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
9781     if (TREE_CODE (f) == FIELD_DECL
9782         && fields_compatible_p (f, orig_field))
9783       return f;
9784
9785   /* ??? Why isn't this on the main fields list?  */
9786   f = TYPE_VFIELD (record);
9787   if (f && TREE_CODE (f) == FIELD_DECL
9788       && fields_compatible_p (f, orig_field))
9789     return f;
9790
9791   /* ??? We should abort here, but Java appears to do Bad Things
9792      with inherited fields.  */
9793   return orig_field;
9794 }
9795
9796 /* Return value of a constant X and sign-extend it.  */
9797
9798 HOST_WIDE_INT
9799 int_cst_value (const_tree x)
9800 {
9801   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9802   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
9803
9804   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9805   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9806               || TREE_INT_CST_HIGH (x) == -1);
9807
9808   if (bits < HOST_BITS_PER_WIDE_INT)
9809     {
9810       bool negative = ((val >> (bits - 1)) & 1) != 0;
9811       if (negative)
9812         val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
9813       else
9814         val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
9815     }
9816
9817   return val;
9818 }
9819
9820 /* Return value of a constant X and sign-extend it.  */
9821
9822 HOST_WIDEST_INT
9823 widest_int_cst_value (const_tree x)
9824 {
9825   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9826   unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
9827
9828 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9829   gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
9830   val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
9831           << HOST_BITS_PER_WIDE_INT);
9832 #else
9833   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9834   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9835               || TREE_INT_CST_HIGH (x) == -1);
9836 #endif
9837
9838   if (bits < HOST_BITS_PER_WIDEST_INT)
9839     {
9840       bool negative = ((val >> (bits - 1)) & 1) != 0;
9841       if (negative)
9842         val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
9843       else
9844         val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
9845     }
9846
9847   return val;
9848 }
9849
9850 /* If TYPE is an integral type, return an equivalent type which is
9851     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
9852     return TYPE itself.  */
9853
9854 tree
9855 signed_or_unsigned_type_for (int unsignedp, tree type)
9856 {
9857   tree t = type;
9858   if (POINTER_TYPE_P (type))
9859     {
9860       /* If the pointer points to the normal address space, use the
9861          size_type_node.  Otherwise use an appropriate size for the pointer
9862          based on the named address space it points to.  */
9863       if (!TYPE_ADDR_SPACE (TREE_TYPE (t)))
9864         t = size_type_node;
9865       else
9866         return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9867     }
9868
9869   if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
9870     return t;
9871
9872   return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9873 }
9874
9875 /* Returns unsigned variant of TYPE.  */
9876
9877 tree
9878 unsigned_type_for (tree type)
9879 {
9880   return signed_or_unsigned_type_for (1, type);
9881 }
9882
9883 /* Returns signed variant of TYPE.  */
9884
9885 tree
9886 signed_type_for (tree type)
9887 {
9888   return signed_or_unsigned_type_for (0, type);
9889 }
9890
9891 /* Returns the largest value obtainable by casting something in INNER type to
9892    OUTER type.  */
9893
9894 tree
9895 upper_bound_in_type (tree outer, tree inner)
9896 {
9897   unsigned HOST_WIDE_INT lo, hi;
9898   unsigned int det = 0;
9899   unsigned oprec = TYPE_PRECISION (outer);
9900   unsigned iprec = TYPE_PRECISION (inner);
9901   unsigned prec;
9902
9903   /* Compute a unique number for every combination.  */
9904   det |= (oprec > iprec) ? 4 : 0;
9905   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
9906   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
9907
9908   /* Determine the exponent to use.  */
9909   switch (det)
9910     {
9911     case 0:
9912     case 1:
9913       /* oprec <= iprec, outer: signed, inner: don't care.  */
9914       prec = oprec - 1;
9915       break;
9916     case 2:
9917     case 3:
9918       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
9919       prec = oprec;
9920       break;
9921     case 4:
9922       /* oprec > iprec, outer: signed, inner: signed.  */
9923       prec = iprec - 1;
9924       break;
9925     case 5:
9926       /* oprec > iprec, outer: signed, inner: unsigned.  */
9927       prec = iprec;
9928       break;
9929     case 6:
9930       /* oprec > iprec, outer: unsigned, inner: signed.  */
9931       prec = oprec;
9932       break;
9933     case 7:
9934       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
9935       prec = iprec;
9936       break;
9937     default:
9938       gcc_unreachable ();
9939     }
9940
9941   /* Compute 2^^prec - 1.  */
9942   if (prec <= HOST_BITS_PER_WIDE_INT)
9943     {
9944       hi = 0;
9945       lo = ((~(unsigned HOST_WIDE_INT) 0)
9946             >> (HOST_BITS_PER_WIDE_INT - prec));
9947     }
9948   else
9949     {
9950       hi = ((~(unsigned HOST_WIDE_INT) 0)
9951             >> (2 * HOST_BITS_PER_WIDE_INT - prec));
9952       lo = ~(unsigned HOST_WIDE_INT) 0;
9953     }
9954
9955   return build_int_cst_wide (outer, lo, hi);
9956 }
9957
9958 /* Returns the smallest value obtainable by casting something in INNER type to
9959    OUTER type.  */
9960
9961 tree
9962 lower_bound_in_type (tree outer, tree inner)
9963 {
9964   unsigned HOST_WIDE_INT lo, hi;
9965   unsigned oprec = TYPE_PRECISION (outer);
9966   unsigned iprec = TYPE_PRECISION (inner);
9967
9968   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
9969      and obtain 0.  */
9970   if (TYPE_UNSIGNED (outer)
9971       /* If we are widening something of an unsigned type, OUTER type
9972          contains all values of INNER type.  In particular, both INNER
9973          and OUTER types have zero in common.  */
9974       || (oprec > iprec && TYPE_UNSIGNED (inner)))
9975     lo = hi = 0;
9976   else
9977     {
9978       /* If we are widening a signed type to another signed type, we
9979          want to obtain -2^^(iprec-1).  If we are keeping the
9980          precision or narrowing to a signed type, we want to obtain
9981          -2^(oprec-1).  */
9982       unsigned prec = oprec > iprec ? iprec : oprec;
9983
9984       if (prec <= HOST_BITS_PER_WIDE_INT)
9985         {
9986           hi = ~(unsigned HOST_WIDE_INT) 0;
9987           lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
9988         }
9989       else
9990         {
9991           hi = ((~(unsigned HOST_WIDE_INT) 0)
9992                 << (prec - HOST_BITS_PER_WIDE_INT - 1));
9993           lo = 0;
9994         }
9995     }
9996
9997   return build_int_cst_wide (outer, lo, hi);
9998 }
9999
10000 /* Return nonzero if two operands that are suitable for PHI nodes are
10001    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
10002    SSA_NAME or invariant.  Note that this is strictly an optimization.
10003    That is, callers of this function can directly call operand_equal_p
10004    and get the same result, only slower.  */
10005
10006 int
10007 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
10008 {
10009   if (arg0 == arg1)
10010     return 1;
10011   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
10012     return 0;
10013   return operand_equal_p (arg0, arg1, 0);
10014 }
10015
10016 /* Returns number of zeros at the end of binary representation of X.
10017
10018    ??? Use ffs if available?  */
10019
10020 tree
10021 num_ending_zeros (const_tree x)
10022 {
10023   unsigned HOST_WIDE_INT fr, nfr;
10024   unsigned num, abits;
10025   tree type = TREE_TYPE (x);
10026
10027   if (TREE_INT_CST_LOW (x) == 0)
10028     {
10029       num = HOST_BITS_PER_WIDE_INT;
10030       fr = TREE_INT_CST_HIGH (x);
10031     }
10032   else
10033     {
10034       num = 0;
10035       fr = TREE_INT_CST_LOW (x);
10036     }
10037
10038   for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
10039     {
10040       nfr = fr >> abits;
10041       if (nfr << abits == fr)
10042         {
10043           num += abits;
10044           fr = nfr;
10045         }
10046     }
10047
10048   if (num > TYPE_PRECISION (type))
10049     num = TYPE_PRECISION (type);
10050
10051   return build_int_cst_type (type, num);
10052 }
10053
10054
10055 #define WALK_SUBTREE(NODE)                              \
10056   do                                                    \
10057     {                                                   \
10058       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
10059       if (result)                                       \
10060         return result;                                  \
10061     }                                                   \
10062   while (0)
10063
10064 /* This is a subroutine of walk_tree that walks field of TYPE that are to
10065    be walked whenever a type is seen in the tree.  Rest of operands and return
10066    value are as for walk_tree.  */
10067
10068 static tree
10069 walk_type_fields (tree type, walk_tree_fn func, void *data,
10070                   struct pointer_set_t *pset, walk_tree_lh lh)
10071 {
10072   tree result = NULL_TREE;
10073
10074   switch (TREE_CODE (type))
10075     {
10076     case POINTER_TYPE:
10077     case REFERENCE_TYPE:
10078       /* We have to worry about mutually recursive pointers.  These can't
10079          be written in C.  They can in Ada.  It's pathological, but
10080          there's an ACATS test (c38102a) that checks it.  Deal with this
10081          by checking if we're pointing to another pointer, that one
10082          points to another pointer, that one does too, and we have no htab.
10083          If so, get a hash table.  We check three levels deep to avoid
10084          the cost of the hash table if we don't need one.  */
10085       if (POINTER_TYPE_P (TREE_TYPE (type))
10086           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
10087           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
10088           && !pset)
10089         {
10090           result = walk_tree_without_duplicates (&TREE_TYPE (type),
10091                                                  func, data);
10092           if (result)
10093             return result;
10094
10095           break;
10096         }
10097
10098       /* ... fall through ... */
10099
10100     case COMPLEX_TYPE:
10101       WALK_SUBTREE (TREE_TYPE (type));
10102       break;
10103
10104     case METHOD_TYPE:
10105       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
10106
10107       /* Fall through.  */
10108
10109     case FUNCTION_TYPE:
10110       WALK_SUBTREE (TREE_TYPE (type));
10111       {
10112         tree arg;
10113
10114         /* We never want to walk into default arguments.  */
10115         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
10116           WALK_SUBTREE (TREE_VALUE (arg));
10117       }
10118       break;
10119
10120     case ARRAY_TYPE:
10121       /* Don't follow this nodes's type if a pointer for fear that
10122          we'll have infinite recursion.  If we have a PSET, then we
10123          need not fear.  */
10124       if (pset
10125           || (!POINTER_TYPE_P (TREE_TYPE (type))
10126               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
10127         WALK_SUBTREE (TREE_TYPE (type));
10128       WALK_SUBTREE (TYPE_DOMAIN (type));
10129       break;
10130
10131     case OFFSET_TYPE:
10132       WALK_SUBTREE (TREE_TYPE (type));
10133       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
10134       break;
10135
10136     default:
10137       break;
10138     }
10139
10140   return NULL_TREE;
10141 }
10142
10143 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
10144    called with the DATA and the address of each sub-tree.  If FUNC returns a
10145    non-NULL value, the traversal is stopped, and the value returned by FUNC
10146    is returned.  If PSET is non-NULL it is used to record the nodes visited,
10147    and to avoid visiting a node more than once.  */
10148
10149 tree
10150 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10151              struct pointer_set_t *pset, walk_tree_lh lh)
10152 {
10153   enum tree_code code;
10154   int walk_subtrees;
10155   tree result;
10156
10157 #define WALK_SUBTREE_TAIL(NODE)                         \
10158   do                                                    \
10159     {                                                   \
10160        tp = & (NODE);                                   \
10161        goto tail_recurse;                               \
10162     }                                                   \
10163   while (0)
10164
10165  tail_recurse:
10166   /* Skip empty subtrees.  */
10167   if (!*tp)
10168     return NULL_TREE;
10169
10170   /* Don't walk the same tree twice, if the user has requested
10171      that we avoid doing so.  */
10172   if (pset && pointer_set_insert (pset, *tp))
10173     return NULL_TREE;
10174
10175   /* Call the function.  */
10176   walk_subtrees = 1;
10177   result = (*func) (tp, &walk_subtrees, data);
10178
10179   /* If we found something, return it.  */
10180   if (result)
10181     return result;
10182
10183   code = TREE_CODE (*tp);
10184
10185   /* Even if we didn't, FUNC may have decided that there was nothing
10186      interesting below this point in the tree.  */
10187   if (!walk_subtrees)
10188     {
10189       /* But we still need to check our siblings.  */
10190       if (code == TREE_LIST)
10191         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10192       else if (code == OMP_CLAUSE)
10193         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10194       else
10195         return NULL_TREE;
10196     }
10197
10198   if (lh)
10199     {
10200       result = (*lh) (tp, &walk_subtrees, func, data, pset);
10201       if (result || !walk_subtrees)
10202         return result;
10203     }
10204
10205   switch (code)
10206     {
10207     case ERROR_MARK:
10208     case IDENTIFIER_NODE:
10209     case INTEGER_CST:
10210     case REAL_CST:
10211     case FIXED_CST:
10212     case VECTOR_CST:
10213     case STRING_CST:
10214     case BLOCK:
10215     case PLACEHOLDER_EXPR:
10216     case SSA_NAME:
10217     case FIELD_DECL:
10218     case RESULT_DECL:
10219       /* None of these have subtrees other than those already walked
10220          above.  */
10221       break;
10222
10223     case TREE_LIST:
10224       WALK_SUBTREE (TREE_VALUE (*tp));
10225       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10226       break;
10227
10228     case TREE_VEC:
10229       {
10230         int len = TREE_VEC_LENGTH (*tp);
10231
10232         if (len == 0)
10233           break;
10234
10235         /* Walk all elements but the first.  */
10236         while (--len)
10237           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
10238
10239         /* Now walk the first one as a tail call.  */
10240         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
10241       }
10242
10243     case COMPLEX_CST:
10244       WALK_SUBTREE (TREE_REALPART (*tp));
10245       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
10246
10247     case CONSTRUCTOR:
10248       {
10249         unsigned HOST_WIDE_INT idx;
10250         constructor_elt *ce;
10251
10252         for (idx = 0;
10253              VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
10254              idx++)
10255           WALK_SUBTREE (ce->value);
10256       }
10257       break;
10258
10259     case SAVE_EXPR:
10260       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
10261
10262     case BIND_EXPR:
10263       {
10264         tree decl;
10265         for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
10266           {
10267             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
10268                into declarations that are just mentioned, rather than
10269                declared; they don't really belong to this part of the tree.
10270                And, we can see cycles: the initializer for a declaration
10271                can refer to the declaration itself.  */
10272             WALK_SUBTREE (DECL_INITIAL (decl));
10273             WALK_SUBTREE (DECL_SIZE (decl));
10274             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
10275           }
10276         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
10277       }
10278
10279     case STATEMENT_LIST:
10280       {
10281         tree_stmt_iterator i;
10282         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
10283           WALK_SUBTREE (*tsi_stmt_ptr (i));
10284       }
10285       break;
10286
10287     case OMP_CLAUSE:
10288       switch (OMP_CLAUSE_CODE (*tp))
10289         {
10290         case OMP_CLAUSE_PRIVATE:
10291         case OMP_CLAUSE_SHARED:
10292         case OMP_CLAUSE_FIRSTPRIVATE:
10293         case OMP_CLAUSE_COPYIN:
10294         case OMP_CLAUSE_COPYPRIVATE:
10295         case OMP_CLAUSE_IF:
10296         case OMP_CLAUSE_NUM_THREADS:
10297         case OMP_CLAUSE_SCHEDULE:
10298           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
10299           /* FALLTHRU */
10300
10301         case OMP_CLAUSE_NOWAIT:
10302         case OMP_CLAUSE_ORDERED:
10303         case OMP_CLAUSE_DEFAULT:
10304         case OMP_CLAUSE_UNTIED:
10305           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10306
10307         case OMP_CLAUSE_LASTPRIVATE:
10308           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
10309           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
10310           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10311
10312         case OMP_CLAUSE_COLLAPSE:
10313           {
10314             int i;
10315             for (i = 0; i < 3; i++)
10316               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10317             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10318           }
10319
10320         case OMP_CLAUSE_REDUCTION:
10321           {
10322             int i;
10323             for (i = 0; i < 4; i++)
10324               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10325             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10326           }
10327
10328         default:
10329           gcc_unreachable ();
10330         }
10331       break;
10332
10333     case TARGET_EXPR:
10334       {
10335         int i, len;
10336
10337         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10338            But, we only want to walk once.  */
10339         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
10340         for (i = 0; i < len; ++i)
10341           WALK_SUBTREE (TREE_OPERAND (*tp, i));
10342         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
10343       }
10344
10345     case DECL_EXPR:
10346       /* If this is a TYPE_DECL, walk into the fields of the type that it's
10347          defining.  We only want to walk into these fields of a type in this
10348          case and not in the general case of a mere reference to the type.
10349
10350          The criterion is as follows: if the field can be an expression, it
10351          must be walked only here.  This should be in keeping with the fields
10352          that are directly gimplified in gimplify_type_sizes in order for the
10353          mark/copy-if-shared/unmark machinery of the gimplifier to work with
10354          variable-sized types.
10355
10356          Note that DECLs get walked as part of processing the BIND_EXPR.  */
10357       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
10358         {
10359           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
10360           if (TREE_CODE (*type_p) == ERROR_MARK)
10361             return NULL_TREE;
10362
10363           /* Call the function for the type.  See if it returns anything or
10364              doesn't want us to continue.  If we are to continue, walk both
10365              the normal fields and those for the declaration case.  */
10366           result = (*func) (type_p, &walk_subtrees, data);
10367           if (result || !walk_subtrees)
10368             return result;
10369
10370           result = walk_type_fields (*type_p, func, data, pset, lh);
10371           if (result)
10372             return result;
10373
10374           /* If this is a record type, also walk the fields.  */
10375           if (RECORD_OR_UNION_TYPE_P (*type_p))
10376             {
10377               tree field;
10378
10379               for (field = TYPE_FIELDS (*type_p); field;
10380                    field = TREE_CHAIN (field))
10381                 {
10382                   /* We'd like to look at the type of the field, but we can
10383                      easily get infinite recursion.  So assume it's pointed
10384                      to elsewhere in the tree.  Also, ignore things that
10385                      aren't fields.  */
10386                   if (TREE_CODE (field) != FIELD_DECL)
10387                     continue;
10388
10389                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
10390                   WALK_SUBTREE (DECL_SIZE (field));
10391                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
10392                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10393                     WALK_SUBTREE (DECL_QUALIFIER (field));
10394                 }
10395             }
10396
10397           /* Same for scalar types.  */
10398           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
10399                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
10400                    || TREE_CODE (*type_p) == INTEGER_TYPE
10401                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
10402                    || TREE_CODE (*type_p) == REAL_TYPE)
10403             {
10404               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
10405               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
10406             }
10407
10408           WALK_SUBTREE (TYPE_SIZE (*type_p));
10409           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
10410         }
10411       /* FALLTHRU */
10412
10413     default:
10414       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
10415         {
10416           int i, len;
10417
10418           /* Walk over all the sub-trees of this operand.  */
10419           len = TREE_OPERAND_LENGTH (*tp);
10420
10421           /* Go through the subtrees.  We need to do this in forward order so
10422              that the scope of a FOR_EXPR is handled properly.  */
10423           if (len)
10424             {
10425               for (i = 0; i < len - 1; ++i)
10426                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
10427               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
10428             }
10429         }
10430       /* If this is a type, walk the needed fields in the type.  */
10431       else if (TYPE_P (*tp))
10432         return walk_type_fields (*tp, func, data, pset, lh);
10433       break;
10434     }
10435
10436   /* We didn't find what we were looking for.  */
10437   return NULL_TREE;
10438
10439 #undef WALK_SUBTREE_TAIL
10440 }
10441 #undef WALK_SUBTREE
10442
10443 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
10444
10445 tree
10446 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
10447                                 walk_tree_lh lh)
10448 {
10449   tree result;
10450   struct pointer_set_t *pset;
10451
10452   pset = pointer_set_create ();
10453   result = walk_tree_1 (tp, func, data, pset, lh);
10454   pointer_set_destroy (pset);
10455   return result;
10456 }
10457
10458
10459 tree *
10460 tree_block (tree t)
10461 {
10462   char const c = TREE_CODE_CLASS (TREE_CODE (t));
10463
10464   if (IS_EXPR_CODE_CLASS (c))
10465     return &t->exp.block;
10466   gcc_unreachable ();
10467   return NULL;
10468 }
10469
10470 /* Create a nameless artificial label and put it in the current
10471    function context.  The label has a location of LOC.  Returns the
10472    newly created label.  */
10473
10474 tree
10475 create_artificial_label (location_t loc)
10476 {
10477   tree lab = build_decl (loc,
10478                          LABEL_DECL, NULL_TREE, void_type_node);
10479
10480   DECL_ARTIFICIAL (lab) = 1;
10481   DECL_IGNORED_P (lab) = 1;
10482   DECL_CONTEXT (lab) = current_function_decl;
10483   return lab;
10484 }
10485
10486 /*  Given a tree, try to return a useful variable name that we can use
10487     to prefix a temporary that is being assigned the value of the tree.
10488     I.E. given  <temp> = &A, return A.  */
10489
10490 const char *
10491 get_name (tree t)
10492 {
10493   tree stripped_decl;
10494
10495   stripped_decl = t;
10496   STRIP_NOPS (stripped_decl);
10497   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
10498     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
10499   else
10500     {
10501       switch (TREE_CODE (stripped_decl))
10502         {
10503         case ADDR_EXPR:
10504           return get_name (TREE_OPERAND (stripped_decl, 0));
10505         default:
10506           return NULL;
10507         }
10508     }
10509 }
10510
10511 /* Return true if TYPE has a variable argument list.  */
10512
10513 bool
10514 stdarg_p (tree fntype)
10515 {
10516   function_args_iterator args_iter;
10517   tree n = NULL_TREE, t;
10518
10519   if (!fntype)
10520     return false;
10521
10522   FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
10523     {
10524       n = t;
10525     }
10526
10527   return n != NULL_TREE && n != void_type_node;
10528 }
10529
10530 /* Return true if TYPE has a prototype.  */
10531
10532 bool
10533 prototype_p (tree fntype)
10534 {
10535   tree t;
10536
10537   gcc_assert (fntype != NULL_TREE);
10538
10539   t = TYPE_ARG_TYPES (fntype);
10540   return (t != NULL_TREE);
10541 }
10542
10543 /* If BLOCK is inlined from an __attribute__((__artificial__))
10544    routine, return pointer to location from where it has been
10545    called.  */
10546 location_t *
10547 block_nonartificial_location (tree block)
10548 {
10549   location_t *ret = NULL;
10550
10551   while (block && TREE_CODE (block) == BLOCK
10552          && BLOCK_ABSTRACT_ORIGIN (block))
10553     {
10554       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
10555
10556       while (TREE_CODE (ao) == BLOCK
10557              && BLOCK_ABSTRACT_ORIGIN (ao)
10558              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
10559         ao = BLOCK_ABSTRACT_ORIGIN (ao);
10560
10561       if (TREE_CODE (ao) == FUNCTION_DECL)
10562         {
10563           /* If AO is an artificial inline, point RET to the
10564              call site locus at which it has been inlined and continue
10565              the loop, in case AO's caller is also an artificial
10566              inline.  */
10567           if (DECL_DECLARED_INLINE_P (ao)
10568               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
10569             ret = &BLOCK_SOURCE_LOCATION (block);
10570           else
10571             break;
10572         }
10573       else if (TREE_CODE (ao) != BLOCK)
10574         break;
10575
10576       block = BLOCK_SUPERCONTEXT (block);
10577     }
10578   return ret;
10579 }
10580
10581
10582 /* If EXP is inlined from an __attribute__((__artificial__))
10583    function, return the location of the original call expression.  */
10584
10585 location_t
10586 tree_nonartificial_location (tree exp)
10587 {
10588   location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
10589
10590   if (loc)
10591     return *loc;
10592   else
10593     return EXPR_LOCATION (exp);
10594 }
10595
10596
10597 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10598    nodes.  */
10599
10600 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
10601
10602 static hashval_t
10603 cl_option_hash_hash (const void *x)
10604 {
10605   const_tree const t = (const_tree) x;
10606   const char *p;
10607   size_t i;
10608   size_t len = 0;
10609   hashval_t hash = 0;
10610
10611   if (TREE_CODE (t) == OPTIMIZATION_NODE)
10612     {
10613       p = (const char *)TREE_OPTIMIZATION (t);
10614       len = sizeof (struct cl_optimization);
10615     }
10616
10617   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
10618     {
10619       p = (const char *)TREE_TARGET_OPTION (t);
10620       len = sizeof (struct cl_target_option);
10621     }
10622
10623   else
10624     gcc_unreachable ();
10625
10626   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10627      something else.  */
10628   for (i = 0; i < len; i++)
10629     if (p[i])
10630       hash = (hash << 4) ^ ((i << 2) | p[i]);
10631
10632   return hash;
10633 }
10634
10635 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
10636    TARGET_OPTION tree node) is the same as that given by *Y, which is the
10637    same.  */
10638
10639 static int
10640 cl_option_hash_eq (const void *x, const void *y)
10641 {
10642   const_tree const xt = (const_tree) x;
10643   const_tree const yt = (const_tree) y;
10644   const char *xp;
10645   const char *yp;
10646   size_t len;
10647
10648   if (TREE_CODE (xt) != TREE_CODE (yt))
10649     return 0;
10650
10651   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
10652     {
10653       xp = (const char *)TREE_OPTIMIZATION (xt);
10654       yp = (const char *)TREE_OPTIMIZATION (yt);
10655       len = sizeof (struct cl_optimization);
10656     }
10657
10658   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
10659     {
10660       xp = (const char *)TREE_TARGET_OPTION (xt);
10661       yp = (const char *)TREE_TARGET_OPTION (yt);
10662       len = sizeof (struct cl_target_option);
10663     }
10664
10665   else
10666     gcc_unreachable ();
10667
10668   return (memcmp (xp, yp, len) == 0);
10669 }
10670
10671 /* Build an OPTIMIZATION_NODE based on the current options.  */
10672
10673 tree
10674 build_optimization_node (void)
10675 {
10676   tree t;
10677   void **slot;
10678
10679   /* Use the cache of optimization nodes.  */
10680
10681   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node));
10682
10683   slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
10684   t = (tree) *slot;
10685   if (!t)
10686     {
10687       /* Insert this one into the hash table.  */
10688       t = cl_optimization_node;
10689       *slot = t;
10690
10691       /* Make a new node for next time round.  */
10692       cl_optimization_node = make_node (OPTIMIZATION_NODE);
10693     }
10694
10695   return t;
10696 }
10697
10698 /* Build a TARGET_OPTION_NODE based on the current options.  */
10699
10700 tree
10701 build_target_option_node (void)
10702 {
10703   tree t;
10704   void **slot;
10705
10706   /* Use the cache of optimization nodes.  */
10707
10708   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node));
10709
10710   slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
10711   t = (tree) *slot;
10712   if (!t)
10713     {
10714       /* Insert this one into the hash table.  */
10715       t = cl_target_option_node;
10716       *slot = t;
10717
10718       /* Make a new node for next time round.  */
10719       cl_target_option_node = make_node (TARGET_OPTION_NODE);
10720     }
10721
10722   return t;
10723 }
10724
10725 /* Determine the "ultimate origin" of a block.  The block may be an inlined
10726    instance of an inlined instance of a block which is local to an inline
10727    function, so we have to trace all of the way back through the origin chain
10728    to find out what sort of node actually served as the original seed for the
10729    given block.  */
10730
10731 tree
10732 block_ultimate_origin (const_tree block)
10733 {
10734   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
10735
10736   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10737      nodes in the function to point to themselves; ignore that if
10738      we're trying to output the abstract instance of this function.  */
10739   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
10740     return NULL_TREE;
10741
10742   if (immediate_origin == NULL_TREE)
10743     return NULL_TREE;
10744   else
10745     {
10746       tree ret_val;
10747       tree lookahead = immediate_origin;
10748
10749       do
10750         {
10751           ret_val = lookahead;
10752           lookahead = (TREE_CODE (ret_val) == BLOCK
10753                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
10754         }
10755       while (lookahead != NULL && lookahead != ret_val);
10756
10757       /* The block's abstract origin chain may not be the *ultimate* origin of
10758          the block. It could lead to a DECL that has an abstract origin set.
10759          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10760          will give us if it has one).  Note that DECL's abstract origins are
10761          supposed to be the most distant ancestor (or so decl_ultimate_origin
10762          claims), so we don't need to loop following the DECL origins.  */
10763       if (DECL_P (ret_val))
10764         return DECL_ORIGIN (ret_val);
10765
10766       return ret_val;
10767     }
10768 }
10769
10770 /* Return true if T1 and T2 are equivalent lists.  */
10771
10772 bool
10773 list_equal_p (const_tree t1, const_tree t2)
10774 {
10775   for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
10776     if (TREE_VALUE (t1) != TREE_VALUE (t2))
10777       return false;
10778   return !t1 && !t2;
10779 }
10780
10781 /* Return true iff conversion in EXP generates no instruction.  Mark
10782    it inline so that we fully inline into the stripping functions even
10783    though we have two uses of this function.  */
10784
10785 static inline bool
10786 tree_nop_conversion (const_tree exp)
10787 {
10788   tree outer_type, inner_type;
10789
10790   if (!CONVERT_EXPR_P (exp)
10791       && TREE_CODE (exp) != NON_LVALUE_EXPR)
10792     return false;
10793   if (TREE_OPERAND (exp, 0) == error_mark_node)
10794     return false;
10795
10796   outer_type = TREE_TYPE (exp);
10797   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10798
10799   if (!inner_type)
10800     return false;
10801
10802   /* Use precision rather then machine mode when we can, which gives
10803      the correct answer even for submode (bit-field) types.  */
10804   if ((INTEGRAL_TYPE_P (outer_type)
10805        || POINTER_TYPE_P (outer_type)
10806        || TREE_CODE (outer_type) == OFFSET_TYPE)
10807       && (INTEGRAL_TYPE_P (inner_type)
10808           || POINTER_TYPE_P (inner_type)
10809           || TREE_CODE (inner_type) == OFFSET_TYPE))
10810     return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
10811
10812   /* Otherwise fall back on comparing machine modes (e.g. for
10813      aggregate types, floats).  */
10814   return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
10815 }
10816
10817 /* Return true iff conversion in EXP generates no instruction.  Don't
10818    consider conversions changing the signedness.  */
10819
10820 static bool
10821 tree_sign_nop_conversion (const_tree exp)
10822 {
10823   tree outer_type, inner_type;
10824
10825   if (!tree_nop_conversion (exp))
10826     return false;
10827
10828   outer_type = TREE_TYPE (exp);
10829   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10830
10831   return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
10832           && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
10833 }
10834
10835 /* Strip conversions from EXP according to tree_nop_conversion and
10836    return the resulting expression.  */
10837
10838 tree
10839 tree_strip_nop_conversions (tree exp)
10840 {
10841   while (tree_nop_conversion (exp))
10842     exp = TREE_OPERAND (exp, 0);
10843   return exp;
10844 }
10845
10846 /* Strip conversions from EXP according to tree_sign_nop_conversion
10847    and return the resulting expression.  */
10848
10849 tree
10850 tree_strip_sign_nop_conversions (tree exp)
10851 {
10852   while (tree_sign_nop_conversion (exp))
10853     exp = TREE_OPERAND (exp, 0);
10854   return exp;
10855 }
10856
10857 static GTY(()) tree gcc_eh_personality_decl;
10858
10859 /* Return the GCC personality function decl.  */
10860
10861 tree
10862 lhd_gcc_personality (void)
10863 {
10864   if (!gcc_eh_personality_decl)
10865     gcc_eh_personality_decl
10866       = build_personality_function (USING_SJLJ_EXCEPTIONS
10867                                     ? "__gcc_personality_sj0"
10868                                     : "__gcc_personality_v0");
10869
10870   return gcc_eh_personality_decl;
10871 }
10872
10873 /* Try to find a base info of BINFO that would have its field decl at offset
10874    OFFSET within the BINFO type and which is of EXPECTED_TYPE.  If it can be
10875    found, return, otherwise return NULL_TREE.  */
10876
10877 tree
10878 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
10879 {
10880   tree type;
10881
10882   if (offset == 0)
10883     return binfo;
10884
10885   type = TREE_TYPE (binfo);
10886   while (offset > 0)
10887     {
10888       tree base_binfo, found_binfo;
10889       HOST_WIDE_INT pos, size;
10890       tree fld;
10891       int i;
10892
10893       if (TREE_CODE (type) != RECORD_TYPE)
10894         return NULL_TREE;
10895
10896       for (fld = TYPE_FIELDS (type); fld; fld = TREE_CHAIN (fld))
10897         {
10898           if (TREE_CODE (fld) != FIELD_DECL)
10899             continue;
10900
10901           pos = int_bit_position (fld);
10902           size = tree_low_cst (DECL_SIZE (fld), 1);
10903           if (pos <= offset && (pos + size) > offset)
10904             break;
10905         }
10906       if (!fld)
10907         return NULL_TREE;
10908
10909       found_binfo = NULL_TREE;
10910       for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10911         if (TREE_TYPE (base_binfo) == TREE_TYPE (fld))
10912           {
10913             found_binfo = base_binfo;
10914             break;
10915           }
10916
10917       if (!found_binfo)
10918         return NULL_TREE;
10919
10920       type = TREE_TYPE (fld);
10921       binfo = found_binfo;
10922       offset -= pos;
10923     }
10924   if (type != expected_type)
10925     return NULL_TREE;
10926   return binfo;
10927 }
10928
10929 /* Returns true if X is a typedef decl.  */
10930
10931 bool
10932 is_typedef_decl (tree x)
10933 {
10934   return (x && TREE_CODE (x) == TYPE_DECL
10935           && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
10936 }
10937
10938 /* Returns true iff TYPE is a type variant created for a typedef. */
10939
10940 bool
10941 typedef_variant_p (tree type)
10942 {
10943   return is_typedef_decl (TYPE_NAME (type));
10944 }
10945
10946 #include "gt-tree.h"