gcc/tree.c

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