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