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