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