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