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