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