gcc/tree.c

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