gcc/tree.c

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