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