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
   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 2, 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 COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23 /* This file contains the low level primitives for operating on tree nodes,
  24    including allocation, list operations, interning of identifiers,
  25    construction of data type nodes and statement nodes,
  26    and construction of type conversion nodes.  It also contains
  27    tables index by tree code that describe how to take apart
  28    nodes of that code.
  29
  30    It is intended to be language-independent, but occasionally
  31    calls language-dependent routines defined (for C) in typecheck.c.  */
  32
  33 #include "config.h"
  34 #include "system.h"
  35 #include "coretypes.h"
  36 #include "tm.h"
  37 #include "flags.h"
  38 #include "tree.h"
  39 #include "real.h"
  40 #include "tm_p.h"
  41 #include "function.h"
  42 #include "obstack.h"
  43 #include "toplev.h"
  44 #include "ggc.h"
  45 #include "hashtab.h"
  46 #include "output.h"
  47 #include "target.h"
  48 #include "langhooks.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
  55 /* Each tree code class has an associated string representation.
  56    These must correspond to the tree_code_class entries.  */
  57
  58 const char *const tree_code_class_strings[] =
  59 {
  60   "exceptional",
  61   "constant",
  62   "type",
  63   "declaration",
  64   "reference",
  65   "comparison",
  66   "unary",
  67   "binary",
  68   "statement",
  69   "expression",
  70 };
  71
  72 /* obstack.[ch] explicitly declined to prototype this.  */
  73 extern int _obstack_allocated_p (struct obstack *h, void *obj);
  74
  75 #ifdef GATHER_STATISTICS
  76 /* Statistics-gathering stuff.  */
  77
  78 int tree_node_counts[(int) all_kinds];
  79 int tree_node_sizes[(int) all_kinds];
  80
  81 /* Keep in sync with tree.h:enum tree_node_kind.  */
  82 static const char * const tree_node_kind_names[] = {
  83   "decls",
  84   "types",
  85   "blocks",
  86   "stmts",
  87   "refs",
  88   "exprs",
  89   "constants",
  90   "identifiers",
  91   "perm_tree_lists",
  92   "temp_tree_lists",
  93   "vecs",
  94   "binfos",
  95   "phi_nodes",
  96   "ssa names",
  97   "constructors",
  98   "random kinds",
  99   "lang_decl kinds",
 100   "lang_type kinds",
 101   "omp clauses"
 102 };
 103 #endif /* GATHER_STATISTICS */
 104
 105 /* Unique id for next decl created.  */
 106 static GTY(()) int next_decl_uid;
 107 /* Unique id for next type created.  */
 108 static GTY(()) int next_type_uid = 1;
 109
 110 /* Since we cannot rehash a type after it is in the table, we have to
 111    keep the hash code.  */
 112
 113 struct type_hash GTY(())
 114 {
 115   unsigned long hash;
 116   tree type;
 117 };
 118
 119 /* Initial size of the hash table (rounded to next prime).  */
 120 #define TYPE_HASH_INITIAL_SIZE 1000
 121
 122 /* Now here is the hash table.  When recording a type, it is added to
 123    the slot whose index is the hash code.  Note that the hash table is
 124    used for several kinds of types (function types, array types and
 125    array index range types, for now).  While all these live in the
 126    same table, they are completely independent, and the hash code is
 127    computed differently for each of these.  */
 128
 129 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
 130      htab_t type_hash_table;
 131
 132 /* Hash table and temporary node for larger integer const values.  */
 133 static GTY (()) tree int_cst_node;
 134 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
 135      htab_t int_cst_hash_table;
 136
 137 /* General tree->tree mapping  structure for use in hash tables.  */
 138
 139
 140 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 141      htab_t debug_expr_for_decl;
 142
 143 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 144      htab_t value_expr_for_decl;
 145
 146 static GTY ((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map)))
 147   htab_t init_priority_for_decl;
 148
 149 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 150   htab_t restrict_base_for_decl;
 151
 152 struct tree_int_map GTY(())
 153 {
 154   tree from;
 155   unsigned short to;
 156 };
 157 static unsigned int tree_int_map_hash (const void *);
 158 static int tree_int_map_eq (const void *, const void *);
 159 static int tree_int_map_marked_p (const void *);
 160 static void set_type_quals (tree, int);
 161 static int type_hash_eq (const void *, const void *);
 162 static hashval_t type_hash_hash (const void *);
 163 static hashval_t int_cst_hash_hash (const void *);
 164 static int int_cst_hash_eq (const void *, const void *);
 165 static void print_type_hash_statistics (void);
 166 static void print_debug_expr_statistics (void);
 167 static void print_value_expr_statistics (void);
 168 static tree make_vector_type (tree, int, enum machine_mode);
 169 static int type_hash_marked_p (const void *);
 170 static unsigned int type_hash_list (tree, hashval_t);
 171 static unsigned int attribute_hash_list (tree, hashval_t);
 172
 173 tree global_trees[TI_MAX];
 174 tree integer_types[itk_none];
 175
 176 unsigned char tree_contains_struct[256][64];
 177
 178 /* Number of operands for each OpenMP clause.  */
 179 unsigned const char omp_clause_num_ops[] =
 180 {
 181   0, /* OMP_CLAUSE_ERROR  */
 182   1, /* OMP_CLAUSE_PRIVATE  */
 183   1, /* OMP_CLAUSE_SHARED  */
 184   1, /* OMP_CLAUSE_FIRSTPRIVATE  */
 185   1, /* OMP_CLAUSE_LASTPRIVATE  */
 186   4, /* OMP_CLAUSE_REDUCTION  */
 187   1, /* OMP_CLAUSE_COPYIN  */
 188   1, /* OMP_CLAUSE_COPYPRIVATE  */
 189   1, /* OMP_CLAUSE_IF  */
 190   1, /* OMP_CLAUSE_NUM_THREADS  */
 191   1, /* OMP_CLAUSE_SCHEDULE  */
 192   0, /* OMP_CLAUSE_NOWAIT  */
 193   0, /* OMP_CLAUSE_ORDERED  */
 194   0  /* OMP_CLAUSE_DEFAULT  */
 195 };
 196
 197 const char * const omp_clause_code_name[] =
 198 {
 199   "error_clause",
 200   "private",
 201   "shared",
 202   "firstprivate",
 203   "lastprivate",
 204   "reduction",
 205   "copyin",
 206   "copyprivate",
 207   "if",
 208   "num_threads",
 209   "schedule",
 210   "nowait",
 211   "ordered",
 212   "default"
 213 };
 214 \f
 215 /* Init tree.c.  */
 216
 217 void
 218 init_ttree (void)
 219 {
 220   /* Initialize the hash table of types.  */
 221   type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
 222                                      type_hash_eq, 0);
 223
 224   debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
 225                                          tree_map_eq, 0);
 226
 227   value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
 228                                          tree_map_eq, 0);
 229   init_priority_for_decl = htab_create_ggc (512, tree_int_map_hash,
 230                                             tree_int_map_eq, 0);
 231   restrict_base_for_decl = htab_create_ggc (256, tree_map_hash,
 232                                             tree_map_eq, 0);
 233
 234   int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
 235                                         int_cst_hash_eq, NULL);
 236
 237   int_cst_node = make_node (INTEGER_CST);
 238
 239   tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON] = 1;
 240   tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON] = 1;
 241   tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON] = 1;
 242
 243
 244   tree_contains_struct[CONST_DECL][TS_DECL_COMMON] = 1;
 245   tree_contains_struct[VAR_DECL][TS_DECL_COMMON] = 1;
 246   tree_contains_struct[PARM_DECL][TS_DECL_COMMON] = 1;
 247   tree_contains_struct[RESULT_DECL][TS_DECL_COMMON] = 1;
 248   tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON] = 1;
 249   tree_contains_struct[TYPE_DECL][TS_DECL_COMMON] = 1;
 250   tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON] = 1;
 251   tree_contains_struct[LABEL_DECL][TS_DECL_COMMON] = 1;
 252   tree_contains_struct[FIELD_DECL][TS_DECL_COMMON] = 1;
 253
 254
 255   tree_contains_struct[CONST_DECL][TS_DECL_WRTL] = 1;
 256   tree_contains_struct[VAR_DECL][TS_DECL_WRTL] = 1;
 257   tree_contains_struct[PARM_DECL][TS_DECL_WRTL] = 1;
 258   tree_contains_struct[RESULT_DECL][TS_DECL_WRTL] = 1;
 259   tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL] = 1;
 260   tree_contains_struct[LABEL_DECL][TS_DECL_WRTL] = 1;
 261
 262   tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL] = 1;
 263   tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL] = 1;
 264   tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL] = 1;
 265   tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL] = 1;
 266   tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL] = 1;
 267   tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL] = 1;
 268   tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL] = 1;
 269   tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL] = 1;
 270   tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL] = 1;
 271   tree_contains_struct[STRUCT_FIELD_TAG][TS_DECL_MINIMAL] = 1;
 272   tree_contains_struct[NAME_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
 273   tree_contains_struct[SYMBOL_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
 274
 275   tree_contains_struct[STRUCT_FIELD_TAG][TS_MEMORY_TAG] = 1;
 276   tree_contains_struct[NAME_MEMORY_TAG][TS_MEMORY_TAG] = 1;
 277   tree_contains_struct[SYMBOL_MEMORY_TAG][TS_MEMORY_TAG] = 1;
 278
 279   tree_contains_struct[STRUCT_FIELD_TAG][TS_STRUCT_FIELD_TAG] = 1;
 280
 281   tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS] = 1;
 282   tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS] = 1;
 283   tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS] = 1;
 284   tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS] = 1;
 285
 286   tree_contains_struct[VAR_DECL][TS_VAR_DECL] = 1;
 287   tree_contains_struct[FIELD_DECL][TS_FIELD_DECL] = 1;
 288   tree_contains_struct[PARM_DECL][TS_PARM_DECL] = 1;
 289   tree_contains_struct[LABEL_DECL][TS_LABEL_DECL] = 1;
 290   tree_contains_struct[RESULT_DECL][TS_RESULT_DECL] = 1;
 291   tree_contains_struct[CONST_DECL][TS_CONST_DECL] = 1;
 292   tree_contains_struct[TYPE_DECL][TS_TYPE_DECL] = 1;
 293   tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL] = 1;
 294
 295   lang_hooks.init_ts ();
 296 }
 297
 298 \f
 299 /* The name of the object as the assembler will see it (but before any
 300    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
 301    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
 302 tree
 303 decl_assembler_name (tree decl)
 304 {
 305   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 306     lang_hooks.set_decl_assembler_name (decl);
 307   return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
 308 }
 309
 310 /* Compute the number of bytes occupied by a tree with code CODE.
 311    This function cannot be used for TREE_VEC, PHI_NODE, or STRING_CST
 312    codes, which are of variable length.  */
 313 size_t
 314 tree_code_size (enum tree_code code)
 315 {
 316   switch (TREE_CODE_CLASS (code))
 317     {
 318     case tcc_declaration:  /* A decl node */
 319       {
 320         switch (code)
 321           {
 322           case FIELD_DECL:
 323             return sizeof (struct tree_field_decl);
 324           case PARM_DECL:
 325             return sizeof (struct tree_parm_decl);
 326           case VAR_DECL:
 327             return sizeof (struct tree_var_decl);
 328           case LABEL_DECL:
 329             return sizeof (struct tree_label_decl);
 330           case RESULT_DECL:
 331             return sizeof (struct tree_result_decl);
 332           case CONST_DECL:
 333             return sizeof (struct tree_const_decl);
 334           case TYPE_DECL:
 335             return sizeof (struct tree_type_decl);
 336           case FUNCTION_DECL:
 337             return sizeof (struct tree_function_decl);
 338           case NAME_MEMORY_TAG:
 339           case SYMBOL_MEMORY_TAG:
 340             return sizeof (struct tree_memory_tag);
 341           case STRUCT_FIELD_TAG:
 342             return sizeof (struct tree_struct_field_tag);
 343           default:
 344             return sizeof (struct tree_decl_non_common);
 345           }
 346       }
 347
 348     case tcc_type:  /* a type node */
 349       return sizeof (struct tree_type);
 350
 351     case tcc_reference:   /* a reference */
 352     case tcc_expression:  /* an expression */
 353     case tcc_statement:   /* an expression with side effects */
 354     case tcc_comparison:  /* a comparison expression */
 355     case tcc_unary:       /* a unary arithmetic expression */
 356     case tcc_binary:      /* a binary arithmetic expression */
 357       return (sizeof (struct tree_exp)
 358               + (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
 359
 360     case tcc_constant:  /* a constant */
 361       switch (code)
 362         {
 363         case INTEGER_CST:       return sizeof (struct tree_int_cst);
 364         case REAL_CST:          return sizeof (struct tree_real_cst);
 365         case COMPLEX_CST:       return sizeof (struct tree_complex);
 366         case VECTOR_CST:        return sizeof (struct tree_vector);
 367         case STRING_CST:        gcc_unreachable ();
 368         default:
 369           return lang_hooks.tree_size (code);
 370         }
 371
 372     case tcc_exceptional:  /* something random, like an identifier.  */
 373       switch (code)
 374         {
 375         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
 376         case TREE_LIST:         return sizeof (struct tree_list);
 377
 378         case ERROR_MARK:
 379         case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
 380
 381         case TREE_VEC:
 382         case OMP_CLAUSE:
 383         case PHI_NODE:          gcc_unreachable ();
 384
 385         case SSA_NAME:          return sizeof (struct tree_ssa_name);
 386
 387         case STATEMENT_LIST:    return sizeof (struct tree_statement_list);
 388         case BLOCK:             return sizeof (struct tree_block);
 389         case VALUE_HANDLE:      return sizeof (struct tree_value_handle);
 390         case CONSTRUCTOR:       return sizeof (struct tree_constructor);
 391
 392         default:
 393           return lang_hooks.tree_size (code);
 394         }
 395
 396     default:
 397       gcc_unreachable ();
 398     }
 399 }
 400
 401 /* Compute the number of bytes occupied by NODE.  This routine only
 402    looks at TREE_CODE, except for PHI_NODE and TREE_VEC nodes.  */
 403 size_t
 404 tree_size (tree node)
 405 {
 406   enum tree_code code = TREE_CODE (node);
 407   switch (code)
 408     {
 409     case PHI_NODE:
 410       return (sizeof (struct tree_phi_node)
 411               + (PHI_ARG_CAPACITY (node) - 1) * sizeof (struct phi_arg_d));
 412
 413     case TREE_BINFO:
 414       return (offsetof (struct tree_binfo, base_binfos)
 415               + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
 416
 417     case TREE_VEC:
 418       return (sizeof (struct tree_vec)
 419               + (TREE_VEC_LENGTH (node) - 1) * sizeof(char *));
 420
 421     case STRING_CST:
 422       return sizeof (struct tree_string) + TREE_STRING_LENGTH (node) - 1;
 423
 424     case OMP_CLAUSE:
 425       return (sizeof (struct tree_omp_clause)
 426               + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
 427                 * sizeof (tree));
 428
 429     default:
 430       return tree_code_size (code);
 431     }
 432 }
 433
 434 /* Return a newly allocated node of code CODE.  For decl and type
 435    nodes, some other fields are initialized.  The rest of the node is
 436    initialized to zero.  This function cannot be used for PHI_NODE,
 437    TREE_VEC or OMP_CLAUSE nodes, which is enforced by asserts in
 438    tree_code_size.
 439
 440    Achoo!  I got a code in the node.  */
 441
 442 tree
 443 make_node_stat (enum tree_code code MEM_STAT_DECL)
 444 {
 445   tree t;
 446   enum tree_code_class type = TREE_CODE_CLASS (code);
 447   size_t length = tree_code_size (code);
 448 #ifdef GATHER_STATISTICS
 449   tree_node_kind kind;
 450
 451   switch (type)
 452     {
 453     case tcc_declaration:  /* A decl node */
 454       kind = d_kind;
 455       break;
 456
 457     case tcc_type:  /* a type node */
 458       kind = t_kind;
 459       break;
 460
 461     case tcc_statement:  /* an expression with side effects */
 462       kind = s_kind;
 463       break;
 464
 465     case tcc_reference:  /* a reference */
 466       kind = r_kind;
 467       break;
 468
 469     case tcc_expression:  /* an expression */
 470     case tcc_comparison:  /* a comparison expression */
 471     case tcc_unary:  /* a unary arithmetic expression */
 472     case tcc_binary:  /* a binary arithmetic expression */
 473       kind = e_kind;
 474       break;
 475
 476     case tcc_constant:  /* a constant */
 477       kind = c_kind;
 478       break;
 479
 480     case tcc_exceptional:  /* something random, like an identifier.  */
 481       switch (code)
 482         {
 483         case IDENTIFIER_NODE:
 484           kind = id_kind;
 485           break;
 486
 487         case TREE_VEC:
 488           kind = vec_kind;
 489           break;
 490
 491         case TREE_BINFO:
 492           kind = binfo_kind;
 493           break;
 494
 495         case PHI_NODE:
 496           kind = phi_kind;
 497           break;
 498
 499         case SSA_NAME:
 500           kind = ssa_name_kind;
 501           break;
 502
 503         case BLOCK:
 504           kind = b_kind;
 505           break;
 506
 507         case CONSTRUCTOR:
 508           kind = constr_kind;
 509           break;
 510
 511         default:
 512           kind = x_kind;
 513           break;
 514         }
 515       break;
 516
 517     default:
 518       gcc_unreachable ();
 519     }
 520
 521   tree_node_counts[(int) kind]++;
 522   tree_node_sizes[(int) kind] += length;
 523 #endif
 524
 525   if (code == IDENTIFIER_NODE)
 526     t = ggc_alloc_zone_pass_stat (length, &tree_id_zone);
 527   else
 528     t = ggc_alloc_zone_pass_stat (length, &tree_zone);
 529
 530   memset (t, 0, length);
 531
 532   TREE_SET_CODE (t, code);
 533
 534   switch (type)
 535     {
 536     case tcc_statement:
 537       TREE_SIDE_EFFECTS (t) = 1;
 538       break;
 539
 540     case tcc_declaration:
 541       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 542         DECL_IN_SYSTEM_HEADER (t) = in_system_header;
 543       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 544         {
 545           if (code != FUNCTION_DECL)
 546             DECL_ALIGN (t) = 1;
 547           DECL_USER_ALIGN (t) = 0;
 548           /* We have not yet computed the alias set for this declaration.  */
 549           DECL_POINTER_ALIAS_SET (t) = -1;
 550         }
 551       DECL_SOURCE_LOCATION (t) = input_location;
 552       DECL_UID (t) = next_decl_uid++;
 553
 554       break;
 555
 556     case tcc_type:
 557       TYPE_UID (t) = next_type_uid++;
 558       TYPE_ALIGN (t) = BITS_PER_UNIT;
 559       TYPE_USER_ALIGN (t) = 0;
 560       TYPE_MAIN_VARIANT (t) = t;
 561
 562       /* Default to no attributes for type, but let target change that.  */
 563       TYPE_ATTRIBUTES (t) = NULL_TREE;
 564       targetm.set_default_type_attributes (t);
 565
 566       /* We have not yet computed the alias set for this type.  */
 567       TYPE_ALIAS_SET (t) = -1;
 568       break;
 569
 570     case tcc_constant:
 571       TREE_CONSTANT (t) = 1;
 572       TREE_INVARIANT (t) = 1;
 573       break;
 574
 575     case tcc_expression:
 576       switch (code)
 577         {
 578         case INIT_EXPR:
 579         case MODIFY_EXPR:
 580         case VA_ARG_EXPR:
 581         case PREDECREMENT_EXPR:
 582         case PREINCREMENT_EXPR:
 583         case POSTDECREMENT_EXPR:
 584         case POSTINCREMENT_EXPR:
 585           /* All of these have side-effects, no matter what their
 586              operands are.  */
 587           TREE_SIDE_EFFECTS (t) = 1;
 588           break;
 589
 590         default:
 591           break;
 592         }
 593       break;
 594
 595     default:
 596       /* Other classes need no special treatment.  */
 597       break;
 598     }
 599
 600   return t;
 601 }
 602 \f
 603 /* Return a new node with the same contents as NODE except that its
 604    TREE_CHAIN is zero and it has a fresh uid.  */
 605
 606 tree
 607 copy_node_stat (tree node MEM_STAT_DECL)
 608 {
 609   tree t;
 610   enum tree_code code = TREE_CODE (node);
 611   size_t length;
 612
 613   gcc_assert (code != STATEMENT_LIST);
 614
 615   length = tree_size (node);
 616   t = ggc_alloc_zone_pass_stat (length, &tree_zone);
 617   memcpy (t, node, length);
 618
 619   TREE_CHAIN (t) = 0;
 620   TREE_ASM_WRITTEN (t) = 0;
 621   TREE_VISITED (t) = 0;
 622   t->common.ann = 0;
 623
 624   if (TREE_CODE_CLASS (code) == tcc_declaration)
 625     {
 626       DECL_UID (t) = next_decl_uid++;
 627       if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
 628           && DECL_HAS_VALUE_EXPR_P (node))
 629         {
 630           SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
 631           DECL_HAS_VALUE_EXPR_P (t) = 1;
 632         }
 633       if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
 634         {
 635           SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
 636           DECL_HAS_INIT_PRIORITY_P (t) = 1;
 637         }
 638       if (TREE_CODE (node) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (node))
 639         {
 640           SET_DECL_RESTRICT_BASE (t, DECL_GET_RESTRICT_BASE (node));
 641           DECL_BASED_ON_RESTRICT_P (t) = 1;
 642         }
 643     }
 644   else if (TREE_CODE_CLASS (code) == tcc_type)
 645     {
 646       TYPE_UID (t) = next_type_uid++;
 647       /* The following is so that the debug code for
 648          the copy is different from the original type.
 649          The two statements usually duplicate each other
 650          (because they clear fields of the same union),
 651          but the optimizer should catch that.  */
 652       TYPE_SYMTAB_POINTER (t) = 0;
 653       TYPE_SYMTAB_ADDRESS (t) = 0;
 654
 655       /* Do not copy the values cache.  */
 656       if (TYPE_CACHED_VALUES_P(t))
 657         {
 658           TYPE_CACHED_VALUES_P (t) = 0;
 659           TYPE_CACHED_VALUES (t) = NULL_TREE;
 660         }
 661     }
 662
 663   return t;
 664 }
 665
 666 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
 667    For example, this can copy a list made of TREE_LIST nodes.  */
 668
 669 tree
 670 copy_list (tree list)
 671 {
 672   tree head;
 673   tree prev, next;
 674
 675   if (list == 0)
 676     return 0;
 677
 678   head = prev = copy_node (list);
 679   next = TREE_CHAIN (list);
 680   while (next)
 681     {
 682       TREE_CHAIN (prev) = copy_node (next);
 683       prev = TREE_CHAIN (prev);
 684       next = TREE_CHAIN (next);
 685     }
 686   return head;
 687 }
 688
 689 \f
 690 /* Create an INT_CST node with a LOW value sign extended.  */
 691
 692 tree
 693 build_int_cst (tree type, HOST_WIDE_INT low)
 694 {
 695   return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
 696 }
 697
 698 /* Create an INT_CST node with a LOW value zero extended.  */
 699
 700 tree
 701 build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
 702 {
 703   return build_int_cst_wide (type, low, 0);
 704 }
 705
 706 /* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
 707    if it is negative.  This function is similar to build_int_cst, but
 708    the extra bits outside of the type precision are cleared.  Constants
 709    with these extra bits may confuse the fold so that it detects overflows
 710    even in cases when they do not occur, and in general should be avoided.
 711    We cannot however make this a default behavior of build_int_cst without
 712    more intrusive changes, since there are parts of gcc that rely on the extra
 713    precision of the integer constants.  */
 714
 715 tree
 716 build_int_cst_type (tree type, HOST_WIDE_INT low)
 717 {
 718   unsigned HOST_WIDE_INT val = (unsigned HOST_WIDE_INT) low;
 719   unsigned HOST_WIDE_INT hi, mask;
 720   unsigned bits;
 721   bool signed_p;
 722   bool negative;
 723
 724   if (!type)
 725     type = integer_type_node;
 726
 727   bits = TYPE_PRECISION (type);
 728   signed_p = !TYPE_UNSIGNED (type);
 729
 730   if (bits >= HOST_BITS_PER_WIDE_INT)
 731     negative = (low < 0);
 732   else
 733     {
 734       /* If the sign bit is inside precision of LOW, use it to determine
 735          the sign of the constant.  */
 736       negative = ((val >> (bits - 1)) & 1) != 0;
 737
 738       /* Mask out the bits outside of the precision of the constant.  */
 739       mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1;
 740
 741       if (signed_p && negative)
 742         val |= ~mask;
 743       else
 744         val &= mask;
 745     }
 746
 747   /* Determine the high bits.  */
 748   hi = (negative ? ~(unsigned HOST_WIDE_INT) 0 : 0);
 749
 750   /* For unsigned type we need to mask out the bits outside of the type
 751      precision.  */
 752   if (!signed_p)
 753     {
 754       if (bits <= HOST_BITS_PER_WIDE_INT)
 755         hi = 0;
 756       else
 757         {
 758           bits -= HOST_BITS_PER_WIDE_INT;
 759           mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1;
 760           hi &= mask;
 761         }
 762     }
 763
 764   return build_int_cst_wide (type, val, hi);
 765 }
 766
 767 /* These are the hash table functions for the hash table of INTEGER_CST
 768    nodes of a sizetype.  */
 769
 770 /* Return the hash code code X, an INTEGER_CST.  */
 771
 772 static hashval_t
 773 int_cst_hash_hash (const void *x)
 774 {
 775   tree t = (tree) x;
 776
 777   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
 778           ^ htab_hash_pointer (TREE_TYPE (t)));
 779 }
 780
 781 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
 782    is the same as that given by *Y, which is the same.  */
 783
 784 static int
 785 int_cst_hash_eq (const void *x, const void *y)
 786 {
 787   tree xt = (tree) x;
 788   tree yt = (tree) y;
 789
 790   return (TREE_TYPE (xt) == TREE_TYPE (yt)
 791           && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
 792           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
 793 }
 794
 795 /* Create an INT_CST node of TYPE and value HI:LOW.  If TYPE is NULL,
 796    integer_type_node is used.  The returned node is always shared.
 797    For small integers we use a per-type vector cache, for larger ones
 798    we use a single hash table.  */
 799
 800 tree
 801 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
 802 {
 803   tree t;
 804   int ix = -1;
 805   int limit = 0;
 806
 807   if (!type)
 808     type = integer_type_node;
 809
 810   switch (TREE_CODE (type))
 811     {
 812     case POINTER_TYPE:
 813     case REFERENCE_TYPE:
 814       /* Cache NULL pointer.  */
 815       if (!hi && !low)
 816         {
 817           limit = 1;
 818           ix = 0;
 819         }
 820       break;
 821
 822     case BOOLEAN_TYPE:
 823       /* Cache false or true.  */
 824       limit = 2;
 825       if (!hi && low < 2)
 826         ix = low;
 827       break;
 828
 829     case INTEGER_TYPE:
 830     case OFFSET_TYPE:
 831       if (TYPE_UNSIGNED (type))
 832         {
 833           /* Cache 0..N */
 834           limit = INTEGER_SHARE_LIMIT;
 835           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
 836             ix = low;
 837         }
 838       else
 839         {
 840           /* Cache -1..N */
 841           limit = INTEGER_SHARE_LIMIT + 1;
 842           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
 843             ix = low + 1;
 844           else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
 845             ix = 0;
 846         }
 847       break;
 848     default:
 849       break;
 850     }
 851
 852   if (ix >= 0)
 853     {
 854       /* Look for it in the type's vector of small shared ints.  */
 855       if (!TYPE_CACHED_VALUES_P (type))
 856         {
 857           TYPE_CACHED_VALUES_P (type) = 1;
 858           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
 859         }
 860
 861       t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
 862       if (t)
 863         {
 864           /* Make sure no one is clobbering the shared constant.  */
 865           gcc_assert (TREE_TYPE (t) == type);
 866           gcc_assert (TREE_INT_CST_LOW (t) == low);
 867           gcc_assert (TREE_INT_CST_HIGH (t) == hi);
 868         }
 869       else
 870         {
 871           /* Create a new shared int.  */
 872           t = make_node (INTEGER_CST);
 873
 874           TREE_INT_CST_LOW (t) = low;
 875           TREE_INT_CST_HIGH (t) = hi;
 876           TREE_TYPE (t) = type;
 877
 878           TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
 879         }
 880     }
 881   else
 882     {
 883       /* Use the cache of larger shared ints.  */
 884       void **slot;
 885
 886       TREE_INT_CST_LOW (int_cst_node) = low;
 887       TREE_INT_CST_HIGH (int_cst_node) = hi;
 888       TREE_TYPE (int_cst_node) = type;
 889
 890       slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
 891       t = *slot;
 892       if (!t)
 893         {
 894           /* Insert this one into the hash table.  */
 895           t = int_cst_node;
 896           *slot = t;
 897           /* Make a new node for next time round.  */
 898           int_cst_node = make_node (INTEGER_CST);
 899         }
 900     }
 901
 902   return t;
 903 }
 904
 905 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
 906    and the rest are zeros.  */
 907
 908 tree
 909 build_low_bits_mask (tree type, unsigned bits)
 910 {
 911   unsigned HOST_WIDE_INT low;
 912   HOST_WIDE_INT high;
 913   unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0;
 914
 915   gcc_assert (bits <= TYPE_PRECISION (type));
 916
 917   if (bits == TYPE_PRECISION (type)
 918       && !TYPE_UNSIGNED (type))
 919     {
 920       /* Sign extended all-ones mask.  */
 921       low = all_ones;
 922       high = -1;
 923     }
 924   else if (bits <= HOST_BITS_PER_WIDE_INT)
 925     {
 926       low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
 927       high = 0;
 928     }
 929   else
 930     {
 931       bits -= HOST_BITS_PER_WIDE_INT;
 932       low = all_ones;
 933       high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
 934     }
 935
 936   return build_int_cst_wide (type, low, high);
 937 }
 938
 939 /* Checks that X is integer constant that can be expressed in (unsigned)
 940    HOST_WIDE_INT without loss of precision.  */
 941
 942 bool
 943 cst_and_fits_in_hwi (tree x)
 944 {
 945   if (TREE_CODE (x) != INTEGER_CST)
 946     return false;
 947
 948   if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
 949     return false;
 950
 951   return (TREE_INT_CST_HIGH (x) == 0
 952           || TREE_INT_CST_HIGH (x) == -1);
 953 }
 954
 955 /* Return a new VECTOR_CST node whose type is TYPE and whose values
 956    are in a list pointed to by VALS.  */
 957
 958 tree
 959 build_vector (tree type, tree vals)
 960 {
 961   tree v = make_node (VECTOR_CST);
 962   int over1 = 0, over2 = 0;
 963   tree link;
 964
 965   TREE_VECTOR_CST_ELTS (v) = vals;
 966   TREE_TYPE (v) = type;
 967
 968   /* Iterate through elements and check for overflow.  */
 969   for (link = vals; link; link = TREE_CHAIN (link))
 970     {
 971       tree value = TREE_VALUE (link);
 972
 973       over1 |= TREE_OVERFLOW (value);
 974       over2 |= TREE_CONSTANT_OVERFLOW (value);
 975     }
 976
 977   TREE_OVERFLOW (v) = over1;
 978   TREE_CONSTANT_OVERFLOW (v) = over2;
 979
 980   return v;
 981 }
 982
 983 /* Return a new VECTOR_CST node whose type is TYPE and whose values
 984    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
 985
 986 tree
 987 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
 988 {
 989   tree list = NULL_TREE;
 990   unsigned HOST_WIDE_INT idx;
 991   tree value;
 992
 993   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
 994     list = tree_cons (NULL_TREE, value, list);
 995   return build_vector (type, nreverse (list));
 996 }
 997
 998 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
 999    are in the VEC pointed to by VALS.  */
1000 tree
1001 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1002 {
1003   tree c = make_node (CONSTRUCTOR);
1004   TREE_TYPE (c) = type;
1005   CONSTRUCTOR_ELTS (c) = vals;
1006   return c;
1007 }
1008
1009 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1010    INDEX and VALUE.  */
1011 tree
1012 build_constructor_single (tree type, tree index, tree value)
1013 {
1014   VEC(constructor_elt,gc) *v;
1015   constructor_elt *elt;
1016   tree t;
1017
1018   v = VEC_alloc (constructor_elt, gc, 1);
1019   elt = VEC_quick_push (constructor_elt, v, NULL);
1020   elt->index = index;
1021   elt->value = value;
1022
1023   t = build_constructor (type, v);
1024   TREE_CONSTANT (t) = TREE_CONSTANT (value);
1025   return t;
1026 }
1027
1028
1029 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1030    are in a list pointed to by VALS.  */
1031 tree
1032 build_constructor_from_list (tree type, tree vals)
1033 {
1034   tree t, val;
1035   VEC(constructor_elt,gc) *v = NULL;
1036   bool constant_p = true;
1037
1038   if (vals)
1039     {
1040       v = VEC_alloc (constructor_elt, gc, list_length (vals));
1041       for (t = vals; t; t = TREE_CHAIN (t))
1042         {
1043           constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
1044           val = TREE_VALUE (t);
1045           elt->index = TREE_PURPOSE (t);
1046           elt->value = val;
1047           if (!TREE_CONSTANT (val))
1048             constant_p = false;
1049         }
1050     }
1051
1052   t = build_constructor (type, v);
1053   TREE_CONSTANT (t) = constant_p;
1054   return t;
1055 }
1056
1057
1058 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1059
1060 tree
1061 build_real (tree type, REAL_VALUE_TYPE d)
1062 {
1063   tree v;
1064   REAL_VALUE_TYPE *dp;
1065   int overflow = 0;
1066
1067   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1068      Consider doing it via real_convert now.  */
1069
1070   v = make_node (REAL_CST);
1071   dp = ggc_alloc (sizeof (REAL_VALUE_TYPE));
1072   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1073
1074   TREE_TYPE (v) = type;
1075   TREE_REAL_CST_PTR (v) = dp;
1076   TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
1077   return v;
1078 }
1079
1080 /* Return a new REAL_CST node whose type is TYPE
1081    and whose value is the integer value of the INTEGER_CST node I.  */
1082
1083 REAL_VALUE_TYPE
1084 real_value_from_int_cst (tree type, tree i)
1085 {
1086   REAL_VALUE_TYPE d;
1087
1088   /* Clear all bits of the real value type so that we can later do
1089      bitwise comparisons to see if two values are the same.  */
1090   memset (&d, 0, sizeof d);
1091
1092   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1093                      TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1094                      TYPE_UNSIGNED (TREE_TYPE (i)));
1095   return d;
1096 }
1097
1098 /* Given a tree representing an integer constant I, return a tree
1099    representing the same value as a floating-point constant of type TYPE.  */
1100
1101 tree
1102 build_real_from_int_cst (tree type, tree i)
1103 {
1104   tree v;
1105   int overflow = TREE_OVERFLOW (i);
1106
1107   v = build_real (type, real_value_from_int_cst (type, i));
1108
1109   TREE_OVERFLOW (v) |= overflow;
1110   TREE_CONSTANT_OVERFLOW (v) |= overflow;
1111   return v;
1112 }
1113
1114 /* Return a newly constructed STRING_CST node whose value is
1115    the LEN characters at STR.
1116    The TREE_TYPE is not initialized.  */
1117
1118 tree
1119 build_string (int len, const char *str)
1120 {
1121   tree s;
1122   size_t length;
1123
1124   length = len + sizeof (struct tree_string);
1125
1126 #ifdef GATHER_STATISTICS
1127   tree_node_counts[(int) c_kind]++;
1128   tree_node_sizes[(int) c_kind] += length;
1129 #endif
1130
1131   s = ggc_alloc_tree (length);
1132
1133   memset (s, 0, sizeof (struct tree_common));
1134   TREE_SET_CODE (s, STRING_CST);
1135   TREE_CONSTANT (s) = 1;
1136   TREE_INVARIANT (s) = 1;
1137   TREE_STRING_LENGTH (s) = len;
1138   memcpy ((char *) TREE_STRING_POINTER (s), str, len);
1139   ((char *) TREE_STRING_POINTER (s))[len] = '\0';
1140
1141   return s;
1142 }
1143
1144 /* Return a newly constructed COMPLEX_CST node whose value is
1145    specified by the real and imaginary parts REAL and IMAG.
1146    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1147    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1148
1149 tree
1150 build_complex (tree type, tree real, tree imag)
1151 {
1152   tree t = make_node (COMPLEX_CST);
1153
1154   TREE_REALPART (t) = real;
1155   TREE_IMAGPART (t) = imag;
1156   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1157   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1158   TREE_CONSTANT_OVERFLOW (t)
1159     = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
1160   return t;
1161 }
1162
1163 /* Build a BINFO with LEN language slots.  */
1164
1165 tree
1166 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1167 {
1168   tree t;
1169   size_t length = (offsetof (struct tree_binfo, base_binfos)
1170                    + VEC_embedded_size (tree, base_binfos));
1171
1172 #ifdef GATHER_STATISTICS
1173   tree_node_counts[(int) binfo_kind]++;
1174   tree_node_sizes[(int) binfo_kind] += length;
1175 #endif
1176
1177   t = ggc_alloc_zone_pass_stat (length, &tree_zone);
1178
1179   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1180
1181   TREE_SET_CODE (t, TREE_BINFO);
1182
1183   VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1184
1185   return t;
1186 }
1187
1188
1189 /* Build a newly constructed TREE_VEC node of length LEN.  */
1190
1191 tree
1192 make_tree_vec_stat (int len MEM_STAT_DECL)
1193 {
1194   tree t;
1195   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1196
1197 #ifdef GATHER_STATISTICS
1198   tree_node_counts[(int) vec_kind]++;
1199   tree_node_sizes[(int) vec_kind] += length;
1200 #endif
1201
1202   t = ggc_alloc_zone_pass_stat (length, &tree_zone);
1203
1204   memset (t, 0, length);
1205
1206   TREE_SET_CODE (t, TREE_VEC);
1207   TREE_VEC_LENGTH (t) = len;
1208
1209   return t;
1210 }
1211 \f
1212 /* Return 1 if EXPR is the integer constant zero or a complex constant
1213    of zero.  */
1214
1215 int
1216 integer_zerop (tree expr)
1217 {
1218   STRIP_NOPS (expr);
1219
1220   return ((TREE_CODE (expr) == INTEGER_CST
1221            && TREE_INT_CST_LOW (expr) == 0
1222            && TREE_INT_CST_HIGH (expr) == 0)
1223           || (TREE_CODE (expr) == COMPLEX_CST
1224               && integer_zerop (TREE_REALPART (expr))
1225               && integer_zerop (TREE_IMAGPART (expr))));
1226 }
1227
1228 /* Return 1 if EXPR is the integer constant one or the corresponding
1229    complex constant.  */
1230
1231 int
1232 integer_onep (tree expr)
1233 {
1234   STRIP_NOPS (expr);
1235
1236   return ((TREE_CODE (expr) == INTEGER_CST
1237            && TREE_INT_CST_LOW (expr) == 1
1238            && TREE_INT_CST_HIGH (expr) == 0)
1239           || (TREE_CODE (expr) == COMPLEX_CST
1240               && integer_onep (TREE_REALPART (expr))
1241               && integer_zerop (TREE_IMAGPART (expr))));
1242 }
1243
1244 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1245    it contains.  Likewise for the corresponding complex constant.  */
1246
1247 int
1248 integer_all_onesp (tree expr)
1249 {
1250   int prec;
1251   int uns;
1252
1253   STRIP_NOPS (expr);
1254
1255   if (TREE_CODE (expr) == COMPLEX_CST
1256       && integer_all_onesp (TREE_REALPART (expr))
1257       && integer_zerop (TREE_IMAGPART (expr)))
1258     return 1;
1259
1260   else if (TREE_CODE (expr) != INTEGER_CST)
1261     return 0;
1262
1263   uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1264   if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1265       && TREE_INT_CST_HIGH (expr) == -1)
1266     return 1;
1267   if (!uns)
1268     return 0;
1269
1270   /* Note that using TYPE_PRECISION here is wrong.  We care about the
1271      actual bits, not the (arbitrary) range of the type.  */
1272   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1273   if (prec >= HOST_BITS_PER_WIDE_INT)
1274     {
1275       HOST_WIDE_INT high_value;
1276       int shift_amount;
1277
1278       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1279
1280       /* Can not handle precisions greater than twice the host int size.  */
1281       gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1282       if (shift_amount == HOST_BITS_PER_WIDE_INT)
1283         /* Shifting by the host word size is undefined according to the ANSI
1284            standard, so we must handle this as a special case.  */
1285         high_value = -1;
1286       else
1287         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1288
1289       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1290               && TREE_INT_CST_HIGH (expr) == high_value);
1291     }
1292   else
1293     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1294 }
1295
1296 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1297    one bit on).  */
1298
1299 int
1300 integer_pow2p (tree expr)
1301 {
1302   int prec;
1303   HOST_WIDE_INT high, low;
1304
1305   STRIP_NOPS (expr);
1306
1307   if (TREE_CODE (expr) == COMPLEX_CST
1308       && integer_pow2p (TREE_REALPART (expr))
1309       && integer_zerop (TREE_IMAGPART (expr)))
1310     return 1;
1311
1312   if (TREE_CODE (expr) != INTEGER_CST)
1313     return 0;
1314
1315   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1316           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1317   high = TREE_INT_CST_HIGH (expr);
1318   low = TREE_INT_CST_LOW (expr);
1319
1320   /* First clear all bits that are beyond the type's precision in case
1321      we've been sign extended.  */
1322
1323   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1324     ;
1325   else if (prec > HOST_BITS_PER_WIDE_INT)
1326     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1327   else
1328     {
1329       high = 0;
1330       if (prec < HOST_BITS_PER_WIDE_INT)
1331         low &= ~((HOST_WIDE_INT) (-1) << prec);
1332     }
1333
1334   if (high == 0 && low == 0)
1335     return 0;
1336
1337   return ((high == 0 && (low & (low - 1)) == 0)
1338           || (low == 0 && (high & (high - 1)) == 0));
1339 }
1340
1341 /* Return 1 if EXPR is an integer constant other than zero or a
1342    complex constant other than zero.  */
1343
1344 int
1345 integer_nonzerop (tree expr)
1346 {
1347   STRIP_NOPS (expr);
1348
1349   return ((TREE_CODE (expr) == INTEGER_CST
1350            && (TREE_INT_CST_LOW (expr) != 0
1351                || TREE_INT_CST_HIGH (expr) != 0))
1352           || (TREE_CODE (expr) == COMPLEX_CST
1353               && (integer_nonzerop (TREE_REALPART (expr))
1354                   || integer_nonzerop (TREE_IMAGPART (expr)))));
1355 }
1356
1357 /* Return the power of two represented by a tree node known to be a
1358    power of two.  */
1359
1360 int
1361 tree_log2 (tree expr)
1362 {
1363   int prec;
1364   HOST_WIDE_INT high, low;
1365
1366   STRIP_NOPS (expr);
1367
1368   if (TREE_CODE (expr) == COMPLEX_CST)
1369     return tree_log2 (TREE_REALPART (expr));
1370
1371   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1372           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1373
1374   high = TREE_INT_CST_HIGH (expr);
1375   low = TREE_INT_CST_LOW (expr);
1376
1377   /* First clear all bits that are beyond the type's precision in case
1378      we've been sign extended.  */
1379
1380   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1381     ;
1382   else if (prec > HOST_BITS_PER_WIDE_INT)
1383     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1384   else
1385     {
1386       high = 0;
1387       if (prec < HOST_BITS_PER_WIDE_INT)
1388         low &= ~((HOST_WIDE_INT) (-1) << prec);
1389     }
1390
1391   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1392           : exact_log2 (low));
1393 }
1394
1395 /* Similar, but return the largest integer Y such that 2 ** Y is less
1396    than or equal to EXPR.  */
1397
1398 int
1399 tree_floor_log2 (tree expr)
1400 {
1401   int prec;
1402   HOST_WIDE_INT high, low;
1403
1404   STRIP_NOPS (expr);
1405
1406   if (TREE_CODE (expr) == COMPLEX_CST)
1407     return tree_log2 (TREE_REALPART (expr));
1408
1409   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1410           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1411
1412   high = TREE_INT_CST_HIGH (expr);
1413   low = TREE_INT_CST_LOW (expr);
1414
1415   /* First clear all bits that are beyond the type's precision in case
1416      we've been sign extended.  Ignore if type's precision hasn't been set
1417      since what we are doing is setting it.  */
1418
1419   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1420     ;
1421   else if (prec > HOST_BITS_PER_WIDE_INT)
1422     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1423   else
1424     {
1425       high = 0;
1426       if (prec < HOST_BITS_PER_WIDE_INT)
1427         low &= ~((HOST_WIDE_INT) (-1) << prec);
1428     }
1429
1430   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1431           : floor_log2 (low));
1432 }
1433
1434 /* Return 1 if EXPR is the real constant zero.  */
1435
1436 int
1437 real_zerop (tree expr)
1438 {
1439   STRIP_NOPS (expr);
1440
1441   return ((TREE_CODE (expr) == REAL_CST
1442            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
1443           || (TREE_CODE (expr) == COMPLEX_CST
1444               && real_zerop (TREE_REALPART (expr))
1445               && real_zerop (TREE_IMAGPART (expr))));
1446 }
1447
1448 /* Return 1 if EXPR is the real constant one in real or complex form.  */
1449
1450 int
1451 real_onep (tree expr)
1452 {
1453   STRIP_NOPS (expr);
1454
1455   return ((TREE_CODE (expr) == REAL_CST
1456            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
1457           || (TREE_CODE (expr) == COMPLEX_CST
1458               && real_onep (TREE_REALPART (expr))
1459               && real_zerop (TREE_IMAGPART (expr))));
1460 }
1461
1462 /* Return 1 if EXPR is the real constant two.  */
1463
1464 int
1465 real_twop (tree expr)
1466 {
1467   STRIP_NOPS (expr);
1468
1469   return ((TREE_CODE (expr) == REAL_CST
1470            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
1471           || (TREE_CODE (expr) == COMPLEX_CST
1472               && real_twop (TREE_REALPART (expr))
1473               && real_zerop (TREE_IMAGPART (expr))));
1474 }
1475
1476 /* Return 1 if EXPR is the real constant minus one.  */
1477
1478 int
1479 real_minus_onep (tree expr)
1480 {
1481   STRIP_NOPS (expr);
1482
1483   return ((TREE_CODE (expr) == REAL_CST
1484            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1))
1485           || (TREE_CODE (expr) == COMPLEX_CST
1486               && real_minus_onep (TREE_REALPART (expr))
1487               && real_zerop (TREE_IMAGPART (expr))));
1488 }
1489
1490 /* Nonzero if EXP is a constant or a cast of a constant.  */
1491
1492 int
1493 really_constant_p (tree exp)
1494 {
1495   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1496   while (TREE_CODE (exp) == NOP_EXPR
1497          || TREE_CODE (exp) == CONVERT_EXPR
1498          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1499     exp = TREE_OPERAND (exp, 0);
1500   return TREE_CONSTANT (exp);
1501 }
1502 \f
1503 /* Return first list element whose TREE_VALUE is ELEM.
1504    Return 0 if ELEM is not in LIST.  */
1505
1506 tree
1507 value_member (tree elem, tree list)
1508 {
1509   while (list)
1510     {
1511       if (elem == TREE_VALUE (list))
1512         return list;
1513       list = TREE_CHAIN (list);
1514     }
1515   return NULL_TREE;
1516 }
1517
1518 /* Return first list element whose TREE_PURPOSE is ELEM.
1519    Return 0 if ELEM is not in LIST.  */
1520
1521 tree
1522 purpose_member (tree elem, tree list)
1523 {
1524   while (list)
1525     {
1526       if (elem == TREE_PURPOSE (list))
1527         return list;
1528       list = TREE_CHAIN (list);
1529     }
1530   return NULL_TREE;
1531 }
1532
1533 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1534
1535 int
1536 chain_member (tree elem, tree chain)
1537 {
1538   while (chain)
1539     {
1540       if (elem == chain)
1541         return 1;
1542       chain = TREE_CHAIN (chain);
1543     }
1544
1545   return 0;
1546 }
1547
1548 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1549    We expect a null pointer to mark the end of the chain.
1550    This is the Lisp primitive `length'.  */
1551
1552 int
1553 list_length (tree t)
1554 {
1555   tree p = t;
1556 #ifdef ENABLE_TREE_CHECKING
1557   tree q = t;
1558 #endif
1559   int len = 0;
1560
1561   while (p)
1562     {
1563       p = TREE_CHAIN (p);
1564 #ifdef ENABLE_TREE_CHECKING
1565       if (len % 2)
1566         q = TREE_CHAIN (q);
1567       gcc_assert (p != q);
1568 #endif
1569       len++;
1570     }
1571
1572   return len;
1573 }
1574
1575 /* Returns the number of FIELD_DECLs in TYPE.  */
1576
1577 int
1578 fields_length (tree type)
1579 {
1580   tree t = TYPE_FIELDS (type);
1581   int count = 0;
1582
1583   for (; t; t = TREE_CHAIN (t))
1584     if (TREE_CODE (t) == FIELD_DECL)
1585       ++count;
1586
1587   return count;
1588 }
1589
1590 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1591    by modifying the last node in chain 1 to point to chain 2.
1592    This is the Lisp primitive `nconc'.  */
1593
1594 tree
1595 chainon (tree op1, tree op2)
1596 {
1597   tree t1;
1598
1599   if (!op1)
1600     return op2;
1601   if (!op2)
1602     return op1;
1603
1604   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1605     continue;
1606   TREE_CHAIN (t1) = op2;
1607
1608 #ifdef ENABLE_TREE_CHECKING
1609   {
1610     tree t2;
1611     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1612       gcc_assert (t2 != t1);
1613   }
1614 #endif
1615
1616   return op1;
1617 }
1618
1619 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
1620
1621 tree
1622 tree_last (tree chain)
1623 {
1624   tree next;
1625   if (chain)
1626     while ((next = TREE_CHAIN (chain)))
1627       chain = next;
1628   return chain;
1629 }
1630
1631 /* Reverse the order of elements in the chain T,
1632    and return the new head of the chain (old last element).  */
1633
1634 tree
1635 nreverse (tree t)
1636 {
1637   tree prev = 0, decl, next;
1638   for (decl = t; decl; decl = next)
1639     {
1640       next = TREE_CHAIN (decl);
1641       TREE_CHAIN (decl) = prev;
1642       prev = decl;
1643     }
1644   return prev;
1645 }
1646 \f
1647 /* Return a newly created TREE_LIST node whose
1648    purpose and value fields are PARM and VALUE.  */
1649
1650 tree
1651 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
1652 {
1653   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
1654   TREE_PURPOSE (t) = parm;
1655   TREE_VALUE (t) = value;
1656   return t;
1657 }
1658
1659 /* Return a newly created TREE_LIST node whose
1660    purpose and value fields are PURPOSE and VALUE
1661    and whose TREE_CHAIN is CHAIN.  */
1662
1663 tree
1664 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
1665 {
1666   tree node;
1667
1668   node = ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
1669
1670   memset (node, 0, sizeof (struct tree_common));
1671
1672 #ifdef GATHER_STATISTICS
1673   tree_node_counts[(int) x_kind]++;
1674   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
1675 #endif
1676
1677   TREE_SET_CODE (node, TREE_LIST);
1678   TREE_CHAIN (node) = chain;
1679   TREE_PURPOSE (node) = purpose;
1680   TREE_VALUE (node) = value;
1681   return node;
1682 }
1683
1684 \f
1685 /* Return the size nominally occupied by an object of type TYPE
1686    when it resides in memory.  The value is measured in units of bytes,
1687    and its data type is that normally used for type sizes
1688    (which is the first type created by make_signed_type or
1689    make_unsigned_type).  */
1690
1691 tree
1692 size_in_bytes (tree type)
1693 {
1694   tree t;
1695
1696   if (type == error_mark_node)
1697     return integer_zero_node;
1698
1699   type = TYPE_MAIN_VARIANT (type);
1700   t = TYPE_SIZE_UNIT (type);
1701
1702   if (t == 0)
1703     {
1704       lang_hooks.types.incomplete_type_error (NULL_TREE, type);
1705       return size_zero_node;
1706     }
1707
1708   if (TREE_CODE (t) == INTEGER_CST)
1709     t = force_fit_type (t, 0, false, false);
1710
1711   return t;
1712 }
1713
1714 /* Return the size of TYPE (in bytes) as a wide integer
1715    or return -1 if the size can vary or is larger than an integer.  */
1716
1717 HOST_WIDE_INT
1718 int_size_in_bytes (tree type)
1719 {
1720   tree t;
1721
1722   if (type == error_mark_node)
1723     return 0;
1724
1725   type = TYPE_MAIN_VARIANT (type);
1726   t = TYPE_SIZE_UNIT (type);
1727   if (t == 0
1728       || TREE_CODE (t) != INTEGER_CST
1729       || TREE_INT_CST_HIGH (t) != 0
1730       /* If the result would appear negative, it's too big to represent.  */
1731       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
1732     return -1;
1733
1734   return TREE_INT_CST_LOW (t);
1735 }
1736
1737 /* Return the maximum size of TYPE (in bytes) as a wide integer
1738    or return -1 if the size can vary or is larger than an integer.  */
1739
1740 HOST_WIDE_INT
1741 max_int_size_in_bytes (tree type)
1742 {
1743   HOST_WIDE_INT size = -1;
1744   tree size_tree;
1745
1746   /* If this is an array type, check for a possible MAX_SIZE attached.  */
1747
1748   if (TREE_CODE (type) == ARRAY_TYPE)
1749     {
1750       size_tree = TYPE_ARRAY_MAX_SIZE (type);
1751
1752       if (size_tree && host_integerp (size_tree, 1))
1753         size = tree_low_cst (size_tree, 1);
1754     }
1755
1756   /* If we still haven't been able to get a size, see if the language
1757      can compute a maximum size.  */
1758
1759   if (size == -1)
1760     {
1761       size_tree = lang_hooks.types.max_size (type);
1762
1763       if (size_tree && host_integerp (size_tree, 1))
1764         size = tree_low_cst (size_tree, 1);
1765     }
1766
1767   return size;
1768 }
1769 \f
1770 /* Return the bit position of FIELD, in bits from the start of the record.
1771    This is a tree of type bitsizetype.  */
1772
1773 tree
1774 bit_position (tree field)
1775 {
1776   return bit_from_pos (DECL_FIELD_OFFSET (field),
1777                        DECL_FIELD_BIT_OFFSET (field));
1778 }
1779
1780 /* Likewise, but return as an integer.  It must be representable in
1781    that way (since it could be a signed value, we don't have the
1782    option of returning -1 like int_size_in_byte can.  */
1783
1784 HOST_WIDE_INT
1785 int_bit_position (tree field)
1786 {
1787   return tree_low_cst (bit_position (field), 0);
1788 }
1789 \f
1790 /* Return the byte position of FIELD, in bytes from the start of the record.
1791    This is a tree of type sizetype.  */
1792
1793 tree
1794 byte_position (tree field)
1795 {
1796   return byte_from_pos (DECL_FIELD_OFFSET (field),
1797                         DECL_FIELD_BIT_OFFSET (field));
1798 }
1799
1800 /* Likewise, but return as an integer.  It must be representable in
1801    that way (since it could be a signed value, we don't have the
1802    option of returning -1 like int_size_in_byte can.  */
1803
1804 HOST_WIDE_INT
1805 int_byte_position (tree field)
1806 {
1807   return tree_low_cst (byte_position (field), 0);
1808 }
1809 \f
1810 /* Return the strictest alignment, in bits, that T is known to have.  */
1811
1812 unsigned int
1813 expr_align (tree t)
1814 {
1815   unsigned int align0, align1;
1816
1817   switch (TREE_CODE (t))
1818     {
1819     case NOP_EXPR:  case CONVERT_EXPR:  case NON_LVALUE_EXPR:
1820       /* If we have conversions, we know that the alignment of the
1821          object must meet each of the alignments of the types.  */
1822       align0 = expr_align (TREE_OPERAND (t, 0));
1823       align1 = TYPE_ALIGN (TREE_TYPE (t));
1824       return MAX (align0, align1);
1825
1826     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
1827     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
1828     case CLEANUP_POINT_EXPR:
1829       /* These don't change the alignment of an object.  */
1830       return expr_align (TREE_OPERAND (t, 0));
1831
1832     case COND_EXPR:
1833       /* The best we can do is say that the alignment is the least aligned
1834          of the two arms.  */
1835       align0 = expr_align (TREE_OPERAND (t, 1));
1836       align1 = expr_align (TREE_OPERAND (t, 2));
1837       return MIN (align0, align1);
1838
1839     case LABEL_DECL:     case CONST_DECL:
1840     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
1841       if (DECL_ALIGN (t) != 0)
1842         return DECL_ALIGN (t);
1843       break;
1844
1845     case FUNCTION_DECL:
1846       return FUNCTION_BOUNDARY;
1847
1848     default:
1849       break;
1850     }
1851
1852   /* Otherwise take the alignment from that of the type.  */
1853   return TYPE_ALIGN (TREE_TYPE (t));
1854 }
1855 \f
1856 /* Return, as a tree node, the number of elements for TYPE (which is an
1857    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
1858
1859 tree
1860 array_type_nelts (tree type)
1861 {
1862   tree index_type, min, max;
1863
1864   /* If they did it with unspecified bounds, then we should have already
1865      given an error about it before we got here.  */
1866   if (! TYPE_DOMAIN (type))
1867     return error_mark_node;
1868
1869   index_type = TYPE_DOMAIN (type);
1870   min = TYPE_MIN_VALUE (index_type);
1871   max = TYPE_MAX_VALUE (index_type);
1872
1873   return (integer_zerop (min)
1874           ? max
1875           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
1876 }
1877 \f
1878 /* If arg is static -- a reference to an object in static storage -- then
1879    return the object.  This is not the same as the C meaning of `static'.
1880    If arg isn't static, return NULL.  */
1881
1882 tree
1883 staticp (tree arg)
1884 {
1885   switch (TREE_CODE (arg))
1886     {
1887     case FUNCTION_DECL:
1888       /* Nested functions are static, even though taking their address will
1889          involve a trampoline as we unnest the nested function and create
1890          the trampoline on the tree level.  */
1891       return arg;
1892
1893     case VAR_DECL:
1894       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
1895               && ! DECL_THREAD_LOCAL_P (arg)
1896               && ! DECL_DLLIMPORT_P (arg)
1897               ? arg : NULL);
1898
1899     case CONST_DECL:
1900       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
1901               ? arg : NULL);
1902
1903     case CONSTRUCTOR:
1904       return TREE_STATIC (arg) ? arg : NULL;
1905
1906     case LABEL_DECL:
1907     case STRING_CST:
1908       return arg;
1909
1910     case COMPONENT_REF:
1911       /* If the thing being referenced is not a field, then it is
1912          something language specific.  */
1913       if (TREE_CODE (TREE_OPERAND (arg, 1)) != FIELD_DECL)
1914         return (*lang_hooks.staticp) (arg);
1915
1916       /* If we are referencing a bitfield, we can't evaluate an
1917          ADDR_EXPR at compile time and so it isn't a constant.  */
1918       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
1919         return NULL;
1920
1921       return staticp (TREE_OPERAND (arg, 0));
1922
1923     case BIT_FIELD_REF:
1924       return NULL;
1925
1926     case MISALIGNED_INDIRECT_REF:
1927     case ALIGN_INDIRECT_REF:
1928     case INDIRECT_REF:
1929       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
1930
1931     case ARRAY_REF:
1932     case ARRAY_RANGE_REF:
1933       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1934           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1935         return staticp (TREE_OPERAND (arg, 0));
1936       else
1937         return false;
1938
1939     default:
1940       if ((unsigned int) TREE_CODE (arg)
1941           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
1942         return lang_hooks.staticp (arg);
1943       else
1944         return NULL;
1945     }
1946 }
1947 \f
1948 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1949    Do this to any expression which may be used in more than one place,
1950    but must be evaluated only once.
1951
1952    Normally, expand_expr would reevaluate the expression each time.
1953    Calling save_expr produces something that is evaluated and recorded
1954    the first time expand_expr is called on it.  Subsequent calls to
1955    expand_expr just reuse the recorded value.
1956
1957    The call to expand_expr that generates code that actually computes
1958    the value is the first call *at compile time*.  Subsequent calls
1959    *at compile time* generate code to use the saved value.
1960    This produces correct result provided that *at run time* control
1961    always flows through the insns made by the first expand_expr
1962    before reaching the other places where the save_expr was evaluated.
1963    You, the caller of save_expr, must make sure this is so.
1964
1965    Constants, and certain read-only nodes, are returned with no
1966    SAVE_EXPR because that is safe.  Expressions containing placeholders
1967    are not touched; see tree.def for an explanation of what these
1968    are used for.  */
1969
1970 tree
1971 save_expr (tree expr)
1972 {
1973   tree t = fold (expr);
1974   tree inner;
1975
1976   /* If the tree evaluates to a constant, then we don't want to hide that
1977      fact (i.e. this allows further folding, and direct checks for constants).
1978      However, a read-only object that has side effects cannot be bypassed.
1979      Since it is no problem to reevaluate literals, we just return the
1980      literal node.  */
1981   inner = skip_simple_arithmetic (t);
1982
1983   if (TREE_INVARIANT (inner)
1984       || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
1985       || TREE_CODE (inner) == SAVE_EXPR
1986       || TREE_CODE (inner) == ERROR_MARK)
1987     return t;
1988
1989   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1990      it means that the size or offset of some field of an object depends on
1991      the value within another field.
1992
1993      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1994      and some variable since it would then need to be both evaluated once and
1995      evaluated more than once.  Front-ends must assure this case cannot
1996      happen by surrounding any such subexpressions in their own SAVE_EXPR
1997      and forcing evaluation at the proper time.  */
1998   if (contains_placeholder_p (inner))
1999     return t;
2000
2001   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2002
2003   /* This expression might be placed ahead of a jump to ensure that the
2004      value was computed on both sides of the jump.  So make sure it isn't
2005      eliminated as dead.  */
2006   TREE_SIDE_EFFECTS (t) = 1;
2007   TREE_INVARIANT (t) = 1;
2008   return t;
2009 }
2010
2011 /* Look inside EXPR and into any simple arithmetic operations.  Return
2012    the innermost non-arithmetic node.  */
2013
2014 tree
2015 skip_simple_arithmetic (tree expr)
2016 {
2017   tree inner;
2018
2019   /* We don't care about whether this can be used as an lvalue in this
2020      context.  */
2021   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2022     expr = TREE_OPERAND (expr, 0);
2023
2024   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2025      a constant, it will be more efficient to not make another SAVE_EXPR since
2026      it will allow better simplification and GCSE will be able to merge the
2027      computations if they actually occur.  */
2028   inner = expr;
2029   while (1)
2030     {
2031       if (UNARY_CLASS_P (inner))
2032         inner = TREE_OPERAND (inner, 0);
2033       else if (BINARY_CLASS_P (inner))
2034         {
2035           if (TREE_INVARIANT (TREE_OPERAND (inner, 1)))
2036             inner = TREE_OPERAND (inner, 0);
2037           else if (TREE_INVARIANT (TREE_OPERAND (inner, 0)))
2038             inner = TREE_OPERAND (inner, 1);
2039           else
2040             break;
2041         }
2042       else
2043         break;
2044     }
2045
2046   return inner;
2047 }
2048
2049 /* Return which tree structure is used by T.  */
2050
2051 enum tree_node_structure_enum
2052 tree_node_structure (tree t)
2053 {
2054   enum tree_code code = TREE_CODE (t);
2055
2056   switch (TREE_CODE_CLASS (code))
2057     {
2058     case tcc_declaration:
2059       {
2060         switch (code)
2061           {
2062           case FIELD_DECL:
2063             return TS_FIELD_DECL;
2064           case PARM_DECL:
2065             return TS_PARM_DECL;
2066           case VAR_DECL:
2067             return TS_VAR_DECL;
2068           case LABEL_DECL:
2069             return TS_LABEL_DECL;
2070           case RESULT_DECL:
2071             return TS_RESULT_DECL;
2072           case CONST_DECL:
2073             return TS_CONST_DECL;
2074           case TYPE_DECL:
2075             return TS_TYPE_DECL;
2076           case FUNCTION_DECL:
2077             return TS_FUNCTION_DECL;
2078           case SYMBOL_MEMORY_TAG:
2079           case NAME_MEMORY_TAG:
2080           case STRUCT_FIELD_TAG:
2081             return TS_MEMORY_TAG;
2082           default:
2083             return TS_DECL_NON_COMMON;
2084           }
2085       }
2086     case tcc_type:
2087       return TS_TYPE;
2088     case tcc_reference:
2089     case tcc_comparison:
2090     case tcc_unary:
2091     case tcc_binary:
2092     case tcc_expression:
2093     case tcc_statement:
2094       return TS_EXP;
2095     default:  /* tcc_constant and tcc_exceptional */
2096       break;
2097     }
2098   switch (code)
2099     {
2100       /* tcc_constant cases.  */
2101     case INTEGER_CST:           return TS_INT_CST;
2102     case REAL_CST:              return TS_REAL_CST;
2103     case COMPLEX_CST:           return TS_COMPLEX;
2104     case VECTOR_CST:            return TS_VECTOR;
2105     case STRING_CST:            return TS_STRING;
2106       /* tcc_exceptional cases.  */
2107     case ERROR_MARK:            return TS_COMMON;
2108     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
2109     case TREE_LIST:             return TS_LIST;
2110     case TREE_VEC:              return TS_VEC;
2111     case PHI_NODE:              return TS_PHI_NODE;
2112     case SSA_NAME:              return TS_SSA_NAME;
2113     case PLACEHOLDER_EXPR:      return TS_COMMON;
2114     case STATEMENT_LIST:        return TS_STATEMENT_LIST;
2115     case BLOCK:                 return TS_BLOCK;
2116     case CONSTRUCTOR:           return TS_CONSTRUCTOR;
2117     case TREE_BINFO:            return TS_BINFO;
2118     case VALUE_HANDLE:          return TS_VALUE_HANDLE;
2119     case OMP_CLAUSE:            return TS_OMP_CLAUSE;
2120
2121     default:
2122       gcc_unreachable ();
2123     }
2124 }
2125 \f
2126 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2127    or offset that depends on a field within a record.  */
2128
2129 bool
2130 contains_placeholder_p (tree exp)
2131 {
2132   enum tree_code code;
2133
2134   if (!exp)
2135     return 0;
2136
2137   code = TREE_CODE (exp);
2138   if (code == PLACEHOLDER_EXPR)
2139     return 1;
2140
2141   switch (TREE_CODE_CLASS (code))
2142     {
2143     case tcc_reference:
2144       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2145          position computations since they will be converted into a
2146          WITH_RECORD_EXPR involving the reference, which will assume
2147          here will be valid.  */
2148       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2149
2150     case tcc_exceptional:
2151       if (code == TREE_LIST)
2152         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2153                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2154       break;
2155
2156     case tcc_unary:
2157     case tcc_binary:
2158     case tcc_comparison:
2159     case tcc_expression:
2160       switch (code)
2161         {
2162         case COMPOUND_EXPR:
2163           /* Ignoring the first operand isn't quite right, but works best.  */
2164           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2165
2166         case COND_EXPR:
2167           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2168                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2169                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2170
2171         case CALL_EXPR:
2172           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2173
2174         default:
2175           break;
2176         }
2177
2178       switch (TREE_CODE_LENGTH (code))
2179         {
2180         case 1:
2181           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2182         case 2:
2183           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2184                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2185         default:
2186           return 0;
2187         }
2188
2189     default:
2190       return 0;
2191     }
2192   return 0;
2193 }
2194
2195 /* Return true if any part of the computation of TYPE involves a
2196    PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2197    (for QUAL_UNION_TYPE) and field positions.  */
2198
2199 static bool
2200 type_contains_placeholder_1 (tree type)
2201 {
2202   /* If the size contains a placeholder or the parent type (component type in
2203      the case of arrays) type involves a placeholder, this type does.  */
2204   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2205       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2206       || (TREE_TYPE (type) != 0
2207           && type_contains_placeholder_p (TREE_TYPE (type))))
2208     return true;
2209
2210   /* Now do type-specific checks.  Note that the last part of the check above
2211      greatly limits what we have to do below.  */
2212   switch (TREE_CODE (type))
2213     {
2214     case VOID_TYPE:
2215     case COMPLEX_TYPE:
2216     case ENUMERAL_TYPE:
2217     case BOOLEAN_TYPE:
2218     case POINTER_TYPE:
2219     case OFFSET_TYPE:
2220     case REFERENCE_TYPE:
2221     case METHOD_TYPE:
2222     case FUNCTION_TYPE:
2223     case VECTOR_TYPE:
2224       return false;
2225
2226     case INTEGER_TYPE:
2227     case REAL_TYPE:
2228       /* Here we just check the bounds.  */
2229       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2230               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2231
2232     case ARRAY_TYPE:
2233       /* We're already checked the component type (TREE_TYPE), so just check
2234          the index type.  */
2235       return type_contains_placeholder_p (TYPE_DOMAIN (type));
2236
2237     case RECORD_TYPE:
2238     case UNION_TYPE:
2239     case QUAL_UNION_TYPE:
2240       {
2241         tree field;
2242
2243         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2244           if (TREE_CODE (field) == FIELD_DECL
2245               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2246                   || (TREE_CODE (type) == QUAL_UNION_TYPE
2247                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2248                   || type_contains_placeholder_p (TREE_TYPE (field))))
2249             return true;
2250
2251         return false;
2252       }
2253
2254     default:
2255       gcc_unreachable ();
2256     }
2257 }
2258
2259 bool
2260 type_contains_placeholder_p (tree type)
2261 {
2262   bool result;
2263
2264   /* If the contains_placeholder_bits field has been initialized,
2265      then we know the answer.  */
2266   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2267     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2268
2269   /* Indicate that we've seen this type node, and the answer is false.
2270      This is what we want to return if we run into recursion via fields.  */
2271   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2272
2273   /* Compute the real value.  */
2274   result = type_contains_placeholder_1 (type);
2275
2276   /* Store the real value.  */
2277   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2278
2279   return result;
2280 }
2281 \f
2282 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2283    return a tree with all occurrences of references to F in a
2284    PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
2285    contains only arithmetic expressions or a CALL_EXPR with a
2286    PLACEHOLDER_EXPR occurring only in its arglist.  */
2287
2288 tree
2289 substitute_in_expr (tree exp, tree f, tree r)
2290 {
2291   enum tree_code code = TREE_CODE (exp);
2292   tree op0, op1, op2, op3;
2293   tree new;
2294   tree inner;
2295
2296   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2297   if (code == TREE_LIST)
2298     {
2299       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
2300       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
2301       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2302         return exp;
2303
2304       return tree_cons (TREE_PURPOSE (exp), op1, op0);
2305     }
2306   else if (code == COMPONENT_REF)
2307    {
2308      /* If this expression is getting a value from a PLACEHOLDER_EXPR
2309         and it is the right field, replace it with R.  */
2310      for (inner = TREE_OPERAND (exp, 0);
2311           REFERENCE_CLASS_P (inner);
2312           inner = TREE_OPERAND (inner, 0))
2313        ;
2314      if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2315          && TREE_OPERAND (exp, 1) == f)
2316        return r;
2317
2318      /* If this expression hasn't been completed let, leave it alone.  */
2319      if (TREE_CODE (inner) == PLACEHOLDER_EXPR && TREE_TYPE (inner) == 0)
2320        return exp;
2321
2322      op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2323      if (op0 == TREE_OPERAND (exp, 0))
2324        return exp;
2325
2326      new = fold_build3 (COMPONENT_REF, TREE_TYPE (exp),
2327                         op0, TREE_OPERAND (exp, 1), NULL_TREE);
2328    }
2329   else
2330     switch (TREE_CODE_CLASS (code))
2331       {
2332       case tcc_constant:
2333       case tcc_declaration:
2334         return exp;
2335
2336       case tcc_exceptional:
2337       case tcc_unary:
2338       case tcc_binary:
2339       case tcc_comparison:
2340       case tcc_expression:
2341       case tcc_reference:
2342         switch (TREE_CODE_LENGTH (code))
2343           {
2344           case 0:
2345             return exp;
2346
2347           case 1:
2348             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2349             if (op0 == TREE_OPERAND (exp, 0))
2350               return exp;
2351
2352             new = fold_build1 (code, TREE_TYPE (exp), op0);
2353             break;
2354
2355           case 2:
2356             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2357             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
2358
2359             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2360               return exp;
2361
2362             new = fold_build2 (code, TREE_TYPE (exp), op0, op1);
2363             break;
2364
2365           case 3:
2366             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2367             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
2368             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
2369
2370             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2371                 && op2 == TREE_OPERAND (exp, 2))
2372               return exp;
2373
2374             new = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
2375             break;
2376
2377           case 4:
2378             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2379             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
2380             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
2381             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
2382
2383             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2384                 && op2 == TREE_OPERAND (exp, 2)
2385                 && op3 == TREE_OPERAND (exp, 3))
2386               return exp;
2387
2388             new = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
2389             break;
2390
2391           default:
2392             gcc_unreachable ();
2393           }
2394         break;
2395
2396       default:
2397         gcc_unreachable ();
2398       }
2399
2400   TREE_READONLY (new) = TREE_READONLY (exp);
2401   return new;
2402 }
2403
2404 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
2405    for it within OBJ, a tree that is an object or a chain of references.  */
2406
2407 tree
2408 substitute_placeholder_in_expr (tree exp, tree obj)
2409 {
2410   enum tree_code code = TREE_CODE (exp);
2411   tree op0, op1, op2, op3;
2412
2413   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
2414      in the chain of OBJ.  */
2415   if (code == PLACEHOLDER_EXPR)
2416     {
2417       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
2418       tree elt;
2419
2420       for (elt = obj; elt != 0;
2421            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
2422                    || TREE_CODE (elt) == COND_EXPR)
2423                   ? TREE_OPERAND (elt, 1)
2424                   : (REFERENCE_CLASS_P (elt)
2425                      || UNARY_CLASS_P (elt)
2426                      || BINARY_CLASS_P (elt)
2427                      || EXPRESSION_CLASS_P (elt))
2428                   ? TREE_OPERAND (elt, 0) : 0))
2429         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
2430           return elt;
2431
2432       for (elt = obj; elt != 0;
2433            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
2434                    || TREE_CODE (elt) == COND_EXPR)
2435                   ? TREE_OPERAND (elt, 1)
2436                   : (REFERENCE_CLASS_P (elt)
2437                      || UNARY_CLASS_P (elt)
2438                      || BINARY_CLASS_P (elt)
2439                      || EXPRESSION_CLASS_P (elt))
2440                   ? TREE_OPERAND (elt, 0) : 0))
2441         if (POINTER_TYPE_P (TREE_TYPE (elt))
2442             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
2443                 == need_type))
2444           return fold_build1 (INDIRECT_REF, need_type, elt);
2445
2446       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
2447          survives until RTL generation, there will be an error.  */
2448       return exp;
2449     }
2450
2451   /* TREE_LIST is special because we need to look at TREE_VALUE
2452      and TREE_CHAIN, not TREE_OPERANDS.  */
2453   else if (code == TREE_LIST)
2454     {
2455       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
2456       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
2457       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2458         return exp;
2459
2460       return tree_cons (TREE_PURPOSE (exp), op1, op0);
2461     }
2462   else
2463     switch (TREE_CODE_CLASS (code))
2464       {
2465       case tcc_constant:
2466       case tcc_declaration:
2467         return exp;
2468
2469       case tcc_exceptional:
2470       case tcc_unary:
2471       case tcc_binary:
2472       case tcc_comparison:
2473       case tcc_expression:
2474       case tcc_reference:
2475       case tcc_statement:
2476         switch (TREE_CODE_LENGTH (code))
2477           {
2478           case 0:
2479             return exp;
2480
2481           case 1:
2482             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
2483             if (op0 == TREE_OPERAND (exp, 0))
2484               return exp;
2485             else
2486               return fold_build1 (code, TREE_TYPE (exp), op0);
2487
2488           case 2:
2489             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
2490             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
2491
2492             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2493               return exp;
2494             else
2495               return fold_build2 (code, TREE_TYPE (exp), op0, op1);
2496
2497           case 3:
2498             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
2499             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
2500             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
2501
2502             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2503                 && op2 == TREE_OPERAND (exp, 2))
2504               return exp;
2505             else
2506               return fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
2507
2508           case 4:
2509             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
2510             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
2511             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
2512             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
2513
2514             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2515                 && op2 == TREE_OPERAND (exp, 2)
2516                 && op3 == TREE_OPERAND (exp, 3))
2517               return exp;
2518             else
2519               return fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
2520
2521           default:
2522             gcc_unreachable ();
2523           }
2524         break;
2525
2526       default:
2527         gcc_unreachable ();
2528       }
2529 }
2530 \f
2531 /* Stabilize a reference so that we can use it any number of times
2532    without causing its operands to be evaluated more than once.
2533    Returns the stabilized reference.  This works by means of save_expr,
2534    so see the caveats in the comments about save_expr.
2535
2536    Also allows conversion expressions whose operands are references.
2537    Any other kind of expression is returned unchanged.  */
2538
2539 tree
2540 stabilize_reference (tree ref)
2541 {
2542   tree result;
2543   enum tree_code code = TREE_CODE (ref);
2544
2545   switch (code)
2546     {
2547     case VAR_DECL:
2548     case PARM_DECL:
2549     case RESULT_DECL:
2550       /* No action is needed in this case.  */
2551       return ref;
2552
2553     case NOP_EXPR:
2554     case CONVERT_EXPR:
2555     case FLOAT_EXPR:
2556     case FIX_TRUNC_EXPR:
2557     case FIX_FLOOR_EXPR:
2558     case FIX_ROUND_EXPR:
2559     case FIX_CEIL_EXPR:
2560       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2561       break;
2562
2563     case INDIRECT_REF:
2564       result = build_nt (INDIRECT_REF,
2565                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2566       break;
2567
2568     case COMPONENT_REF:
2569       result = build_nt (COMPONENT_REF,
2570                          stabilize_reference (TREE_OPERAND (ref, 0)),
2571                          TREE_OPERAND (ref, 1), NULL_TREE);
2572       break;
2573
2574     case BIT_FIELD_REF:
2575       result = build_nt (BIT_FIELD_REF,
2576                          stabilize_reference (TREE_OPERAND (ref, 0)),
2577                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2578                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2579       break;
2580
2581     case ARRAY_REF:
2582       result = build_nt (ARRAY_REF,
2583                          stabilize_reference (TREE_OPERAND (ref, 0)),
2584                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2585                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
2586       break;
2587
2588     case ARRAY_RANGE_REF:
2589       result = build_nt (ARRAY_RANGE_REF,
2590                          stabilize_reference (TREE_OPERAND (ref, 0)),
2591                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2592                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
2593       break;
2594
2595     case COMPOUND_EXPR:
2596       /* We cannot wrap the first expression in a SAVE_EXPR, as then
2597          it wouldn't be ignored.  This matters when dealing with
2598          volatiles.  */
2599       return stabilize_reference_1 (ref);
2600
2601       /* If arg isn't a kind of lvalue we recognize, make no change.
2602          Caller should recognize the error for an invalid lvalue.  */
2603     default:
2604       return ref;
2605
2606     case ERROR_MARK:
2607       return error_mark_node;
2608     }
2609
2610   TREE_TYPE (result) = TREE_TYPE (ref);
2611   TREE_READONLY (result) = TREE_READONLY (ref);
2612   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2613   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2614
2615   return result;
2616 }
2617
2618 /* Subroutine of stabilize_reference; this is called for subtrees of
2619    references.  Any expression with side-effects must be put in a SAVE_EXPR
2620    to ensure that it is only evaluated once.
2621
2622    We don't put SAVE_EXPR nodes around everything, because assigning very
2623    simple expressions to temporaries causes us to miss good opportunities
2624    for optimizations.  Among other things, the opportunity to fold in the
2625    addition of a constant into an addressing mode often gets lost, e.g.
2626    "y[i+1] += x;".  In general, we take the approach that we should not make
2627    an assignment unless we are forced into it - i.e., that any non-side effect
2628    operator should be allowed, and that cse should take care of coalescing
2629    multiple utterances of the same expression should that prove fruitful.  */
2630
2631 tree
2632 stabilize_reference_1 (tree e)
2633 {
2634   tree result;
2635   enum tree_code code = TREE_CODE (e);
2636
2637   /* We cannot ignore const expressions because it might be a reference
2638      to a const array but whose index contains side-effects.  But we can
2639      ignore things that are actual constant or that already have been
2640      handled by this function.  */
2641
2642   if (TREE_INVARIANT (e))
2643     return e;
2644
2645   switch (TREE_CODE_CLASS (code))
2646     {
2647     case tcc_exceptional:
2648     case tcc_type:
2649     case tcc_declaration:
2650     case tcc_comparison:
2651     case tcc_statement:
2652     case tcc_expression:
2653     case tcc_reference:
2654       /* If the expression has side-effects, then encase it in a SAVE_EXPR
2655          so that it will only be evaluated once.  */
2656       /* The reference (r) and comparison (<) classes could be handled as
2657          below, but it is generally faster to only evaluate them once.  */
2658       if (TREE_SIDE_EFFECTS (e))
2659         return save_expr (e);
2660       return e;
2661
2662     case tcc_constant:
2663       /* Constants need no processing.  In fact, we should never reach
2664          here.  */
2665       return e;
2666
2667     case tcc_binary:
2668       /* Division is slow and tends to be compiled with jumps,
2669          especially the division by powers of 2 that is often
2670          found inside of an array reference.  So do it just once.  */
2671       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2672           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2673           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2674           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2675         return save_expr (e);
2676       /* Recursively stabilize each operand.  */
2677       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2678                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
2679       break;
2680
2681     case tcc_unary:
2682       /* Recursively stabilize each operand.  */
2683       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2684       break;
2685
2686     default:
2687       gcc_unreachable ();
2688     }
2689
2690   TREE_TYPE (result) = TREE_TYPE (e);
2691   TREE_READONLY (result) = TREE_READONLY (e);
2692   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2693   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2694   TREE_INVARIANT (result) = 1;
2695
2696   return result;
2697 }
2698 \f
2699 /* Low-level constructors for expressions.  */
2700
2701 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
2702    TREE_INVARIANT, and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
2703
2704 void
2705 recompute_tree_invariant_for_addr_expr (tree t)
2706 {
2707   tree node;
2708   bool tc = true, ti = true, se = false;
2709
2710   /* We started out assuming this address is both invariant and constant, but
2711      does not have side effects.  Now go down any handled components and see if
2712      any of them involve offsets that are either non-constant or non-invariant.
2713      Also check for side-effects.
2714
2715      ??? Note that this code makes no attempt to deal with the case where
2716      taking the address of something causes a copy due to misalignment.  */
2717
2718 #define UPDATE_TITCSE(NODE)  \
2719 do { tree _node = (NODE); \
2720      if (_node && !TREE_INVARIANT (_node)) ti = false; \
2721      if (_node && !TREE_CONSTANT (_node)) tc = false; \
2722      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
2723
2724   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
2725        node = TREE_OPERAND (node, 0))
2726     {
2727       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
2728          array reference (probably made temporarily by the G++ front end),
2729          so ignore all the operands.  */
2730       if ((TREE_CODE (node) == ARRAY_REF
2731            || TREE_CODE (node) == ARRAY_RANGE_REF)
2732           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
2733         {
2734           UPDATE_TITCSE (TREE_OPERAND (node, 1));
2735           if (TREE_OPERAND (node, 2))
2736             UPDATE_TITCSE (TREE_OPERAND (node, 2));
2737           if (TREE_OPERAND (node, 3))
2738             UPDATE_TITCSE (TREE_OPERAND (node, 3));
2739         }
2740       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
2741          FIELD_DECL, apparently.  The G++ front end can put something else
2742          there, at least temporarily.  */
2743       else if (TREE_CODE (node) == COMPONENT_REF
2744                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
2745         {
2746           if (TREE_OPERAND (node, 2))
2747             UPDATE_TITCSE (TREE_OPERAND (node, 2));
2748         }
2749       else if (TREE_CODE (node) == BIT_FIELD_REF)
2750         UPDATE_TITCSE (TREE_OPERAND (node, 2));
2751     }
2752
2753   node = lang_hooks.expr_to_decl (node, &tc, &ti, &se);
2754
2755   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
2756      the address, since &(*a)->b is a form of addition.  If it's a decl, it's
2757      invariant and constant if the decl is static.  It's also invariant if it's
2758      a decl in the current function.  Taking the address of a volatile variable
2759      is not volatile.  If it's a constant, the address is both invariant and
2760      constant.  Otherwise it's neither.  */
2761   if (TREE_CODE (node) == INDIRECT_REF)
2762     UPDATE_TITCSE (TREE_OPERAND (node, 0));
2763   else if (DECL_P (node))
2764     {
2765       if (staticp (node))
2766         ;
2767       else if (decl_function_context (node) == current_function_decl
2768                /* Addresses of thread-local variables are invariant.  */
2769                || (TREE_CODE (node) == VAR_DECL
2770                    && DECL_THREAD_LOCAL_P (node)))
2771         tc = false;
2772       else
2773         ti = tc = false;
2774     }
2775   else if (CONSTANT_CLASS_P (node))
2776     ;
2777   else
2778     {
2779       ti = tc = false;
2780       se |= TREE_SIDE_EFFECTS (node);
2781     }
2782
2783   TREE_CONSTANT (t) = tc;
2784   TREE_INVARIANT (t) = ti;
2785   TREE_SIDE_EFFECTS (t) = se;
2786 #undef UPDATE_TITCSE
2787 }
2788
2789 /* Build an expression of code CODE, data type TYPE, and operands as
2790    specified.  Expressions and reference nodes can be created this way.
2791    Constants, decls, types and misc nodes cannot be.
2792
2793    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
2794    enough for all extant tree codes.  */
2795
2796 tree
2797 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
2798 {
2799   tree t;
2800
2801   gcc_assert (TREE_CODE_LENGTH (code) == 0);
2802
2803   t = make_node_stat (code PASS_MEM_STAT);
2804   TREE_TYPE (t) = tt;
2805
2806   return t;
2807 }
2808
2809 tree
2810 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
2811 {
2812   int length = sizeof (struct tree_exp);
2813 #ifdef GATHER_STATISTICS
2814   tree_node_kind kind;
2815 #endif
2816   tree t;
2817
2818 #ifdef GATHER_STATISTICS
2819   switch (TREE_CODE_CLASS (code))
2820     {
2821     case tcc_statement:  /* an expression with side effects */
2822       kind = s_kind;
2823       break;
2824     case tcc_reference:  /* a reference */
2825       kind = r_kind;
2826       break;
2827     default:
2828       kind = e_kind;
2829       break;
2830     }
2831
2832   tree_node_counts[(int) kind]++;
2833   tree_node_sizes[(int) kind] += length;
2834 #endif
2835
2836   gcc_assert (TREE_CODE_LENGTH (code) == 1);
2837
2838   t = ggc_alloc_zone_pass_stat (length, &tree_zone);
2839
2840   memset (t, 0, sizeof (struct tree_common));
2841
2842   TREE_SET_CODE (t, code);
2843
2844   TREE_TYPE (t) = type;
2845 #ifdef USE_MAPPED_LOCATION
2846   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
2847 #else
2848   SET_EXPR_LOCUS (t, NULL);
2849 #endif
2850   TREE_COMPLEXITY (t) = 0;
2851   TREE_OPERAND (t, 0) = node;
2852   TREE_BLOCK (t) = NULL_TREE;
2853   if (node && !TYPE_P (node))
2854     {
2855       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
2856       TREE_READONLY (t) = TREE_READONLY (node);
2857     }
2858
2859   if (TREE_CODE_CLASS (code) == tcc_statement)
2860     TREE_SIDE_EFFECTS (t) = 1;
2861   else switch (code)
2862     {
2863     case VA_ARG_EXPR:
2864       /* All of these have side-effects, no matter what their
2865          operands are.  */
2866       TREE_SIDE_EFFECTS (t) = 1;
2867       TREE_READONLY (t) = 0;
2868       break;
2869
2870     case MISALIGNED_INDIRECT_REF:
2871     case ALIGN_INDIRECT_REF:
2872     case INDIRECT_REF:
2873       /* Whether a dereference is readonly has nothing to do with whether
2874          its operand is readonly.  */
2875       TREE_READONLY (t) = 0;
2876       break;
2877
2878     case ADDR_EXPR:
2879       if (node)
2880         recompute_tree_invariant_for_addr_expr (t);
2881       break;
2882
2883     default:
2884       if (TREE_CODE_CLASS (code) == tcc_unary
2885           && node && !TYPE_P (node)
2886           && TREE_CONSTANT (node))
2887         TREE_CONSTANT (t) = 1;
2888       if (TREE_CODE_CLASS (code) == tcc_unary
2889           && node && TREE_INVARIANT (node))
2890         TREE_INVARIANT (t) = 1;
2891       if (TREE_CODE_CLASS (code) == tcc_reference
2892           && node && TREE_THIS_VOLATILE (node))
2893         TREE_THIS_VOLATILE (t) = 1;
2894       break;
2895     }
2896
2897   return t;
2898 }
2899
2900 #define PROCESS_ARG(N)                  \
2901   do {                                  \
2902     TREE_OPERAND (t, N) = arg##N;       \
2903     if (arg##N &&!TYPE_P (arg##N))      \
2904       {                                 \
2905         if (TREE_SIDE_EFFECTS (arg##N)) \
2906           side_effects = 1;             \
2907         if (!TREE_READONLY (arg##N))    \
2908           read_only = 0;                \
2909         if (!TREE_CONSTANT (arg##N))    \
2910           constant = 0;                 \
2911         if (!TREE_INVARIANT (arg##N))   \
2912           invariant = 0;                \
2913       }                                 \
2914   } while (0)
2915
2916 tree
2917 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
2918 {
2919   bool constant, read_only, side_effects, invariant;
2920   tree t;
2921
2922   gcc_assert (TREE_CODE_LENGTH (code) == 2);
2923
2924   t = make_node_stat (code PASS_MEM_STAT);
2925   TREE_TYPE (t) = tt;
2926
2927   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2928      result based on those same flags for the arguments.  But if the
2929      arguments aren't really even `tree' expressions, we shouldn't be trying
2930      to do this.  */
2931
2932   /* Expressions without side effects may be constant if their
2933      arguments are as well.  */
2934   constant = (TREE_CODE_CLASS (code) == tcc_comparison
2935               || TREE_CODE_CLASS (code) == tcc_binary);
2936   read_only = 1;
2937   side_effects = TREE_SIDE_EFFECTS (t);
2938   invariant = constant;
2939
2940   PROCESS_ARG(0);
2941   PROCESS_ARG(1);
2942
2943   TREE_READONLY (t) = read_only;
2944   TREE_CONSTANT (t) = constant;
2945   TREE_INVARIANT (t) = invariant;
2946   TREE_SIDE_EFFECTS (t) = side_effects;
2947   TREE_THIS_VOLATILE (t)
2948     = (TREE_CODE_CLASS (code) == tcc_reference
2949        && arg0 && TREE_THIS_VOLATILE (arg0));
2950
2951   return t;
2952 }
2953
2954 tree
2955 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
2956              tree arg2 MEM_STAT_DECL)
2957 {
2958   bool constant, read_only, side_effects, invariant;
2959   tree t;
2960
2961   gcc_assert (TREE_CODE_LENGTH (code) == 3);
2962
2963   t = make_node_stat (code PASS_MEM_STAT);
2964   TREE_TYPE (t) = tt;
2965
2966   side_effects = TREE_SIDE_EFFECTS (t);
2967
2968   PROCESS_ARG(0);
2969   PROCESS_ARG(1);
2970   PROCESS_ARG(2);
2971
2972   if (code == CALL_EXPR && !side_effects)
2973     {
2974       tree node;
2975       int i;
2976
2977       /* Calls have side-effects, except those to const or
2978          pure functions.  */
2979       i = call_expr_flags (t);
2980       if (!(i & (ECF_CONST | ECF_PURE)))
2981         side_effects = 1;
2982
2983       /* And even those have side-effects if their arguments do.  */
2984       else for (node = arg1; node; node = TREE_CHAIN (node))
2985         if (TREE_SIDE_EFFECTS (TREE_VALUE (node)))
2986           {
2987             side_effects = 1;
2988             break;
2989           }
2990     }
2991
2992   TREE_SIDE_EFFECTS (t) = side_effects;
2993   TREE_THIS_VOLATILE (t)
2994     = (TREE_CODE_CLASS (code) == tcc_reference
2995        && arg0 && TREE_THIS_VOLATILE (arg0));
2996
2997   return t;
2998 }
2999
3000 tree
3001 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3002              tree arg2, tree arg3 MEM_STAT_DECL)
3003 {
3004   bool constant, read_only, side_effects, invariant;
3005   tree t;
3006
3007   gcc_assert (TREE_CODE_LENGTH (code) == 4);
3008
3009   t = make_node_stat (code PASS_MEM_STAT);
3010   TREE_TYPE (t) = tt;
3011
3012   side_effects = TREE_SIDE_EFFECTS (t);
3013
3014   PROCESS_ARG(0);
3015   PROCESS_ARG(1);
3016   PROCESS_ARG(2);
3017   PROCESS_ARG(3);
3018
3019   TREE_SIDE_EFFECTS (t) = side_effects;
3020   TREE_THIS_VOLATILE (t)
3021     = (TREE_CODE_CLASS (code) == tcc_reference
3022        && arg0 && TREE_THIS_VOLATILE (arg0));
3023
3024   return t;
3025 }
3026
3027 tree
3028 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3029              tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
3030 {
3031   bool constant, read_only, side_effects, invariant;
3032   tree t;
3033
3034   gcc_assert (TREE_CODE_LENGTH (code) == 5);
3035
3036   t = make_node_stat (code PASS_MEM_STAT);
3037   TREE_TYPE (t) = tt;
3038
3039   side_effects = TREE_SIDE_EFFECTS (t);
3040
3041   PROCESS_ARG(0);
3042   PROCESS_ARG(1);
3043   PROCESS_ARG(2);
3044   PROCESS_ARG(3);
3045   PROCESS_ARG(4);
3046
3047   TREE_SIDE_EFFECTS (t) = side_effects;
3048   TREE_THIS_VOLATILE (t)
3049     = (TREE_CODE_CLASS (code) == tcc_reference
3050        && arg0 && TREE_THIS_VOLATILE (arg0));
3051
3052   return t;
3053 }
3054
3055 tree
3056 build7_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3057              tree arg2, tree arg3, tree arg4, tree arg5,
3058              tree arg6 MEM_STAT_DECL)
3059 {
3060   bool constant, read_only, side_effects, invariant;
3061   tree t;
3062
3063   gcc_assert (code == TARGET_MEM_REF);
3064
3065   t = make_node_stat (code PASS_MEM_STAT);
3066   TREE_TYPE (t) = tt;
3067
3068   side_effects = TREE_SIDE_EFFECTS (t);
3069
3070   PROCESS_ARG(0);
3071   PROCESS_ARG(1);
3072   PROCESS_ARG(2);
3073   PROCESS_ARG(3);
3074   PROCESS_ARG(4);
3075   PROCESS_ARG(5);
3076   PROCESS_ARG(6);
3077
3078   TREE_SIDE_EFFECTS (t) = side_effects;
3079   TREE_THIS_VOLATILE (t) = 0;
3080
3081   return t;
3082 }
3083
3084 /* Similar except don't specify the TREE_TYPE
3085    and leave the TREE_SIDE_EFFECTS as 0.
3086    It is permissible for arguments to be null,
3087    or even garbage if their values do not matter.  */
3088
3089 tree
3090 build_nt (enum tree_code code, ...)
3091 {
3092   tree t;
3093   int length;
3094   int i;
3095   va_list p;
3096
3097   va_start (p, code);
3098
3099   t = make_node (code);
3100   length = TREE_CODE_LENGTH (code);
3101
3102   for (i = 0; i < length; i++)
3103     TREE_OPERAND (t, i) = va_arg (p, tree);
3104
3105   va_end (p);
3106   return t;
3107 }
3108 \f
3109 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3110    We do NOT enter this node in any sort of symbol table.
3111
3112    layout_decl is used to set up the decl's storage layout.
3113    Other slots are initialized to 0 or null pointers.  */
3114
3115 tree
3116 build_decl_stat (enum tree_code code, tree name, tree type MEM_STAT_DECL)
3117 {
3118   tree t;
3119
3120   t = make_node_stat (code PASS_MEM_STAT);
3121
3122 /*  if (type == error_mark_node)
3123     type = integer_type_node; */
3124 /* That is not done, deliberately, so that having error_mark_node
3125    as the type can suppress useless errors in the use of this variable.  */
3126
3127   DECL_NAME (t) = name;
3128   TREE_TYPE (t) = type;
3129
3130   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
3131     layout_decl (t, 0);
3132   else if (code == FUNCTION_DECL)
3133     DECL_MODE (t) = FUNCTION_MODE;
3134
3135   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
3136     {
3137       /* Set default visibility to whatever the user supplied with
3138          visibility_specified depending on #pragma GCC visibility.  */
3139       DECL_VISIBILITY (t) = default_visibility;
3140       DECL_VISIBILITY_SPECIFIED (t) = visibility_options.inpragma;
3141     }
3142
3143   return t;
3144 }
3145
3146 /* Builds and returns function declaration with NAME and TYPE.  */
3147
3148 tree
3149 build_fn_decl (const char *name, tree type)
3150 {
3151   tree id = get_identifier (name);
3152   tree decl = build_decl (FUNCTION_DECL, id, type);
3153
3154   DECL_EXTERNAL (decl) = 1;
3155   TREE_PUBLIC (decl) = 1;
3156   DECL_ARTIFICIAL (decl) = 1;
3157   TREE_NOTHROW (decl) = 1;
3158
3159   return decl;
3160 }
3161
3162 \f
3163 /* BLOCK nodes are used to represent the structure of binding contours
3164    and declarations, once those contours have been exited and their contents
3165    compiled.  This information is used for outputting debugging info.  */
3166
3167 tree
3168 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
3169 {
3170   tree block = make_node (BLOCK);
3171
3172   BLOCK_VARS (block) = vars;
3173   BLOCK_SUBBLOCKS (block) = subblocks;
3174   BLOCK_SUPERCONTEXT (block) = supercontext;
3175   BLOCK_CHAIN (block) = chain;
3176   return block;
3177 }
3178
3179 #if 1 /* ! defined(USE_MAPPED_LOCATION) */
3180 /* ??? gengtype doesn't handle conditionals */
3181 static GTY(()) source_locus last_annotated_node;
3182 #endif
3183
3184 #ifdef USE_MAPPED_LOCATION
3185
3186 expanded_location
3187 expand_location (source_location loc)
3188 {
3189   expanded_location xloc;
3190   if (loc == 0) { xloc.file = NULL; xloc.line = 0;  xloc.column = 0; }
3191   else
3192     {
3193       const struct line_map *map = linemap_lookup (&line_table, loc);
3194       xloc.file = map->to_file;
3195       xloc.line = SOURCE_LINE (map, loc);
3196       xloc.column = SOURCE_COLUMN (map, loc);
3197     };
3198   return xloc;
3199 }
3200
3201 #else
3202
3203 /* Record the exact location where an expression or an identifier were
3204    encountered.  */
3205
3206 void
3207 annotate_with_file_line (tree node, const char *file, int line)
3208 {
3209   /* Roughly one percent of the calls to this function are to annotate
3210      a node with the same information already attached to that node!
3211      Just return instead of wasting memory.  */
3212   if (EXPR_LOCUS (node)
3213       && EXPR_LINENO (node) == line
3214       && (EXPR_FILENAME (node) == file
3215           || !strcmp (EXPR_FILENAME (node), file)))
3216     {
3217       last_annotated_node = EXPR_LOCUS (node);
3218       return;
3219     }
3220
3221   /* In heavily macroized code (such as GCC itself) this single
3222      entry cache can reduce the number of allocations by more
3223      than half.  */
3224   if (last_annotated_node
3225       && last_annotated_node->line == line
3226       && (last_annotated_node->file == file
3227           || !strcmp (last_annotated_node->file, file)))
3228     {
3229       SET_EXPR_LOCUS (node, last_annotated_node);
3230       return;
3231     }
3232
3233   SET_EXPR_LOCUS (node, ggc_alloc (sizeof (location_t)));
3234   EXPR_LINENO (node) = line;
3235   EXPR_FILENAME (node) = file;
3236   last_annotated_node = EXPR_LOCUS (node);
3237 }
3238
3239 void
3240 annotate_with_locus (tree node, location_t locus)
3241 {
3242   annotate_with_file_line (node, locus.file, locus.line);
3243 }
3244 #endif
3245 \f
3246 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
3247    is ATTRIBUTE.  */
3248
3249 tree
3250 build_decl_attribute_variant (tree ddecl, tree attribute)
3251 {
3252   DECL_ATTRIBUTES (ddecl) = attribute;
3253   return ddecl;
3254 }
3255
3256 /* Borrowed from hashtab.c iterative_hash implementation.  */
3257 #define mix(a,b,c) \
3258 { \
3259   a -= b; a -= c; a ^= (c>>13); \
3260   b -= c; b -= a; b ^= (a<< 8); \
3261   c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
3262   a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
3263   b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
3264   c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
3265   a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
3266   b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
3267   c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
3268 }
3269
3270
3271 /* Produce good hash value combining VAL and VAL2.  */
3272 static inline hashval_t
3273 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
3274 {
3275   /* the golden ratio; an arbitrary value.  */
3276   hashval_t a = 0x9e3779b9;
3277
3278   mix (a, val, val2);
3279   return val2;
3280 }
3281
3282 /* Produce good hash value combining PTR and VAL2.  */
3283 static inline hashval_t
3284 iterative_hash_pointer (void *ptr, hashval_t val2)
3285 {
3286   if (sizeof (ptr) == sizeof (hashval_t))
3287     return iterative_hash_hashval_t ((size_t) ptr, val2);
3288   else
3289     {
3290       hashval_t a = (hashval_t) (size_t) ptr;
3291       /* Avoid warnings about shifting of more than the width of the type on
3292          hosts that won't execute this path.  */
3293       int zero = 0;
3294       hashval_t b = (hashval_t) ((size_t) ptr >> (sizeof (hashval_t) * 8 + zero));
3295       mix (a, b, val2);
3296       return val2;
3297     }
3298 }
3299
3300 /* Produce good hash value combining VAL and VAL2.  */
3301 static inline hashval_t
3302 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
3303 {
3304   if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
3305     return iterative_hash_hashval_t (val, val2);
3306   else
3307     {
3308       hashval_t a = (hashval_t) val;
3309       /* Avoid warnings about shifting of more than the width of the type on
3310          hosts that won't execute this path.  */
3311       int zero = 0;
3312       hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
3313       mix (a, b, val2);
3314       if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
3315         {
3316           hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
3317           hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
3318           mix (a, b, val2);
3319         }
3320       return val2;
3321     }
3322 }
3323
3324 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
3325    is ATTRIBUTE.
3326
3327    Record such modified types already made so we don't make duplicates.  */
3328
3329 tree
3330 build_type_attribute_variant (tree ttype, tree attribute)
3331 {
3332   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
3333     {
3334       hashval_t hashcode = 0;
3335       tree ntype;
3336       enum tree_code code = TREE_CODE (ttype);
3337
3338       ntype = copy_node (ttype);
3339
3340       TYPE_POINTER_TO (ntype) = 0;
3341       TYPE_REFERENCE_TO (ntype) = 0;
3342       TYPE_ATTRIBUTES (ntype) = attribute;
3343
3344       /* Create a new main variant of TYPE.  */
3345       TYPE_MAIN_VARIANT (ntype) = ntype;
3346       TYPE_NEXT_VARIANT (ntype) = 0;
3347       set_type_quals (ntype, TYPE_UNQUALIFIED);
3348
3349       hashcode = iterative_hash_object (code, hashcode);
3350       if (TREE_TYPE (ntype))
3351         hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
3352                                           hashcode);
3353       hashcode = attribute_hash_list (attribute, hashcode);
3354
3355       switch (TREE_CODE (ntype))
3356         {
3357         case FUNCTION_TYPE:
3358           hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
3359           break;
3360         case ARRAY_TYPE:
3361           hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
3362                                             hashcode);
3363           break;
3364         case INTEGER_TYPE:
3365           hashcode = iterative_hash_object
3366             (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
3367           hashcode = iterative_hash_object
3368             (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
3369           break;
3370         case REAL_TYPE:
3371           {
3372             unsigned int precision = TYPE_PRECISION (ntype);
3373             hashcode = iterative_hash_object (precision, hashcode);
3374           }
3375           break;
3376         default:
3377           break;
3378         }
3379
3380       ntype = type_hash_canon (hashcode, ntype);
3381       ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
3382     }
3383
3384   return ttype;
3385 }
3386
3387
3388 /* Return nonzero if IDENT is a valid name for attribute ATTR,
3389    or zero if not.
3390
3391    We try both `text' and `__text__', ATTR may be either one.  */
3392 /* ??? It might be a reasonable simplification to require ATTR to be only
3393    `text'.  One might then also require attribute lists to be stored in
3394    their canonicalized form.  */
3395
3396 static int
3397 is_attribute_with_length_p (const char *attr, int attr_len, tree ident)
3398 {
3399   int ident_len;
3400   const char *p;
3401
3402   if (TREE_CODE (ident) != IDENTIFIER_NODE)
3403     return 0;
3404
3405   p = IDENTIFIER_POINTER (ident);
3406   ident_len = IDENTIFIER_LENGTH (ident);
3407
3408   if (ident_len == attr_len
3409       && strcmp (attr, p) == 0)
3410     return 1;
3411
3412   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
3413   if (attr[0] == '_')
3414     {
3415       gcc_assert (attr[1] == '_');
3416       gcc_assert (attr[attr_len - 2] == '_');
3417       gcc_assert (attr[attr_len - 1] == '_');
3418       gcc_assert (attr[1] == '_');
3419       if (ident_len == attr_len - 4
3420           && strncmp (attr + 2, p, attr_len - 4) == 0)
3421         return 1;
3422     }
3423   else
3424     {
3425       if (ident_len == attr_len + 4
3426           && p[0] == '_' && p[1] == '_'
3427           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
3428           && strncmp (attr, p + 2, attr_len) == 0)
3429         return 1;
3430     }
3431
3432   return 0;
3433 }
3434
3435 /* Return nonzero if IDENT is a valid name for attribute ATTR,
3436    or zero if not.
3437
3438    We try both `text' and `__text__', ATTR may be either one.  */
3439
3440 int
3441 is_attribute_p (const char *attr, tree ident)
3442 {
3443   return is_attribute_with_length_p (attr, strlen (attr), ident);
3444 }
3445
3446 /* Given an attribute name and a list of attributes, return a pointer to the
3447    attribute's list element if the attribute is part of the list, or NULL_TREE
3448    if not found.  If the attribute appears more than once, this only
3449    returns the first occurrence; the TREE_CHAIN of the return value should
3450    be passed back in if further occurrences are wanted.  */
3451
3452 tree
3453 lookup_attribute (const char *attr_name, tree list)
3454 {
3455   tree l;
3456   size_t attr_len = strlen (attr_name);
3457
3458   for (l = list; l; l = TREE_CHAIN (l))
3459     {
3460       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
3461       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
3462         return l;
3463     }
3464
3465   return NULL_TREE;
3466 }
3467
3468 /* Return an attribute list that is the union of a1 and a2.  */
3469
3470 tree
3471 merge_attributes (tree a1, tree a2)
3472 {
3473   tree attributes;
3474
3475   /* Either one unset?  Take the set one.  */
3476
3477   if ((attributes = a1) == 0)
3478     attributes = a2;
3479
3480   /* One that completely contains the other?  Take it.  */
3481
3482   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
3483     {
3484       if (attribute_list_contained (a2, a1))
3485         attributes = a2;
3486       else
3487         {
3488           /* Pick the longest list, and hang on the other list.  */
3489
3490           if (list_length (a1) < list_length (a2))
3491             attributes = a2, a2 = a1;
3492
3493           for (; a2 != 0; a2 = TREE_CHAIN (a2))
3494             {
3495               tree a;
3496               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
3497                                          attributes);
3498                    a != NULL_TREE;
3499                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
3500                                          TREE_CHAIN (a)))
3501                 {
3502                   if (simple_cst_equal (TREE_VALUE (a), TREE_VALUE (a2)) == 1)
3503                     break;
3504                 }
3505               if (a == NULL_TREE)
3506                 {
3507                   a1 = copy_node (a2);
3508                   TREE_CHAIN (a1) = attributes;
3509                   attributes = a1;
3510                 }
3511             }
3512         }
3513     }
3514   return attributes;
3515 }
3516
3517 /* Given types T1 and T2, merge their attributes and return
3518   the result.  */
3519
3520 tree
3521 merge_type_attributes (tree t1, tree t2)
3522 {
3523   return merge_attributes (TYPE_ATTRIBUTES (t1),
3524                            TYPE_ATTRIBUTES (t2));
3525 }
3526
3527 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
3528    the result.  */
3529
3530 tree
3531 merge_decl_attributes (tree olddecl, tree newdecl)
3532 {
3533   return merge_attributes (DECL_ATTRIBUTES (olddecl),
3534                            DECL_ATTRIBUTES (newdecl));
3535 }
3536
3537 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
3538
3539 /* Specialization of merge_decl_attributes for various Windows targets.
3540
3541    This handles the following situation:
3542
3543      __declspec (dllimport) int foo;
3544      int foo;
3545
3546    The second instance of `foo' nullifies the dllimport.  */
3547
3548 tree
3549 merge_dllimport_decl_attributes (tree old, tree new)
3550 {
3551   tree a;
3552   int delete_dllimport_p = 1;
3553
3554   /* What we need to do here is remove from `old' dllimport if it doesn't
3555      appear in `new'.  dllimport behaves like extern: if a declaration is
3556      marked dllimport and a definition appears later, then the object
3557      is not dllimport'd.  We also remove a `new' dllimport if the old list
3558      contains dllexport:  dllexport always overrides dllimport, regardless
3559      of the order of declaration.  */
3560   if (!VAR_OR_FUNCTION_DECL_P (new))
3561     delete_dllimport_p = 0;
3562   else if (DECL_DLLIMPORT_P (new)
3563            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
3564     {
3565       DECL_DLLIMPORT_P (new) = 0;
3566       warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
3567               "dllimport ignored", new);
3568     }
3569   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new))
3570     {
3571       /* Warn about overriding a symbol that has already been used. eg:
3572            extern int __attribute__ ((dllimport)) foo;
3573            int* bar () {return &foo;}
3574            int foo;
3575       */
3576       if (TREE_USED (old))
3577         {
3578           warning (0, "%q+D redeclared without dllimport attribute "
3579                    "after being referenced with dll linkage", new);
3580           /* If we have used a variable's address with dllimport linkage,
3581               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
3582               decl may already have had TREE_INVARIANT and TREE_CONSTANT
3583               computed.
3584               We still remove the attribute so that assembler code refers
3585               to '&foo rather than '_imp__foo'.  */
3586           if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
3587             DECL_DLLIMPORT_P (new) = 1;
3588         }
3589
3590       /* Let an inline definition silently override the external reference,
3591          but otherwise warn about attribute inconsistency.  */
3592       else if (TREE_CODE (new) == VAR_DECL
3593                || !DECL_DECLARED_INLINE_P (new))
3594         warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
3595                   "previous dllimport ignored", new);
3596     }
3597   else
3598     delete_dllimport_p = 0;
3599
3600   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new));
3601
3602   if (delete_dllimport_p)
3603     {
3604       tree prev, t;
3605       const size_t attr_len = strlen ("dllimport");
3606
3607       /* Scan the list for dllimport and delete it.  */
3608       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
3609         {
3610           if (is_attribute_with_length_p ("dllimport", attr_len,
3611                                           TREE_PURPOSE (t)))
3612             {
3613               if (prev == NULL_TREE)
3614                 a = TREE_CHAIN (a);
3615               else
3616                 TREE_CHAIN (prev) = TREE_CHAIN (t);
3617               break;
3618             }
3619         }
3620     }
3621
3622   return a;
3623 }
3624
3625 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
3626    struct attribute_spec.handler.  */
3627
3628 tree
3629 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
3630                       bool *no_add_attrs)
3631 {
3632   tree node = *pnode;
3633
3634   /* These attributes may apply to structure and union types being created,
3635      but otherwise should pass to the declaration involved.  */
3636   if (!DECL_P (node))
3637     {
3638       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
3639                    | (int) ATTR_FLAG_ARRAY_NEXT))
3640         {
3641           *no_add_attrs = true;
3642           return tree_cons (name, args, NULL_TREE);
3643         }
3644       if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
3645         {
3646           warning (OPT_Wattributes, "%qs attribute ignored",
3647                    IDENTIFIER_POINTER (name));
3648           *no_add_attrs = true;
3649         }
3650
3651       return NULL_TREE;
3652     }
3653
3654   /* Report error on dllimport ambiguities seen now before they cause
3655      any damage.  */
3656   if (is_attribute_p ("dllimport", name))
3657     {
3658       /* Honor any target-specific overrides. */
3659       if (!targetm.valid_dllimport_attribute_p (node))
3660         *no_add_attrs = true;
3661
3662      else if (TREE_CODE (node) == FUNCTION_DECL
3663                 && DECL_DECLARED_INLINE_P (node))
3664         {
3665           warning (OPT_Wattributes, "inline function %q+D declared as "
3666                   " dllimport: attribute ignored", node);
3667           *no_add_attrs = true;
3668         }
3669       /* Like MS, treat definition of dllimported variables and
3670          non-inlined functions on declaration as syntax errors. */
3671      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
3672         {
3673           error ("function %q+D definition is marked dllimport", node);
3674           *no_add_attrs = true;
3675         }
3676
3677      else if (TREE_CODE (node) == VAR_DECL)
3678         {
3679           if (DECL_INITIAL (node))
3680             {
3681               error ("variable %q+D definition is marked dllimport",
3682                      node);
3683               *no_add_attrs = true;
3684             }
3685
3686           /* `extern' needn't be specified with dllimport.
3687              Specify `extern' now and hope for the best.  Sigh.  */
3688           DECL_EXTERNAL (node) = 1;
3689           /* Also, implicitly give dllimport'd variables declared within
3690              a function global scope, unless declared static.  */
3691           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
3692             TREE_PUBLIC (node) = 1;
3693         }
3694
3695       if (*no_add_attrs == false)
3696         DECL_DLLIMPORT_P (node) = 1;
3697     }
3698
3699   /*  Report error if symbol is not accessible at global scope.  */
3700   if (!TREE_PUBLIC (node)
3701       && (TREE_CODE (node) == VAR_DECL
3702           || TREE_CODE (node) == FUNCTION_DECL))
3703     {
3704       error ("external linkage required for symbol %q+D because of "
3705              "%qs attribute", node, IDENTIFIER_POINTER (name));
3706       *no_add_attrs = true;
3707     }
3708
3709   return NULL_TREE;
3710 }
3711
3712 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
3713 \f
3714 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
3715    of the various TYPE_QUAL values.  */
3716
3717 static void
3718 set_type_quals (tree type, int type_quals)
3719 {
3720   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
3721   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
3722   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
3723 }
3724
3725 /* Returns true iff cand is equivalent to base with type_quals.  */
3726
3727 bool
3728 check_qualified_type (tree cand, tree base, int type_quals)
3729 {
3730   return (TYPE_QUALS (cand) == type_quals
3731           && TYPE_NAME (cand) == TYPE_NAME (base)
3732           /* Apparently this is needed for Objective-C.  */
3733           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
3734           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
3735                                    TYPE_ATTRIBUTES (base)));
3736 }
3737
3738 /* Return a version of the TYPE, qualified as indicated by the
3739    TYPE_QUALS, if one exists.  If no qualified version exists yet,
3740    return NULL_TREE.  */
3741
3742 tree
3743 get_qualified_type (tree type, int type_quals)
3744 {
3745   tree t;
3746
3747   if (TYPE_QUALS (type) == type_quals)
3748     return type;
3749
3750   /* Search the chain of variants to see if there is already one there just
3751      like the one we need to have.  If so, use that existing one.  We must
3752      preserve the TYPE_NAME, since there is code that depends on this.  */
3753   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
3754     if (check_qualified_type (t, type, type_quals))
3755       return t;
3756
3757   return NULL_TREE;
3758 }
3759
3760 /* Like get_qualified_type, but creates the type if it does not
3761    exist.  This function never returns NULL_TREE.  */
3762
3763 tree
3764 build_qualified_type (tree type, int type_quals)
3765 {
3766   tree t;
3767
3768   /* See if we already have the appropriate qualified variant.  */
3769   t = get_qualified_type (type, type_quals);
3770
3771   /* If not, build it.  */
3772   if (!t)
3773     {
3774       t = build_variant_type_copy (type);
3775       set_type_quals (t, type_quals);
3776     }
3777
3778   return t;
3779 }
3780
3781 /* Create a new distinct copy of TYPE.  The new type is made its own
3782    MAIN_VARIANT.  */
3783
3784 tree
3785 build_distinct_type_copy (tree type)
3786 {
3787   tree t = copy_node (type);
3788
3789   TYPE_POINTER_TO (t) = 0;
3790   TYPE_REFERENCE_TO (t) = 0;
3791
3792   /* Make it its own variant.  */
3793   TYPE_MAIN_VARIANT (t) = t;
3794   TYPE_NEXT_VARIANT (t) = 0;
3795
3796   return t;
3797 }
3798
3799 /* Create a new variant of TYPE, equivalent but distinct.
3800    This is so the caller can modify it.  */
3801
3802 tree
3803 build_variant_type_copy (tree type)
3804 {
3805   tree t, m = TYPE_MAIN_VARIANT (type);
3806
3807   t = build_distinct_type_copy (type);
3808
3809   /* Add the new type to the chain of variants of TYPE.  */
3810   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
3811   TYPE_NEXT_VARIANT (m) = t;
3812   TYPE_MAIN_VARIANT (t) = m;
3813
3814   return t;
3815 }
3816 \f
3817 /* Return true if the from tree in both tree maps are equal.  */
3818
3819 int
3820 tree_map_eq (const void *va, const void *vb)
3821 {
3822   const struct tree_map  *a = va, *b = vb;
3823   return (a->from == b->from);
3824 }
3825
3826 /* Hash a from tree in a tree_map.  */
3827
3828 unsigned int
3829 tree_map_hash (const void *item)
3830 {
3831   return (((const struct tree_map *) item)->hash);
3832 }
3833
3834 /* Return true if this tree map structure is marked for garbage collection
3835    purposes.  We simply return true if the from tree is marked, so that this
3836    structure goes away when the from tree goes away.  */
3837
3838 int
3839 tree_map_marked_p (const void *p)
3840 {
3841   tree from = ((struct tree_map *) p)->from;
3842
3843   return ggc_marked_p (from);
3844 }
3845
3846 /* Return true if the trees in the tree_int_map *'s VA and VB are equal.  */
3847
3848 static int
3849 tree_int_map_eq (const void *va, const void *vb)
3850 {
3851   const struct tree_int_map  *a = va, *b = vb;
3852   return (a->from == b->from);
3853 }
3854
3855 /* Hash a from tree in the tree_int_map * ITEM.  */
3856
3857 static unsigned int
3858 tree_int_map_hash (const void *item)
3859 {
3860   return htab_hash_pointer (((const struct tree_int_map *)item)->from);
3861 }
3862
3863 /* Return true if this tree int map structure is marked for garbage collection
3864    purposes.  We simply return true if the from tree_int_map *P's from tree is marked, so that this
3865    structure goes away when the from tree goes away.  */
3866
3867 static int
3868 tree_int_map_marked_p (const void *p)
3869 {
3870   tree from = ((struct tree_int_map *) p)->from;
3871
3872   return ggc_marked_p (from);
3873 }
3874 /* Lookup an init priority for FROM, and return it if we find one.  */
3875
3876 unsigned short
3877 decl_init_priority_lookup (tree from)
3878 {
3879   struct tree_int_map *h, in;
3880   in.from = from;
3881
3882   h = htab_find_with_hash (init_priority_for_decl,
3883                            &in, htab_hash_pointer (from));
3884   if (h)
3885     return h->to;
3886   return 0;
3887 }
3888
3889 /* Insert a mapping FROM->TO in the init priority hashtable.  */
3890
3891 void
3892 decl_init_priority_insert (tree from, unsigned short to)
3893 {
3894   struct tree_int_map *h;
3895   void **loc;
3896
3897   h = ggc_alloc (sizeof (struct tree_int_map));
3898   h->from = from;
3899   h->to = to;
3900   loc = htab_find_slot_with_hash (init_priority_for_decl, h,
3901                                   htab_hash_pointer (from), INSERT);
3902   *(struct tree_int_map **) loc = h;
3903 }
3904
3905 /* Look up a restrict qualified base decl for FROM.  */
3906
3907 tree
3908 decl_restrict_base_lookup (tree from)
3909 {
3910   struct tree_map *h;
3911   struct tree_map in;
3912
3913   in.from = from;
3914   h = htab_find_with_hash (restrict_base_for_decl, &in,
3915                            htab_hash_pointer (from));
3916   return h ? h->to : NULL_TREE;
3917 }
3918
3919 /* Record the restrict qualified base TO for FROM.  */
3920
3921 void
3922 decl_restrict_base_insert (tree from, tree to)
3923 {
3924   struct tree_map *h;
3925   void **loc;
3926
3927   h = ggc_alloc (sizeof (struct tree_map));
3928   h->hash = htab_hash_pointer (from);
3929   h->from = from;
3930   h->to = to;
3931   loc = htab_find_slot_with_hash (restrict_base_for_decl, h, h->hash, INSERT);
3932   *(struct tree_map **) loc = h;
3933 }
3934
3935 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
3936
3937 static void
3938 print_debug_expr_statistics (void)
3939 {
3940   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
3941            (long) htab_size (debug_expr_for_decl),
3942            (long) htab_elements (debug_expr_for_decl),
3943            htab_collisions (debug_expr_for_decl));
3944 }
3945
3946 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
3947
3948 static void
3949 print_value_expr_statistics (void)
3950 {
3951   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
3952            (long) htab_size (value_expr_for_decl),
3953            (long) htab_elements (value_expr_for_decl),
3954            htab_collisions (value_expr_for_decl));
3955 }
3956
3957 /* Print out statistics for the RESTRICT_BASE_FOR_DECL hash table, but
3958    don't print anything if the table is empty.  */
3959
3960 static void
3961 print_restrict_base_statistics (void)
3962 {
3963   if (htab_elements (restrict_base_for_decl) != 0)
3964     fprintf (stderr,
3965              "RESTRICT_BASE    hash: size %ld, %ld elements, %f collisions\n",
3966              (long) htab_size (restrict_base_for_decl),
3967              (long) htab_elements (restrict_base_for_decl),
3968              htab_collisions (restrict_base_for_decl));
3969 }
3970
3971 /* Lookup a debug expression for FROM, and return it if we find one.  */
3972
3973 tree
3974 decl_debug_expr_lookup (tree from)
3975 {
3976   struct tree_map *h, in;
3977   in.from = from;
3978
3979   h = htab_find_with_hash (debug_expr_for_decl, &in, htab_hash_pointer (from));
3980   if (h)
3981     return h->to;
3982   return NULL_TREE;
3983 }
3984
3985 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
3986
3987 void
3988 decl_debug_expr_insert (tree from, tree to)
3989 {
3990   struct tree_map *h;
3991   void **loc;
3992
3993   h = ggc_alloc (sizeof (struct tree_map));
3994   h->hash = htab_hash_pointer (from);
3995   h->from = from;
3996   h->to = to;
3997   loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
3998   *(struct tree_map **) loc = h;
3999 }
4000
4001 /* Lookup a value expression for FROM, and return it if we find one.  */
4002
4003 tree
4004 decl_value_expr_lookup (tree from)
4005 {
4006   struct tree_map *h, in;
4007   in.from = from;
4008
4009   h = htab_find_with_hash (value_expr_for_decl, &in, htab_hash_pointer (from));
4010   if (h)
4011     return h->to;
4012   return NULL_TREE;
4013 }
4014
4015 /* Insert a mapping FROM->TO in the value expression hashtable.  */
4016
4017 void
4018 decl_value_expr_insert (tree from, tree to)
4019 {
4020   struct tree_map *h;
4021   void **loc;
4022
4023   h = ggc_alloc (sizeof (struct tree_map));
4024   h->hash = htab_hash_pointer (from);
4025   h->from = from;
4026   h->to = to;
4027   loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT);
4028   *(struct tree_map **) loc = h;
4029 }
4030
4031 /* Hashing of types so that we don't make duplicates.
4032    The entry point is `type_hash_canon'.  */
4033
4034 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
4035    with types in the TREE_VALUE slots), by adding the hash codes
4036    of the individual types.  */
4037
4038 unsigned int
4039 type_hash_list (tree list, hashval_t hashcode)
4040 {
4041   tree tail;
4042
4043   for (tail = list; tail; tail = TREE_CHAIN (tail))
4044     if (TREE_VALUE (tail) != error_mark_node)
4045       hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
4046                                         hashcode);
4047
4048   return hashcode;
4049 }
4050
4051 /* These are the Hashtable callback functions.  */
4052
4053 /* Returns true iff the types are equivalent.  */
4054
4055 static int
4056 type_hash_eq (const void *va, const void *vb)
4057 {
4058   const struct type_hash *a = va, *b = vb;
4059
4060   /* First test the things that are the same for all types.  */
4061   if (a->hash != b->hash
4062       || TREE_CODE (a->type) != TREE_CODE (b->type)
4063       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
4064       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
4065                                  TYPE_ATTRIBUTES (b->type))
4066       || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
4067       || TYPE_MODE (a->type) != TYPE_MODE (b->type))
4068     return 0;
4069
4070   switch (TREE_CODE (a->type))
4071     {
4072     case VOID_TYPE:
4073     case COMPLEX_TYPE:
4074     case POINTER_TYPE:
4075     case REFERENCE_TYPE:
4076       return 1;
4077
4078     case VECTOR_TYPE:
4079       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
4080
4081     case ENUMERAL_TYPE:
4082       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
4083           && !(TYPE_VALUES (a->type)
4084                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
4085                && TYPE_VALUES (b->type)
4086                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
4087                && type_list_equal (TYPE_VALUES (a->type),
4088                                    TYPE_VALUES (b->type))))
4089         return 0;
4090
4091       /* ... fall through ... */
4092
4093     case INTEGER_TYPE:
4094     case REAL_TYPE:
4095     case BOOLEAN_TYPE:
4096       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
4097                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
4098                                       TYPE_MAX_VALUE (b->type)))
4099               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
4100                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
4101                                          TYPE_MIN_VALUE (b->type))));
4102
4103     case OFFSET_TYPE:
4104       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
4105
4106     case METHOD_TYPE:
4107       return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
4108               && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
4109                   || (TYPE_ARG_TYPES (a->type)
4110                       && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
4111                       && TYPE_ARG_TYPES (b->type)
4112                       && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
4113                       && type_list_equal (TYPE_ARG_TYPES (a->type),
4114                                           TYPE_ARG_TYPES (b->type)))));
4115
4116     case ARRAY_TYPE:
4117       return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
4118
4119     case RECORD_TYPE:
4120     case UNION_TYPE:
4121     case QUAL_UNION_TYPE:
4122       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
4123               || (TYPE_FIELDS (a->type)
4124                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
4125                   && TYPE_FIELDS (b->type)
4126                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
4127                   && type_list_equal (TYPE_FIELDS (a->type),
4128                                       TYPE_FIELDS (b->type))));
4129
4130     case FUNCTION_TYPE:
4131       return (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
4132               || (TYPE_ARG_TYPES (a->type)
4133                   && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
4134                   && TYPE_ARG_TYPES (b->type)
4135                   && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
4136                   && type_list_equal (TYPE_ARG_TYPES (a->type),
4137                                       TYPE_ARG_TYPES (b->type))));
4138
4139     default:
4140       return 0;
4141     }
4142 }
4143
4144 /* Return the cached hash value.  */
4145
4146 static hashval_t
4147 type_hash_hash (const void *item)
4148 {
4149   return ((const struct type_hash *) item)->hash;
4150 }
4151
4152 /* Look in the type hash table for a type isomorphic to TYPE.
4153    If one is found, return it.  Otherwise return 0.  */
4154
4155 tree
4156 type_hash_lookup (hashval_t hashcode, tree type)
4157 {
4158   struct type_hash *h, in;
4159
4160   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
4161      must call that routine before comparing TYPE_ALIGNs.  */
4162   layout_type (type);
4163
4164   in.hash = hashcode;
4165   in.type = type;
4166
4167   h = htab_find_with_hash (type_hash_table, &in, hashcode);
4168   if (h)
4169     return h->type;
4170   return NULL_TREE;
4171 }
4172
4173 /* Add an entry to the type-hash-table
4174    for a type TYPE whose hash code is HASHCODE.  */
4175
4176 void
4177 type_hash_add (hashval_t hashcode, tree type)
4178 {
4179   struct type_hash *h;
4180   void **loc;
4181
4182   h = ggc_alloc (sizeof (struct type_hash));
4183   h->hash = hashcode;
4184   h->type = type;
4185   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
4186   *(struct type_hash **) loc = h;
4187 }
4188
4189 /* Given TYPE, and HASHCODE its hash code, return the canonical
4190    object for an identical type if one already exists.
4191    Otherwise, return TYPE, and record it as the canonical object.
4192
4193    To use this function, first create a type of the sort you want.
4194    Then compute its hash code from the fields of the type that
4195    make it different from other similar types.
4196    Then call this function and use the value.  */
4197
4198 tree
4199 type_hash_canon (unsigned int hashcode, tree type)
4200 {
4201   tree t1;
4202
4203   /* The hash table only contains main variants, so ensure that's what we're
4204      being passed.  */
4205   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
4206
4207   if (!lang_hooks.types.hash_types)
4208     return type;
4209
4210   /* See if the type is in the hash table already.  If so, return it.
4211      Otherwise, add the type.  */
4212   t1 = type_hash_lookup (hashcode, type);
4213   if (t1 != 0)
4214     {
4215 #ifdef GATHER_STATISTICS
4216       tree_node_counts[(int) t_kind]--;
4217       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
4218 #endif
4219       return t1;
4220     }
4221   else
4222     {
4223       type_hash_add (hashcode, type);
4224       return type;
4225     }
4226 }
4227
4228 /* See if the data pointed to by the type hash table is marked.  We consider
4229    it marked if the type is marked or if a debug type number or symbol
4230    table entry has been made for the type.  This reduces the amount of
4231    debugging output and eliminates that dependency of the debug output on
4232    the number of garbage collections.  */
4233
4234 static int
4235 type_hash_marked_p (const void *p)
4236 {
4237   tree type = ((struct type_hash *) p)->type;
4238
4239   return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
4240 }
4241
4242 static void
4243 print_type_hash_statistics (void)
4244 {
4245   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
4246            (long) htab_size (type_hash_table),
4247            (long) htab_elements (type_hash_table),
4248            htab_collisions (type_hash_table));
4249 }
4250
4251 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
4252    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
4253    by adding the hash codes of the individual attributes.  */
4254
4255 unsigned int
4256 attribute_hash_list (tree list, hashval_t hashcode)
4257 {
4258   tree tail;
4259
4260   for (tail = list; tail; tail = TREE_CHAIN (tail))
4261     /* ??? Do we want to add in TREE_VALUE too? */
4262     hashcode = iterative_hash_object
4263       (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
4264   return hashcode;
4265 }
4266
4267 /* Given two lists of attributes, return true if list l2 is
4268    equivalent to l1.  */
4269
4270 int
4271 attribute_list_equal (tree l1, tree l2)
4272 {
4273   return attribute_list_contained (l1, l2)
4274          && attribute_list_contained (l2, l1);
4275 }
4276
4277 /* Given two lists of attributes, return true if list L2 is
4278    completely contained within L1.  */
4279 /* ??? This would be faster if attribute names were stored in a canonicalized
4280    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
4281    must be used to show these elements are equivalent (which they are).  */
4282 /* ??? It's not clear that attributes with arguments will always be handled
4283    correctly.  */
4284
4285 int
4286 attribute_list_contained (tree l1, tree l2)
4287 {
4288   tree t1, t2;
4289
4290   /* First check the obvious, maybe the lists are identical.  */
4291   if (l1 == l2)
4292     return 1;
4293
4294   /* Maybe the lists are similar.  */
4295   for (t1 = l1, t2 = l2;
4296        t1 != 0 && t2 != 0
4297         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
4298         && TREE_VALUE (t1) == TREE_VALUE (t2);
4299        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
4300
4301   /* Maybe the lists are equal.  */
4302   if (t1 == 0 && t2 == 0)
4303     return 1;
4304
4305   for (; t2 != 0; t2 = TREE_CHAIN (t2))
4306     {
4307       tree attr;
4308       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
4309            attr != NULL_TREE;
4310            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
4311                                     TREE_CHAIN (attr)))
4312         {
4313           if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
4314             break;
4315         }
4316
4317       if (attr == 0)
4318         return 0;
4319
4320       if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
4321         return 0;
4322     }
4323
4324   return 1;
4325 }
4326
4327 /* Given two lists of types
4328    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
4329    return 1 if the lists contain the same types in the same order.
4330    Also, the TREE_PURPOSEs must match.  */
4331
4332 int
4333 type_list_equal (tree l1, tree l2)
4334 {
4335   tree t1, t2;
4336
4337   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
4338     if (TREE_VALUE (t1) != TREE_VALUE (t2)
4339         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
4340             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
4341                   && (TREE_TYPE (TREE_PURPOSE (t1))
4342                       == TREE_TYPE (TREE_PURPOSE (t2))))))
4343       return 0;
4344
4345   return t1 == t2;
4346 }
4347
4348 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
4349    given by TYPE.  If the argument list accepts variable arguments,
4350    then this function counts only the ordinary arguments.  */
4351
4352 int
4353 type_num_arguments (tree type)
4354 {
4355   int i = 0;
4356   tree t;
4357
4358   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
4359     /* If the function does not take a variable number of arguments,
4360        the last element in the list will have type `void'.  */
4361     if (VOID_TYPE_P (TREE_VALUE (t)))
4362       break;
4363     else
4364       ++i;
4365
4366   return i;
4367 }
4368
4369 /* Nonzero if integer constants T1 and T2
4370    represent the same constant value.  */
4371
4372 int
4373 tree_int_cst_equal (tree t1, tree t2)
4374 {
4375   if (t1 == t2)
4376     return 1;
4377
4378   if (t1 == 0 || t2 == 0)
4379     return 0;
4380
4381   if (TREE_CODE (t1) == INTEGER_CST
4382       && TREE_CODE (t2) == INTEGER_CST
4383       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
4384       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
4385     return 1;
4386
4387   return 0;
4388 }
4389
4390 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
4391    The precise way of comparison depends on their data type.  */
4392
4393 int
4394 tree_int_cst_lt (tree t1, tree t2)
4395 {
4396   if (t1 == t2)
4397     return 0;
4398
4399   if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
4400     {
4401       int t1_sgn = tree_int_cst_sgn (t1);
4402       int t2_sgn = tree_int_cst_sgn (t2);
4403
4404       if (t1_sgn < t2_sgn)
4405         return 1;
4406       else if (t1_sgn > t2_sgn)
4407         return 0;
4408       /* Otherwise, both are non-negative, so we compare them as
4409          unsigned just in case one of them would overflow a signed
4410          type.  */
4411     }
4412   else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
4413     return INT_CST_LT (t1, t2);
4414
4415   return INT_CST_LT_UNSIGNED (t1, t2);
4416 }
4417
4418 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
4419
4420 int
4421 tree_int_cst_compare (tree t1, tree t2)
4422 {
4423   if (tree_int_cst_lt (t1, t2))
4424     return -1;
4425   else if (tree_int_cst_lt (t2, t1))
4426     return 1;
4427   else
4428     return 0;
4429 }
4430
4431 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
4432    the host.  If POS is zero, the value can be represented in a single
4433    HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
4434    be represented in a single unsigned HOST_WIDE_INT.  */
4435
4436 int
4437 host_integerp (tree t, int pos)
4438 {
4439   return (TREE_CODE (t) == INTEGER_CST
4440           && ((TREE_INT_CST_HIGH (t) == 0
4441                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
4442               || (! pos && TREE_INT_CST_HIGH (t) == -1
4443                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
4444                   && !TYPE_UNSIGNED (TREE_TYPE (t)))
4445               || (pos && TREE_INT_CST_HIGH (t) == 0)));
4446 }
4447
4448 /* Return the HOST_WIDE_INT least significant bits of T if it is an
4449    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
4450    be non-negative.  We must be able to satisfy the above conditions.  */
4451
4452 HOST_WIDE_INT
4453 tree_low_cst (tree t, int pos)
4454 {
4455   gcc_assert (host_integerp (t, pos));
4456   return TREE_INT_CST_LOW (t);
4457 }
4458
4459 /* Return the most significant bit of the integer constant T.  */
4460
4461 int
4462 tree_int_cst_msb (tree t)
4463 {
4464   int prec;
4465   HOST_WIDE_INT h;
4466   unsigned HOST_WIDE_INT l;
4467
4468   /* Note that using TYPE_PRECISION here is wrong.  We care about the
4469      actual bits, not the (arbitrary) range of the type.  */
4470   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
4471   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
4472                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
4473   return (l & 1) == 1;
4474 }
4475
4476 /* Return an indication of the sign of the integer constant T.
4477    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
4478    Note that -1 will never be returned if T's type is unsigned.  */
4479
4480 int
4481 tree_int_cst_sgn (tree t)
4482 {
4483   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
4484     return 0;
4485   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
4486     return 1;
4487   else if (TREE_INT_CST_HIGH (t) < 0)
4488     return -1;
4489   else
4490     return 1;
4491 }
4492
4493 /* Compare two constructor-element-type constants.  Return 1 if the lists
4494    are known to be equal; otherwise return 0.  */
4495
4496 int
4497 simple_cst_list_equal (tree l1, tree l2)
4498 {
4499   while (l1 != NULL_TREE && l2 != NULL_TREE)
4500     {
4501       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
4502         return 0;
4503
4504       l1 = TREE_CHAIN (l1);
4505       l2 = TREE_CHAIN (l2);
4506     }
4507
4508   return l1 == l2;
4509 }
4510
4511 /* Return truthvalue of whether T1 is the same tree structure as T2.
4512    Return 1 if they are the same.
4513    Return 0 if they are understandably different.
4514    Return -1 if either contains tree structure not understood by
4515    this function.  */
4516
4517 int
4518 simple_cst_equal (tree t1, tree t2)
4519 {
4520   enum tree_code code1, code2;
4521   int cmp;
4522   int i;
4523
4524   if (t1 == t2)
4525     return 1;
4526   if (t1 == 0 || t2 == 0)
4527     return 0;
4528
4529   code1 = TREE_CODE (t1);
4530   code2 = TREE_CODE (t2);
4531
4532   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
4533     {
4534       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
4535           || code2 == NON_LVALUE_EXPR)
4536         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4537       else
4538         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
4539     }
4540
4541   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
4542            || code2 == NON_LVALUE_EXPR)
4543     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
4544
4545   if (code1 != code2)
4546     return 0;
4547
4548   switch (code1)
4549     {
4550     case INTEGER_CST:
4551       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
4552               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
4553
4554     case REAL_CST:
4555       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
4556
4557     case STRING_CST:
4558       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
4559               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
4560                          TREE_STRING_LENGTH (t1)));
4561
4562     case CONSTRUCTOR:
4563       {
4564         unsigned HOST_WIDE_INT idx;
4565         VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
4566         VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
4567
4568         if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
4569           return false;
4570
4571         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
4572           /* ??? Should we handle also fields here? */
4573           if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
4574                                  VEC_index (constructor_elt, v2, idx)->value))
4575             return false;
4576         return true;
4577       }
4578
4579     case SAVE_EXPR:
4580       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4581
4582     case CALL_EXPR:
4583       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4584       if (cmp <= 0)
4585         return cmp;
4586       return
4587         simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
4588
4589     case TARGET_EXPR:
4590       /* Special case: if either target is an unallocated VAR_DECL,
4591          it means that it's going to be unified with whatever the
4592          TARGET_EXPR is really supposed to initialize, so treat it
4593          as being equivalent to anything.  */
4594       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
4595            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
4596            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
4597           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
4598               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
4599               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
4600         cmp = 1;
4601       else
4602         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4603
4604       if (cmp <= 0)
4605         return cmp;
4606
4607       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
4608
4609     case WITH_CLEANUP_EXPR:
4610       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4611       if (cmp <= 0)
4612         return cmp;
4613
4614       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
4615
4616     case COMPONENT_REF:
4617       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
4618         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4619
4620       return 0;
4621
4622     case VAR_DECL:
4623     case PARM_DECL:
4624     case CONST_DECL:
4625     case FUNCTION_DECL:
4626       return 0;
4627
4628     default:
4629       break;
4630     }
4631
4632   /* This general rule works for most tree codes.  All exceptions should be
4633      handled above.  If this is a language-specific tree code, we can't
4634      trust what might be in the operand, so say we don't know
4635      the situation.  */
4636   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
4637     return -1;
4638
4639   switch (TREE_CODE_CLASS (code1))
4640     {
4641     case tcc_unary:
4642     case tcc_binary:
4643     case tcc_comparison:
4644     case tcc_expression:
4645     case tcc_reference:
4646     case tcc_statement:
4647       cmp = 1;
4648       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
4649         {
4650           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
4651           if (cmp <= 0)
4652             return cmp;
4653         }
4654
4655       return cmp;
4656
4657     default:
4658       return -1;
4659     }
4660 }
4661
4662 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
4663    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
4664    than U, respectively.  */
4665
4666 int
4667 compare_tree_int (tree t, unsigned HOST_WIDE_INT u)
4668 {
4669   if (tree_int_cst_sgn (t) < 0)
4670     return -1;
4671   else if (TREE_INT_CST_HIGH (t) != 0)
4672     return 1;
4673   else if (TREE_INT_CST_LOW (t) == u)
4674     return 0;
4675   else if (TREE_INT_CST_LOW (t) < u)
4676     return -1;
4677   else
4678     return 1;
4679 }
4680
4681 /* Return true if CODE represents an associative tree code.  Otherwise
4682    return false.  */
4683 bool
4684 associative_tree_code (enum tree_code code)
4685 {
4686   switch (code)
4687     {
4688     case BIT_IOR_EXPR:
4689     case BIT_AND_EXPR:
4690     case BIT_XOR_EXPR:
4691     case PLUS_EXPR:
4692     case MULT_EXPR:
4693     case MIN_EXPR:
4694     case MAX_EXPR:
4695       return true;
4696
4697     default:
4698       break;
4699     }
4700   return false;
4701 }
4702
4703 /* Return true if CODE represents a commutative tree code.  Otherwise
4704    return false.  */
4705 bool
4706 commutative_tree_code (enum tree_code code)
4707 {
4708   switch (code)
4709     {
4710     case PLUS_EXPR:
4711     case MULT_EXPR:
4712     case MIN_EXPR:
4713     case MAX_EXPR:
4714     case BIT_IOR_EXPR:
4715     case BIT_XOR_EXPR:
4716     case BIT_AND_EXPR:
4717     case NE_EXPR:
4718     case EQ_EXPR:
4719     case UNORDERED_EXPR:
4720     case ORDERED_EXPR:
4721     case UNEQ_EXPR:
4722     case LTGT_EXPR:
4723     case TRUTH_AND_EXPR:
4724     case TRUTH_XOR_EXPR:
4725     case TRUTH_OR_EXPR:
4726       return true;
4727
4728     default:
4729       break;
4730     }
4731   return false;
4732 }
4733
4734 /* Generate a hash value for an expression.  This can be used iteratively
4735    by passing a previous result as the "val" argument.
4736
4737    This function is intended to produce the same hash for expressions which
4738    would compare equal using operand_equal_p.  */
4739
4740 hashval_t
4741 iterative_hash_expr (tree t, hashval_t val)
4742 {
4743   int i;
4744   enum tree_code code;
4745   char class;
4746
4747   if (t == NULL_TREE)
4748     return iterative_hash_pointer (t, val);
4749
4750   code = TREE_CODE (t);
4751
4752   switch (code)
4753     {
4754     /* Alas, constants aren't shared, so we can't rely on pointer
4755        identity.  */
4756     case INTEGER_CST:
4757       val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
4758       return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
4759     case REAL_CST:
4760       {
4761         unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
4762
4763         return iterative_hash_hashval_t (val2, val);
4764       }
4765     case STRING_CST:
4766       return iterative_hash (TREE_STRING_POINTER (t),
4767                              TREE_STRING_LENGTH (t), val);
4768     case COMPLEX_CST:
4769       val = iterative_hash_expr (TREE_REALPART (t), val);
4770       return iterative_hash_expr (TREE_IMAGPART (t), val);
4771     case VECTOR_CST:
4772       return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
4773
4774     case SSA_NAME:
4775     case VALUE_HANDLE:
4776       /* we can just compare by pointer.  */
4777       return iterative_hash_pointer (t, val);
4778
4779     case TREE_LIST:
4780       /* A list of expressions, for a CALL_EXPR or as the elements of a
4781          VECTOR_CST.  */
4782       for (; t; t = TREE_CHAIN (t))
4783         val = iterative_hash_expr (TREE_VALUE (t), val);
4784       return val;
4785     case CONSTRUCTOR:
4786       {
4787         unsigned HOST_WIDE_INT idx;
4788         tree field, value;
4789         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
4790           {
4791             val = iterative_hash_expr (field, val);
4792             val = iterative_hash_expr (value, val);
4793           }
4794         return val;
4795       }
4796     case FUNCTION_DECL:
4797       /* When referring to a built-in FUNCTION_DECL, use the
4798          __builtin__ form.  Otherwise nodes that compare equal
4799          according to operand_equal_p might get different
4800          hash codes.  */
4801       if (DECL_BUILT_IN (t))
4802         {
4803           val = iterative_hash_pointer (built_in_decls[DECL_FUNCTION_CODE (t)],
4804                                       val);
4805           return val;
4806         }
4807       /* else FALL THROUGH */
4808     default:
4809       class = TREE_CODE_CLASS (code);
4810
4811       if (class == tcc_declaration)
4812         {
4813           /* DECL's have a unique ID */
4814           val = iterative_hash_host_wide_int (DECL_UID (t), val);
4815         }
4816       else
4817         {
4818           gcc_assert (IS_EXPR_CODE_CLASS (class));
4819
4820           val = iterative_hash_object (code, val);
4821
4822           /* Don't hash the type, that can lead to having nodes which
4823              compare equal according to operand_equal_p, but which
4824              have different hash codes.  */
4825           if (code == NOP_EXPR
4826               || code == CONVERT_EXPR
4827               || code == NON_LVALUE_EXPR)
4828             {
4829               /* Make sure to include signness in the hash computation.  */
4830               val += TYPE_UNSIGNED (TREE_TYPE (t));
4831               val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
4832             }
4833
4834           else if (commutative_tree_code (code))
4835             {
4836               /* It's a commutative expression.  We want to hash it the same
4837                  however it appears.  We do this by first hashing both operands
4838                  and then rehashing based on the order of their independent
4839                  hashes.  */
4840               hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
4841               hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
4842               hashval_t t;
4843
4844               if (one > two)
4845                 t = one, one = two, two = t;
4846
4847               val = iterative_hash_hashval_t (one, val);
4848               val = iterative_hash_hashval_t (two, val);
4849             }
4850           else
4851             for (i = TREE_CODE_LENGTH (code) - 1; i >= 0; --i)
4852               val = iterative_hash_expr (TREE_OPERAND (t, i), val);
4853         }
4854       return val;
4855       break;
4856     }
4857 }
4858 \f
4859 /* Constructors for pointer, array and function types.
4860    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
4861    constructed by language-dependent code, not here.)  */
4862
4863 /* Construct, lay out and return the type of pointers to TO_TYPE with
4864    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
4865    reference all of memory. If such a type has already been
4866    constructed, reuse it.  */
4867
4868 tree
4869 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
4870                              bool can_alias_all)
4871 {
4872   tree t;
4873
4874   if (to_type == error_mark_node)
4875     return error_mark_node;
4876
4877   /* In some cases, languages will have things that aren't a POINTER_TYPE
4878      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
4879      In that case, return that type without regard to the rest of our
4880      operands.
4881
4882      ??? This is a kludge, but consistent with the way this function has
4883      always operated and there doesn't seem to be a good way to avoid this
4884      at the moment.  */
4885   if (TYPE_POINTER_TO (to_type) != 0
4886       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
4887     return TYPE_POINTER_TO (to_type);
4888
4889   /* First, if we already have a type for pointers to TO_TYPE and it's
4890      the proper mode, use it.  */
4891   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
4892     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
4893       return t;
4894
4895   t = make_node (POINTER_TYPE);
4896
4897   TREE_TYPE (t) = to_type;
4898   TYPE_MODE (t) = mode;
4899   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
4900   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
4901   TYPE_POINTER_TO (to_type) = t;
4902
4903   /* Lay out the type.  This function has many callers that are concerned
4904      with expression-construction, and this simplifies them all.  */
4905   layout_type (t);
4906
4907   return t;
4908 }
4909
4910 /* By default build pointers in ptr_mode.  */
4911
4912 tree
4913 build_pointer_type (tree to_type)
4914 {
4915   return build_pointer_type_for_mode (to_type, ptr_mode, false);
4916 }
4917
4918 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
4919
4920 tree
4921 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
4922                                bool can_alias_all)
4923 {
4924   tree t;
4925
4926   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
4927      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
4928      In that case, return that type without regard to the rest of our
4929      operands.
4930
4931      ??? This is a kludge, but consistent with the way this function has
4932      always operated and there doesn't seem to be a good way to avoid this
4933      at the moment.  */
4934   if (TYPE_REFERENCE_TO (to_type) != 0
4935       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
4936     return TYPE_REFERENCE_TO (to_type);
4937
4938   /* First, if we already have a type for pointers to TO_TYPE and it's
4939      the proper mode, use it.  */
4940   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
4941     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
4942       return t;
4943
4944   t = make_node (REFERENCE_TYPE);
4945
4946   TREE_TYPE (t) = to_type;
4947   TYPE_MODE (t) = mode;
4948   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
4949   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
4950   TYPE_REFERENCE_TO (to_type) = t;
4951
4952   layout_type (t);
4953
4954   return t;
4955 }
4956
4957
4958 /* Build the node for the type of references-to-TO_TYPE by default
4959    in ptr_mode.  */
4960
4961 tree
4962 build_reference_type (tree to_type)
4963 {
4964   return build_reference_type_for_mode (to_type, ptr_mode, false);
4965 }
4966
4967 /* Build a type that is compatible with t but has no cv quals anywhere
4968    in its type, thus
4969
4970    const char *const *const *  ->  char ***.  */
4971
4972 tree
4973 build_type_no_quals (tree t)
4974 {
4975   switch (TREE_CODE (t))
4976     {
4977     case POINTER_TYPE:
4978       return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
4979                                           TYPE_MODE (t),
4980                                           TYPE_REF_CAN_ALIAS_ALL (t));
4981     case REFERENCE_TYPE:
4982       return
4983         build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
4984                                        TYPE_MODE (t),
4985                                        TYPE_REF_CAN_ALIAS_ALL (t));
4986     default:
4987       return TYPE_MAIN_VARIANT (t);
4988     }
4989 }
4990
4991 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
4992    MAXVAL should be the maximum value in the domain
4993    (one less than the length of the array).
4994
4995    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
4996    We don't enforce this limit, that is up to caller (e.g. language front end).
4997    The limit exists because the result is a signed type and we don't handle
4998    sizes that use more than one HOST_WIDE_INT.  */
4999
5000 tree
5001 build_index_type (tree maxval)
5002 {
5003   tree itype = make_node (INTEGER_TYPE);
5004
5005   TREE_TYPE (itype) = sizetype;
5006   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
5007   TYPE_MIN_VALUE (itype) = size_zero_node;
5008   TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
5009   TYPE_MODE (itype) = TYPE_MODE (sizetype);
5010   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
5011   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
5012   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
5013   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
5014
5015   if (host_integerp (maxval, 1))
5016     return type_hash_canon (tree_low_cst (maxval, 1), itype);
5017   else
5018     return itype;
5019 }
5020
5021 /* Builds a signed or unsigned integer type of precision PRECISION.
5022    Used for C bitfields whose precision does not match that of
5023    built-in target types.  */
5024 tree
5025 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
5026                                 int unsignedp)
5027 {
5028   tree itype = make_node (INTEGER_TYPE);
5029
5030   TYPE_PRECISION (itype) = precision;
5031
5032   if (unsignedp)
5033     fixup_unsigned_type (itype);
5034   else
5035     fixup_signed_type (itype);
5036
5037   if (host_integerp (TYPE_MAX_VALUE (itype), 1))
5038     return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
5039
5040   return itype;
5041 }
5042
5043 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
5044    ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
5045    high bound HIGHVAL.  If TYPE is NULL, sizetype is used.  */
5046
5047 tree
5048 build_range_type (tree type, tree lowval, tree highval)
5049 {
5050   tree itype = make_node (INTEGER_TYPE);
5051
5052   TREE_TYPE (itype) = type;
5053   if (type == NULL_TREE)
5054     type = sizetype;
5055
5056   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
5057   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
5058
5059   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
5060   TYPE_MODE (itype) = TYPE_MODE (type);
5061   TYPE_SIZE (itype) = TYPE_SIZE (type);
5062   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
5063   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
5064   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
5065
5066   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
5067     return type_hash_canon (tree_low_cst (highval, 0)
5068                             - tree_low_cst (lowval, 0),
5069                             itype);
5070   else
5071     return itype;
5072 }
5073
5074 /* Just like build_index_type, but takes lowval and highval instead
5075    of just highval (maxval).  */
5076
5077 tree
5078 build_index_2_type (tree lowval, tree highval)
5079 {
5080   return build_range_type (sizetype, lowval, highval);
5081 }
5082
5083 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
5084    and number of elements specified by the range of values of INDEX_TYPE.
5085    If such a type has already been constructed, reuse it.  */
5086
5087 tree
5088 build_array_type (tree elt_type, tree index_type)
5089 {
5090   tree t;
5091   hashval_t hashcode = 0;
5092
5093   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
5094     {
5095       error ("arrays of functions are not meaningful");
5096       elt_type = integer_type_node;
5097     }
5098
5099   t = make_node (ARRAY_TYPE);
5100   TREE_TYPE (t) = elt_type;
5101   TYPE_DOMAIN (t) = index_type;
5102
5103   if (index_type == 0)
5104     {
5105       layout_type (t);
5106       return t;
5107     }
5108
5109   hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
5110   hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
5111   t = type_hash_canon (hashcode, t);
5112
5113   if (!COMPLETE_TYPE_P (t))
5114     layout_type (t);
5115   return t;
5116 }
5117
5118 /* Return the TYPE of the elements comprising
5119    the innermost dimension of ARRAY.  */
5120
5121 tree
5122 get_inner_array_type (tree array)
5123 {
5124   tree type = TREE_TYPE (array);
5125
5126   while (TREE_CODE (type) == ARRAY_TYPE)
5127     type = TREE_TYPE (type);
5128
5129   return type;
5130 }
5131
5132 /* Construct, lay out and return
5133    the type of functions returning type VALUE_TYPE
5134    given arguments of types ARG_TYPES.
5135    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
5136    are data type nodes for the arguments of the function.
5137    If such a type has already been constructed, reuse it.  */
5138
5139 tree
5140 build_function_type (tree value_type, tree arg_types)
5141 {
5142   tree t;
5143   hashval_t hashcode = 0;
5144
5145   if (TREE_CODE (value_type) == FUNCTION_TYPE)
5146     {
5147       error ("function return type cannot be function");
5148       value_type = integer_type_node;
5149     }
5150
5151   /* Make a node of the sort we want.  */
5152   t = make_node (FUNCTION_TYPE);
5153   TREE_TYPE (t) = value_type;
5154   TYPE_ARG_TYPES (t) = arg_types;
5155
5156   /* If we already have such a type, use the old one.  */
5157   hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
5158   hashcode = type_hash_list (arg_types, hashcode);
5159   t = type_hash_canon (hashcode, t);
5160
5161   if (!COMPLETE_TYPE_P (t))
5162     layout_type (t);
5163   return t;
5164 }
5165
5166 /* Build a function type.  The RETURN_TYPE is the type returned by the
5167    function.  If additional arguments are provided, they are
5168    additional argument types.  The list of argument types must always
5169    be terminated by NULL_TREE.  */
5170
5171 tree
5172 build_function_type_list (tree return_type, ...)
5173 {
5174   tree t, args, last;
5175   va_list p;
5176
5177   va_start (p, return_type);
5178
5179   t = va_arg (p, tree);
5180   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree))
5181     args = tree_cons (NULL_TREE, t, args);
5182
5183   if (args == NULL_TREE)
5184     args = void_list_node;
5185   else
5186     {
5187       last = args;
5188       args = nreverse (args);
5189       TREE_CHAIN (last) = void_list_node;
5190     }
5191   args = build_function_type (return_type, args);
5192
5193   va_end (p);
5194   return args;
5195 }
5196
5197 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
5198    and ARGTYPES (a TREE_LIST) are the return type and arguments types
5199    for the method.  An implicit additional parameter (of type
5200    pointer-to-BASETYPE) is added to the ARGTYPES.  */
5201
5202 tree
5203 build_method_type_directly (tree basetype,
5204                             tree rettype,
5205                             tree argtypes)
5206 {
5207   tree t;
5208   tree ptype;
5209   int hashcode = 0;
5210
5211   /* Make a node of the sort we want.  */
5212   t = make_node (METHOD_TYPE);
5213
5214   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
5215   TREE_TYPE (t) = rettype;
5216   ptype = build_pointer_type (basetype);
5217
5218   /* The actual arglist for this function includes a "hidden" argument
5219      which is "this".  Put it into the list of argument types.  */
5220   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
5221   TYPE_ARG_TYPES (t) = argtypes;
5222
5223   /* If we already have such a type, use the old one.  */
5224   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
5225   hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
5226   hashcode = type_hash_list (argtypes, hashcode);
5227   t = type_hash_canon (hashcode, t);
5228
5229   if (!COMPLETE_TYPE_P (t))
5230     layout_type (t);
5231
5232   return t;
5233 }
5234
5235 /* Construct, lay out and return the type of methods belonging to class
5236    BASETYPE and whose arguments and values are described by TYPE.
5237    If that type exists already, reuse it.
5238    TYPE must be a FUNCTION_TYPE node.  */
5239
5240 tree
5241 build_method_type (tree basetype, tree type)
5242 {
5243   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
5244
5245   return build_method_type_directly (basetype,
5246                                      TREE_TYPE (type),
5247                                      TYPE_ARG_TYPES (type));
5248 }
5249
5250 /* Construct, lay out and return the type of offsets to a value
5251    of type TYPE, within an object of type BASETYPE.
5252    If a suitable offset type exists already, reuse it.  */
5253
5254 tree
5255 build_offset_type (tree basetype, tree type)
5256 {
5257   tree t;
5258   hashval_t hashcode = 0;
5259
5260   /* Make a node of the sort we want.  */
5261   t = make_node (OFFSET_TYPE);
5262
5263   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
5264   TREE_TYPE (t) = type;
5265
5266   /* If we already have such a type, use the old one.  */
5267   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
5268   hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
5269   t = type_hash_canon (hashcode, t);
5270
5271   if (!COMPLETE_TYPE_P (t))
5272     layout_type (t);
5273
5274   return t;
5275 }
5276
5277 /* Create a complex type whose components are COMPONENT_TYPE.  */
5278
5279 tree
5280 build_complex_type (tree component_type)
5281 {
5282   tree t;
5283   hashval_t hashcode;
5284
5285   /* Make a node of the sort we want.  */
5286   t = make_node (COMPLEX_TYPE);
5287
5288   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
5289
5290   /* If we already have such a type, use the old one.  */
5291   hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
5292   t = type_hash_canon (hashcode, t);
5293
5294   if (!COMPLETE_TYPE_P (t))
5295     layout_type (t);
5296
5297   /* If we are writing Dwarf2 output we need to create a name,
5298      since complex is a fundamental type.  */
5299   if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
5300       && ! TYPE_NAME (t))
5301     {
5302       const char *name;
5303       if (component_type == char_type_node)
5304         name = "complex char";
5305       else if (component_type == signed_char_type_node)
5306         name = "complex signed char";
5307       else if (component_type == unsigned_char_type_node)
5308         name = "complex unsigned char";
5309       else if (component_type == short_integer_type_node)
5310         name = "complex short int";
5311       else if (component_type == short_unsigned_type_node)
5312         name = "complex short unsigned int";
5313       else if (component_type == integer_type_node)
5314         name = "complex int";
5315       else if (component_type == unsigned_type_node)
5316         name = "complex unsigned int";
5317       else if (component_type == long_integer_type_node)
5318         name = "complex long int";
5319       else if (component_type == long_unsigned_type_node)
5320         name = "complex long unsigned int";
5321       else if (component_type == long_long_integer_type_node)
5322         name = "complex long long int";
5323       else if (component_type == long_long_unsigned_type_node)
5324         name = "complex long long unsigned int";
5325       else
5326         name = 0;
5327
5328       if (name != 0)
5329         TYPE_NAME (t) = get_identifier (name);
5330     }
5331
5332   return build_qualified_type (t, TYPE_QUALS (component_type));
5333 }
5334 \f
5335 /* Return OP, stripped of any conversions to wider types as much as is safe.
5336    Converting the value back to OP's type makes a value equivalent to OP.
5337
5338    If FOR_TYPE is nonzero, we return a value which, if converted to
5339    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
5340
5341    If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
5342    narrowest type that can hold the value, even if they don't exactly fit.
5343    Otherwise, bit-field references are changed to a narrower type
5344    only if they can be fetched directly from memory in that type.
5345
5346    OP must have integer, real or enumeral type.  Pointers are not allowed!
5347
5348    There are some cases where the obvious value we could return
5349    would regenerate to OP if converted to OP's type,
5350    but would not extend like OP to wider types.
5351    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
5352    For example, if OP is (unsigned short)(signed char)-1,
5353    we avoid returning (signed char)-1 if FOR_TYPE is int,
5354    even though extending that to an unsigned short would regenerate OP,
5355    since the result of extending (signed char)-1 to (int)
5356    is different from (int) OP.  */
5357
5358 tree
5359 get_unwidened (tree op, tree for_type)
5360 {
5361   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
5362   tree type = TREE_TYPE (op);
5363   unsigned final_prec
5364     = TYPE_PRECISION (for_type != 0 ? for_type : type);
5365   int uns
5366     = (for_type != 0 && for_type != type
5367        && final_prec > TYPE_PRECISION (type)
5368        && TYPE_UNSIGNED (type));
5369   tree win = op;
5370
5371   while (TREE_CODE (op) == NOP_EXPR
5372          || TREE_CODE (op) == CONVERT_EXPR)
5373     {
5374       int bitschange;
5375
5376       /* TYPE_PRECISION on vector types has different meaning
5377          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
5378          so avoid them here.  */
5379       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
5380         break;
5381
5382       bitschange = TYPE_PRECISION (TREE_TYPE (op))
5383                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
5384
5385       /* Truncations are many-one so cannot be removed.
5386          Unless we are later going to truncate down even farther.  */
5387       if (bitschange < 0
5388           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
5389         break;
5390
5391       /* See what's inside this conversion.  If we decide to strip it,
5392          we will set WIN.  */
5393       op = TREE_OPERAND (op, 0);
5394
5395       /* If we have not stripped any zero-extensions (uns is 0),
5396          we can strip any kind of extension.
5397          If we have previously stripped a zero-extension,
5398          only zero-extensions can safely be stripped.
5399          Any extension can be stripped if the bits it would produce
5400          are all going to be discarded later by truncating to FOR_TYPE.  */
5401
5402       if (bitschange > 0)
5403         {
5404           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
5405             win = op;
5406           /* TYPE_UNSIGNED says whether this is a zero-extension.
5407              Let's avoid computing it if it does not affect WIN
5408              and if UNS will not be needed again.  */
5409           if ((uns
5410                || TREE_CODE (op) == NOP_EXPR
5411                || TREE_CODE (op) == CONVERT_EXPR)
5412               && TYPE_UNSIGNED (TREE_TYPE (op)))
5413             {
5414               uns = 1;
5415               win = op;
5416             }
5417         }
5418     }
5419
5420   if (TREE_CODE (op) == COMPONENT_REF
5421       /* Since type_for_size always gives an integer type.  */
5422       && TREE_CODE (type) != REAL_TYPE
5423       /* Don't crash if field not laid out yet.  */
5424       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
5425       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
5426     {
5427       unsigned int innerprec
5428         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
5429       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
5430                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
5431       type = lang_hooks.types.type_for_size (innerprec, unsignedp);
5432
5433       /* We can get this structure field in the narrowest type it fits in.
5434          If FOR_TYPE is 0, do this only for a field that matches the
5435          narrower type exactly and is aligned for it
5436          The resulting extension to its nominal type (a fullword type)
5437          must fit the same conditions as for other extensions.  */
5438
5439       if (type != 0
5440           && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (op)))
5441           && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
5442           && (! uns || final_prec <= innerprec || unsignedp))
5443         {
5444           win = build3 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
5445                         TREE_OPERAND (op, 1), NULL_TREE);
5446           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
5447           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
5448         }
5449     }
5450
5451   return win;
5452 }
5453 \f
5454 /* Return OP or a simpler expression for a narrower value
5455    which can be sign-extended or zero-extended to give back OP.
5456    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
5457    or 0 if the value should be sign-extended.  */
5458
5459 tree
5460 get_narrower (tree op, int *unsignedp_ptr)
5461 {
5462   int uns = 0;
5463   int first = 1;
5464   tree win = op;
5465   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
5466
5467   while (TREE_CODE (op) == NOP_EXPR)
5468     {
5469       int bitschange
5470         = (TYPE_PRECISION (TREE_TYPE (op))
5471            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
5472
5473       /* Truncations are many-one so cannot be removed.  */
5474       if (bitschange < 0)
5475         break;
5476
5477       /* See what's inside this conversion.  If we decide to strip it,
5478          we will set WIN.  */
5479
5480       if (bitschange > 0)
5481         {
5482           op = TREE_OPERAND (op, 0);
5483           /* An extension: the outermost one can be stripped,
5484              but remember whether it is zero or sign extension.  */
5485           if (first)
5486             uns = TYPE_UNSIGNED (TREE_TYPE (op));
5487           /* Otherwise, if a sign extension has been stripped,
5488              only sign extensions can now be stripped;
5489              if a zero extension has been stripped, only zero-extensions.  */
5490           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
5491             break;
5492           first = 0;
5493         }
5494       else /* bitschange == 0 */
5495         {
5496           /* A change in nominal type can always be stripped, but we must
5497              preserve the unsignedness.  */
5498           if (first)
5499             uns = TYPE_UNSIGNED (TREE_TYPE (op));
5500           first = 0;
5501           op = TREE_OPERAND (op, 0);
5502           /* Keep trying to narrow, but don't assign op to win if it
5503              would turn an integral type into something else.  */
5504           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
5505             continue;
5506         }
5507
5508       win = op;
5509     }
5510
5511   if (TREE_CODE (op) == COMPONENT_REF
5512       /* Since type_for_size always gives an integer type.  */
5513       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
5514       /* Ensure field is laid out already.  */
5515       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
5516       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
5517     {
5518       unsigned HOST_WIDE_INT innerprec
5519         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
5520       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
5521                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
5522       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
5523
5524       /* We can get this structure field in a narrower type that fits it,
5525          but the resulting extension to its nominal type (a fullword type)
5526          must satisfy the same conditions as for other extensions.
5527
5528          Do this only for fields that are aligned (not bit-fields),
5529          because when bit-field insns will be used there is no
5530          advantage in doing this.  */
5531
5532       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
5533           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
5534           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
5535           && type != 0)
5536         {
5537           if (first)
5538             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
5539           win = build3 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
5540                         TREE_OPERAND (op, 1), NULL_TREE);
5541           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
5542           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
5543         }
5544     }
5545   *unsignedp_ptr = uns;
5546   return win;
5547 }
5548 \f
5549 /* Nonzero if integer constant C has a value that is permissible
5550    for type TYPE (an INTEGER_TYPE).  */
5551
5552 int
5553 int_fits_type_p (tree c, tree type)
5554 {
5555   tree type_low_bound = TYPE_MIN_VALUE (type);
5556   tree type_high_bound = TYPE_MAX_VALUE (type);
5557   bool ok_for_low_bound, ok_for_high_bound;
5558   tree tmp;
5559
5560   /* If at least one bound of the type is a constant integer, we can check
5561      ourselves and maybe make a decision. If no such decision is possible, but
5562      this type is a subtype, try checking against that.  Otherwise, use
5563      force_fit_type, which checks against the precision.
5564
5565      Compute the status for each possibly constant bound, and return if we see
5566      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
5567      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
5568      for "constant known to fit".  */
5569
5570   /* Check if C >= type_low_bound.  */
5571   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
5572     {
5573       if (tree_int_cst_lt (c, type_low_bound))
5574         return 0;
5575       ok_for_low_bound = true;
5576     }
5577   else
5578     ok_for_low_bound = false;
5579
5580   /* Check if c <= type_high_bound.  */
5581   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
5582     {
5583       if (tree_int_cst_lt (type_high_bound, c))
5584         return 0;
5585       ok_for_high_bound = true;
5586     }
5587   else
5588     ok_for_high_bound = false;
5589
5590   /* If the constant fits both bounds, the result is known.  */
5591   if (ok_for_low_bound && ok_for_high_bound)
5592     return 1;
5593
5594   /* Perform some generic filtering which may allow making a decision
5595      even if the bounds are not constant.  First, negative integers
5596      never fit in unsigned types, */
5597   if (TYPE_UNSIGNED (type) && tree_int_cst_sgn (c) < 0)
5598     return 0;
5599
5600   /* Second, narrower types always fit in wider ones.  */
5601   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
5602     return 1;
5603
5604   /* Third, unsigned integers with top bit set never fit signed types.  */
5605   if (! TYPE_UNSIGNED (type)
5606       && TYPE_UNSIGNED (TREE_TYPE (c))
5607       && tree_int_cst_msb (c))
5608     return 0;
5609
5610   /* If we haven't been able to decide at this point, there nothing more we
5611      can check ourselves here.  Look at the base type if we have one and it
5612      has the same precision.  */
5613   if (TREE_CODE (type) == INTEGER_TYPE
5614       && TREE_TYPE (type) != 0
5615       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
5616     return int_fits_type_p (c, TREE_TYPE (type));
5617
5618   /* Or to force_fit_type, if nothing else.  */
5619   tmp = copy_node (c);
5620   TREE_TYPE (tmp) = type;
5621   tmp = force_fit_type (tmp, -1, false, false);
5622   return TREE_INT_CST_HIGH (tmp) == TREE_INT_CST_HIGH (c)
5623          && TREE_INT_CST_LOW (tmp) == TREE_INT_CST_LOW (c);
5624 }
5625
5626 /* Subprogram of following function.  Called by walk_tree.
5627
5628    Return *TP if it is an automatic variable or parameter of the
5629    function passed in as DATA.  */
5630
5631 static tree
5632 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
5633 {
5634   tree fn = (tree) data;
5635
5636   if (TYPE_P (*tp))
5637     *walk_subtrees = 0;
5638
5639   else if (DECL_P (*tp)
5640            && lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
5641     return *tp;
5642
5643   return NULL_TREE;
5644 }
5645
5646 /* Returns true if T is, contains, or refers to a type with variable
5647    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
5648    arguments, but not the return type.  If FN is nonzero, only return
5649    true if a modifier of the type or position of FN is a variable or
5650    parameter inside FN.
5651
5652    This concept is more general than that of C99 'variably modified types':
5653    in C99, a struct type is never variably modified because a VLA may not
5654    appear as a structure member.  However, in GNU C code like:
5655
5656      struct S { int i[f()]; };
5657
5658    is valid, and other languages may define similar constructs.  */
5659
5660 bool
5661 variably_modified_type_p (tree type, tree fn)
5662 {
5663   tree t;
5664
5665 /* Test if T is either variable (if FN is zero) or an expression containing
5666    a variable in FN.  */
5667 #define RETURN_TRUE_IF_VAR(T)                                           \
5668   do { tree _t = (T);                                                   \
5669     if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
5670         && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
5671       return true;  } while (0)
5672
5673   if (type == error_mark_node)
5674     return false;
5675
5676   /* If TYPE itself has variable size, it is variably modified.  */
5677   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
5678   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
5679
5680   switch (TREE_CODE (type))
5681     {
5682     case POINTER_TYPE:
5683     case REFERENCE_TYPE:
5684     case VECTOR_TYPE:
5685       if (variably_modified_type_p (TREE_TYPE (type), fn))
5686         return true;
5687       break;
5688
5689     case FUNCTION_TYPE:
5690     case METHOD_TYPE:
5691       /* If TYPE is a function type, it is variably modified if the
5692          return type is variably modified.  */
5693       if (variably_modified_type_p (TREE_TYPE (type), fn))
5694           return true;
5695       break;
5696
5697     case INTEGER_TYPE:
5698     case REAL_TYPE:
5699     case ENUMERAL_TYPE:
5700     case BOOLEAN_TYPE:
5701       /* Scalar types are variably modified if their end points
5702          aren't constant.  */
5703       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
5704       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
5705       break;
5706
5707     case RECORD_TYPE:
5708     case UNION_TYPE:
5709     case QUAL_UNION_TYPE:
5710       /* We can't see if any of the fields are variably-modified by the
5711          definition we normally use, since that would produce infinite
5712          recursion via pointers.  */
5713       /* This is variably modified if some field's type is.  */
5714       for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
5715         if (TREE_CODE (t) == FIELD_DECL)
5716           {
5717             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
5718             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
5719             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
5720
5721             if (TREE_CODE (type) == QUAL_UNION_TYPE)
5722               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
5723           }
5724         break;
5725
5726     case ARRAY_TYPE:
5727       /* Do not call ourselves to avoid infinite recursion.  This is
5728          variably modified if the element type is.  */
5729       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
5730       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
5731       break;
5732
5733     default:
5734       break;
5735     }
5736
5737   /* The current language may have other cases to check, but in general,
5738      all other types are not variably modified.  */
5739   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
5740
5741 #undef RETURN_TRUE_IF_VAR
5742 }
5743
5744 /* Given a DECL or TYPE, return the scope in which it was declared, or
5745    NULL_TREE if there is no containing scope.  */
5746
5747 tree
5748 get_containing_scope (tree t)
5749 {
5750   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
5751 }
5752
5753 /* Return the innermost context enclosing DECL that is
5754    a FUNCTION_DECL, or zero if none.  */
5755
5756 tree
5757 decl_function_context (tree decl)
5758 {
5759   tree context;
5760
5761   if (TREE_CODE (decl) == ERROR_MARK)
5762     return 0;
5763
5764   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
5765      where we look up the function at runtime.  Such functions always take
5766      a first argument of type 'pointer to real context'.
5767
5768      C++ should really be fixed to use DECL_CONTEXT for the real context,
5769      and use something else for the "virtual context".  */
5770   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
5771     context
5772       = TYPE_MAIN_VARIANT
5773         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
5774   else
5775     context = DECL_CONTEXT (decl);
5776
5777   while (context && TREE_CODE (context) != FUNCTION_DECL)
5778     {
5779       if (TREE_CODE (context) == BLOCK)
5780         context = BLOCK_SUPERCONTEXT (context);
5781       else
5782         context = get_containing_scope (context);
5783     }
5784
5785   return context;
5786 }
5787
5788 /* Return the innermost context enclosing DECL that is
5789    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
5790    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
5791
5792 tree
5793 decl_type_context (tree decl)
5794 {
5795   tree context = DECL_CONTEXT (decl);
5796
5797   while (context)
5798     switch (TREE_CODE (context))
5799       {
5800       case NAMESPACE_DECL:
5801       case TRANSLATION_UNIT_DECL:
5802         return NULL_TREE;
5803
5804       case RECORD_TYPE:
5805       case UNION_TYPE:
5806       case QUAL_UNION_TYPE:
5807         return context;
5808
5809       case TYPE_DECL:
5810       case FUNCTION_DECL:
5811         context = DECL_CONTEXT (context);
5812         break;
5813
5814       case BLOCK:
5815         context = BLOCK_SUPERCONTEXT (context);
5816         break;
5817
5818       default:
5819         gcc_unreachable ();
5820       }
5821
5822   return NULL_TREE;
5823 }
5824
5825 /* CALL is a CALL_EXPR.  Return the declaration for the function
5826    called, or NULL_TREE if the called function cannot be
5827    determined.  */
5828
5829 tree
5830 get_callee_fndecl (tree call)
5831 {
5832   tree addr;
5833
5834   if (call == error_mark_node)
5835     return call;
5836
5837   /* It's invalid to call this function with anything but a
5838      CALL_EXPR.  */
5839   gcc_assert (TREE_CODE (call) == CALL_EXPR);
5840
5841   /* The first operand to the CALL is the address of the function
5842      called.  */
5843   addr = TREE_OPERAND (call, 0);
5844
5845   STRIP_NOPS (addr);
5846
5847   /* If this is a readonly function pointer, extract its initial value.  */
5848   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
5849       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
5850       && DECL_INITIAL (addr))
5851     addr = DECL_INITIAL (addr);
5852
5853   /* If the address is just `&f' for some function `f', then we know
5854      that `f' is being called.  */
5855   if (TREE_CODE (addr) == ADDR_EXPR
5856       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
5857     return TREE_OPERAND (addr, 0);
5858
5859   /* We couldn't figure out what was being called.  Maybe the front
5860      end has some idea.  */
5861   return lang_hooks.lang_get_callee_fndecl (call);
5862 }
5863
5864 /* Print debugging information about tree nodes generated during the compile,
5865    and any language-specific information.  */
5866
5867 void
5868 dump_tree_statistics (void)
5869 {
5870 #ifdef GATHER_STATISTICS
5871   int i;
5872   int total_nodes, total_bytes;
5873 #endif
5874
5875   fprintf (stderr, "\n??? tree nodes created\n\n");
5876 #ifdef GATHER_STATISTICS
5877   fprintf (stderr, "Kind                   Nodes      Bytes\n");
5878   fprintf (stderr, "---------------------------------------\n");
5879   total_nodes = total_bytes = 0;
5880   for (i = 0; i < (int) all_kinds; i++)
5881     {
5882       fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
5883                tree_node_counts[i], tree_node_sizes[i]);
5884       total_nodes += tree_node_counts[i];
5885       total_bytes += tree_node_sizes[i];
5886     }
5887   fprintf (stderr, "---------------------------------------\n");
5888   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
5889   fprintf (stderr, "---------------------------------------\n");
5890   ssanames_print_statistics ();
5891   phinodes_print_statistics ();
5892 #else
5893   fprintf (stderr, "(No per-node statistics)\n");
5894 #endif
5895   print_type_hash_statistics ();
5896   print_debug_expr_statistics ();
5897   print_value_expr_statistics ();
5898   print_restrict_base_statistics ();
5899   lang_hooks.print_statistics ();
5900 }
5901 \f
5902 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
5903
5904 /* Generate a crc32 of a string.  */
5905
5906 unsigned
5907 crc32_string (unsigned chksum, const char *string)
5908 {
5909   do
5910     {
5911       unsigned value = *string << 24;
5912       unsigned ix;
5913
5914       for (ix = 8; ix--; value <<= 1)
5915         {
5916           unsigned feedback;
5917
5918           feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
5919           chksum <<= 1;
5920           chksum ^= feedback;
5921         }
5922     }
5923   while (*string++);
5924   return chksum;
5925 }
5926
5927 /* P is a string that will be used in a symbol.  Mask out any characters
5928    that are not valid in that context.  */
5929
5930 void
5931 clean_symbol_name (char *p)
5932 {
5933   for (; *p; p++)
5934     if (! (ISALNUM (*p)
5935 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
5936             || *p == '$'
5937 #endif
5938 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
5939             || *p == '.'
5940 #endif
5941            ))
5942       *p = '_';
5943 }
5944
5945 /* Generate a name for a function unique to this translation unit.
5946    TYPE is some string to identify the purpose of this function to the
5947    linker or collect2.  */
5948
5949 tree
5950 get_file_function_name_long (const char *type)
5951 {
5952   char *buf;
5953   const char *p;
5954   char *q;
5955
5956   if (first_global_object_name)
5957     {
5958       p = first_global_object_name;
5959
5960       /* For type 'F', the generated name must be unique not only to this
5961          translation unit but also to any given link.  Since global names
5962          can be overloaded, we concatenate the first global object name
5963          with a string derived from the file name of this object.  */
5964       if (!strcmp (type, "F"))
5965         {
5966           const char *file = main_input_filename;
5967
5968           if (! file)
5969             file = input_filename;
5970
5971           q = alloca (strlen (p) + 10);
5972           sprintf (q, "%s_%08X", p, crc32_string (0, file));
5973
5974           p = q;
5975         }
5976     }
5977   else
5978     {
5979       /* We don't have anything that we know to be unique to this translation
5980          unit, so use what we do have and throw in some randomness.  */
5981       unsigned len;
5982       const char *name = weak_global_object_name;
5983       const char *file = main_input_filename;
5984
5985       if (! name)
5986         name = "";
5987       if (! file)
5988         file = input_filename;
5989
5990       len = strlen (file);
5991       q = alloca (9 * 2 + len + 1);
5992       memcpy (q, file, len + 1);
5993       clean_symbol_name (q);
5994
5995       sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
5996                crc32_string (0, flag_random_seed));
5997
5998       p = q;
5999     }
6000
6001   buf = alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) + strlen (type));
6002
6003   /* Set up the name of the file-level functions we may need.
6004      Use a global object (which is already required to be unique over
6005      the program) rather than the file name (which imposes extra
6006      constraints).  */
6007   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
6008
6009   return get_identifier (buf);
6010 }
6011
6012 /* If KIND=='I', return a suitable global initializer (constructor) name.
6013    If KIND=='D', return a suitable global clean-up (destructor) name.  */
6014
6015 tree
6016 get_file_function_name (int kind)
6017 {
6018   char p[2];
6019
6020   p[0] = kind;
6021   p[1] = 0;
6022
6023   return get_file_function_name_long (p);
6024 }
6025 \f
6026 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
6027
6028 /* Complain that the tree code of NODE does not match the expected 0
6029    terminated list of trailing codes. The trailing code list can be
6030    empty, for a more vague error message.  FILE, LINE, and FUNCTION
6031    are of the caller.  */
6032
6033 void
6034 tree_check_failed (const tree node, const char *file,
6035                    int line, const char *function, ...)
6036 {
6037   va_list args;
6038   char *buffer;
6039   unsigned length = 0;
6040   int code;
6041
6042   va_start (args, function);
6043   while ((code = va_arg (args, int)))
6044     length += 4 + strlen (tree_code_name[code]);
6045   va_end (args);
6046   if (length)
6047     {
6048       va_start (args, function);
6049       length += strlen ("expected ");
6050       buffer = alloca (length);
6051       length = 0;
6052       while ((code = va_arg (args, int)))
6053         {
6054           const char *prefix = length ? " or " : "expected ";
6055
6056           strcpy (buffer + length, prefix);
6057           length += strlen (prefix);
6058           strcpy (buffer + length, tree_code_name[code]);
6059           length += strlen (tree_code_name[code]);
6060         }
6061       va_end (args);
6062     }
6063   else
6064     buffer = (char *)"unexpected node";
6065
6066   internal_error ("tree check: %s, have %s in %s, at %s:%d",
6067                   buffer, tree_code_name[TREE_CODE (node)],
6068                   function, trim_filename (file), line);
6069 }
6070
6071 /* Complain that the tree code of NODE does match the expected 0
6072    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
6073    the caller.  */
6074
6075 void
6076 tree_not_check_failed (const tree node, const char *file,
6077                        int line, const char *function, ...)
6078 {
6079   va_list args;
6080   char *buffer;
6081   unsigned length = 0;
6082   int code;
6083
6084   va_start (args, function);
6085   while ((code = va_arg (args, int)))
6086     length += 4 + strlen (tree_code_name[code]);
6087   va_end (args);
6088   va_start (args, function);
6089   buffer = alloca (length);
6090   length = 0;
6091   while ((code = va_arg (args, int)))
6092     {
6093       if (length)
6094         {
6095           strcpy (buffer + length, " or ");
6096           length += 4;
6097         }
6098       strcpy (buffer + length, tree_code_name[code]);
6099       length += strlen (tree_code_name[code]);
6100     }
6101   va_end (args);
6102
6103   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
6104                   buffer, tree_code_name[TREE_CODE (node)],
6105                   function, trim_filename (file), line);
6106 }
6107
6108 /* Similar to tree_check_failed, except that we check for a class of tree
6109    code, given in CL.  */
6110
6111 void
6112 tree_class_check_failed (const tree node, const enum tree_code_class cl,
6113                          const char *file, int line, const char *function)
6114 {
6115   internal_error
6116     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
6117      TREE_CODE_CLASS_STRING (cl),
6118      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
6119      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
6120 }
6121
6122 /* Similar to tree_check_failed, except that instead of specifying a
6123    dozen codes, use the knowledge that they're all sequential.  */
6124
6125 void
6126 tree_range_check_failed (const tree node, const char *file, int line,
6127                          const char *function, enum tree_code c1,
6128                          enum tree_code c2)
6129 {
6130   char *buffer;
6131   unsigned length = 0;
6132   enum tree_code c;
6133
6134   for (c = c1; c <= c2; ++c)
6135     length += 4 + strlen (tree_code_name[c]);
6136
6137   length += strlen ("expected ");
6138   buffer = alloca (length);
6139   length = 0;
6140
6141   for (c = c1; c <= c2; ++c)
6142     {
6143       const char *prefix = length ? " or " : "expected ";
6144
6145       strcpy (buffer + length, prefix);
6146       length += strlen (prefix);
6147       strcpy (buffer + length, tree_code_name[c]);
6148       length += strlen (tree_code_name[c]);
6149     }
6150
6151   internal_error ("tree check: %s, have %s in %s, at %s:%d",
6152                   buffer, tree_code_name[TREE_CODE (node)],
6153                   function, trim_filename (file), line);
6154 }
6155
6156
6157 /* Similar to tree_check_failed, except that we check that a tree does
6158    not have the specified code, given in CL.  */
6159
6160 void
6161 tree_not_class_check_failed (const tree node, const enum tree_code_class cl,
6162                              const char *file, int line, const char *function)
6163 {
6164   internal_error
6165     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
6166      TREE_CODE_CLASS_STRING (cl),
6167      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
6168      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
6169 }
6170
6171
6172 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
6173
6174 void
6175 omp_clause_check_failed (const tree node, const char *file, int line,
6176                          const char *function, enum omp_clause_code code)
6177 {
6178   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
6179                   omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
6180                   function, trim_filename (file), line);
6181 }
6182
6183
6184 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
6185
6186 void
6187 omp_clause_range_check_failed (const tree node, const char *file, int line,
6188                                const char *function, enum omp_clause_code c1,
6189                                enum omp_clause_code c2)
6190 {
6191   char *buffer;
6192   unsigned length = 0;
6193   enum omp_clause_code c;
6194
6195   for (c = c1; c <= c2; ++c)
6196     length += 4 + strlen (omp_clause_code_name[c]);
6197
6198   length += strlen ("expected ");
6199   buffer = alloca (length);
6200   length = 0;
6201
6202   for (c = c1; c <= c2; ++c)
6203     {
6204       const char *prefix = length ? " or " : "expected ";
6205
6206       strcpy (buffer + length, prefix);
6207       length += strlen (prefix);
6208       strcpy (buffer + length, omp_clause_code_name[c]);
6209       length += strlen (omp_clause_code_name[c]);
6210     }
6211
6212   internal_error ("tree check: %s, have %s in %s, at %s:%d",
6213                   buffer, omp_clause_code_name[TREE_CODE (node)],
6214                   function, trim_filename (file), line);
6215 }
6216
6217
6218 #undef DEFTREESTRUCT
6219 #define DEFTREESTRUCT(VAL, NAME) NAME,
6220
6221 static const char *ts_enum_names[] = {
6222 #include "treestruct.def"
6223 };
6224 #undef DEFTREESTRUCT
6225
6226 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
6227
6228 /* Similar to tree_class_check_failed, except that we check for
6229    whether CODE contains the tree structure identified by EN.  */
6230
6231 void
6232 tree_contains_struct_check_failed (const tree node,
6233                                    const enum tree_node_structure_enum en,
6234                                    const char *file, int line,
6235                                    const char *function)
6236 {
6237   internal_error
6238     ("tree check: expected tree that contains %qs structure, have %qs  in %s, at %s:%d",
6239      TS_ENUM_NAME(en),
6240      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
6241 }
6242
6243
6244 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
6245    (dynamically sized) vector.  */
6246
6247 void
6248 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
6249                            const char *function)
6250 {
6251   internal_error
6252     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
6253      idx + 1, len, function, trim_filename (file), line);
6254 }
6255
6256 /* Similar to above, except that the check is for the bounds of a PHI_NODE's
6257    (dynamically sized) vector.  */
6258
6259 void
6260 phi_node_elt_check_failed (int idx, int len, const char *file, int line,
6261                             const char *function)
6262 {
6263   internal_error
6264     ("tree check: accessed elt %d of phi_node with %d elts in %s, at %s:%d",
6265      idx + 1, len, function, trim_filename (file), line);
6266 }
6267
6268 /* Similar to above, except that the check is for the bounds of the operand
6269    vector of an expression node.  */
6270
6271 void
6272 tree_operand_check_failed (int idx, enum tree_code code, const char *file,
6273                            int line, const char *function)
6274 {
6275   internal_error
6276     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
6277      idx + 1, tree_code_name[code], TREE_CODE_LENGTH (code),
6278      function, trim_filename (file), line);
6279 }
6280
6281 /* Similar to above, except that the check is for the number of
6282    operands of an OMP_CLAUSE node.  */
6283
6284 void
6285 omp_clause_operand_check_failed (int idx, tree t, const char *file,
6286                                  int line, const char *function)
6287 {
6288   internal_error
6289     ("tree check: accessed operand %d of omp_clause %s with %d operands "
6290      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
6291      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
6292      trim_filename (file), line);
6293 }
6294 #endif /* ENABLE_TREE_CHECKING */
6295 \f
6296 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
6297    and mapped to the machine mode MODE.  Initialize its fields and build
6298    the information necessary for debugging output.  */
6299
6300 static tree
6301 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
6302 {
6303   tree t = make_node (VECTOR_TYPE);
6304
6305   TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
6306   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
6307   TYPE_MODE (t) = mode;
6308   TYPE_READONLY (t) = TYPE_READONLY (innertype);
6309   TYPE_VOLATILE (t) = TYPE_VOLATILE (innertype);
6310
6311   layout_type (t);
6312
6313   {
6314     tree index = build_int_cst (NULL_TREE, nunits - 1);
6315     tree array = build_array_type (innertype, build_index_type (index));
6316     tree rt = make_node (RECORD_TYPE);
6317
6318     TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
6319     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
6320     layout_type (rt);
6321     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
6322     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
6323        the representation type, and we want to find that die when looking up
6324        the vector type.  This is most easily achieved by making the TYPE_UID
6325        numbers equal.  */
6326     TYPE_UID (rt) = TYPE_UID (t);
6327   }
6328
6329   /* Build our main variant, based on the main variant of the inner type.  */
6330   if (TYPE_MAIN_VARIANT (innertype) != innertype)
6331     {
6332       tree innertype_main_variant = TYPE_MAIN_VARIANT (innertype);
6333       unsigned int hash = TYPE_HASH (innertype_main_variant);
6334       TYPE_MAIN_VARIANT (t)
6335         = type_hash_canon (hash, make_vector_type (innertype_main_variant,
6336                                                    nunits, mode));
6337     }
6338
6339   return t;
6340 }
6341
6342 static tree
6343 make_or_reuse_type (unsigned size, int unsignedp)
6344 {
6345   if (size == INT_TYPE_SIZE)
6346     return unsignedp ? unsigned_type_node : integer_type_node;
6347   if (size == CHAR_TYPE_SIZE)
6348     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
6349   if (size == SHORT_TYPE_SIZE)
6350     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
6351   if (size == LONG_TYPE_SIZE)
6352     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
6353   if (size == LONG_LONG_TYPE_SIZE)
6354     return (unsignedp ? long_long_unsigned_type_node
6355             : long_long_integer_type_node);
6356
6357   if (unsignedp)
6358     return make_unsigned_type (size);
6359   else
6360     return make_signed_type (size);
6361 }
6362
6363 /* Create nodes for all integer types (and error_mark_node) using the sizes
6364    of C datatypes.  The caller should call set_sizetype soon after calling
6365    this function to select one of the types as sizetype.  */
6366
6367 void
6368 build_common_tree_nodes (bool signed_char, bool signed_sizetype)
6369 {
6370   error_mark_node = make_node (ERROR_MARK);
6371   TREE_TYPE (error_mark_node) = error_mark_node;
6372
6373   initialize_sizetypes (signed_sizetype);
6374
6375   /* Define both `signed char' and `unsigned char'.  */
6376   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
6377   TYPE_STRING_FLAG (signed_char_type_node) = 1;
6378   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
6379   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
6380
6381   /* Define `char', which is like either `signed char' or `unsigned char'
6382      but not the same as either.  */
6383   char_type_node
6384     = (signed_char
6385        ? make_signed_type (CHAR_TYPE_SIZE)
6386        : make_unsigned_type (CHAR_TYPE_SIZE));
6387   TYPE_STRING_FLAG (char_type_node) = 1;
6388
6389   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
6390   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
6391   integer_type_node = make_signed_type (INT_TYPE_SIZE);
6392   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
6393   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
6394   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
6395   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
6396   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
6397
6398   /* Define a boolean type.  This type only represents boolean values but
6399      may be larger than char depending on the value of BOOL_TYPE_SIZE.
6400      Front ends which want to override this size (i.e. Java) can redefine
6401      boolean_type_node before calling build_common_tree_nodes_2.  */
6402   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6403   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6404   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
6405   TYPE_PRECISION (boolean_type_node) = 1;
6406
6407   /* Fill in the rest of the sized types.  Reuse existing type nodes
6408      when possible.  */
6409   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
6410   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
6411   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
6412   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
6413   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
6414
6415   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
6416   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
6417   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
6418   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
6419   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
6420
6421   access_public_node = get_identifier ("public");
6422   access_protected_node = get_identifier ("protected");
6423   access_private_node = get_identifier ("private");
6424 }
6425
6426 /* Call this function after calling build_common_tree_nodes and set_sizetype.
6427    It will create several other common tree nodes.  */
6428
6429 void
6430 build_common_tree_nodes_2 (int short_double)
6431 {
6432   /* Define these next since types below may used them.  */
6433   integer_zero_node = build_int_cst (NULL_TREE, 0);
6434   integer_one_node = build_int_cst (NULL_TREE, 1);
6435   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
6436
6437   size_zero_node = size_int (0);
6438   size_one_node = size_int (1);
6439   bitsize_zero_node = bitsize_int (0);
6440   bitsize_one_node = bitsize_int (1);
6441   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
6442
6443   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
6444   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
6445
6446   void_type_node = make_node (VOID_TYPE);
6447   layout_type (void_type_node);
6448
6449   /* We are not going to have real types in C with less than byte alignment,
6450      so we might as well not have any types that claim to have it.  */
6451   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
6452   TYPE_USER_ALIGN (void_type_node) = 0;
6453
6454   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
6455   layout_type (TREE_TYPE (null_pointer_node));
6456
6457   ptr_type_node = build_pointer_type (void_type_node);
6458   const_ptr_type_node
6459     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
6460   fileptr_type_node = ptr_type_node;
6461
6462   float_type_node = make_node (REAL_TYPE);
6463   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
6464   layout_type (float_type_node);
6465
6466   double_type_node = make_node (REAL_TYPE);
6467   if (short_double)
6468     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
6469   else
6470     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
6471   layout_type (double_type_node);
6472
6473   long_double_type_node = make_node (REAL_TYPE);
6474   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
6475   layout_type (long_double_type_node);
6476
6477   float_ptr_type_node = build_pointer_type (float_type_node);
6478   double_ptr_type_node = build_pointer_type (double_type_node);
6479   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
6480   integer_ptr_type_node = build_pointer_type (integer_type_node);
6481
6482   /* Decimal float types. */
6483   dfloat32_type_node = make_node (REAL_TYPE);
6484   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
6485   layout_type (dfloat32_type_node);
6486   TYPE_MODE (dfloat32_type_node) = SDmode;
6487   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
6488
6489   dfloat64_type_node = make_node (REAL_TYPE);
6490   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
6491   layout_type (dfloat64_type_node);
6492   TYPE_MODE (dfloat64_type_node) = DDmode;
6493   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
6494
6495   dfloat128_type_node = make_node (REAL_TYPE);
6496   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
6497   layout_type (dfloat128_type_node);
6498   TYPE_MODE (dfloat128_type_node) = TDmode;
6499   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
6500
6501   complex_integer_type_node = make_node (COMPLEX_TYPE);
6502   TREE_TYPE (complex_integer_type_node) = integer_type_node;
6503   layout_type (complex_integer_type_node);
6504
6505   complex_float_type_node = make_node (COMPLEX_TYPE);
6506   TREE_TYPE (complex_float_type_node) = float_type_node;
6507   layout_type (complex_float_type_node);
6508
6509   complex_double_type_node = make_node (COMPLEX_TYPE);
6510   TREE_TYPE (complex_double_type_node) = double_type_node;
6511   layout_type (complex_double_type_node);
6512
6513   complex_long_double_type_node = make_node (COMPLEX_TYPE);
6514   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
6515   layout_type (complex_long_double_type_node);
6516
6517   {
6518     tree t = targetm.build_builtin_va_list ();
6519
6520     /* Many back-ends define record types without setting TYPE_NAME.
6521        If we copied the record type here, we'd keep the original
6522        record type without a name.  This breaks name mangling.  So,
6523        don't copy record types and let c_common_nodes_and_builtins()
6524        declare the type to be __builtin_va_list.  */
6525     if (TREE_CODE (t) != RECORD_TYPE)
6526       t = build_variant_type_copy (t);
6527
6528     va_list_type_node = t;
6529   }
6530 }
6531
6532 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
6533
6534 static void
6535 local_define_builtin (const char *name, tree type, enum built_in_function code,
6536                       const char *library_name, int ecf_flags)
6537 {
6538   tree decl;
6539
6540   decl = lang_hooks.builtin_function (name, type, code, BUILT_IN_NORMAL,
6541                                       library_name, NULL_TREE);
6542   if (ecf_flags & ECF_CONST)
6543     TREE_READONLY (decl) = 1;
6544   if (ecf_flags & ECF_PURE)
6545     DECL_IS_PURE (decl) = 1;
6546   if (ecf_flags & ECF_NORETURN)
6547     TREE_THIS_VOLATILE (decl) = 1;
6548   if (ecf_flags & ECF_NOTHROW)
6549     TREE_NOTHROW (decl) = 1;
6550   if (ecf_flags & ECF_MALLOC)
6551     DECL_IS_MALLOC (decl) = 1;
6552
6553   built_in_decls[code] = decl;
6554   implicit_built_in_decls[code] = decl;
6555 }
6556
6557 /* Call this function after instantiating all builtins that the language
6558    front end cares about.  This will build the rest of the builtins that
6559    are relied upon by the tree optimizers and the middle-end.  */
6560
6561 void
6562 build_common_builtin_nodes (void)
6563 {
6564   tree tmp, ftype;
6565
6566   if (built_in_decls[BUILT_IN_MEMCPY] == NULL
6567       || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
6568     {
6569       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
6570       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
6571       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
6572       ftype = build_function_type (ptr_type_node, tmp);
6573
6574       if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
6575         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
6576                               "memcpy", ECF_NOTHROW);
6577       if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
6578         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
6579                               "memmove", ECF_NOTHROW);
6580     }
6581
6582   if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
6583     {
6584       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
6585       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
6586       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
6587       ftype = build_function_type (integer_type_node, tmp);
6588       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
6589                             "memcmp", ECF_PURE | ECF_NOTHROW);
6590     }
6591
6592   if (built_in_decls[BUILT_IN_MEMSET] == NULL)
6593     {
6594       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
6595       tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
6596       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
6597       ftype = build_function_type (ptr_type_node, tmp);
6598       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
6599                             "memset", ECF_NOTHROW);
6600     }
6601
6602   if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
6603     {
6604       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
6605       ftype = build_function_type (ptr_type_node, tmp);
6606       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
6607                             "alloca", ECF_NOTHROW | ECF_MALLOC);
6608     }
6609
6610   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
6611   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
6612   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
6613   ftype = build_function_type (void_type_node, tmp);
6614   local_define_builtin ("__builtin_init_trampoline", ftype,
6615                         BUILT_IN_INIT_TRAMPOLINE,
6616                         "__builtin_init_trampoline", ECF_NOTHROW);
6617
6618   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
6619   ftype = build_function_type (ptr_type_node, tmp);
6620   local_define_builtin ("__builtin_adjust_trampoline", ftype,
6621                         BUILT_IN_ADJUST_TRAMPOLINE,
6622                         "__builtin_adjust_trampoline",
6623                         ECF_CONST | ECF_NOTHROW);
6624
6625   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
6626   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
6627   ftype = build_function_type (void_type_node, tmp);
6628   local_define_builtin ("__builtin_nonlocal_goto", ftype,
6629                         BUILT_IN_NONLOCAL_GOTO,
6630                         "__builtin_nonlocal_goto",
6631                         ECF_NORETURN | ECF_NOTHROW);
6632
6633   ftype = build_function_type (ptr_type_node, void_list_node);
6634   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
6635                         "__builtin_stack_save", ECF_NOTHROW);
6636
6637   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
6638   ftype = build_function_type (void_type_node, tmp);
6639   local_define_builtin ("__builtin_stack_restore", ftype,
6640                         BUILT_IN_STACK_RESTORE,
6641                         "__builtin_stack_restore", ECF_NOTHROW);
6642
6643   ftype = build_function_type (void_type_node, void_list_node);
6644   local_define_builtin ("__builtin_profile_func_enter", ftype,
6645                         BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
6646   local_define_builtin ("__builtin_profile_func_exit", ftype,
6647                         BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
6648
6649   /* Complex multiplication and division.  These are handled as builtins
6650      rather than optabs because emit_library_call_value doesn't support
6651      complex.  Further, we can do slightly better with folding these
6652      beasties if the real and complex parts of the arguments are separate.  */
6653   {
6654     enum machine_mode mode;
6655
6656     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
6657       {
6658         char mode_name_buf[4], *q;
6659         const char *p;
6660         enum built_in_function mcode, dcode;
6661         tree type, inner_type;
6662
6663         type = lang_hooks.types.type_for_mode (mode, 0);
6664         if (type == NULL)
6665           continue;
6666         inner_type = TREE_TYPE (type);
6667
6668         tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
6669         tmp = tree_cons (NULL_TREE, inner_type, tmp);
6670         tmp = tree_cons (NULL_TREE, inner_type, tmp);
6671         tmp = tree_cons (NULL_TREE, inner_type, tmp);
6672         ftype = build_function_type (type, tmp);
6673
6674         mcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
6675         dcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
6676
6677         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
6678           *q = TOLOWER (*p);
6679         *q = '\0';
6680
6681         built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
6682         local_define_builtin (built_in_names[mcode], ftype, mcode,
6683                               built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
6684
6685         built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
6686         local_define_builtin (built_in_names[dcode], ftype, dcode,
6687                               built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
6688       }
6689   }
6690 }
6691
6692 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
6693    better way.
6694
6695    If we requested a pointer to a vector, build up the pointers that
6696    we stripped off while looking for the inner type.  Similarly for
6697    return values from functions.
6698
6699    The argument TYPE is the top of the chain, and BOTTOM is the
6700    new type which we will point to.  */
6701
6702 tree
6703 reconstruct_complex_type (tree type, tree bottom)
6704 {
6705   tree inner, outer;
6706
6707   if (POINTER_TYPE_P (type))
6708     {
6709       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
6710       outer = build_pointer_type (inner);
6711     }
6712   else if (TREE_CODE (type) == ARRAY_TYPE)
6713     {
6714       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
6715       outer = build_array_type (inner, TYPE_DOMAIN (type));
6716     }
6717   else if (TREE_CODE (type) == FUNCTION_TYPE)
6718     {
6719       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
6720       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
6721     }
6722   else if (TREE_CODE (type) == METHOD_TYPE)
6723     {
6724       tree argtypes;
6725       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
6726       /* The build_method_type_directly() routine prepends 'this' to argument list,
6727          so we must compensate by getting rid of it.  */
6728       argtypes = TYPE_ARG_TYPES (type);
6729       outer = build_method_type_directly (TYPE_METHOD_BASETYPE (type),
6730                                           inner,
6731                                           TYPE_ARG_TYPES (type));
6732       TYPE_ARG_TYPES (outer) = argtypes;
6733     }
6734   else
6735     return bottom;
6736
6737   TYPE_READONLY (outer) = TYPE_READONLY (type);
6738   TYPE_VOLATILE (outer) = TYPE_VOLATILE (type);
6739
6740   return outer;
6741 }
6742
6743 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
6744    the inner type.  */
6745 tree
6746 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
6747 {
6748   int nunits;
6749
6750   switch (GET_MODE_CLASS (mode))
6751     {
6752     case MODE_VECTOR_INT:
6753     case MODE_VECTOR_FLOAT:
6754       nunits = GET_MODE_NUNITS (mode);
6755       break;
6756
6757     case MODE_INT:
6758       /* Check that there are no leftover bits.  */
6759       gcc_assert (GET_MODE_BITSIZE (mode)
6760                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
6761
6762       nunits = GET_MODE_BITSIZE (mode)
6763                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
6764       break;
6765
6766     default:
6767       gcc_unreachable ();
6768     }
6769
6770   return make_vector_type (innertype, nunits, mode);
6771 }
6772
6773 /* Similarly, but takes the inner type and number of units, which must be
6774    a power of two.  */
6775
6776 tree
6777 build_vector_type (tree innertype, int nunits)
6778 {
6779   return make_vector_type (innertype, nunits, VOIDmode);
6780 }
6781
6782 /* Build RESX_EXPR with given REGION_NUMBER.  */
6783 tree
6784 build_resx (int region_number)
6785 {
6786   tree t;
6787   t = build1 (RESX_EXPR, void_type_node,
6788               build_int_cst (NULL_TREE, region_number));
6789   return t;
6790 }
6791
6792 /* Given an initializer INIT, return TRUE if INIT is zero or some
6793    aggregate of zeros.  Otherwise return FALSE.  */
6794 bool
6795 initializer_zerop (tree init)
6796 {
6797   tree elt;
6798
6799   STRIP_NOPS (init);
6800
6801   switch (TREE_CODE (init))
6802     {
6803     case INTEGER_CST:
6804       return integer_zerop (init);
6805
6806     case REAL_CST:
6807       /* ??? Note that this is not correct for C4X float formats.  There,
6808          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
6809          negative exponent.  */
6810       return real_zerop (init)
6811         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
6812
6813     case COMPLEX_CST:
6814       return integer_zerop (init)
6815         || (real_zerop (init)
6816             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
6817             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
6818
6819     case VECTOR_CST:
6820       for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
6821         if (!initializer_zerop (TREE_VALUE (elt)))
6822           return false;
6823       return true;
6824
6825     case CONSTRUCTOR:
6826       {
6827         unsigned HOST_WIDE_INT idx;
6828
6829         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
6830           if (!initializer_zerop (elt))
6831             return false;
6832         return true;
6833       }
6834
6835     default:
6836       return false;
6837     }
6838 }
6839
6840 /* Build an empty statement.  */
6841
6842 tree
6843 build_empty_stmt (void)
6844 {
6845   return build1 (NOP_EXPR, void_type_node, size_zero_node);
6846 }
6847
6848
6849 /* Build an OpenMP clause with code CODE.  */
6850
6851 tree
6852 build_omp_clause (enum omp_clause_code code)
6853 {
6854   tree t;
6855   int size, length;
6856
6857   length = omp_clause_num_ops[code];
6858   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
6859
6860   t = ggc_alloc (size);
6861   memset (t, 0, size);
6862   TREE_SET_CODE (t, OMP_CLAUSE);
6863   OMP_CLAUSE_SET_CODE (t, code);
6864
6865 #ifdef GATHER_STATISTICS
6866   tree_node_counts[(int) omp_clause_kind]++;
6867   tree_node_sizes[(int) omp_clause_kind] += size;
6868 #endif
6869
6870   return t;
6871 }
6872
6873
6874 /* Returns true if it is possible to prove that the index of
6875    an array access REF (an ARRAY_REF expression) falls into the
6876    array bounds.  */
6877
6878 bool
6879 in_array_bounds_p (tree ref)
6880 {
6881   tree idx = TREE_OPERAND (ref, 1);
6882   tree min, max;
6883
6884   if (TREE_CODE (idx) != INTEGER_CST)
6885     return false;
6886
6887   min = array_ref_low_bound (ref);
6888   max = array_ref_up_bound (ref);
6889   if (!min
6890       || !max
6891       || TREE_CODE (min) != INTEGER_CST
6892       || TREE_CODE (max) != INTEGER_CST)
6893     return false;
6894
6895   if (tree_int_cst_lt (idx, min)
6896       || tree_int_cst_lt (max, idx))
6897     return false;
6898
6899   return true;
6900 }
6901
6902 /* Return true if T (assumed to be a DECL) is a global variable.  */
6903
6904 bool
6905 is_global_var (tree t)
6906 {
6907   if (MTAG_P (t))
6908     return (TREE_STATIC (t) || MTAG_GLOBAL (t));
6909   else
6910     return (TREE_STATIC (t) || DECL_EXTERNAL (t));
6911 }
6912
6913 /* Return true if T (assumed to be a DECL) must be assigned a memory
6914    location.  */
6915
6916 bool
6917 needs_to_live_in_memory (tree t)
6918 {
6919   return (TREE_ADDRESSABLE (t)
6920           || is_global_var (t)
6921           || (TREE_CODE (t) == RESULT_DECL
6922               && aggregate_value_p (t, current_function_decl)));
6923 }
6924
6925 /* There are situations in which a language considers record types
6926    compatible which have different field lists.  Decide if two fields
6927    are compatible.  It is assumed that the parent records are compatible.  */
6928
6929 bool
6930 fields_compatible_p (tree f1, tree f2)
6931 {
6932   if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
6933                         DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
6934     return false;
6935
6936   if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
6937                         DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
6938     return false;
6939
6940   if (!lang_hooks.types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
6941     return false;
6942
6943   return true;
6944 }
6945
6946 /* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
6947
6948 tree
6949 find_compatible_field (tree record, tree orig_field)
6950 {
6951   tree f;
6952
6953   for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
6954     if (TREE_CODE (f) == FIELD_DECL
6955         && fields_compatible_p (f, orig_field))
6956       return f;
6957
6958   /* ??? Why isn't this on the main fields list?  */
6959   f = TYPE_VFIELD (record);
6960   if (f && TREE_CODE (f) == FIELD_DECL
6961       && fields_compatible_p (f, orig_field))
6962     return f;
6963
6964   /* ??? We should abort here, but Java appears to do Bad Things
6965      with inherited fields.  */
6966   return orig_field;
6967 }
6968
6969 /* Return value of a constant X.  */
6970
6971 HOST_WIDE_INT
6972 int_cst_value (tree x)
6973 {
6974   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
6975   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
6976   bool negative = ((val >> (bits - 1)) & 1) != 0;
6977
6978   gcc_assert (bits <= HOST_BITS_PER_WIDE_INT);
6979
6980   if (negative)
6981     val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
6982   else
6983     val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
6984
6985   return val;
6986 }
6987
6988 /* Returns the greatest common divisor of A and B, which must be
6989    INTEGER_CSTs.  */
6990
6991 tree
6992 tree_fold_gcd (tree a, tree b)
6993 {
6994   tree a_mod_b;
6995   tree type = TREE_TYPE (a);
6996
6997   gcc_assert (TREE_CODE (a) == INTEGER_CST);
6998   gcc_assert (TREE_CODE (b) == INTEGER_CST);
6999
7000   if (integer_zerop (a))
7001     return b;
7002
7003   if (integer_zerop (b))
7004     return a;
7005
7006   if (tree_int_cst_sgn (a) == -1)
7007     a = fold_build2 (MULT_EXPR, type, a,
7008                      build_int_cst (type, -1));
7009
7010   if (tree_int_cst_sgn (b) == -1)
7011     b = fold_build2 (MULT_EXPR, type, b,
7012                      build_int_cst (type, -1));
7013
7014   while (1)
7015     {
7016       a_mod_b = fold_build2 (FLOOR_MOD_EXPR, type, a, b);
7017
7018       if (!TREE_INT_CST_LOW (a_mod_b)
7019           && !TREE_INT_CST_HIGH (a_mod_b))
7020         return b;
7021
7022       a = b;
7023       b = a_mod_b;
7024     }
7025 }
7026
7027 /* Returns unsigned variant of TYPE.  */
7028
7029 tree
7030 unsigned_type_for (tree type)
7031 {
7032   if (POINTER_TYPE_P (type))
7033     return lang_hooks.types.unsigned_type (size_type_node);
7034   return lang_hooks.types.unsigned_type (type);
7035 }
7036
7037 /* Returns signed variant of TYPE.  */
7038
7039 tree
7040 signed_type_for (tree type)
7041 {
7042   if (POINTER_TYPE_P (type))
7043     return lang_hooks.types.signed_type (size_type_node);
7044   return lang_hooks.types.signed_type (type);
7045 }
7046
7047 /* Returns the largest value obtainable by casting something in INNER type to
7048    OUTER type.  */
7049
7050 tree
7051 upper_bound_in_type (tree outer, tree inner)
7052 {
7053   unsigned HOST_WIDE_INT lo, hi;
7054   unsigned int det = 0;
7055   unsigned oprec = TYPE_PRECISION (outer);
7056   unsigned iprec = TYPE_PRECISION (inner);
7057   unsigned prec;
7058
7059   /* Compute a unique number for every combination.  */
7060   det |= (oprec > iprec) ? 4 : 0;
7061   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
7062   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
7063
7064   /* Determine the exponent to use.  */
7065   switch (det)
7066     {
7067     case 0:
7068     case 1:
7069       /* oprec <= iprec, outer: signed, inner: don't care.  */
7070       prec = oprec - 1;
7071       break;
7072     case 2:
7073     case 3:
7074       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
7075       prec = oprec;
7076       break;
7077     case 4:
7078       /* oprec > iprec, outer: signed, inner: signed.  */
7079       prec = iprec - 1;
7080       break;
7081     case 5:
7082       /* oprec > iprec, outer: signed, inner: unsigned.  */
7083       prec = iprec;
7084       break;
7085     case 6:
7086       /* oprec > iprec, outer: unsigned, inner: signed.  */
7087       prec = oprec;
7088       break;
7089     case 7:
7090       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
7091       prec = iprec;
7092       break;
7093     default:
7094       gcc_unreachable ();
7095     }
7096
7097   /* Compute 2^^prec - 1.  */
7098   if (prec <= HOST_BITS_PER_WIDE_INT)
7099     {
7100       hi = 0;
7101       lo = ((~(unsigned HOST_WIDE_INT) 0)
7102             >> (HOST_BITS_PER_WIDE_INT - prec));
7103     }
7104   else
7105     {
7106       hi = ((~(unsigned HOST_WIDE_INT) 0)
7107             >> (2 * HOST_BITS_PER_WIDE_INT - prec));
7108       lo = ~(unsigned HOST_WIDE_INT) 0;
7109     }
7110
7111   return build_int_cst_wide (outer, lo, hi);
7112 }
7113
7114 /* Returns the smallest value obtainable by casting something in INNER type to
7115    OUTER type.  */
7116
7117 tree
7118 lower_bound_in_type (tree outer, tree inner)
7119 {
7120   unsigned HOST_WIDE_INT lo, hi;
7121   unsigned oprec = TYPE_PRECISION (outer);
7122   unsigned iprec = TYPE_PRECISION (inner);
7123
7124   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
7125      and obtain 0.  */
7126   if (TYPE_UNSIGNED (outer)
7127       /* If we are widening something of an unsigned type, OUTER type
7128          contains all values of INNER type.  In particular, both INNER
7129          and OUTER types have zero in common.  */
7130       || (oprec > iprec && TYPE_UNSIGNED (inner)))
7131     lo = hi = 0;
7132   else
7133     {
7134       /* If we are widening a signed type to another signed type, we
7135          want to obtain -2^^(iprec-1).  If we are keeping the
7136          precision or narrowing to a signed type, we want to obtain
7137          -2^(oprec-1).  */
7138       unsigned prec = oprec > iprec ? iprec : oprec;
7139
7140       if (prec <= HOST_BITS_PER_WIDE_INT)
7141         {
7142           hi = ~(unsigned HOST_WIDE_INT) 0;
7143           lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
7144         }
7145       else
7146         {
7147           hi = ((~(unsigned HOST_WIDE_INT) 0)
7148                 << (prec - HOST_BITS_PER_WIDE_INT - 1));
7149           lo = 0;
7150         }
7151     }
7152
7153   return build_int_cst_wide (outer, lo, hi);
7154 }
7155
7156 /* Return nonzero if two operands that are suitable for PHI nodes are
7157    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
7158    SSA_NAME or invariant.  Note that this is strictly an optimization.
7159    That is, callers of this function can directly call operand_equal_p
7160    and get the same result, only slower.  */
7161
7162 int
7163 operand_equal_for_phi_arg_p (tree arg0, tree arg1)
7164 {
7165   if (arg0 == arg1)
7166     return 1;
7167   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
7168     return 0;
7169   return operand_equal_p (arg0, arg1, 0);
7170 }
7171
7172 /* Returns number of zeros at the end of binary representation of X.
7173
7174    ??? Use ffs if available?  */
7175
7176 tree
7177 num_ending_zeros (tree x)
7178 {
7179   unsigned HOST_WIDE_INT fr, nfr;
7180   unsigned num, abits;
7181   tree type = TREE_TYPE (x);
7182
7183   if (TREE_INT_CST_LOW (x) == 0)
7184     {
7185       num = HOST_BITS_PER_WIDE_INT;
7186       fr = TREE_INT_CST_HIGH (x);
7187     }
7188   else
7189     {
7190       num = 0;
7191       fr = TREE_INT_CST_LOW (x);
7192     }
7193
7194   for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
7195     {
7196       nfr = fr >> abits;
7197       if (nfr << abits == fr)
7198         {
7199           num += abits;
7200           fr = nfr;
7201         }
7202     }
7203
7204   if (num > TYPE_PRECISION (type))
7205     num = TYPE_PRECISION (type);
7206
7207   return build_int_cst_type (type, num);
7208 }
7209
7210
7211 #define WALK_SUBTREE(NODE)                              \
7212   do                                                    \
7213     {                                                   \
7214       result = walk_tree (&(NODE), func, data, pset);   \
7215       if (result)                                       \
7216         return result;                                  \
7217     }                                                   \
7218   while (0)
7219
7220 /* This is a subroutine of walk_tree that walks field of TYPE that are to
7221    be walked whenever a type is seen in the tree.  Rest of operands and return
7222    value are as for walk_tree.  */
7223
7224 static tree
7225 walk_type_fields (tree type, walk_tree_fn func, void *data,
7226                   struct pointer_set_t *pset)
7227 {
7228   tree result = NULL_TREE;
7229
7230   switch (TREE_CODE (type))
7231     {
7232     case POINTER_TYPE:
7233     case REFERENCE_TYPE:
7234       /* We have to worry about mutually recursive pointers.  These can't
7235          be written in C.  They can in Ada.  It's pathological, but
7236          there's an ACATS test (c38102a) that checks it.  Deal with this
7237          by checking if we're pointing to another pointer, that one
7238          points to another pointer, that one does too, and we have no htab.
7239          If so, get a hash table.  We check three levels deep to avoid
7240          the cost of the hash table if we don't need one.  */
7241       if (POINTER_TYPE_P (TREE_TYPE (type))
7242           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
7243           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
7244           && !pset)
7245         {
7246           result = walk_tree_without_duplicates (&TREE_TYPE (type),
7247                                                  func, data);
7248           if (result)
7249             return result;
7250
7251           break;
7252         }
7253
7254       /* ... fall through ... */
7255
7256     case COMPLEX_TYPE:
7257       WALK_SUBTREE (TREE_TYPE (type));
7258       break;
7259
7260     case METHOD_TYPE:
7261       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
7262
7263       /* Fall through.  */
7264
7265     case FUNCTION_TYPE:
7266       WALK_SUBTREE (TREE_TYPE (type));
7267       {
7268         tree arg;
7269
7270         /* We never want to walk into default arguments.  */
7271         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
7272           WALK_SUBTREE (TREE_VALUE (arg));
7273       }
7274       break;
7275
7276     case ARRAY_TYPE:
7277       /* Don't follow this nodes's type if a pointer for fear that we'll
7278          have infinite recursion.  Those types are uninteresting anyway.  */
7279       if (!POINTER_TYPE_P (TREE_TYPE (type))
7280           && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE)
7281         WALK_SUBTREE (TREE_TYPE (type));
7282       WALK_SUBTREE (TYPE_DOMAIN (type));
7283       break;
7284
7285     case BOOLEAN_TYPE:
7286     case ENUMERAL_TYPE:
7287     case INTEGER_TYPE:
7288     case REAL_TYPE:
7289       WALK_SUBTREE (TYPE_MIN_VALUE (type));
7290       WALK_SUBTREE (TYPE_MAX_VALUE (type));
7291       break;
7292
7293     case OFFSET_TYPE:
7294       WALK_SUBTREE (TREE_TYPE (type));
7295       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
7296       break;
7297
7298     default:
7299       break;
7300     }
7301
7302   return NULL_TREE;
7303 }
7304
7305 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
7306    called with the DATA and the address of each sub-tree.  If FUNC returns a
7307    non-NULL value, the traversal is stopped, and the value returned by FUNC
7308    is returned.  If PSET is non-NULL it is used to record the nodes visited,
7309    and to avoid visiting a node more than once.  */
7310
7311 tree
7312 walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset)
7313 {
7314   enum tree_code code;
7315   int walk_subtrees;
7316   tree result;
7317
7318 #define WALK_SUBTREE_TAIL(NODE)                         \
7319   do                                                    \
7320     {                                                   \
7321        tp = & (NODE);                                   \
7322        goto tail_recurse;                               \
7323     }                                                   \
7324   while (0)
7325
7326  tail_recurse:
7327   /* Skip empty subtrees.  */
7328   if (!*tp)
7329     return NULL_TREE;
7330
7331   /* Don't walk the same tree twice, if the user has requested
7332      that we avoid doing so.  */
7333   if (pset && pointer_set_insert (pset, *tp))
7334     return NULL_TREE;
7335
7336   /* Call the function.  */
7337   walk_subtrees = 1;
7338   result = (*func) (tp, &walk_subtrees, data);
7339
7340   /* If we found something, return it.  */
7341   if (result)
7342     return result;
7343
7344   code = TREE_CODE (*tp);
7345
7346   /* Even if we didn't, FUNC may have decided that there was nothing
7347      interesting below this point in the tree.  */
7348   if (!walk_subtrees)
7349     {
7350       /* But we still need to check our siblings.  */
7351       if (code == TREE_LIST)
7352         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
7353       else if (code == OMP_CLAUSE)
7354         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
7355       else
7356         return NULL_TREE;
7357     }
7358
7359   result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func,
7360                                                    data, pset);
7361   if (result || ! walk_subtrees)
7362     return result;
7363
7364   switch (code)
7365     {
7366     case ERROR_MARK:
7367     case IDENTIFIER_NODE:
7368     case INTEGER_CST:
7369     case REAL_CST:
7370     case VECTOR_CST:
7371     case STRING_CST:
7372     case BLOCK:
7373     case PLACEHOLDER_EXPR:
7374     case SSA_NAME:
7375     case FIELD_DECL:
7376     case RESULT_DECL:
7377       /* None of these have subtrees other than those already walked
7378          above.  */
7379       break;
7380
7381     case TREE_LIST:
7382       WALK_SUBTREE (TREE_VALUE (*tp));
7383       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
7384       break;
7385
7386     case TREE_VEC:
7387       {
7388         int len = TREE_VEC_LENGTH (*tp);
7389
7390         if (len == 0)
7391           break;
7392
7393         /* Walk all elements but the first.  */
7394         while (--len)
7395           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
7396
7397         /* Now walk the first one as a tail call.  */
7398         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
7399       }
7400
7401     case COMPLEX_CST:
7402       WALK_SUBTREE (TREE_REALPART (*tp));
7403       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
7404
7405     case CONSTRUCTOR:
7406       {
7407         unsigned HOST_WIDE_INT idx;
7408         constructor_elt *ce;
7409
7410         for (idx = 0;
7411              VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
7412              idx++)
7413           WALK_SUBTREE (ce->value);
7414       }
7415       break;
7416
7417     case SAVE_EXPR:
7418       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
7419
7420     case BIND_EXPR:
7421       {
7422         tree decl;
7423         for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
7424           {
7425             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
7426                into declarations that are just mentioned, rather than
7427                declared; they don't really belong to this part of the tree.
7428                And, we can see cycles: the initializer for a declaration
7429                can refer to the declaration itself.  */
7430             WALK_SUBTREE (DECL_INITIAL (decl));
7431             WALK_SUBTREE (DECL_SIZE (decl));
7432             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
7433           }
7434         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
7435       }
7436
7437     case STATEMENT_LIST:
7438       {
7439         tree_stmt_iterator i;
7440         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
7441           WALK_SUBTREE (*tsi_stmt_ptr (i));
7442       }
7443       break;
7444
7445     case OMP_CLAUSE:
7446       switch (OMP_CLAUSE_CODE (*tp))
7447         {
7448         case OMP_CLAUSE_PRIVATE:
7449         case OMP_CLAUSE_SHARED:
7450         case OMP_CLAUSE_FIRSTPRIVATE:
7451         case OMP_CLAUSE_LASTPRIVATE:
7452         case OMP_CLAUSE_COPYIN:
7453         case OMP_CLAUSE_COPYPRIVATE:
7454         case OMP_CLAUSE_IF:
7455         case OMP_CLAUSE_NUM_THREADS:
7456         case OMP_CLAUSE_SCHEDULE:
7457           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
7458           /* FALLTHRU */
7459
7460         case OMP_CLAUSE_NOWAIT:
7461         case OMP_CLAUSE_ORDERED:
7462         case OMP_CLAUSE_DEFAULT:
7463           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
7464
7465         case OMP_CLAUSE_REDUCTION:
7466           {
7467             int i;
7468             for (i = 0; i < 4; i++)
7469               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
7470             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
7471           }
7472
7473         default:
7474           gcc_unreachable ();
7475         }
7476       break;
7477
7478     case TARGET_EXPR:
7479       {
7480         int i, len;
7481
7482         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
7483            But, we only want to walk once.  */
7484         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
7485         for (i = 0; i < len; ++i)
7486           WALK_SUBTREE (TREE_OPERAND (*tp, i));
7487         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
7488       }
7489
7490     case DECL_EXPR:
7491       /* Walk into various fields of the type that it's defining.  We only
7492          want to walk into these fields of a type in this case.  Note that
7493          decls get walked as part of the processing of a BIND_EXPR.
7494
7495          ??? Precisely which fields of types that we are supposed to walk in
7496          this case vs. the normal case aren't well defined.  */
7497       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL
7498           && TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp))) != ERROR_MARK)
7499         {
7500           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
7501
7502           /* Call the function for the type.  See if it returns anything or
7503              doesn't want us to continue.  If we are to continue, walk both
7504              the normal fields and those for the declaration case.  */
7505           result = (*func) (type_p, &walk_subtrees, data);
7506           if (result || !walk_subtrees)
7507             return NULL_TREE;
7508
7509           result = walk_type_fields (*type_p, func, data, pset);
7510           if (result)
7511             return result;
7512
7513           /* If this is a record type, also walk the fields.  */
7514           if (TREE_CODE (*type_p) == RECORD_TYPE
7515               || TREE_CODE (*type_p) == UNION_TYPE
7516               || TREE_CODE (*type_p) == QUAL_UNION_TYPE)
7517             {
7518               tree field;
7519
7520               for (field = TYPE_FIELDS (*type_p); field;
7521                    field = TREE_CHAIN (field))
7522                 {
7523                   /* We'd like to look at the type of the field, but we can
7524                      easily get infinite recursion.  So assume it's pointed
7525                      to elsewhere in the tree.  Also, ignore things that
7526                      aren't fields.  */
7527                   if (TREE_CODE (field) != FIELD_DECL)
7528                     continue;
7529
7530                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
7531                   WALK_SUBTREE (DECL_SIZE (field));
7532                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
7533                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
7534                     WALK_SUBTREE (DECL_QUALIFIER (field));
7535                 }
7536             }
7537
7538           WALK_SUBTREE (TYPE_SIZE (*type_p));
7539           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
7540         }
7541       /* FALLTHRU */
7542
7543     default:
7544       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
7545         {
7546           int i, len;
7547
7548           /* Walk over all the sub-trees of this operand.  */
7549           len = TREE_CODE_LENGTH (code);
7550
7551           /* Go through the subtrees.  We need to do this in forward order so
7552              that the scope of a FOR_EXPR is handled properly.  */
7553           if (len)
7554             {
7555               for (i = 0; i < len - 1; ++i)
7556                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
7557               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
7558             }
7559         }
7560
7561       /* If this is a type, walk the needed fields in the type.  */
7562       else if (TYPE_P (*tp))
7563         return walk_type_fields (*tp, func, data, pset);
7564       break;
7565     }
7566
7567   /* We didn't find what we were looking for.  */
7568   return NULL_TREE;
7569
7570 #undef WALK_SUBTREE_TAIL
7571 }
7572 #undef WALK_SUBTREE
7573
7574 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
7575
7576 tree
7577 walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
7578 {
7579   tree result;
7580   struct pointer_set_t *pset;
7581
7582   pset = pointer_set_create ();
7583   result = walk_tree (tp, func, data, pset);
7584   pointer_set_destroy (pset);
7585   return result;
7586 }
7587
7588
7589 /* Return true if STMT is an empty statement or contains nothing but
7590    empty statements.  */
7591
7592 bool
7593 empty_body_p (tree stmt)
7594 {
7595   tree_stmt_iterator i;
7596   tree body;
7597
7598   if (IS_EMPTY_STMT (stmt))
7599     return true;
7600   else if (TREE_CODE (stmt) == BIND_EXPR)
7601     body = BIND_EXPR_BODY (stmt);
7602   else if (TREE_CODE (stmt) == STATEMENT_LIST)
7603     body = stmt;
7604   else
7605     return false;
7606
7607   for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
7608     if (!empty_body_p (tsi_stmt (i)))
7609       return false;
7610
7611   return true;
7612 }
7613
7614 #include "gt-tree.h"