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