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