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