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