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
4079   /* These attributes may apply to structure and union types being created,
4080      but otherwise should pass to the declaration involved.  */
4081   if (!DECL_P (node))
4082     {
4083       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
4084                    | (int) ATTR_FLAG_ARRAY_NEXT))
4085         {
4086           *no_add_attrs = true;
4087           return tree_cons (name, args, NULL_TREE);
4088         }
4089       if (TREE_CODE (node) == RECORD_TYPE
4090           || TREE_CODE (node) == UNION_TYPE)
4091         {
4092           node = TYPE_NAME (node);
4093           if (!node)
4094             return NULL_TREE;
4095         }
4096       else
4097         {
4098           warning (OPT_Wattributes, "%qE attribute ignored",
4099                    name);
4100           *no_add_attrs = true;
4101           return NULL_TREE;
4102         }
4103     }
4104
4105   if (TREE_CODE (node) != FUNCTION_DECL
4106       && TREE_CODE (node) != VAR_DECL
4107       && TREE_CODE (node) != TYPE_DECL)
4108     {
4109       *no_add_attrs = true;
4110       warning (OPT_Wattributes, "%qE attribute ignored",
4111                name);
4112       return NULL_TREE;
4113     }
4114
4115   if (TREE_CODE (node) == TYPE_DECL
4116       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
4117       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
4118     {
4119       *no_add_attrs = true;
4120       warning (OPT_Wattributes, "%qE attribute ignored",
4121                name);
4122       return NULL_TREE;
4123     }
4124
4125   /* Report error on dllimport ambiguities seen now before they cause
4126      any damage.  */
4127   else if (is_attribute_p ("dllimport", name))
4128     {
4129       /* Honor any target-specific overrides. */
4130       if (!targetm.valid_dllimport_attribute_p (node))
4131         *no_add_attrs = true;
4132
4133      else if (TREE_CODE (node) == FUNCTION_DECL
4134                 && DECL_DECLARED_INLINE_P (node))
4135         {
4136           warning (OPT_Wattributes, "inline function %q+D declared as "
4137                   " dllimport: attribute ignored", node);
4138           *no_add_attrs = true;
4139         }
4140       /* Like MS, treat definition of dllimported variables and
4141          non-inlined functions on declaration as syntax errors. */
4142      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
4143         {
4144           error ("function %q+D definition is marked dllimport", node);
4145           *no_add_attrs = true;
4146         }
4147
4148      else if (TREE_CODE (node) == VAR_DECL)
4149         {
4150           if (DECL_INITIAL (node))
4151             {
4152               error ("variable %q+D definition is marked dllimport",
4153                      node);
4154               *no_add_attrs = true;
4155             }
4156
4157           /* `extern' needn't be specified with dllimport.
4158              Specify `extern' now and hope for the best.  Sigh.  */
4159           DECL_EXTERNAL (node) = 1;
4160           /* Also, implicitly give dllimport'd variables declared within
4161              a function global scope, unless declared static.  */
4162           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
4163             TREE_PUBLIC (node) = 1;
4164         }
4165
4166       if (*no_add_attrs == false)
4167         DECL_DLLIMPORT_P (node) = 1;
4168     }
4169
4170   /*  Report error if symbol is not accessible at global scope.  */
4171   if (!TREE_PUBLIC (node)
4172       && (TREE_CODE (node) == VAR_DECL
4173           || TREE_CODE (node) == FUNCTION_DECL))
4174     {
4175       error ("external linkage required for symbol %q+D because of "
4176              "%qE attribute", node, name);
4177       *no_add_attrs = true;
4178     }
4179
4180   /* A dllexport'd entity must have default visibility so that other
4181      program units (shared libraries or the main executable) can see
4182      it.  A dllimport'd entity must have default visibility so that
4183      the linker knows that undefined references within this program
4184      unit can be resolved by the dynamic linker.  */
4185   if (!*no_add_attrs)
4186     {
4187       if (DECL_VISIBILITY_SPECIFIED (node)
4188           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
4189         error ("%qE implies default visibility, but %qD has already "
4190                "been declared with a different visibility",
4191                name, node);
4192       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
4193       DECL_VISIBILITY_SPECIFIED (node) = 1;
4194     }
4195
4196   return NULL_TREE;
4197 }
4198
4199 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
4200 \f
4201 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
4202    of the various TYPE_QUAL values.  */
4203
4204 static void
4205 set_type_quals (tree type, int type_quals)
4206 {
4207   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
4208   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
4209   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
4210 }
4211
4212 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
4213
4214 bool
4215 check_qualified_type (const_tree cand, const_tree base, int type_quals)
4216 {
4217   return (TYPE_QUALS (cand) == type_quals
4218           && TYPE_NAME (cand) == TYPE_NAME (base)
4219           /* Apparently this is needed for Objective-C.  */
4220           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
4221           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
4222                                    TYPE_ATTRIBUTES (base)));
4223 }
4224
4225 /* Return a version of the TYPE, qualified as indicated by the
4226    TYPE_QUALS, if one exists.  If no qualified version exists yet,
4227    return NULL_TREE.  */
4228
4229 tree
4230 get_qualified_type (tree type, int type_quals)
4231 {
4232   tree t;
4233
4234   if (TYPE_QUALS (type) == type_quals)
4235     return type;
4236
4237   /* Search the chain of variants to see if there is already one there just
4238      like the one we need to have.  If so, use that existing one.  We must
4239      preserve the TYPE_NAME, since there is code that depends on this.  */
4240   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
4241     if (check_qualified_type (t, type, type_quals))
4242       return t;
4243
4244   return NULL_TREE;
4245 }
4246
4247 /* Like get_qualified_type, but creates the type if it does not
4248    exist.  This function never returns NULL_TREE.  */
4249
4250 tree
4251 build_qualified_type (tree type, int type_quals)
4252 {
4253   tree t;
4254
4255   /* See if we already have the appropriate qualified variant.  */
4256   t = get_qualified_type (type, type_quals);
4257
4258   /* If not, build it.  */
4259   if (!t)
4260     {
4261       t = build_variant_type_copy (type);
4262       set_type_quals (t, type_quals);
4263
4264       if (TYPE_STRUCTURAL_EQUALITY_P (type))
4265         /* Propagate structural equality. */
4266         SET_TYPE_STRUCTURAL_EQUALITY (t);
4267       else if (TYPE_CANONICAL (type) != type)
4268         /* Build the underlying canonical type, since it is different
4269            from TYPE. */
4270         TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
4271                                                    type_quals);
4272       else
4273         /* T is its own canonical type. */
4274         TYPE_CANONICAL (t) = t;
4275
4276     }
4277
4278   return t;
4279 }
4280
4281 /* Create a new distinct copy of TYPE.  The new type is made its own
4282    MAIN_VARIANT. If TYPE requires structural equality checks, the
4283    resulting type requires structural equality checks; otherwise, its
4284    TYPE_CANONICAL points to itself. */
4285
4286 tree
4287 build_distinct_type_copy (tree type)
4288 {
4289   tree t = copy_node (type);
4290
4291   TYPE_POINTER_TO (t) = 0;
4292   TYPE_REFERENCE_TO (t) = 0;
4293
4294   /* Set the canonical type either to a new equivalence class, or
4295      propagate the need for structural equality checks. */
4296   if (TYPE_STRUCTURAL_EQUALITY_P (type))
4297     SET_TYPE_STRUCTURAL_EQUALITY (t);
4298   else
4299     TYPE_CANONICAL (t) = t;
4300
4301   /* Make it its own variant.  */
4302   TYPE_MAIN_VARIANT (t) = t;
4303   TYPE_NEXT_VARIANT (t) = 0;
4304
4305   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
4306      whose TREE_TYPE is not t.  This can also happen in the Ada
4307      frontend when using subtypes.  */
4308
4309   return t;
4310 }
4311
4312 /* Create a new variant of TYPE, equivalent but distinct.  This is so
4313    the caller can modify it. TYPE_CANONICAL for the return type will
4314    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
4315    are considered equal by the language itself (or that both types
4316    require structural equality checks). */
4317
4318 tree
4319 build_variant_type_copy (tree type)
4320 {
4321   tree t, m = TYPE_MAIN_VARIANT (type);
4322
4323   t = build_distinct_type_copy (type);
4324
4325   /* Since we're building a variant, assume that it is a non-semantic
4326      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
4327   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
4328
4329   /* Add the new type to the chain of variants of TYPE.  */
4330   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
4331   TYPE_NEXT_VARIANT (m) = t;
4332   TYPE_MAIN_VARIANT (t) = m;
4333
4334   return t;
4335 }
4336 \f
4337 /* Return true if the from tree in both tree maps are equal.  */
4338
4339 int
4340 tree_map_base_eq (const void *va, const void *vb)
4341 {
4342   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
4343     *const b = (const struct tree_map_base *) vb;
4344   return (a->from == b->from);
4345 }
4346
4347 /* Hash a from tree in a tree_map.  */
4348
4349 unsigned int
4350 tree_map_base_hash (const void *item)
4351 {
4352   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
4353 }
4354
4355 /* Return true if this tree map structure is marked for garbage collection
4356    purposes.  We simply return true if the from tree is marked, so that this
4357    structure goes away when the from tree goes away.  */
4358
4359 int
4360 tree_map_base_marked_p (const void *p)
4361 {
4362   return ggc_marked_p (((const struct tree_map_base *) p)->from);
4363 }
4364
4365 unsigned int
4366 tree_map_hash (const void *item)
4367 {
4368   return (((const struct tree_map *) item)->hash);
4369 }
4370
4371 /* Return the initialization priority for DECL.  */
4372
4373 priority_type
4374 decl_init_priority_lookup (tree decl)
4375 {
4376   struct tree_priority_map *h;
4377   struct tree_map_base in;
4378
4379   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
4380   in.from = decl;
4381   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
4382   return h ? h->init : DEFAULT_INIT_PRIORITY;
4383 }
4384
4385 /* Return the finalization priority for DECL.  */
4386
4387 priority_type
4388 decl_fini_priority_lookup (tree decl)
4389 {
4390   struct tree_priority_map *h;
4391   struct tree_map_base in;
4392
4393   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
4394   in.from = decl;
4395   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
4396   return h ? h->fini : DEFAULT_INIT_PRIORITY;
4397 }
4398
4399 /* Return the initialization and finalization priority information for
4400    DECL.  If there is no previous priority information, a freshly
4401    allocated structure is returned.  */
4402
4403 static struct tree_priority_map *
4404 decl_priority_info (tree decl)
4405 {
4406   struct tree_priority_map in;
4407   struct tree_priority_map *h;
4408   void **loc;
4409
4410   in.base.from = decl;
4411   loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
4412   h = (struct tree_priority_map *) *loc;
4413   if (!h)
4414     {
4415       h = GGC_CNEW (struct tree_priority_map);
4416       *loc = h;
4417       h->base.from = decl;
4418       h->init = DEFAULT_INIT_PRIORITY;
4419       h->fini = DEFAULT_INIT_PRIORITY;
4420     }
4421
4422   return h;
4423 }
4424
4425 /* Set the initialization priority for DECL to PRIORITY.  */
4426
4427 void
4428 decl_init_priority_insert (tree decl, priority_type priority)
4429 {
4430   struct tree_priority_map *h;
4431
4432   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
4433   h = decl_priority_info (decl);
4434   h->init = priority;
4435 }
4436
4437 /* Set the finalization priority for DECL to PRIORITY.  */
4438
4439 void
4440 decl_fini_priority_insert (tree decl, priority_type priority)
4441 {
4442   struct tree_priority_map *h;
4443
4444   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
4445   h = decl_priority_info (decl);
4446   h->fini = priority;
4447 }
4448
4449 /* Look up a restrict qualified base decl for FROM.  */
4450
4451 tree
4452 decl_restrict_base_lookup (tree from)
4453 {
4454   struct tree_map *h;
4455   struct tree_map in;
4456
4457   in.base.from = from;
4458   h = (struct tree_map *) htab_find_with_hash (restrict_base_for_decl, &in,
4459                                                htab_hash_pointer (from));
4460   return h ? h->to : NULL_TREE;
4461 }
4462
4463 /* Record the restrict qualified base TO for FROM.  */
4464
4465 void
4466 decl_restrict_base_insert (tree from, tree to)
4467 {
4468   struct tree_map *h;
4469   void **loc;
4470
4471   h = GGC_NEW (struct tree_map);
4472   h->hash = htab_hash_pointer (from);
4473   h->base.from = from;
4474   h->to = to;
4475   loc = htab_find_slot_with_hash (restrict_base_for_decl, h, h->hash, INSERT);
4476   *(struct tree_map **) loc = h;
4477 }
4478
4479 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
4480
4481 static void
4482 print_debug_expr_statistics (void)
4483 {
4484   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
4485            (long) htab_size (debug_expr_for_decl),
4486            (long) htab_elements (debug_expr_for_decl),
4487            htab_collisions (debug_expr_for_decl));
4488 }
4489
4490 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
4491
4492 static void
4493 print_value_expr_statistics (void)
4494 {
4495   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
4496            (long) htab_size (value_expr_for_decl),
4497            (long) htab_elements (value_expr_for_decl),
4498            htab_collisions (value_expr_for_decl));
4499 }
4500
4501 /* Print out statistics for the RESTRICT_BASE_FOR_DECL hash table, but
4502    don't print anything if the table is empty.  */
4503
4504 static void
4505 print_restrict_base_statistics (void)
4506 {
4507   if (htab_elements (restrict_base_for_decl) != 0)
4508     fprintf (stderr,
4509              "RESTRICT_BASE    hash: size %ld, %ld elements, %f collisions\n",
4510              (long) htab_size (restrict_base_for_decl),
4511              (long) htab_elements (restrict_base_for_decl),
4512              htab_collisions (restrict_base_for_decl));
4513 }
4514
4515 /* Lookup a debug expression for FROM, and return it if we find one.  */
4516
4517 tree
4518 decl_debug_expr_lookup (tree from)
4519 {
4520   struct tree_map *h, in;
4521   in.base.from = from;
4522
4523   h = (struct tree_map *) htab_find_with_hash (debug_expr_for_decl, &in,
4524                                                htab_hash_pointer (from));
4525   if (h)
4526     return h->to;
4527   return NULL_TREE;
4528 }
4529
4530 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
4531
4532 void
4533 decl_debug_expr_insert (tree from, tree to)
4534 {
4535   struct tree_map *h;
4536   void **loc;
4537
4538   h = GGC_NEW (struct tree_map);
4539   h->hash = htab_hash_pointer (from);
4540   h->base.from = from;
4541   h->to = to;
4542   loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
4543   *(struct tree_map **) loc = h;
4544 }
4545
4546 /* Lookup a value expression for FROM, and return it if we find one.  */
4547
4548 tree
4549 decl_value_expr_lookup (tree from)
4550 {
4551   struct tree_map *h, in;
4552   in.base.from = from;
4553
4554   h = (struct tree_map *) htab_find_with_hash (value_expr_for_decl, &in,
4555                                                htab_hash_pointer (from));
4556   if (h)
4557     return h->to;
4558   return NULL_TREE;
4559 }
4560
4561 /* Insert a mapping FROM->TO in the value expression hashtable.  */
4562
4563 void
4564 decl_value_expr_insert (tree from, tree to)
4565 {
4566   struct tree_map *h;
4567   void **loc;
4568
4569   h = GGC_NEW (struct tree_map);
4570   h->hash = htab_hash_pointer (from);
4571   h->base.from = from;
4572   h->to = to;
4573   loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT);
4574   *(struct tree_map **) loc = h;
4575 }
4576
4577 /* Hashing of types so that we don't make duplicates.
4578    The entry point is `type_hash_canon'.  */
4579
4580 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
4581    with types in the TREE_VALUE slots), by adding the hash codes
4582    of the individual types.  */
4583
4584 static unsigned int
4585 type_hash_list (const_tree list, hashval_t hashcode)
4586 {
4587   const_tree tail;
4588
4589   for (tail = list; tail; tail = TREE_CHAIN (tail))
4590     if (TREE_VALUE (tail) != error_mark_node)
4591       hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
4592                                         hashcode);
4593
4594   return hashcode;
4595 }
4596
4597 /* These are the Hashtable callback functions.  */
4598
4599 /* Returns true iff the types are equivalent.  */
4600
4601 static int
4602 type_hash_eq (const void *va, const void *vb)
4603 {
4604   const struct type_hash *const a = (const struct type_hash *) va,
4605     *const b = (const struct type_hash *) vb;
4606
4607   /* First test the things that are the same for all types.  */
4608   if (a->hash != b->hash
4609       || TREE_CODE (a->type) != TREE_CODE (b->type)
4610       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
4611       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
4612                                  TYPE_ATTRIBUTES (b->type))
4613       || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
4614       || TYPE_MODE (a->type) != TYPE_MODE (b->type)
4615       || (TREE_CODE (a->type) != COMPLEX_TYPE
4616           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
4617     return 0;
4618
4619   switch (TREE_CODE (a->type))
4620     {
4621     case VOID_TYPE:
4622     case COMPLEX_TYPE:
4623     case POINTER_TYPE:
4624     case REFERENCE_TYPE:
4625       return 1;
4626
4627     case VECTOR_TYPE:
4628       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
4629
4630     case ENUMERAL_TYPE:
4631       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
4632           && !(TYPE_VALUES (a->type)
4633                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
4634                && TYPE_VALUES (b->type)
4635                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
4636                && type_list_equal (TYPE_VALUES (a->type),
4637                                    TYPE_VALUES (b->type))))
4638         return 0;
4639
4640       /* ... fall through ... */
4641
4642     case INTEGER_TYPE:
4643     case REAL_TYPE:
4644     case BOOLEAN_TYPE:
4645       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
4646                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
4647                                       TYPE_MAX_VALUE (b->type)))
4648               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
4649                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
4650                                          TYPE_MIN_VALUE (b->type))));
4651
4652     case FIXED_POINT_TYPE:
4653       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
4654
4655     case OFFSET_TYPE:
4656       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
4657
4658     case METHOD_TYPE:
4659       return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
4660               && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
4661                   || (TYPE_ARG_TYPES (a->type)
4662                       && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
4663                       && TYPE_ARG_TYPES (b->type)
4664                       && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
4665                       && type_list_equal (TYPE_ARG_TYPES (a->type),
4666                                           TYPE_ARG_TYPES (b->type)))));
4667
4668     case ARRAY_TYPE:
4669       return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
4670
4671     case RECORD_TYPE:
4672     case UNION_TYPE:
4673     case QUAL_UNION_TYPE:
4674       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
4675               || (TYPE_FIELDS (a->type)
4676                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
4677                   && TYPE_FIELDS (b->type)
4678                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
4679                   && type_list_equal (TYPE_FIELDS (a->type),
4680                                       TYPE_FIELDS (b->type))));
4681
4682     case FUNCTION_TYPE:
4683       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
4684           || (TYPE_ARG_TYPES (a->type)
4685               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
4686               && TYPE_ARG_TYPES (b->type)
4687               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
4688               && type_list_equal (TYPE_ARG_TYPES (a->type),
4689                                   TYPE_ARG_TYPES (b->type))))
4690         break;
4691       return 0;
4692
4693     default:
4694       return 0;
4695     }
4696
4697   if (lang_hooks.types.type_hash_eq != NULL)
4698     return lang_hooks.types.type_hash_eq (a->type, b->type);
4699
4700   return 1;
4701 }
4702
4703 /* Return the cached hash value.  */
4704
4705 static hashval_t
4706 type_hash_hash (const void *item)
4707 {
4708   return ((const struct type_hash *) item)->hash;
4709 }
4710
4711 /* Look in the type hash table for a type isomorphic to TYPE.
4712    If one is found, return it.  Otherwise return 0.  */
4713
4714 tree
4715 type_hash_lookup (hashval_t hashcode, tree type)
4716 {
4717   struct type_hash *h, in;
4718
4719   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
4720      must call that routine before comparing TYPE_ALIGNs.  */
4721   layout_type (type);
4722
4723   in.hash = hashcode;
4724   in.type = type;
4725
4726   h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
4727                                                 hashcode);
4728   if (h)
4729     return h->type;
4730   return NULL_TREE;
4731 }
4732
4733 /* Add an entry to the type-hash-table
4734    for a type TYPE whose hash code is HASHCODE.  */
4735
4736 void
4737 type_hash_add (hashval_t hashcode, tree type)
4738 {
4739   struct type_hash *h;
4740   void **loc;
4741
4742   h = GGC_NEW (struct type_hash);
4743   h->hash = hashcode;
4744   h->type = type;
4745   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
4746   *loc = (void *)h;
4747 }
4748
4749 /* Given TYPE, and HASHCODE its hash code, return the canonical
4750    object for an identical type if one already exists.
4751    Otherwise, return TYPE, and record it as the canonical object.
4752
4753    To use this function, first create a type of the sort you want.
4754    Then compute its hash code from the fields of the type that
4755    make it different from other similar types.
4756    Then call this function and use the value.  */
4757
4758 tree
4759 type_hash_canon (unsigned int hashcode, tree type)
4760 {
4761   tree t1;
4762
4763   /* The hash table only contains main variants, so ensure that's what we're
4764      being passed.  */
4765   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
4766
4767   if (!lang_hooks.types.hash_types)
4768     return type;
4769
4770   /* See if the type is in the hash table already.  If so, return it.
4771      Otherwise, add the type.  */
4772   t1 = type_hash_lookup (hashcode, type);
4773   if (t1 != 0)
4774     {
4775 #ifdef GATHER_STATISTICS
4776       tree_node_counts[(int) t_kind]--;
4777       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
4778 #endif
4779       return t1;
4780     }
4781   else
4782     {
4783       type_hash_add (hashcode, type);
4784       return type;
4785     }
4786 }
4787
4788 /* See if the data pointed to by the type hash table is marked.  We consider
4789    it marked if the type is marked or if a debug type number or symbol
4790    table entry has been made for the type.  This reduces the amount of
4791    debugging output and eliminates that dependency of the debug output on
4792    the number of garbage collections.  */
4793
4794 static int
4795 type_hash_marked_p (const void *p)
4796 {
4797   const_tree const type = ((const struct type_hash *) p)->type;
4798
4799   return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
4800 }
4801
4802 static void
4803 print_type_hash_statistics (void)
4804 {
4805   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
4806            (long) htab_size (type_hash_table),
4807            (long) htab_elements (type_hash_table),
4808            htab_collisions (type_hash_table));
4809 }
4810
4811 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
4812    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
4813    by adding the hash codes of the individual attributes.  */
4814
4815 static unsigned int
4816 attribute_hash_list (const_tree list, hashval_t hashcode)
4817 {
4818   const_tree tail;
4819
4820   for (tail = list; tail; tail = TREE_CHAIN (tail))
4821     /* ??? Do we want to add in TREE_VALUE too? */
4822     hashcode = iterative_hash_object
4823       (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
4824   return hashcode;
4825 }
4826
4827 /* Given two lists of attributes, return true if list l2 is
4828    equivalent to l1.  */
4829
4830 int
4831 attribute_list_equal (const_tree l1, const_tree l2)
4832 {
4833   return attribute_list_contained (l1, l2)
4834          && attribute_list_contained (l2, l1);
4835 }
4836
4837 /* Given two lists of attributes, return true if list L2 is
4838    completely contained within L1.  */
4839 /* ??? This would be faster if attribute names were stored in a canonicalized
4840    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
4841    must be used to show these elements are equivalent (which they are).  */
4842 /* ??? It's not clear that attributes with arguments will always be handled
4843    correctly.  */
4844
4845 int
4846 attribute_list_contained (const_tree l1, const_tree l2)
4847 {
4848   const_tree t1, t2;
4849
4850   /* First check the obvious, maybe the lists are identical.  */
4851   if (l1 == l2)
4852     return 1;
4853
4854   /* Maybe the lists are similar.  */
4855   for (t1 = l1, t2 = l2;
4856        t1 != 0 && t2 != 0
4857         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
4858         && TREE_VALUE (t1) == TREE_VALUE (t2);
4859        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
4860
4861   /* Maybe the lists are equal.  */
4862   if (t1 == 0 && t2 == 0)
4863     return 1;
4864
4865   for (; t2 != 0; t2 = TREE_CHAIN (t2))
4866     {
4867       const_tree attr;
4868       /* This CONST_CAST is okay because lookup_attribute does not
4869          modify its argument and the return value is assigned to a
4870          const_tree.  */
4871       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
4872                                     CONST_CAST_TREE(l1));
4873            attr != NULL_TREE;
4874            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
4875                                     TREE_CHAIN (attr)))
4876         {
4877           if (TREE_VALUE (t2) != NULL
4878               && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
4879               && TREE_VALUE (attr) != NULL
4880               && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
4881             {
4882               if (simple_cst_list_equal (TREE_VALUE (t2),
4883                                          TREE_VALUE (attr)) == 1)
4884                 break;
4885             }
4886           else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
4887             break;
4888         }
4889
4890       if (attr == 0)
4891         return 0;
4892     }
4893
4894   return 1;
4895 }
4896
4897 /* Given two lists of types
4898    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
4899    return 1 if the lists contain the same types in the same order.
4900    Also, the TREE_PURPOSEs must match.  */
4901
4902 int
4903 type_list_equal (const_tree l1, const_tree l2)
4904 {
4905   const_tree t1, t2;
4906
4907   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
4908     if (TREE_VALUE (t1) != TREE_VALUE (t2)
4909         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
4910             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
4911                   && (TREE_TYPE (TREE_PURPOSE (t1))
4912                       == TREE_TYPE (TREE_PURPOSE (t2))))))
4913       return 0;
4914
4915   return t1 == t2;
4916 }
4917
4918 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
4919    given by TYPE.  If the argument list accepts variable arguments,
4920    then this function counts only the ordinary arguments.  */
4921
4922 int
4923 type_num_arguments (const_tree type)
4924 {
4925   int i = 0;
4926   tree t;
4927
4928   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
4929     /* If the function does not take a variable number of arguments,
4930        the last element in the list will have type `void'.  */
4931     if (VOID_TYPE_P (TREE_VALUE (t)))
4932       break;
4933     else
4934       ++i;
4935
4936   return i;
4937 }
4938
4939 /* Nonzero if integer constants T1 and T2
4940    represent the same constant value.  */
4941
4942 int
4943 tree_int_cst_equal (const_tree t1, const_tree t2)
4944 {
4945   if (t1 == t2)
4946     return 1;
4947
4948   if (t1 == 0 || t2 == 0)
4949     return 0;
4950
4951   if (TREE_CODE (t1) == INTEGER_CST
4952       && TREE_CODE (t2) == INTEGER_CST
4953       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
4954       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
4955     return 1;
4956
4957   return 0;
4958 }
4959
4960 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
4961    The precise way of comparison depends on their data type.  */
4962
4963 int
4964 tree_int_cst_lt (const_tree t1, const_tree t2)
4965 {
4966   if (t1 == t2)
4967     return 0;
4968
4969   if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
4970     {
4971       int t1_sgn = tree_int_cst_sgn (t1);
4972       int t2_sgn = tree_int_cst_sgn (t2);
4973
4974       if (t1_sgn < t2_sgn)
4975         return 1;
4976       else if (t1_sgn > t2_sgn)
4977         return 0;
4978       /* Otherwise, both are non-negative, so we compare them as
4979          unsigned just in case one of them would overflow a signed
4980          type.  */
4981     }
4982   else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
4983     return INT_CST_LT (t1, t2);
4984
4985   return INT_CST_LT_UNSIGNED (t1, t2);
4986 }
4987
4988 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
4989
4990 int
4991 tree_int_cst_compare (const_tree t1, const_tree t2)
4992 {
4993   if (tree_int_cst_lt (t1, t2))
4994     return -1;
4995   else if (tree_int_cst_lt (t2, t1))
4996     return 1;
4997   else
4998     return 0;
4999 }
5000
5001 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
5002    the host.  If POS is zero, the value can be represented in a single
5003    HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
5004    be represented in a single unsigned HOST_WIDE_INT.  */
5005
5006 int
5007 host_integerp (const_tree t, int pos)
5008 {
5009   return (TREE_CODE (t) == INTEGER_CST
5010           && ((TREE_INT_CST_HIGH (t) == 0
5011                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
5012               || (! pos && TREE_INT_CST_HIGH (t) == -1
5013                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
5014                   && (!TYPE_UNSIGNED (TREE_TYPE (t))
5015                       || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
5016                           && TYPE_IS_SIZETYPE (TREE_TYPE (t)))))
5017               || (pos && TREE_INT_CST_HIGH (t) == 0)));
5018 }
5019
5020 /* Return the HOST_WIDE_INT least significant bits of T if it is an
5021    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
5022    be non-negative.  We must be able to satisfy the above conditions.  */
5023
5024 HOST_WIDE_INT
5025 tree_low_cst (const_tree t, int pos)
5026 {
5027   gcc_assert (host_integerp (t, pos));
5028   return TREE_INT_CST_LOW (t);
5029 }
5030
5031 /* Return the most significant bit of the integer constant T.  */
5032
5033 int
5034 tree_int_cst_msb (const_tree t)
5035 {
5036   int prec;
5037   HOST_WIDE_INT h;
5038   unsigned HOST_WIDE_INT l;
5039
5040   /* Note that using TYPE_PRECISION here is wrong.  We care about the
5041      actual bits, not the (arbitrary) range of the type.  */
5042   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
5043   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
5044                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
5045   return (l & 1) == 1;
5046 }
5047
5048 /* Return an indication of the sign of the integer constant T.
5049    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
5050    Note that -1 will never be returned if T's type is unsigned.  */
5051
5052 int
5053 tree_int_cst_sgn (const_tree t)
5054 {
5055   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
5056     return 0;
5057   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
5058     return 1;
5059   else if (TREE_INT_CST_HIGH (t) < 0)
5060     return -1;
5061   else
5062     return 1;
5063 }
5064
5065 /* Return the minimum number of bits needed to represent VALUE in a
5066    signed or unsigned type, UNSIGNEDP says which.  */
5067
5068 unsigned int
5069 tree_int_cst_min_precision (tree value, bool unsignedp)
5070 {
5071   int log;
5072
5073   /* If the value is negative, compute its negative minus 1.  The latter
5074      adjustment is because the absolute value of the largest negative value
5075      is one larger than the largest positive value.  This is equivalent to
5076      a bit-wise negation, so use that operation instead.  */
5077
5078   if (tree_int_cst_sgn (value) < 0)
5079     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
5080
5081   /* Return the number of bits needed, taking into account the fact
5082      that we need one more bit for a signed than unsigned type.  */
5083
5084   if (integer_zerop (value))
5085     log = 0;
5086   else
5087     log = tree_floor_log2 (value);
5088
5089   return log + 1 + !unsignedp;
5090 }
5091
5092 /* Compare two constructor-element-type constants.  Return 1 if the lists
5093    are known to be equal; otherwise return 0.  */
5094
5095 int
5096 simple_cst_list_equal (const_tree l1, const_tree l2)
5097 {
5098   while (l1 != NULL_TREE && l2 != NULL_TREE)
5099     {
5100       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
5101         return 0;
5102
5103       l1 = TREE_CHAIN (l1);
5104       l2 = TREE_CHAIN (l2);
5105     }
5106
5107   return l1 == l2;
5108 }
5109
5110 /* Return truthvalue of whether T1 is the same tree structure as T2.
5111    Return 1 if they are the same.
5112    Return 0 if they are understandably different.
5113    Return -1 if either contains tree structure not understood by
5114    this function.  */
5115
5116 int
5117 simple_cst_equal (const_tree t1, const_tree t2)
5118 {
5119   enum tree_code code1, code2;
5120   int cmp;
5121   int i;
5122
5123   if (t1 == t2)
5124     return 1;
5125   if (t1 == 0 || t2 == 0)
5126     return 0;
5127
5128   code1 = TREE_CODE (t1);
5129   code2 = TREE_CODE (t2);
5130
5131   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
5132     {
5133       if (CONVERT_EXPR_CODE_P (code2)
5134           || code2 == NON_LVALUE_EXPR)
5135         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
5136       else
5137         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
5138     }
5139
5140   else if (CONVERT_EXPR_CODE_P (code2)
5141            || code2 == NON_LVALUE_EXPR)
5142     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
5143
5144   if (code1 != code2)
5145     return 0;
5146
5147   switch (code1)
5148     {
5149     case INTEGER_CST:
5150       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
5151               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
5152
5153     case REAL_CST:
5154       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
5155
5156     case FIXED_CST:
5157       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
5158
5159     case STRING_CST:
5160       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
5161               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
5162                          TREE_STRING_LENGTH (t1)));
5163
5164     case CONSTRUCTOR:
5165       {
5166         unsigned HOST_WIDE_INT idx;
5167         VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
5168         VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
5169
5170         if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
5171           return false;
5172
5173         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
5174           /* ??? Should we handle also fields here? */
5175           if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
5176                                  VEC_index (constructor_elt, v2, idx)->value))
5177             return false;
5178         return true;
5179       }
5180
5181     case SAVE_EXPR:
5182       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
5183
5184     case CALL_EXPR:
5185       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
5186       if (cmp <= 0)
5187         return cmp;
5188       if (call_expr_nargs (t1) != call_expr_nargs (t2))
5189         return 0;
5190       {
5191         const_tree arg1, arg2;
5192         const_call_expr_arg_iterator iter1, iter2;
5193         for (arg1 = first_const_call_expr_arg (t1, &iter1),
5194                arg2 = first_const_call_expr_arg (t2, &iter2);
5195              arg1 && arg2;
5196              arg1 = next_const_call_expr_arg (&iter1),
5197                arg2 = next_const_call_expr_arg (&iter2))
5198           {
5199             cmp = simple_cst_equal (arg1, arg2);
5200             if (cmp <= 0)
5201               return cmp;
5202           }
5203         return arg1 == arg2;
5204       }
5205
5206     case TARGET_EXPR:
5207       /* Special case: if either target is an unallocated VAR_DECL,
5208          it means that it's going to be unified with whatever the
5209          TARGET_EXPR is really supposed to initialize, so treat it
5210          as being equivalent to anything.  */
5211       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
5212            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
5213            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
5214           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
5215               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
5216               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
5217         cmp = 1;
5218       else
5219         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
5220
5221       if (cmp <= 0)
5222         return cmp;
5223
5224       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
5225
5226     case WITH_CLEANUP_EXPR:
5227       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
5228       if (cmp <= 0)
5229         return cmp;
5230
5231       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
5232
5233     case COMPONENT_REF:
5234       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
5235         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
5236
5237       return 0;
5238
5239     case VAR_DECL:
5240     case PARM_DECL:
5241     case CONST_DECL:
5242     case FUNCTION_DECL:
5243       return 0;
5244
5245     default:
5246       break;
5247     }
5248
5249   /* This general rule works for most tree codes.  All exceptions should be
5250      handled above.  If this is a language-specific tree code, we can't
5251      trust what might be in the operand, so say we don't know
5252      the situation.  */
5253   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
5254     return -1;
5255
5256   switch (TREE_CODE_CLASS (code1))
5257     {
5258     case tcc_unary:
5259     case tcc_binary:
5260     case tcc_comparison:
5261     case tcc_expression:
5262     case tcc_reference:
5263     case tcc_statement:
5264       cmp = 1;
5265       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
5266         {
5267           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
5268           if (cmp <= 0)
5269             return cmp;
5270         }
5271
5272       return cmp;
5273
5274     default:
5275       return -1;
5276     }
5277 }
5278
5279 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
5280    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
5281    than U, respectively.  */
5282
5283 int
5284 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
5285 {
5286   if (tree_int_cst_sgn (t) < 0)
5287     return -1;
5288   else if (TREE_INT_CST_HIGH (t) != 0)
5289     return 1;
5290   else if (TREE_INT_CST_LOW (t) == u)
5291     return 0;
5292   else if (TREE_INT_CST_LOW (t) < u)
5293     return -1;
5294   else
5295     return 1;
5296 }
5297
5298 /* Return true if CODE represents an associative tree code.  Otherwise
5299    return false.  */
5300 bool
5301 associative_tree_code (enum tree_code code)
5302 {
5303   switch (code)
5304     {
5305     case BIT_IOR_EXPR:
5306     case BIT_AND_EXPR:
5307     case BIT_XOR_EXPR:
5308     case PLUS_EXPR:
5309     case MULT_EXPR:
5310     case MIN_EXPR:
5311     case MAX_EXPR:
5312       return true;
5313
5314     default:
5315       break;
5316     }
5317   return false;
5318 }
5319
5320 /* Return true if CODE represents a commutative tree code.  Otherwise
5321    return false.  */
5322 bool
5323 commutative_tree_code (enum tree_code code)
5324 {
5325   switch (code)
5326     {
5327     case PLUS_EXPR:
5328     case MULT_EXPR:
5329     case MIN_EXPR:
5330     case MAX_EXPR:
5331     case BIT_IOR_EXPR:
5332     case BIT_XOR_EXPR:
5333     case BIT_AND_EXPR:
5334     case NE_EXPR:
5335     case EQ_EXPR:
5336     case UNORDERED_EXPR:
5337     case ORDERED_EXPR:
5338     case UNEQ_EXPR:
5339     case LTGT_EXPR:
5340     case TRUTH_AND_EXPR:
5341     case TRUTH_XOR_EXPR:
5342     case TRUTH_OR_EXPR:
5343       return true;
5344
5345     default:
5346       break;
5347     }
5348   return false;
5349 }
5350
5351 /* Generate a hash value for an expression.  This can be used iteratively
5352    by passing a previous result as the VAL argument.
5353
5354    This function is intended to produce the same hash for expressions which
5355    would compare equal using operand_equal_p.  */
5356
5357 hashval_t
5358 iterative_hash_expr (const_tree t, hashval_t val)
5359 {
5360   int i;
5361   enum tree_code code;
5362   char tclass;
5363
5364   if (t == NULL_TREE)
5365     return iterative_hash_hashval_t (0, val);
5366
5367   code = TREE_CODE (t);
5368
5369   switch (code)
5370     {
5371     /* Alas, constants aren't shared, so we can't rely on pointer
5372        identity.  */
5373     case INTEGER_CST:
5374       val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
5375       return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
5376     case REAL_CST:
5377       {
5378         unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
5379
5380         return iterative_hash_hashval_t (val2, val);
5381       }
5382     case FIXED_CST:
5383       {
5384         unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
5385
5386         return iterative_hash_hashval_t (val2, val);
5387       }
5388     case STRING_CST:
5389       return iterative_hash (TREE_STRING_POINTER (t),
5390                              TREE_STRING_LENGTH (t), val);
5391     case COMPLEX_CST:
5392       val = iterative_hash_expr (TREE_REALPART (t), val);
5393       return iterative_hash_expr (TREE_IMAGPART (t), val);
5394     case VECTOR_CST:
5395       return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
5396
5397     case SSA_NAME:
5398       /* we can just compare by pointer.  */
5399       return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
5400
5401     case TREE_LIST:
5402       /* A list of expressions, for a CALL_EXPR or as the elements of a
5403          VECTOR_CST.  */
5404       for (; t; t = TREE_CHAIN (t))
5405         val = iterative_hash_expr (TREE_VALUE (t), val);
5406       return val;
5407     case CONSTRUCTOR:
5408       {
5409         unsigned HOST_WIDE_INT idx;
5410         tree field, value;
5411         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
5412           {
5413             val = iterative_hash_expr (field, val);
5414             val = iterative_hash_expr (value, val);
5415           }
5416         return val;
5417       }
5418     case FUNCTION_DECL:
5419       /* When referring to a built-in FUNCTION_DECL, use the
5420          __builtin__ form.  Otherwise nodes that compare equal
5421          according to operand_equal_p might get different
5422          hash codes.  */
5423       if (DECL_BUILT_IN (t) && built_in_decls[DECL_FUNCTION_CODE (t)])
5424         {
5425           t = built_in_decls[DECL_FUNCTION_CODE (t)];
5426           code = TREE_CODE (t);
5427         }
5428       /* FALL THROUGH */
5429     default:
5430       tclass = TREE_CODE_CLASS (code);
5431
5432       if (tclass == tcc_declaration)
5433         {
5434           /* DECL's have a unique ID */
5435           val = iterative_hash_host_wide_int (DECL_UID (t), val);
5436         }
5437       else
5438         {
5439           gcc_assert (IS_EXPR_CODE_CLASS (tclass));
5440
5441           val = iterative_hash_object (code, val);
5442
5443           /* Don't hash the type, that can lead to having nodes which
5444              compare equal according to operand_equal_p, but which
5445              have different hash codes.  */
5446           if (CONVERT_EXPR_CODE_P (code)
5447               || code == NON_LVALUE_EXPR)
5448             {
5449               /* Make sure to include signness in the hash computation.  */
5450               val += TYPE_UNSIGNED (TREE_TYPE (t));
5451               val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
5452             }
5453
5454           else if (commutative_tree_code (code))
5455             {
5456               /* It's a commutative expression.  We want to hash it the same
5457                  however it appears.  We do this by first hashing both operands
5458                  and then rehashing based on the order of their independent
5459                  hashes.  */
5460               hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
5461               hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
5462               hashval_t t;
5463
5464               if (one > two)
5465                 t = one, one = two, two = t;
5466
5467               val = iterative_hash_hashval_t (one, val);
5468               val = iterative_hash_hashval_t (two, val);
5469             }
5470           else
5471             for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
5472               val = iterative_hash_expr (TREE_OPERAND (t, i), val);
5473         }
5474       return val;
5475       break;
5476     }
5477 }
5478
5479 /* Generate a hash value for a pair of expressions.  This can be used
5480    iteratively by passing a previous result as the VAL argument.
5481
5482    The same hash value is always returned for a given pair of expressions,
5483    regardless of the order in which they are presented.  This is useful in
5484    hashing the operands of commutative functions.  */
5485
5486 hashval_t
5487 iterative_hash_exprs_commutative (const_tree t1,
5488                                   const_tree t2, hashval_t val)
5489 {
5490   hashval_t one = iterative_hash_expr (t1, 0);
5491   hashval_t two = iterative_hash_expr (t2, 0);
5492   hashval_t t;
5493
5494   if (one > two)
5495     t = one, one = two, two = t;
5496   val = iterative_hash_hashval_t (one, val);
5497   val = iterative_hash_hashval_t (two, val);
5498
5499   return val;
5500 }
5501 \f
5502 /* Constructors for pointer, array and function types.
5503    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
5504    constructed by language-dependent code, not here.)  */
5505
5506 /* Construct, lay out and return the type of pointers to TO_TYPE with
5507    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
5508    reference all of memory. If such a type has already been
5509    constructed, reuse it.  */
5510
5511 tree
5512 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
5513                              bool can_alias_all)
5514 {
5515   tree t;
5516
5517   if (to_type == error_mark_node)
5518     return error_mark_node;
5519
5520   /* If the pointed-to type has the may_alias attribute set, force
5521      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
5522   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
5523     can_alias_all = true;
5524
5525   /* In some cases, languages will have things that aren't a POINTER_TYPE
5526      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
5527      In that case, return that type without regard to the rest of our
5528      operands.
5529
5530      ??? This is a kludge, but consistent with the way this function has
5531      always operated and there doesn't seem to be a good way to avoid this
5532      at the moment.  */
5533   if (TYPE_POINTER_TO (to_type) != 0
5534       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
5535     return TYPE_POINTER_TO (to_type);
5536
5537   /* First, if we already have a type for pointers to TO_TYPE and it's
5538      the proper mode, use it.  */
5539   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
5540     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
5541       return t;
5542
5543   t = make_node (POINTER_TYPE);
5544
5545   TREE_TYPE (t) = to_type;
5546   SET_TYPE_MODE (t, mode);
5547   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
5548   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
5549   TYPE_POINTER_TO (to_type) = t;
5550
5551   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
5552     SET_TYPE_STRUCTURAL_EQUALITY (t);
5553   else if (TYPE_CANONICAL (to_type) != to_type)
5554     TYPE_CANONICAL (t)
5555       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
5556                                      mode, can_alias_all);
5557
5558   /* Lay out the type.  This function has many callers that are concerned
5559      with expression-construction, and this simplifies them all.  */
5560   layout_type (t);
5561
5562   return t;
5563 }
5564
5565 /* By default build pointers in ptr_mode.  */
5566
5567 tree
5568 build_pointer_type (tree to_type)
5569 {
5570   return build_pointer_type_for_mode (to_type, ptr_mode, false);
5571 }
5572
5573 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
5574
5575 tree
5576 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
5577                                bool can_alias_all)
5578 {
5579   tree t;
5580
5581   if (to_type == error_mark_node)
5582     return error_mark_node;
5583
5584   /* If the pointed-to type has the may_alias attribute set, force
5585      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
5586   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
5587     can_alias_all = true;
5588
5589   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
5590      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
5591      In that case, return that type without regard to the rest of our
5592      operands.
5593
5594      ??? This is a kludge, but consistent with the way this function has
5595      always operated and there doesn't seem to be a good way to avoid this
5596      at the moment.  */
5597   if (TYPE_REFERENCE_TO (to_type) != 0
5598       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
5599     return TYPE_REFERENCE_TO (to_type);
5600
5601   /* First, if we already have a type for pointers to TO_TYPE and it's
5602      the proper mode, use it.  */
5603   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
5604     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
5605       return t;
5606
5607   t = make_node (REFERENCE_TYPE);
5608
5609   TREE_TYPE (t) = to_type;
5610   SET_TYPE_MODE (t, mode);
5611   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
5612   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
5613   TYPE_REFERENCE_TO (to_type) = t;
5614
5615   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
5616     SET_TYPE_STRUCTURAL_EQUALITY (t);
5617   else if (TYPE_CANONICAL (to_type) != to_type)
5618     TYPE_CANONICAL (t)
5619       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
5620                                        mode, can_alias_all);
5621
5622   layout_type (t);
5623
5624   return t;
5625 }
5626
5627
5628 /* Build the node for the type of references-to-TO_TYPE by default
5629    in ptr_mode.  */
5630
5631 tree
5632 build_reference_type (tree to_type)
5633 {
5634   return build_reference_type_for_mode (to_type, ptr_mode, false);
5635 }
5636
5637 /* Build a type that is compatible with t but has no cv quals anywhere
5638    in its type, thus
5639
5640    const char *const *const *  ->  char ***.  */
5641
5642 tree
5643 build_type_no_quals (tree t)
5644 {
5645   switch (TREE_CODE (t))
5646     {
5647     case POINTER_TYPE:
5648       return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
5649                                           TYPE_MODE (t),
5650                                           TYPE_REF_CAN_ALIAS_ALL (t));
5651     case REFERENCE_TYPE:
5652       return
5653         build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
5654                                        TYPE_MODE (t),
5655                                        TYPE_REF_CAN_ALIAS_ALL (t));
5656     default:
5657       return TYPE_MAIN_VARIANT (t);
5658     }
5659 }
5660
5661 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
5662    MAXVAL should be the maximum value in the domain
5663    (one less than the length of the array).
5664
5665    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
5666    We don't enforce this limit, that is up to caller (e.g. language front end).
5667    The limit exists because the result is a signed type and we don't handle
5668    sizes that use more than one HOST_WIDE_INT.  */
5669
5670 tree
5671 build_index_type (tree maxval)
5672 {
5673   tree itype = make_node (INTEGER_TYPE);
5674
5675   TREE_TYPE (itype) = sizetype;
5676   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
5677   TYPE_MIN_VALUE (itype) = size_zero_node;
5678   TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
5679   SET_TYPE_MODE (itype, TYPE_MODE (sizetype));
5680   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
5681   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
5682   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
5683   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
5684
5685   if (host_integerp (maxval, 1))
5686     return type_hash_canon (tree_low_cst (maxval, 1), itype);
5687   else
5688     {
5689       /* Since we cannot hash this type, we need to compare it using
5690          structural equality checks. */
5691       SET_TYPE_STRUCTURAL_EQUALITY (itype);
5692       return itype;
5693     }
5694 }
5695
5696 /* Builds a signed or unsigned integer type of precision PRECISION.
5697    Used for C bitfields whose precision does not match that of
5698    built-in target types.  */
5699 tree
5700 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
5701                                 int unsignedp)
5702 {
5703   tree itype = make_node (INTEGER_TYPE);
5704
5705   TYPE_PRECISION (itype) = precision;
5706
5707   if (unsignedp)
5708     fixup_unsigned_type (itype);
5709   else
5710     fixup_signed_type (itype);
5711
5712   if (host_integerp (TYPE_MAX_VALUE (itype), 1))
5713     return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
5714
5715   return itype;
5716 }
5717
5718 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
5719    ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
5720    high bound HIGHVAL.  If TYPE is NULL, sizetype is used.  */
5721
5722 tree
5723 build_range_type (tree type, tree lowval, tree highval)
5724 {
5725   tree itype = make_node (INTEGER_TYPE);
5726
5727   TREE_TYPE (itype) = type;
5728   if (type == NULL_TREE)
5729     type = sizetype;
5730
5731   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
5732   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
5733
5734   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
5735   SET_TYPE_MODE (itype, TYPE_MODE (type));
5736   TYPE_SIZE (itype) = TYPE_SIZE (type);
5737   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
5738   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
5739   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
5740
5741   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
5742     return type_hash_canon (tree_low_cst (highval, 0)
5743                             - tree_low_cst (lowval, 0),
5744                             itype);
5745   else
5746     return itype;
5747 }
5748
5749 /* Return true if the debug information for TYPE, a subtype, should be emitted
5750    as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
5751    high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
5752    debug info and doesn't reflect the source code.  */
5753
5754 bool
5755 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
5756 {
5757   tree base_type = TREE_TYPE (type), low, high;
5758
5759   /* Subrange types have a base type which is an integral type.  */
5760   if (!INTEGRAL_TYPE_P (base_type))
5761     return false;
5762
5763   /* Get the real bounds of the subtype.  */
5764   if (lang_hooks.types.get_subrange_bounds)
5765     lang_hooks.types.get_subrange_bounds (type, &low, &high);
5766   else
5767     {
5768       low = TYPE_MIN_VALUE (type);
5769       high = TYPE_MAX_VALUE (type);
5770     }
5771
5772   /* If the type and its base type have the same representation and the same
5773      name, then the type is not a subrange but a copy of the base type.  */
5774   if ((TREE_CODE (base_type) == INTEGER_TYPE
5775        || TREE_CODE (base_type) == BOOLEAN_TYPE)
5776       && int_size_in_bytes (type) == int_size_in_bytes (base_type)
5777       && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
5778       && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
5779     {
5780       tree type_name = TYPE_NAME (type);
5781       tree base_type_name = TYPE_NAME (base_type);
5782
5783       if (type_name && TREE_CODE (type_name) == TYPE_DECL)
5784         type_name = DECL_NAME (type_name);
5785
5786       if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
5787         base_type_name = DECL_NAME (base_type_name);
5788
5789       if (type_name == base_type_name)
5790         return false;
5791     }
5792
5793   if (lowval)
5794     *lowval = low;
5795   if (highval)
5796     *highval = high;
5797   return true;
5798 }
5799
5800 /* Just like build_index_type, but takes lowval and highval instead
5801    of just highval (maxval).  */
5802
5803 tree
5804 build_index_2_type (tree lowval, tree highval)
5805 {
5806   return build_range_type (sizetype, lowval, highval);
5807 }
5808
5809 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
5810    and number of elements specified by the range of values of INDEX_TYPE.
5811    If such a type has already been constructed, reuse it.  */
5812
5813 tree
5814 build_array_type (tree elt_type, tree index_type)
5815 {
5816   tree t;
5817   hashval_t hashcode = 0;
5818
5819   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
5820     {
5821       error ("arrays of functions are not meaningful");
5822       elt_type = integer_type_node;
5823     }
5824
5825   t = make_node (ARRAY_TYPE);
5826   TREE_TYPE (t) = elt_type;
5827   TYPE_DOMAIN (t) = index_type;
5828
5829   if (index_type == 0)
5830     {
5831       tree save = t;
5832       hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
5833       t = type_hash_canon (hashcode, t);
5834       if (save == t)
5835         layout_type (t);
5836
5837       if (TYPE_CANONICAL (t) == t)
5838         {
5839           if (TYPE_STRUCTURAL_EQUALITY_P (elt_type))
5840             SET_TYPE_STRUCTURAL_EQUALITY (t);
5841           else if (TYPE_CANONICAL (elt_type) != elt_type)
5842             TYPE_CANONICAL (t)
5843               = build_array_type (TYPE_CANONICAL (elt_type), index_type);
5844         }
5845
5846       return t;
5847     }
5848
5849   hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
5850   hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
5851   t = type_hash_canon (hashcode, t);
5852
5853   if (!COMPLETE_TYPE_P (t))
5854     layout_type (t);
5855
5856   if (TYPE_CANONICAL (t) == t)
5857     {
5858       if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
5859           || TYPE_STRUCTURAL_EQUALITY_P (index_type))
5860         SET_TYPE_STRUCTURAL_EQUALITY (t);
5861       else if (TYPE_CANONICAL (elt_type) != elt_type
5862                || TYPE_CANONICAL (index_type) != index_type)
5863         TYPE_CANONICAL (t)
5864           = build_array_type (TYPE_CANONICAL (elt_type),
5865                               TYPE_CANONICAL (index_type));
5866     }
5867
5868   return t;
5869 }
5870
5871 /* Recursively examines the array elements of TYPE, until a non-array
5872    element type is found.  */
5873
5874 tree
5875 strip_array_types (tree type)
5876 {
5877   while (TREE_CODE (type) == ARRAY_TYPE)
5878     type = TREE_TYPE (type);
5879
5880   return type;
5881 }
5882
5883 /* Computes the canonical argument types from the argument type list
5884    ARGTYPES.
5885
5886    Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
5887    on entry to this function, or if any of the ARGTYPES are
5888    structural.
5889
5890    Upon return, *ANY_NONCANONICAL_P will be true iff either it was
5891    true on entry to this function, or if any of the ARGTYPES are
5892    non-canonical.
5893
5894    Returns a canonical argument list, which may be ARGTYPES when the
5895    canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
5896    true) or would not differ from ARGTYPES.  */
5897
5898 static tree
5899 maybe_canonicalize_argtypes(tree argtypes,
5900                             bool *any_structural_p,
5901                             bool *any_noncanonical_p)
5902 {
5903   tree arg;
5904   bool any_noncanonical_argtypes_p = false;
5905
5906   for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
5907     {
5908       if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
5909         /* Fail gracefully by stating that the type is structural.  */
5910         *any_structural_p = true;
5911       else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
5912         *any_structural_p = true;
5913       else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
5914                || TREE_PURPOSE (arg))
5915         /* If the argument has a default argument, we consider it
5916            non-canonical even though the type itself is canonical.
5917            That way, different variants of function and method types
5918            with default arguments will all point to the variant with
5919            no defaults as their canonical type.  */
5920         any_noncanonical_argtypes_p = true;
5921     }
5922
5923   if (*any_structural_p)
5924     return argtypes;
5925
5926   if (any_noncanonical_argtypes_p)
5927     {
5928       /* Build the canonical list of argument types.  */
5929       tree canon_argtypes = NULL_TREE;
5930       bool is_void = false;
5931
5932       for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
5933         {
5934           if (arg == void_list_node)
5935             is_void = true;
5936           else
5937             canon_argtypes = tree_cons (NULL_TREE,
5938                                         TYPE_CANONICAL (TREE_VALUE (arg)),
5939                                         canon_argtypes);
5940         }
5941
5942       canon_argtypes = nreverse (canon_argtypes);
5943       if (is_void)
5944         canon_argtypes = chainon (canon_argtypes, void_list_node);
5945
5946       /* There is a non-canonical type.  */
5947       *any_noncanonical_p = true;
5948       return canon_argtypes;
5949     }
5950
5951   /* The canonical argument types are the same as ARGTYPES.  */
5952   return argtypes;
5953 }
5954
5955 /* Construct, lay out and return
5956    the type of functions returning type VALUE_TYPE
5957    given arguments of types ARG_TYPES.
5958    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
5959    are data type nodes for the arguments of the function.
5960    If such a type has already been constructed, reuse it.  */
5961
5962 tree
5963 build_function_type (tree value_type, tree arg_types)
5964 {
5965   tree t;
5966   hashval_t hashcode = 0;
5967   bool any_structural_p, any_noncanonical_p;
5968   tree canon_argtypes;
5969
5970   if (TREE_CODE (value_type) == FUNCTION_TYPE)
5971     {
5972       error ("function return type cannot be function");
5973       value_type = integer_type_node;
5974     }
5975
5976   /* Make a node of the sort we want.  */
5977   t = make_node (FUNCTION_TYPE);
5978   TREE_TYPE (t) = value_type;
5979   TYPE_ARG_TYPES (t) = arg_types;
5980
5981   /* If we already have such a type, use the old one.  */
5982   hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
5983   hashcode = type_hash_list (arg_types, hashcode);
5984   t = type_hash_canon (hashcode, t);
5985
5986   /* Set up the canonical type. */
5987   any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
5988   any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
5989   canon_argtypes = maybe_canonicalize_argtypes (arg_types,
5990                                                 &any_structural_p,
5991                                                 &any_noncanonical_p);
5992   if (any_structural_p)
5993     SET_TYPE_STRUCTURAL_EQUALITY (t);
5994   else if (any_noncanonical_p)
5995     TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
5996                                               canon_argtypes);
5997
5998   if (!COMPLETE_TYPE_P (t))
5999     layout_type (t);
6000   return t;
6001 }
6002
6003 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.  */
6004
6005 tree
6006 build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
6007 {
6008   tree new_type = NULL;
6009   tree args, new_args = NULL, t;
6010   tree new_reversed;
6011   int i = 0;
6012
6013   for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
6014        args = TREE_CHAIN (args), i++)
6015     if (!bitmap_bit_p (args_to_skip, i))
6016       new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
6017
6018   new_reversed = nreverse (new_args);
6019   if (args)
6020     {
6021       if (new_reversed)
6022         TREE_CHAIN (new_args) = void_list_node;
6023       else
6024         new_reversed = void_list_node;
6025     }
6026     gcc_assert (new_reversed);
6027
6028   /* Use copy_node to preserve as much as possible from original type
6029      (debug info, attribute lists etc.)
6030      Exception is METHOD_TYPEs must have THIS argument.
6031      When we are asked to remove it, we need to build new FUNCTION_TYPE
6032      instead.  */
6033   if (TREE_CODE (orig_type) != METHOD_TYPE
6034       || !bitmap_bit_p (args_to_skip, 0))
6035     {
6036       new_type = copy_node (orig_type);
6037       TYPE_ARG_TYPES (new_type) = new_reversed;
6038     }
6039   else
6040     {
6041       new_type
6042         = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
6043                                                          new_reversed));
6044       TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
6045     }
6046
6047   /* This is a new type, not a copy of an old type.  Need to reassociate
6048      variants.  We can handle everything except the main variant lazily.  */
6049   t = TYPE_MAIN_VARIANT (orig_type);
6050   if (orig_type != t)
6051     {
6052       TYPE_MAIN_VARIANT (new_type) = t;
6053       TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
6054       TYPE_NEXT_VARIANT (t) = new_type;
6055     }
6056   else
6057     {
6058       TYPE_MAIN_VARIANT (new_type) = new_type;
6059       TYPE_NEXT_VARIANT (new_type) = NULL;
6060     }
6061   return new_type;
6062 }
6063
6064 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
6065
6066    Arguments from DECL_ARGUMENTS list can't be removed now, since they are
6067    linked by TREE_CHAIN directly.  It is caller responsibility to eliminate
6068    them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
6069
6070 tree
6071 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
6072 {
6073   tree new_decl = copy_node (orig_decl);
6074   tree new_type;
6075
6076   new_type = TREE_TYPE (orig_decl);
6077   if (prototype_p (new_type))
6078     new_type = build_function_type_skip_args (new_type, args_to_skip);
6079   TREE_TYPE (new_decl) = new_type;
6080
6081   /* For declarations setting DECL_VINDEX (i.e. methods)
6082      we expect first argument to be THIS pointer.   */
6083   if (bitmap_bit_p (args_to_skip, 0))
6084     DECL_VINDEX (new_decl) = NULL_TREE;
6085   return new_decl;
6086 }
6087
6088 /* Build a function type.  The RETURN_TYPE is the type returned by the
6089    function. If VAARGS is set, no void_type_node is appended to the
6090    the list. ARGP muse be alway be terminated be a NULL_TREE.  */
6091
6092 static tree
6093 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
6094 {
6095   tree t, args, last;
6096
6097   t = va_arg (argp, tree);
6098   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
6099     args = tree_cons (NULL_TREE, t, args);
6100
6101   if (vaargs)
6102     {
6103       last = args;
6104       if (args != NULL_TREE)
6105         args = nreverse (args);
6106       gcc_assert (args != NULL_TREE && last != void_list_node);
6107     }
6108   else if (args == NULL_TREE)
6109     args = void_list_node;
6110   else
6111     {
6112       last = args;
6113       args = nreverse (args);
6114       TREE_CHAIN (last) = void_list_node;
6115     }
6116   args = build_function_type (return_type, args);
6117
6118   return args;
6119 }
6120
6121 /* Build a function type.  The RETURN_TYPE is the type returned by the
6122    function.  If additional arguments are provided, they are
6123    additional argument types.  The list of argument types must always
6124    be terminated by NULL_TREE.  */
6125
6126 tree
6127 build_function_type_list (tree return_type, ...)
6128 {
6129   tree args;
6130   va_list p;
6131
6132   va_start (p, return_type);
6133   args = build_function_type_list_1 (false, return_type, p);
6134   va_end (p);
6135   return args;
6136 }
6137
6138 /* Build a variable argument function type.  The RETURN_TYPE is the
6139    type returned by the function.  If additional arguments are provided,
6140    they are additional argument types.  The list of argument types must
6141    always be terminated by NULL_TREE.  */
6142
6143 tree
6144 build_varargs_function_type_list (tree return_type, ...)
6145 {
6146   tree args;
6147   va_list p;
6148
6149   va_start (p, return_type);
6150   args = build_function_type_list_1 (true, return_type, p);
6151   va_end (p);
6152
6153   return args;
6154 }
6155
6156 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
6157    and ARGTYPES (a TREE_LIST) are the return type and arguments types
6158    for the method.  An implicit additional parameter (of type
6159    pointer-to-BASETYPE) is added to the ARGTYPES.  */
6160
6161 tree
6162 build_method_type_directly (tree basetype,
6163                             tree rettype,
6164                             tree argtypes)
6165 {
6166   tree t;
6167   tree ptype;
6168   int hashcode = 0;
6169   bool any_structural_p, any_noncanonical_p;
6170   tree canon_argtypes;
6171
6172   /* Make a node of the sort we want.  */
6173   t = make_node (METHOD_TYPE);
6174
6175   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
6176   TREE_TYPE (t) = rettype;
6177   ptype = build_pointer_type (basetype);
6178
6179   /* The actual arglist for this function includes a "hidden" argument
6180      which is "this".  Put it into the list of argument types.  */
6181   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
6182   TYPE_ARG_TYPES (t) = argtypes;
6183
6184   /* If we already have such a type, use the old one.  */
6185   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
6186   hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
6187   hashcode = type_hash_list (argtypes, hashcode);
6188   t = type_hash_canon (hashcode, t);
6189
6190   /* Set up the canonical type. */
6191   any_structural_p
6192     = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
6193        || TYPE_STRUCTURAL_EQUALITY_P (rettype));
6194   any_noncanonical_p
6195     = (TYPE_CANONICAL (basetype) != basetype
6196        || TYPE_CANONICAL (rettype) != rettype);
6197   canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
6198                                                 &any_structural_p,
6199                                                 &any_noncanonical_p);
6200   if (any_structural_p)
6201     SET_TYPE_STRUCTURAL_EQUALITY (t);
6202   else if (any_noncanonical_p)
6203     TYPE_CANONICAL (t)
6204       = build_method_type_directly (TYPE_CANONICAL (basetype),
6205                                     TYPE_CANONICAL (rettype),
6206                                     canon_argtypes);
6207   if (!COMPLETE_TYPE_P (t))
6208     layout_type (t);
6209
6210   return t;
6211 }
6212
6213 /* Construct, lay out and return the type of methods belonging to class
6214    BASETYPE and whose arguments and values are described by TYPE.
6215    If that type exists already, reuse it.
6216    TYPE must be a FUNCTION_TYPE node.  */
6217
6218 tree
6219 build_method_type (tree basetype, tree type)
6220 {
6221   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
6222
6223   return build_method_type_directly (basetype,
6224                                      TREE_TYPE (type),
6225                                      TYPE_ARG_TYPES (type));
6226 }
6227
6228 /* Construct, lay out and return the type of offsets to a value
6229    of type TYPE, within an object of type BASETYPE.
6230    If a suitable offset type exists already, reuse it.  */
6231
6232 tree
6233 build_offset_type (tree basetype, tree type)
6234 {
6235   tree t;
6236   hashval_t hashcode = 0;
6237
6238   /* Make a node of the sort we want.  */
6239   t = make_node (OFFSET_TYPE);
6240
6241   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
6242   TREE_TYPE (t) = type;
6243
6244   /* If we already have such a type, use the old one.  */
6245   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
6246   hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
6247   t = type_hash_canon (hashcode, t);
6248
6249   if (!COMPLETE_TYPE_P (t))
6250     layout_type (t);
6251
6252   if (TYPE_CANONICAL (t) == t)
6253     {
6254       if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
6255           || TYPE_STRUCTURAL_EQUALITY_P (type))
6256         SET_TYPE_STRUCTURAL_EQUALITY (t);
6257       else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
6258                || TYPE_CANONICAL (type) != type)
6259         TYPE_CANONICAL (t)
6260           = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
6261                                TYPE_CANONICAL (type));
6262     }
6263
6264   return t;
6265 }
6266
6267 /* Create a complex type whose components are COMPONENT_TYPE.  */
6268
6269 tree
6270 build_complex_type (tree component_type)
6271 {
6272   tree t;
6273   hashval_t hashcode;
6274
6275   gcc_assert (INTEGRAL_TYPE_P (component_type)
6276               || SCALAR_FLOAT_TYPE_P (component_type)
6277               || FIXED_POINT_TYPE_P (component_type));
6278
6279   /* Make a node of the sort we want.  */
6280   t = make_node (COMPLEX_TYPE);
6281
6282   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
6283
6284   /* If we already have such a type, use the old one.  */
6285   hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
6286   t = type_hash_canon (hashcode, t);
6287
6288   if (!COMPLETE_TYPE_P (t))
6289     layout_type (t);
6290
6291   if (TYPE_CANONICAL (t) == t)
6292     {
6293       if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
6294         SET_TYPE_STRUCTURAL_EQUALITY (t);
6295       else if (TYPE_CANONICAL (component_type) != component_type)
6296         TYPE_CANONICAL (t)
6297           = build_complex_type (TYPE_CANONICAL (component_type));
6298     }
6299
6300   /* We need to create a name, since complex is a fundamental type.  */
6301   if (! TYPE_NAME (t))
6302     {
6303       const char *name;
6304       if (component_type == char_type_node)
6305         name = "complex char";
6306       else if (component_type == signed_char_type_node)
6307         name = "complex signed char";
6308       else if (component_type == unsigned_char_type_node)
6309         name = "complex unsigned char";
6310       else if (component_type == short_integer_type_node)
6311         name = "complex short int";
6312       else if (component_type == short_unsigned_type_node)
6313         name = "complex short unsigned int";
6314       else if (component_type == integer_type_node)
6315         name = "complex int";
6316       else if (component_type == unsigned_type_node)
6317         name = "complex unsigned int";
6318       else if (component_type == long_integer_type_node)
6319         name = "complex long int";
6320       else if (component_type == long_unsigned_type_node)
6321         name = "complex long unsigned int";
6322       else if (component_type == long_long_integer_type_node)
6323         name = "complex long long int";
6324       else if (component_type == long_long_unsigned_type_node)
6325         name = "complex long long unsigned int";
6326       else
6327         name = 0;
6328
6329       if (name != 0)
6330         TYPE_NAME (t) = build_decl (TYPE_DECL, get_identifier (name), t);
6331     }
6332
6333   return build_qualified_type (t, TYPE_QUALS (component_type));
6334 }
6335
6336 /* If TYPE is a real or complex floating-point type and the target
6337    does not directly support arithmetic on TYPE then return the wider
6338    type to be used for arithmetic on TYPE.  Otherwise, return
6339    NULL_TREE.  */
6340
6341 tree
6342 excess_precision_type (tree type)
6343 {
6344   if (flag_excess_precision != EXCESS_PRECISION_FAST)
6345     {
6346       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
6347       switch (TREE_CODE (type))
6348         {
6349         case REAL_TYPE:
6350           switch (flt_eval_method)
6351             {
6352             case 1:
6353               if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
6354                 return double_type_node;
6355               break;
6356             case 2:
6357               if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
6358                   || TYPE_MODE (type) == TYPE_MODE (double_type_node))
6359                 return long_double_type_node;
6360               break;
6361             default:
6362               gcc_unreachable ();
6363             }
6364           break;
6365         case COMPLEX_TYPE:
6366           if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
6367             return NULL_TREE;
6368           switch (flt_eval_method)
6369             {
6370             case 1:
6371               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
6372                 return complex_double_type_node;
6373               break;
6374             case 2:
6375               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
6376                   || (TYPE_MODE (TREE_TYPE (type))
6377                       == TYPE_MODE (double_type_node)))
6378                 return complex_long_double_type_node;
6379               break;
6380             default:
6381               gcc_unreachable ();
6382             }
6383           break;
6384         default:
6385           break;
6386         }
6387     }
6388   return NULL_TREE;
6389 }
6390 \f
6391 /* Return OP, stripped of any conversions to wider types as much as is safe.
6392    Converting the value back to OP's type makes a value equivalent to OP.
6393
6394    If FOR_TYPE is nonzero, we return a value which, if converted to
6395    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
6396
6397    OP must have integer, real or enumeral type.  Pointers are not allowed!
6398
6399    There are some cases where the obvious value we could return
6400    would regenerate to OP if converted to OP's type,
6401    but would not extend like OP to wider types.
6402    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
6403    For example, if OP is (unsigned short)(signed char)-1,
6404    we avoid returning (signed char)-1 if FOR_TYPE is int,
6405    even though extending that to an unsigned short would regenerate OP,
6406    since the result of extending (signed char)-1 to (int)
6407    is different from (int) OP.  */
6408
6409 tree
6410 get_unwidened (tree op, tree for_type)
6411 {
6412   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
6413   tree type = TREE_TYPE (op);
6414   unsigned final_prec
6415     = TYPE_PRECISION (for_type != 0 ? for_type : type);
6416   int uns
6417     = (for_type != 0 && for_type != type
6418        && final_prec > TYPE_PRECISION (type)
6419        && TYPE_UNSIGNED (type));
6420   tree win = op;
6421
6422   while (CONVERT_EXPR_P (op))
6423     {
6424       int bitschange;
6425
6426       /* TYPE_PRECISION on vector types has different meaning
6427          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
6428          so avoid them here.  */
6429       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
6430         break;
6431
6432       bitschange = TYPE_PRECISION (TREE_TYPE (op))
6433                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
6434
6435       /* Truncations are many-one so cannot be removed.
6436          Unless we are later going to truncate down even farther.  */
6437       if (bitschange < 0
6438           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
6439         break;
6440
6441       /* See what's inside this conversion.  If we decide to strip it,
6442          we will set WIN.  */
6443       op = TREE_OPERAND (op, 0);
6444
6445       /* If we have not stripped any zero-extensions (uns is 0),
6446          we can strip any kind of extension.
6447          If we have previously stripped a zero-extension,
6448          only zero-extensions can safely be stripped.
6449          Any extension can be stripped if the bits it would produce
6450          are all going to be discarded later by truncating to FOR_TYPE.  */
6451
6452       if (bitschange > 0)
6453         {
6454           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
6455             win = op;
6456           /* TYPE_UNSIGNED says whether this is a zero-extension.
6457              Let's avoid computing it if it does not affect WIN
6458              and if UNS will not be needed again.  */
6459           if ((uns
6460                || CONVERT_EXPR_P (op))
6461               && TYPE_UNSIGNED (TREE_TYPE (op)))
6462             {
6463               uns = 1;
6464               win = op;
6465             }
6466         }
6467     }
6468
6469   return win;
6470 }
6471 \f
6472 /* Return OP or a simpler expression for a narrower value
6473    which can be sign-extended or zero-extended to give back OP.
6474    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
6475    or 0 if the value should be sign-extended.  */
6476
6477 tree
6478 get_narrower (tree op, int *unsignedp_ptr)
6479 {
6480   int uns = 0;
6481   int first = 1;
6482   tree win = op;
6483   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
6484
6485   while (TREE_CODE (op) == NOP_EXPR)
6486     {
6487       int bitschange
6488         = (TYPE_PRECISION (TREE_TYPE (op))
6489            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
6490
6491       /* Truncations are many-one so cannot be removed.  */
6492       if (bitschange < 0)
6493         break;
6494
6495       /* See what's inside this conversion.  If we decide to strip it,
6496          we will set WIN.  */
6497
6498       if (bitschange > 0)
6499         {
6500           op = TREE_OPERAND (op, 0);
6501           /* An extension: the outermost one can be stripped,
6502              but remember whether it is zero or sign extension.  */
6503           if (first)
6504             uns = TYPE_UNSIGNED (TREE_TYPE (op));
6505           /* Otherwise, if a sign extension has been stripped,
6506              only sign extensions can now be stripped;
6507              if a zero extension has been stripped, only zero-extensions.  */
6508           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
6509             break;
6510           first = 0;
6511         }
6512       else /* bitschange == 0 */
6513         {
6514           /* A change in nominal type can always be stripped, but we must
6515              preserve the unsignedness.  */
6516           if (first)
6517             uns = TYPE_UNSIGNED (TREE_TYPE (op));
6518           first = 0;
6519           op = TREE_OPERAND (op, 0);
6520           /* Keep trying to narrow, but don't assign op to win if it
6521              would turn an integral type into something else.  */
6522           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
6523             continue;
6524         }
6525
6526       win = op;
6527     }
6528
6529   if (TREE_CODE (op) == COMPONENT_REF
6530       /* Since type_for_size always gives an integer type.  */
6531       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
6532       && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
6533       /* Ensure field is laid out already.  */
6534       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
6535       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
6536     {
6537       unsigned HOST_WIDE_INT innerprec
6538         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
6539       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
6540                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
6541       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
6542
6543       /* We can get this structure field in a narrower type that fits it,
6544          but the resulting extension to its nominal type (a fullword type)
6545          must satisfy the same conditions as for other extensions.
6546
6547          Do this only for fields that are aligned (not bit-fields),
6548          because when bit-field insns will be used there is no
6549          advantage in doing this.  */
6550
6551       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
6552           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
6553           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
6554           && type != 0)
6555         {
6556           if (first)
6557             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
6558           win = fold_convert (type, op);
6559         }
6560     }
6561
6562   *unsignedp_ptr = uns;
6563   return win;
6564 }
6565 \f
6566 /* Nonzero if integer constant C has a value that is permissible
6567    for type TYPE (an INTEGER_TYPE).  */
6568
6569 int
6570 int_fits_type_p (const_tree c, const_tree type)
6571 {
6572   tree type_low_bound, type_high_bound;
6573   bool ok_for_low_bound, ok_for_high_bound, unsc;
6574   double_int dc, dd;
6575
6576   dc = tree_to_double_int (c);
6577   unsc = TYPE_UNSIGNED (TREE_TYPE (c));
6578
6579   if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE
6580       && TYPE_IS_SIZETYPE (TREE_TYPE (c))
6581       && unsc)
6582     /* So c is an unsigned integer whose type is sizetype and type is not.
6583        sizetype'd integers are sign extended even though they are
6584        unsigned. If the integer value fits in the lower end word of c,
6585        and if the higher end word has all its bits set to 1, that
6586        means the higher end bits are set to 1 only for sign extension.
6587        So let's convert c into an equivalent zero extended unsigned
6588        integer.  */
6589     dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c)));
6590
6591 retry:
6592   type_low_bound = TYPE_MIN_VALUE (type);
6593   type_high_bound = TYPE_MAX_VALUE (type);
6594
6595   /* If at least one bound of the type is a constant integer, we can check
6596      ourselves and maybe make a decision. If no such decision is possible, but
6597      this type is a subtype, try checking against that.  Otherwise, use
6598      fit_double_type, which checks against the precision.
6599
6600      Compute the status for each possibly constant bound, and return if we see
6601      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
6602      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
6603      for "constant known to fit".  */
6604
6605   /* Check if c >= type_low_bound.  */
6606   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
6607     {
6608       dd = tree_to_double_int (type_low_bound);
6609       if (TREE_CODE (type) == INTEGER_TYPE
6610           && TYPE_IS_SIZETYPE (type)
6611           && TYPE_UNSIGNED (type))
6612         dd = double_int_zext (dd, TYPE_PRECISION (type));
6613       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
6614         {
6615           int c_neg = (!unsc && double_int_negative_p (dc));
6616           int t_neg = (unsc && double_int_negative_p (dd));
6617
6618           if (c_neg && !t_neg)
6619             return 0;
6620           if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0)
6621             return 0;
6622         }
6623       else if (double_int_cmp (dc, dd, unsc) < 0)
6624         return 0;
6625       ok_for_low_bound = true;
6626     }
6627   else
6628     ok_for_low_bound = false;
6629
6630   /* Check if c <= type_high_bound.  */
6631   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
6632     {
6633       dd = tree_to_double_int (type_high_bound);
6634       if (TREE_CODE (type) == INTEGER_TYPE
6635           && TYPE_IS_SIZETYPE (type)
6636           && TYPE_UNSIGNED (type))
6637         dd = double_int_zext (dd, TYPE_PRECISION (type));
6638       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
6639         {
6640           int c_neg = (!unsc && double_int_negative_p (dc));
6641           int t_neg = (unsc && double_int_negative_p (dd));
6642
6643           if (t_neg && !c_neg)
6644             return 0;
6645           if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0)
6646             return 0;
6647         }
6648       else if (double_int_cmp (dc, dd, unsc) > 0)
6649         return 0;
6650       ok_for_high_bound = true;
6651     }
6652   else
6653     ok_for_high_bound = false;
6654
6655   /* If the constant fits both bounds, the result is known.  */
6656   if (ok_for_low_bound && ok_for_high_bound)
6657     return 1;
6658
6659   /* Perform some generic filtering which may allow making a decision
6660      even if the bounds are not constant.  First, negative integers
6661      never fit in unsigned types, */
6662   if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc))
6663     return 0;
6664
6665   /* Second, narrower types always fit in wider ones.  */
6666   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
6667     return 1;
6668
6669   /* Third, unsigned integers with top bit set never fit signed types.  */
6670   if (! TYPE_UNSIGNED (type) && unsc)
6671     {
6672       int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1;
6673       if (prec < HOST_BITS_PER_WIDE_INT)
6674         {
6675           if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
6676             return 0;
6677         }
6678       else if (((((unsigned HOST_WIDE_INT) 1)
6679                  << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
6680         return 0;
6681     }
6682
6683   /* If we haven't been able to decide at this point, there nothing more we
6684      can check ourselves here.  Look at the base type if we have one and it
6685      has the same precision.  */
6686   if (TREE_CODE (type) == INTEGER_TYPE
6687       && TREE_TYPE (type) != 0
6688       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
6689     {
6690       type = TREE_TYPE (type);
6691       goto retry;
6692     }
6693
6694   /* Or to fit_double_type, if nothing else.  */
6695   return !fit_double_type (dc.low, dc.high, &dc.low, &dc.high, type);
6696 }
6697
6698 /* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
6699    bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
6700    represented (assuming two's-complement arithmetic) within the bit
6701    precision of the type are returned instead.  */
6702
6703 void
6704 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
6705 {
6706   if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
6707       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
6708     mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
6709                         TYPE_UNSIGNED (type));
6710   else
6711     {
6712       if (TYPE_UNSIGNED (type))
6713         mpz_set_ui (min, 0);
6714       else
6715         {
6716           double_int mn;
6717           mn = double_int_mask (TYPE_PRECISION (type) - 1);
6718           mn = double_int_sext (double_int_add (mn, double_int_one),
6719                                 TYPE_PRECISION (type));
6720           mpz_set_double_int (min, mn, false);
6721         }
6722     }
6723
6724   if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
6725       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
6726     mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
6727                         TYPE_UNSIGNED (type));
6728   else
6729     {
6730       if (TYPE_UNSIGNED (type))
6731         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)),
6732                             true);
6733       else
6734         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1),
6735                             true);
6736     }
6737 }
6738
6739 /* Return true if VAR is an automatic variable defined in function FN.  */
6740
6741 bool
6742 auto_var_in_fn_p (const_tree var, const_tree fn)
6743 {
6744   return (DECL_P (var) && DECL_CONTEXT (var) == fn
6745           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
6746                && ! TREE_STATIC (var))
6747               || TREE_CODE (var) == LABEL_DECL
6748               || TREE_CODE (var) == RESULT_DECL));
6749 }
6750
6751 /* Subprogram of following function.  Called by walk_tree.
6752
6753    Return *TP if it is an automatic variable or parameter of the
6754    function passed in as DATA.  */
6755
6756 static tree
6757 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
6758 {
6759   tree fn = (tree) data;
6760
6761   if (TYPE_P (*tp))
6762     *walk_subtrees = 0;
6763
6764   else if (DECL_P (*tp)
6765            && auto_var_in_fn_p (*tp, fn))
6766     return *tp;
6767
6768   return NULL_TREE;
6769 }
6770
6771 /* Returns true if T is, contains, or refers to a type with variable
6772    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
6773    arguments, but not the return type.  If FN is nonzero, only return
6774    true if a modifier of the type or position of FN is a variable or
6775    parameter inside FN.
6776
6777    This concept is more general than that of C99 'variably modified types':
6778    in C99, a struct type is never variably modified because a VLA may not
6779    appear as a structure member.  However, in GNU C code like:
6780
6781      struct S { int i[f()]; };
6782
6783    is valid, and other languages may define similar constructs.  */
6784
6785 bool
6786 variably_modified_type_p (tree type, tree fn)
6787 {
6788   tree t;
6789
6790 /* Test if T is either variable (if FN is zero) or an expression containing
6791    a variable in FN.  */
6792 #define RETURN_TRUE_IF_VAR(T)                                           \
6793   do { tree _t = (T);                                                   \
6794     if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
6795         && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
6796       return true;  } while (0)
6797
6798   if (type == error_mark_node)
6799     return false;
6800
6801   /* If TYPE itself has variable size, it is variably modified.  */
6802   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
6803   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
6804
6805   switch (TREE_CODE (type))
6806     {
6807     case POINTER_TYPE:
6808     case REFERENCE_TYPE:
6809     case VECTOR_TYPE:
6810       if (variably_modified_type_p (TREE_TYPE (type), fn))
6811         return true;
6812       break;
6813
6814     case FUNCTION_TYPE:
6815     case METHOD_TYPE:
6816       /* If TYPE is a function type, it is variably modified if the
6817          return type is variably modified.  */
6818       if (variably_modified_type_p (TREE_TYPE (type), fn))
6819           return true;
6820       break;
6821
6822     case INTEGER_TYPE:
6823     case REAL_TYPE:
6824     case FIXED_POINT_TYPE:
6825     case ENUMERAL_TYPE:
6826     case BOOLEAN_TYPE:
6827       /* Scalar types are variably modified if their end points
6828          aren't constant.  */
6829       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
6830       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
6831       break;
6832
6833     case RECORD_TYPE:
6834     case UNION_TYPE:
6835     case QUAL_UNION_TYPE:
6836       /* We can't see if any of the fields are variably-modified by the
6837          definition we normally use, since that would produce infinite
6838          recursion via pointers.  */
6839       /* This is variably modified if some field's type is.  */
6840       for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
6841         if (TREE_CODE (t) == FIELD_DECL)
6842           {
6843             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
6844             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
6845             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
6846
6847             if (TREE_CODE (type) == QUAL_UNION_TYPE)
6848               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
6849           }
6850         break;
6851
6852     case ARRAY_TYPE:
6853       /* Do not call ourselves to avoid infinite recursion.  This is
6854          variably modified if the element type is.  */
6855       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
6856       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
6857       break;
6858
6859     default:
6860       break;
6861     }
6862
6863   /* The current language may have other cases to check, but in general,
6864      all other types are not variably modified.  */
6865   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
6866
6867 #undef RETURN_TRUE_IF_VAR
6868 }
6869
6870 /* Given a DECL or TYPE, return the scope in which it was declared, or
6871    NULL_TREE if there is no containing scope.  */
6872
6873 tree
6874 get_containing_scope (const_tree t)
6875 {
6876   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
6877 }
6878
6879 /* Return the innermost context enclosing DECL that is
6880    a FUNCTION_DECL, or zero if none.  */
6881
6882 tree
6883 decl_function_context (const_tree decl)
6884 {
6885   tree context;
6886
6887   if (TREE_CODE (decl) == ERROR_MARK)
6888     return 0;
6889
6890   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
6891      where we look up the function at runtime.  Such functions always take
6892      a first argument of type 'pointer to real context'.
6893
6894      C++ should really be fixed to use DECL_CONTEXT for the real context,
6895      and use something else for the "virtual context".  */
6896   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
6897     context
6898       = TYPE_MAIN_VARIANT
6899         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
6900   else
6901     context = DECL_CONTEXT (decl);
6902
6903   while (context && TREE_CODE (context) != FUNCTION_DECL)
6904     {
6905       if (TREE_CODE (context) == BLOCK)
6906         context = BLOCK_SUPERCONTEXT (context);
6907       else
6908         context = get_containing_scope (context);
6909     }
6910
6911   return context;
6912 }
6913
6914 /* Return the innermost context enclosing DECL that is
6915    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
6916    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
6917
6918 tree
6919 decl_type_context (const_tree decl)
6920 {
6921   tree context = DECL_CONTEXT (decl);
6922
6923   while (context)
6924     switch (TREE_CODE (context))
6925       {
6926       case NAMESPACE_DECL:
6927       case TRANSLATION_UNIT_DECL:
6928         return NULL_TREE;
6929
6930       case RECORD_TYPE:
6931       case UNION_TYPE:
6932       case QUAL_UNION_TYPE:
6933         return context;
6934
6935       case TYPE_DECL:
6936       case FUNCTION_DECL:
6937         context = DECL_CONTEXT (context);
6938         break;
6939
6940       case BLOCK:
6941         context = BLOCK_SUPERCONTEXT (context);
6942         break;
6943
6944       default:
6945         gcc_unreachable ();
6946       }
6947
6948   return NULL_TREE;
6949 }
6950
6951 /* CALL is a CALL_EXPR.  Return the declaration for the function
6952    called, or NULL_TREE if the called function cannot be
6953    determined.  */
6954
6955 tree
6956 get_callee_fndecl (const_tree call)
6957 {
6958   tree addr;
6959
6960   if (call == error_mark_node)
6961     return error_mark_node;
6962
6963   /* It's invalid to call this function with anything but a
6964      CALL_EXPR.  */
6965   gcc_assert (TREE_CODE (call) == CALL_EXPR);
6966
6967   /* The first operand to the CALL is the address of the function
6968      called.  */
6969   addr = CALL_EXPR_FN (call);
6970
6971   STRIP_NOPS (addr);
6972
6973   /* If this is a readonly function pointer, extract its initial value.  */
6974   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
6975       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
6976       && DECL_INITIAL (addr))
6977     addr = DECL_INITIAL (addr);
6978
6979   /* If the address is just `&f' for some function `f', then we know
6980      that `f' is being called.  */
6981   if (TREE_CODE (addr) == ADDR_EXPR
6982       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
6983     return TREE_OPERAND (addr, 0);
6984
6985   /* We couldn't figure out what was being called.  */
6986   return NULL_TREE;
6987 }
6988
6989 /* Print debugging information about tree nodes generated during the compile,
6990    and any language-specific information.  */
6991
6992 void
6993 dump_tree_statistics (void)
6994 {
6995 #ifdef GATHER_STATISTICS
6996   int i;
6997   int total_nodes, total_bytes;
6998 #endif
6999
7000   fprintf (stderr, "\n??? tree nodes created\n\n");
7001 #ifdef GATHER_STATISTICS
7002   fprintf (stderr, "Kind                   Nodes      Bytes\n");
7003   fprintf (stderr, "---------------------------------------\n");
7004   total_nodes = total_bytes = 0;
7005   for (i = 0; i < (int) all_kinds; i++)
7006     {
7007       fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
7008                tree_node_counts[i], tree_node_sizes[i]);
7009       total_nodes += tree_node_counts[i];
7010       total_bytes += tree_node_sizes[i];
7011     }
7012   fprintf (stderr, "---------------------------------------\n");
7013   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
7014   fprintf (stderr, "---------------------------------------\n");
7015   ssanames_print_statistics ();
7016   phinodes_print_statistics ();
7017 #else
7018   fprintf (stderr, "(No per-node statistics)\n");
7019 #endif
7020   print_type_hash_statistics ();
7021   print_debug_expr_statistics ();
7022   print_value_expr_statistics ();
7023   print_restrict_base_statistics ();
7024   lang_hooks.print_statistics ();
7025 }
7026 \f
7027 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
7028
7029 /* Generate a crc32 of a string.  */
7030
7031 unsigned
7032 crc32_string (unsigned chksum, const char *string)
7033 {
7034   do
7035     {
7036       unsigned value = *string << 24;
7037       unsigned ix;
7038
7039       for (ix = 8; ix--; value <<= 1)
7040         {
7041           unsigned feedback;
7042
7043           feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
7044           chksum <<= 1;
7045           chksum ^= feedback;
7046         }
7047     }
7048   while (*string++);
7049   return chksum;
7050 }
7051
7052 /* P is a string that will be used in a symbol.  Mask out any characters
7053    that are not valid in that context.  */
7054
7055 void
7056 clean_symbol_name (char *p)
7057 {
7058   for (; *p; p++)
7059     if (! (ISALNUM (*p)
7060 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
7061             || *p == '$'
7062 #endif
7063 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
7064             || *p == '.'
7065 #endif
7066            ))
7067       *p = '_';
7068 }
7069
7070 /* Generate a name for a special-purpose function function.
7071    The generated name may need to be unique across the whole link.
7072    TYPE is some string to identify the purpose of this function to the
7073    linker or collect2; it must start with an uppercase letter,
7074    one of:
7075    I - for constructors
7076    D - for destructors
7077    N - for C++ anonymous namespaces
7078    F - for DWARF unwind frame information.  */
7079
7080 tree
7081 get_file_function_name (const char *type)
7082 {
7083   char *buf;
7084   const char *p;
7085   char *q;
7086
7087   /* If we already have a name we know to be unique, just use that.  */
7088   if (first_global_object_name)
7089     p = q = ASTRDUP (first_global_object_name);
7090   /* If the target is handling the constructors/destructors, they
7091      will be local to this file and the name is only necessary for
7092      debugging purposes.  */
7093   else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
7094     {
7095       const char *file = main_input_filename;
7096       if (! file)
7097         file = input_filename;
7098       /* Just use the file's basename, because the full pathname
7099          might be quite long.  */
7100       p = strrchr (file, '/');
7101       if (p)
7102         p++;
7103       else
7104         p = file;
7105       p = q = ASTRDUP (p);
7106     }
7107   else
7108     {
7109       /* Otherwise, the name must be unique across the entire link.
7110          We don't have anything that we know to be unique to this translation
7111          unit, so use what we do have and throw in some randomness.  */
7112       unsigned len;
7113       const char *name = weak_global_object_name;
7114       const char *file = main_input_filename;
7115
7116       if (! name)
7117         name = "";
7118       if (! file)
7119         file = input_filename;
7120
7121       len = strlen (file);
7122       q = (char *) alloca (9 * 2 + len + 1);
7123       memcpy (q, file, len + 1);
7124
7125       sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
7126                crc32_string (0, get_random_seed (false)));
7127
7128       p = q;
7129     }
7130
7131   clean_symbol_name (q);
7132   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
7133                          + strlen (type));
7134
7135   /* Set up the name of the file-level functions we may need.
7136      Use a global object (which is already required to be unique over
7137      the program) rather than the file name (which imposes extra
7138      constraints).  */
7139   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
7140
7141   return get_identifier (buf);
7142 }
7143 \f
7144 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
7145
7146 /* Complain that the tree code of NODE does not match the expected 0
7147    terminated list of trailing codes. The trailing code list can be
7148    empty, for a more vague error message.  FILE, LINE, and FUNCTION
7149    are of the caller.  */
7150
7151 void
7152 tree_check_failed (const_tree node, const char *file,
7153                    int line, const char *function, ...)
7154 {
7155   va_list args;
7156   const char *buffer;
7157   unsigned length = 0;
7158   int code;
7159
7160   va_start (args, function);
7161   while ((code = va_arg (args, int)))
7162     length += 4 + strlen (tree_code_name[code]);
7163   va_end (args);
7164   if (length)
7165     {
7166       char *tmp;
7167       va_start (args, function);
7168       length += strlen ("expected ");
7169       buffer = tmp = (char *) alloca (length);
7170       length = 0;
7171       while ((code = va_arg (args, int)))
7172         {
7173           const char *prefix = length ? " or " : "expected ";
7174
7175           strcpy (tmp + length, prefix);
7176           length += strlen (prefix);
7177           strcpy (tmp + length, tree_code_name[code]);
7178           length += strlen (tree_code_name[code]);
7179         }
7180       va_end (args);
7181     }
7182   else
7183     buffer = "unexpected node";
7184
7185   internal_error ("tree check: %s, have %s in %s, at %s:%d",
7186                   buffer, tree_code_name[TREE_CODE (node)],
7187                   function, trim_filename (file), line);
7188 }
7189
7190 /* Complain that the tree code of NODE does match the expected 0
7191    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
7192    the caller.  */
7193
7194 void
7195 tree_not_check_failed (const_tree node, const char *file,
7196                        int line, const char *function, ...)
7197 {
7198   va_list args;
7199   char *buffer;
7200   unsigned length = 0;
7201   int code;
7202
7203   va_start (args, function);
7204   while ((code = va_arg (args, int)))
7205     length += 4 + strlen (tree_code_name[code]);
7206   va_end (args);
7207   va_start (args, function);
7208   buffer = (char *) alloca (length);
7209   length = 0;
7210   while ((code = va_arg (args, int)))
7211     {
7212       if (length)
7213         {
7214           strcpy (buffer + length, " or ");
7215           length += 4;
7216         }
7217       strcpy (buffer + length, tree_code_name[code]);
7218       length += strlen (tree_code_name[code]);
7219     }
7220   va_end (args);
7221
7222   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
7223                   buffer, tree_code_name[TREE_CODE (node)],
7224                   function, trim_filename (file), line);
7225 }
7226
7227 /* Similar to tree_check_failed, except that we check for a class of tree
7228    code, given in CL.  */
7229
7230 void
7231 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
7232                          const char *file, int line, const char *function)
7233 {
7234   internal_error
7235     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
7236      TREE_CODE_CLASS_STRING (cl),
7237      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
7238      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
7239 }
7240
7241 /* Similar to tree_check_failed, except that instead of specifying a
7242    dozen codes, use the knowledge that they're all sequential.  */
7243
7244 void
7245 tree_range_check_failed (const_tree node, const char *file, int line,
7246                          const char *function, enum tree_code c1,
7247                          enum tree_code c2)
7248 {
7249   char *buffer;
7250   unsigned length = 0;
7251   unsigned int c;
7252
7253   for (c = c1; c <= c2; ++c)
7254     length += 4 + strlen (tree_code_name[c]);
7255
7256   length += strlen ("expected ");
7257   buffer = (char *) alloca (length);
7258   length = 0;
7259
7260   for (c = c1; c <= c2; ++c)
7261     {
7262       const char *prefix = length ? " or " : "expected ";
7263
7264       strcpy (buffer + length, prefix);
7265       length += strlen (prefix);
7266       strcpy (buffer + length, tree_code_name[c]);
7267       length += strlen (tree_code_name[c]);
7268     }
7269
7270   internal_error ("tree check: %s, have %s in %s, at %s:%d",
7271                   buffer, tree_code_name[TREE_CODE (node)],
7272                   function, trim_filename (file), line);
7273 }
7274
7275
7276 /* Similar to tree_check_failed, except that we check that a tree does
7277    not have the specified code, given in CL.  */
7278
7279 void
7280 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
7281                              const char *file, int line, const char *function)
7282 {
7283   internal_error
7284     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
7285      TREE_CODE_CLASS_STRING (cl),
7286      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
7287      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
7288 }
7289
7290
7291 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
7292
7293 void
7294 omp_clause_check_failed (const_tree node, const char *file, int line,
7295                          const char *function, enum omp_clause_code code)
7296 {
7297   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
7298                   omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
7299                   function, trim_filename (file), line);
7300 }
7301
7302
7303 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
7304
7305 void
7306 omp_clause_range_check_failed (const_tree node, const char *file, int line,
7307                                const char *function, enum omp_clause_code c1,
7308                                enum omp_clause_code c2)
7309 {
7310   char *buffer;
7311   unsigned length = 0;
7312   unsigned int c;
7313
7314   for (c = c1; c <= c2; ++c)
7315     length += 4 + strlen (omp_clause_code_name[c]);
7316
7317   length += strlen ("expected ");
7318   buffer = (char *) alloca (length);
7319   length = 0;
7320
7321   for (c = c1; c <= c2; ++c)
7322     {
7323       const char *prefix = length ? " or " : "expected ";
7324
7325       strcpy (buffer + length, prefix);
7326       length += strlen (prefix);
7327       strcpy (buffer + length, omp_clause_code_name[c]);
7328       length += strlen (omp_clause_code_name[c]);
7329     }
7330
7331   internal_error ("tree check: %s, have %s in %s, at %s:%d",
7332                   buffer, omp_clause_code_name[TREE_CODE (node)],
7333                   function, trim_filename (file), line);
7334 }
7335
7336
7337 #undef DEFTREESTRUCT
7338 #define DEFTREESTRUCT(VAL, NAME) NAME,
7339
7340 static const char *ts_enum_names[] = {
7341 #include "treestruct.def"
7342 };
7343 #undef DEFTREESTRUCT
7344
7345 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
7346
7347 /* Similar to tree_class_check_failed, except that we check for
7348    whether CODE contains the tree structure identified by EN.  */
7349
7350 void
7351 tree_contains_struct_check_failed (const_tree node,
7352                                    const enum tree_node_structure_enum en,
7353                                    const char *file, int line,
7354                                    const char *function)
7355 {
7356   internal_error
7357     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
7358      TS_ENUM_NAME(en),
7359      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
7360 }
7361
7362
7363 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
7364    (dynamically sized) vector.  */
7365
7366 void
7367 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
7368                            const char *function)
7369 {
7370   internal_error
7371     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
7372      idx + 1, len, function, trim_filename (file), line);
7373 }
7374
7375 /* Similar to above, except that the check is for the bounds of the operand
7376    vector of an expression node EXP.  */
7377
7378 void
7379 tree_operand_check_failed (int idx, const_tree exp, const char *file,
7380                            int line, const char *function)
7381 {
7382   int code = TREE_CODE (exp);
7383   internal_error
7384     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
7385      idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
7386      function, trim_filename (file), line);
7387 }
7388
7389 /* Similar to above, except that the check is for the number of
7390    operands of an OMP_CLAUSE node.  */
7391
7392 void
7393 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
7394                                  int line, const char *function)
7395 {
7396   internal_error
7397     ("tree check: accessed operand %d of omp_clause %s with %d operands "
7398      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
7399      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
7400      trim_filename (file), line);
7401 }
7402 #endif /* ENABLE_TREE_CHECKING */
7403 \f
7404 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
7405    and mapped to the machine mode MODE.  Initialize its fields and build
7406    the information necessary for debugging output.  */
7407
7408 static tree
7409 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
7410 {
7411   tree t;
7412   hashval_t hashcode = 0;
7413
7414   /* Build a main variant, based on the main variant of the inner type, then
7415      use it to build the variant we return.  */
7416   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
7417       && TYPE_MAIN_VARIANT (innertype) != innertype)
7418     return build_type_attribute_qual_variant (
7419             make_vector_type (TYPE_MAIN_VARIANT (innertype), nunits, mode),
7420             TYPE_ATTRIBUTES (innertype),
7421             TYPE_QUALS (innertype));
7422
7423   t = make_node (VECTOR_TYPE);
7424   TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
7425   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
7426   SET_TYPE_MODE (t, mode);
7427   TYPE_READONLY (t) = TYPE_READONLY (innertype);
7428   TYPE_VOLATILE (t) = TYPE_VOLATILE (innertype);
7429
7430   if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
7431     SET_TYPE_STRUCTURAL_EQUALITY (t);
7432   else if (TYPE_CANONICAL (innertype) != innertype
7433            || mode != VOIDmode)
7434     TYPE_CANONICAL (t)
7435       = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
7436
7437   layout_type (t);
7438
7439   {
7440     tree index = build_int_cst (NULL_TREE, nunits - 1);
7441     tree array = build_array_type (innertype, build_index_type (index));
7442     tree rt = make_node (RECORD_TYPE);
7443
7444     TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
7445     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
7446     layout_type (rt);
7447     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
7448     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
7449        the representation type, and we want to find that die when looking up
7450        the vector type.  This is most easily achieved by making the TYPE_UID
7451        numbers equal.  */
7452     TYPE_UID (rt) = TYPE_UID (t);
7453   }
7454
7455   hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
7456   hashcode = iterative_hash_host_wide_int (mode, hashcode);
7457   hashcode = iterative_hash_object (TYPE_HASH (innertype), hashcode);
7458   return type_hash_canon (hashcode, t);
7459 }
7460
7461 static tree
7462 make_or_reuse_type (unsigned size, int unsignedp)
7463 {
7464   if (size == INT_TYPE_SIZE)
7465     return unsignedp ? unsigned_type_node : integer_type_node;
7466   if (size == CHAR_TYPE_SIZE)
7467     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
7468   if (size == SHORT_TYPE_SIZE)
7469     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
7470   if (size == LONG_TYPE_SIZE)
7471     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
7472   if (size == LONG_LONG_TYPE_SIZE)
7473     return (unsignedp ? long_long_unsigned_type_node
7474             : long_long_integer_type_node);
7475
7476   if (unsignedp)
7477     return make_unsigned_type (size);
7478   else
7479     return make_signed_type (size);
7480 }
7481
7482 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
7483
7484 static tree
7485 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
7486 {
7487   if (satp)
7488     {
7489       if (size == SHORT_FRACT_TYPE_SIZE)
7490         return unsignedp ? sat_unsigned_short_fract_type_node
7491                          : sat_short_fract_type_node;
7492       if (size == FRACT_TYPE_SIZE)
7493         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
7494       if (size == LONG_FRACT_TYPE_SIZE)
7495         return unsignedp ? sat_unsigned_long_fract_type_node
7496                          : sat_long_fract_type_node;
7497       if (size == LONG_LONG_FRACT_TYPE_SIZE)
7498         return unsignedp ? sat_unsigned_long_long_fract_type_node
7499                          : sat_long_long_fract_type_node;
7500     }
7501   else
7502     {
7503       if (size == SHORT_FRACT_TYPE_SIZE)
7504         return unsignedp ? unsigned_short_fract_type_node
7505                          : short_fract_type_node;
7506       if (size == FRACT_TYPE_SIZE)
7507         return unsignedp ? unsigned_fract_type_node : fract_type_node;
7508       if (size == LONG_FRACT_TYPE_SIZE)
7509         return unsignedp ? unsigned_long_fract_type_node
7510                          : long_fract_type_node;
7511       if (size == LONG_LONG_FRACT_TYPE_SIZE)
7512         return unsignedp ? unsigned_long_long_fract_type_node
7513                          : long_long_fract_type_node;
7514     }
7515
7516   return make_fract_type (size, unsignedp, satp);
7517 }
7518
7519 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
7520
7521 static tree
7522 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
7523 {
7524   if (satp)
7525     {
7526       if (size == SHORT_ACCUM_TYPE_SIZE)
7527         return unsignedp ? sat_unsigned_short_accum_type_node
7528                          : sat_short_accum_type_node;
7529       if (size == ACCUM_TYPE_SIZE)
7530         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
7531       if (size == LONG_ACCUM_TYPE_SIZE)
7532         return unsignedp ? sat_unsigned_long_accum_type_node
7533                          : sat_long_accum_type_node;
7534       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
7535         return unsignedp ? sat_unsigned_long_long_accum_type_node
7536                          : sat_long_long_accum_type_node;
7537     }
7538   else
7539     {
7540       if (size == SHORT_ACCUM_TYPE_SIZE)
7541         return unsignedp ? unsigned_short_accum_type_node
7542                          : short_accum_type_node;
7543       if (size == ACCUM_TYPE_SIZE)
7544         return unsignedp ? unsigned_accum_type_node : accum_type_node;
7545       if (size == LONG_ACCUM_TYPE_SIZE)
7546         return unsignedp ? unsigned_long_accum_type_node
7547                          : long_accum_type_node;
7548       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
7549         return unsignedp ? unsigned_long_long_accum_type_node
7550                          : long_long_accum_type_node;
7551     }
7552
7553   return make_accum_type (size, unsignedp, satp);
7554 }
7555
7556 /* Create nodes for all integer types (and error_mark_node) using the sizes
7557    of C datatypes.  The caller should call set_sizetype soon after calling
7558    this function to select one of the types as sizetype.  */
7559
7560 void
7561 build_common_tree_nodes (bool signed_char, bool signed_sizetype)
7562 {
7563   error_mark_node = make_node (ERROR_MARK);
7564   TREE_TYPE (error_mark_node) = error_mark_node;
7565
7566   initialize_sizetypes (signed_sizetype);
7567
7568   /* Define both `signed char' and `unsigned char'.  */
7569   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
7570   TYPE_STRING_FLAG (signed_char_type_node) = 1;
7571   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
7572   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
7573
7574   /* Define `char', which is like either `signed char' or `unsigned char'
7575      but not the same as either.  */
7576   char_type_node
7577     = (signed_char
7578        ? make_signed_type (CHAR_TYPE_SIZE)
7579        : make_unsigned_type (CHAR_TYPE_SIZE));
7580   TYPE_STRING_FLAG (char_type_node) = 1;
7581
7582   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
7583   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
7584   integer_type_node = make_signed_type (INT_TYPE_SIZE);
7585   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
7586   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
7587   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
7588   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
7589   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
7590
7591   /* Define a boolean type.  This type only represents boolean values but
7592      may be larger than char depending on the value of BOOL_TYPE_SIZE.
7593      Front ends which want to override this size (i.e. Java) can redefine
7594      boolean_type_node before calling build_common_tree_nodes_2.  */
7595   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
7596   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
7597   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
7598   TYPE_PRECISION (boolean_type_node) = 1;
7599
7600   /* Fill in the rest of the sized types.  Reuse existing type nodes
7601      when possible.  */
7602   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
7603   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
7604   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
7605   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
7606   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
7607
7608   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
7609   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
7610   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
7611   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
7612   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
7613
7614   access_public_node = get_identifier ("public");
7615   access_protected_node = get_identifier ("protected");
7616   access_private_node = get_identifier ("private");
7617 }
7618
7619 /* Call this function after calling build_common_tree_nodes and set_sizetype.
7620    It will create several other common tree nodes.  */
7621
7622 void
7623 build_common_tree_nodes_2 (int short_double)
7624 {
7625   /* Define these next since types below may used them.  */
7626   integer_zero_node = build_int_cst (NULL_TREE, 0);
7627   integer_one_node = build_int_cst (NULL_TREE, 1);
7628   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
7629
7630   size_zero_node = size_int (0);
7631   size_one_node = size_int (1);
7632   bitsize_zero_node = bitsize_int (0);
7633   bitsize_one_node = bitsize_int (1);
7634   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
7635
7636   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
7637   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
7638
7639   void_type_node = make_node (VOID_TYPE);
7640   layout_type (void_type_node);
7641
7642   /* We are not going to have real types in C with less than byte alignment,
7643      so we might as well not have any types that claim to have it.  */
7644   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
7645   TYPE_USER_ALIGN (void_type_node) = 0;
7646
7647   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
7648   layout_type (TREE_TYPE (null_pointer_node));
7649
7650   ptr_type_node = build_pointer_type (void_type_node);
7651   const_ptr_type_node
7652     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
7653   fileptr_type_node = ptr_type_node;
7654
7655   float_type_node = make_node (REAL_TYPE);
7656   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
7657   layout_type (float_type_node);
7658
7659   double_type_node = make_node (REAL_TYPE);
7660   if (short_double)
7661     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
7662   else
7663     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
7664   layout_type (double_type_node);
7665
7666   long_double_type_node = make_node (REAL_TYPE);
7667   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
7668   layout_type (long_double_type_node);
7669
7670   float_ptr_type_node = build_pointer_type (float_type_node);
7671   double_ptr_type_node = build_pointer_type (double_type_node);
7672   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
7673   integer_ptr_type_node = build_pointer_type (integer_type_node);
7674
7675   /* Fixed size integer types.  */
7676   uint32_type_node = build_nonstandard_integer_type (32, true);
7677   uint64_type_node = build_nonstandard_integer_type (64, true);
7678
7679   /* Decimal float types. */
7680   dfloat32_type_node = make_node (REAL_TYPE);
7681   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
7682   layout_type (dfloat32_type_node);
7683   SET_TYPE_MODE (dfloat32_type_node, SDmode);
7684   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
7685
7686   dfloat64_type_node = make_node (REAL_TYPE);
7687   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
7688   layout_type (dfloat64_type_node);
7689   SET_TYPE_MODE (dfloat64_type_node, DDmode);
7690   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
7691
7692   dfloat128_type_node = make_node (REAL_TYPE);
7693   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
7694   layout_type (dfloat128_type_node);
7695   SET_TYPE_MODE (dfloat128_type_node, TDmode);
7696   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
7697
7698   complex_integer_type_node = build_complex_type (integer_type_node);
7699   complex_float_type_node = build_complex_type (float_type_node);
7700   complex_double_type_node = build_complex_type (double_type_node);
7701   complex_long_double_type_node = build_complex_type (long_double_type_node);
7702
7703 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
7704 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
7705   sat_ ## KIND ## _type_node = \
7706     make_sat_signed_ ## KIND ## _type (SIZE); \
7707   sat_unsigned_ ## KIND ## _type_node = \
7708     make_sat_unsigned_ ## KIND ## _type (SIZE); \
7709   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
7710   unsigned_ ## KIND ## _type_node = \
7711     make_unsigned_ ## KIND ## _type (SIZE);
7712
7713 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
7714   sat_ ## WIDTH ## KIND ## _type_node = \
7715     make_sat_signed_ ## KIND ## _type (SIZE); \
7716   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
7717     make_sat_unsigned_ ## KIND ## _type (SIZE); \
7718   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
7719   unsigned_ ## WIDTH ## KIND ## _type_node = \
7720     make_unsigned_ ## KIND ## _type (SIZE);
7721
7722 /* Make fixed-point type nodes based on four different widths.  */
7723 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
7724   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
7725   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
7726   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
7727   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
7728
7729 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
7730 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
7731   NAME ## _type_node = \
7732     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
7733   u ## NAME ## _type_node = \
7734     make_or_reuse_unsigned_ ## KIND ## _type \
7735       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
7736   sat_ ## NAME ## _type_node = \
7737     make_or_reuse_sat_signed_ ## KIND ## _type \
7738       (GET_MODE_BITSIZE (MODE ## mode)); \
7739   sat_u ## NAME ## _type_node = \
7740     make_or_reuse_sat_unsigned_ ## KIND ## _type \
7741       (GET_MODE_BITSIZE (U ## MODE ## mode));
7742
7743   /* Fixed-point type and mode nodes.  */
7744   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
7745   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
7746   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
7747   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
7748   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
7749   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
7750   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
7751   MAKE_FIXED_MODE_NODE (accum, ha, HA)
7752   MAKE_FIXED_MODE_NODE (accum, sa, SA)
7753   MAKE_FIXED_MODE_NODE (accum, da, DA)
7754   MAKE_FIXED_MODE_NODE (accum, ta, TA)
7755
7756   {
7757     tree t = targetm.build_builtin_va_list ();
7758
7759     /* Many back-ends define record types without setting TYPE_NAME.
7760        If we copied the record type here, we'd keep the original
7761        record type without a name.  This breaks name mangling.  So,
7762        don't copy record types and let c_common_nodes_and_builtins()
7763        declare the type to be __builtin_va_list.  */
7764     if (TREE_CODE (t) != RECORD_TYPE)
7765       t = build_variant_type_copy (t);
7766
7767     va_list_type_node = t;
7768   }
7769 }
7770
7771 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
7772
7773 static void
7774 local_define_builtin (const char *name, tree type, enum built_in_function code,
7775                       const char *library_name, int ecf_flags)
7776 {
7777   tree decl;
7778
7779   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
7780                                library_name, NULL_TREE);
7781   if (ecf_flags & ECF_CONST)
7782     TREE_READONLY (decl) = 1;
7783   if (ecf_flags & ECF_PURE)
7784     DECL_PURE_P (decl) = 1;
7785   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
7786     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
7787   if (ecf_flags & ECF_NORETURN)
7788     TREE_THIS_VOLATILE (decl) = 1;
7789   if (ecf_flags & ECF_NOTHROW)
7790     TREE_NOTHROW (decl) = 1;
7791   if (ecf_flags & ECF_MALLOC)
7792     DECL_IS_MALLOC (decl) = 1;
7793
7794   built_in_decls[code] = decl;
7795   implicit_built_in_decls[code] = decl;
7796 }
7797
7798 /* Call this function after instantiating all builtins that the language
7799    front end cares about.  This will build the rest of the builtins that
7800    are relied upon by the tree optimizers and the middle-end.  */
7801
7802 void
7803 build_common_builtin_nodes (void)
7804 {
7805   tree tmp, ftype;
7806
7807   if (built_in_decls[BUILT_IN_MEMCPY] == NULL
7808       || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
7809     {
7810       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
7811       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
7812       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
7813       ftype = build_function_type (ptr_type_node, tmp);
7814
7815       if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
7816         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
7817                               "memcpy", ECF_NOTHROW);
7818       if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
7819         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
7820                               "memmove", ECF_NOTHROW);
7821     }
7822
7823   if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
7824     {
7825       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
7826       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
7827       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
7828       ftype = build_function_type (integer_type_node, tmp);
7829       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
7830                             "memcmp", ECF_PURE | ECF_NOTHROW);
7831     }
7832
7833   if (built_in_decls[BUILT_IN_MEMSET] == NULL)
7834     {
7835       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
7836       tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
7837       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
7838       ftype = build_function_type (ptr_type_node, tmp);
7839       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
7840                             "memset", ECF_NOTHROW);
7841     }
7842
7843   if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
7844     {
7845       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
7846       ftype = build_function_type (ptr_type_node, tmp);
7847       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
7848                             "alloca", ECF_NOTHROW | ECF_MALLOC);
7849     }
7850
7851   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7852   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
7853   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
7854   ftype = build_function_type (void_type_node, tmp);
7855   local_define_builtin ("__builtin_init_trampoline", ftype,
7856                         BUILT_IN_INIT_TRAMPOLINE,
7857                         "__builtin_init_trampoline", ECF_NOTHROW);
7858
7859   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7860   ftype = build_function_type (ptr_type_node, tmp);
7861   local_define_builtin ("__builtin_adjust_trampoline", ftype,
7862                         BUILT_IN_ADJUST_TRAMPOLINE,
7863                         "__builtin_adjust_trampoline",
7864                         ECF_CONST | ECF_NOTHROW);
7865
7866   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7867   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
7868   ftype = build_function_type (void_type_node, tmp);
7869   local_define_builtin ("__builtin_nonlocal_goto", ftype,
7870                         BUILT_IN_NONLOCAL_GOTO,
7871                         "__builtin_nonlocal_goto",
7872                         ECF_NORETURN | ECF_NOTHROW);
7873
7874   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7875   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
7876   ftype = build_function_type (void_type_node, tmp);
7877   local_define_builtin ("__builtin_setjmp_setup", ftype,
7878                         BUILT_IN_SETJMP_SETUP,
7879                         "__builtin_setjmp_setup", ECF_NOTHROW);
7880
7881   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7882   ftype = build_function_type (ptr_type_node, tmp);
7883   local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
7884                         BUILT_IN_SETJMP_DISPATCHER,
7885                         "__builtin_setjmp_dispatcher",
7886                         ECF_PURE | ECF_NOTHROW);
7887
7888   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7889   ftype = build_function_type (void_type_node, tmp);
7890   local_define_builtin ("__builtin_setjmp_receiver", ftype,
7891                         BUILT_IN_SETJMP_RECEIVER,
7892                         "__builtin_setjmp_receiver", ECF_NOTHROW);
7893
7894   ftype = build_function_type (ptr_type_node, void_list_node);
7895   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
7896                         "__builtin_stack_save", ECF_NOTHROW);
7897
7898   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7899   ftype = build_function_type (void_type_node, tmp);
7900   local_define_builtin ("__builtin_stack_restore", ftype,
7901                         BUILT_IN_STACK_RESTORE,
7902                         "__builtin_stack_restore", ECF_NOTHROW);
7903
7904   ftype = build_function_type (void_type_node, void_list_node);
7905   local_define_builtin ("__builtin_profile_func_enter", ftype,
7906                         BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
7907   local_define_builtin ("__builtin_profile_func_exit", ftype,
7908                         BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
7909
7910   /* Complex multiplication and division.  These are handled as builtins
7911      rather than optabs because emit_library_call_value doesn't support
7912      complex.  Further, we can do slightly better with folding these
7913      beasties if the real and complex parts of the arguments are separate.  */
7914   {
7915     int mode;
7916
7917     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
7918       {
7919         char mode_name_buf[4], *q;
7920         const char *p;
7921         enum built_in_function mcode, dcode;
7922         tree type, inner_type;
7923
7924         type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
7925         if (type == NULL)
7926           continue;
7927         inner_type = TREE_TYPE (type);
7928
7929         tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
7930         tmp = tree_cons (NULL_TREE, inner_type, tmp);
7931         tmp = tree_cons (NULL_TREE, inner_type, tmp);
7932         tmp = tree_cons (NULL_TREE, inner_type, tmp);
7933         ftype = build_function_type (type, tmp);
7934
7935         mcode = ((enum built_in_function)
7936                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
7937         dcode = ((enum built_in_function)
7938                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
7939
7940         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
7941           *q = TOLOWER (*p);
7942         *q = '\0';
7943
7944         built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
7945         local_define_builtin (built_in_names[mcode], ftype, mcode,
7946                               built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
7947
7948         built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
7949         local_define_builtin (built_in_names[dcode], ftype, dcode,
7950                               built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
7951       }
7952   }
7953 }
7954
7955 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
7956    better way.
7957
7958    If we requested a pointer to a vector, build up the pointers that
7959    we stripped off while looking for the inner type.  Similarly for
7960    return values from functions.
7961
7962    The argument TYPE is the top of the chain, and BOTTOM is the
7963    new type which we will point to.  */
7964
7965 tree
7966 reconstruct_complex_type (tree type, tree bottom)
7967 {
7968   tree inner, outer;
7969
7970   if (TREE_CODE (type) == POINTER_TYPE)
7971     {
7972       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
7973       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
7974                                            TYPE_REF_CAN_ALIAS_ALL (type));
7975     }
7976   else if (TREE_CODE (type) == REFERENCE_TYPE)
7977     {
7978       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
7979       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
7980                                              TYPE_REF_CAN_ALIAS_ALL (type));
7981     }
7982   else if (TREE_CODE (type) == ARRAY_TYPE)
7983     {
7984       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
7985       outer = build_array_type (inner, TYPE_DOMAIN (type));
7986     }
7987   else if (TREE_CODE (type) == FUNCTION_TYPE)
7988     {
7989       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
7990       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
7991     }
7992   else if (TREE_CODE (type) == METHOD_TYPE)
7993     {
7994       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
7995       /* The build_method_type_directly() routine prepends 'this' to argument list,
7996          so we must compensate by getting rid of it.  */
7997       outer
7998         = build_method_type_directly
7999             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
8000              inner,
8001              TREE_CHAIN (TYPE_ARG_TYPES (type)));
8002     }
8003   else if (TREE_CODE (type) == OFFSET_TYPE)
8004     {
8005       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
8006       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
8007     }
8008   else
8009     return bottom;
8010
8011   return build_qualified_type (outer, TYPE_QUALS (type));
8012 }
8013
8014 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
8015    the inner type.  */
8016 tree
8017 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
8018 {
8019   int nunits;
8020
8021   switch (GET_MODE_CLASS (mode))
8022     {
8023     case MODE_VECTOR_INT:
8024     case MODE_VECTOR_FLOAT:
8025     case MODE_VECTOR_FRACT:
8026     case MODE_VECTOR_UFRACT:
8027     case MODE_VECTOR_ACCUM:
8028     case MODE_VECTOR_UACCUM:
8029       nunits = GET_MODE_NUNITS (mode);
8030       break;
8031
8032     case MODE_INT:
8033       /* Check that there are no leftover bits.  */
8034       gcc_assert (GET_MODE_BITSIZE (mode)
8035                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
8036
8037       nunits = GET_MODE_BITSIZE (mode)
8038                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
8039       break;
8040
8041     default:
8042       gcc_unreachable ();
8043     }
8044
8045   return make_vector_type (innertype, nunits, mode);
8046 }
8047
8048 /* Similarly, but takes the inner type and number of units, which must be
8049    a power of two.  */
8050
8051 tree
8052 build_vector_type (tree innertype, int nunits)
8053 {
8054   return make_vector_type (innertype, nunits, VOIDmode);
8055 }
8056
8057 /* Similarly, but takes the inner type and number of units, which must be
8058    a power of two.  */
8059
8060 tree
8061 build_opaque_vector_type (tree innertype, int nunits)
8062 {
8063   tree t;
8064   innertype = build_distinct_type_copy (innertype);
8065   t = make_vector_type (innertype, nunits, VOIDmode);
8066   TYPE_VECTOR_OPAQUE (t) = true;
8067   return t;
8068 }
8069
8070
8071 /* Build RESX_EXPR with given REGION_NUMBER.  */
8072 tree
8073 build_resx (int region_number)
8074 {
8075   tree t;
8076   t = build1 (RESX_EXPR, void_type_node,
8077               build_int_cst (NULL_TREE, region_number));
8078   return t;
8079 }
8080
8081 /* Given an initializer INIT, return TRUE if INIT is zero or some
8082    aggregate of zeros.  Otherwise return FALSE.  */
8083 bool
8084 initializer_zerop (const_tree init)
8085 {
8086   tree elt;
8087
8088   STRIP_NOPS (init);
8089
8090   switch (TREE_CODE (init))
8091     {
8092     case INTEGER_CST:
8093       return integer_zerop (init);
8094
8095     case REAL_CST:
8096       /* ??? Note that this is not correct for C4X float formats.  There,
8097          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
8098          negative exponent.  */
8099       return real_zerop (init)
8100         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
8101
8102     case FIXED_CST:
8103       return fixed_zerop (init);
8104
8105     case COMPLEX_CST:
8106       return integer_zerop (init)
8107         || (real_zerop (init)
8108             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
8109             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
8110
8111     case VECTOR_CST:
8112       for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
8113         if (!initializer_zerop (TREE_VALUE (elt)))
8114           return false;
8115       return true;
8116
8117     case CONSTRUCTOR:
8118       {
8119         unsigned HOST_WIDE_INT idx;
8120
8121         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
8122           if (!initializer_zerop (elt))
8123             return false;
8124         return true;
8125       }
8126
8127     default:
8128       return false;
8129     }
8130 }
8131
8132 /* Build an empty statement.  */
8133
8134 tree
8135 build_empty_stmt (void)
8136 {
8137   return build1 (NOP_EXPR, void_type_node, size_zero_node);
8138 }
8139
8140
8141 /* Build an OpenMP clause with code CODE.  */
8142
8143 tree
8144 build_omp_clause (enum omp_clause_code code)
8145 {
8146   tree t;
8147   int size, length;
8148
8149   length = omp_clause_num_ops[code];
8150   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
8151
8152   t = GGC_NEWVAR (union tree_node, size);
8153   memset (t, 0, size);
8154   TREE_SET_CODE (t, OMP_CLAUSE);
8155   OMP_CLAUSE_SET_CODE (t, code);
8156
8157 #ifdef GATHER_STATISTICS
8158   tree_node_counts[(int) omp_clause_kind]++;
8159   tree_node_sizes[(int) omp_clause_kind] += size;
8160 #endif
8161
8162   return t;
8163 }
8164
8165 /* Set various status flags when building a CALL_EXPR object T.  */
8166
8167 static void
8168 process_call_operands (tree t)
8169 {
8170   bool side_effects;
8171
8172   side_effects = TREE_SIDE_EFFECTS (t);
8173   if (!side_effects)
8174     {
8175       int i, n;
8176       n = TREE_OPERAND_LENGTH (t);
8177       for (i = 1; i < n; i++)
8178         {
8179           tree op = TREE_OPERAND (t, i);
8180           if (op && TREE_SIDE_EFFECTS (op))
8181             {
8182               side_effects = 1;
8183               break;
8184             }
8185         }
8186     }
8187   if (!side_effects)
8188     {
8189       int i;
8190
8191       /* Calls have side-effects, except those to const or
8192          pure functions.  */
8193       i = call_expr_flags (t);
8194       if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
8195         side_effects = 1;
8196     }
8197   TREE_SIDE_EFFECTS (t) = side_effects;
8198 }
8199
8200 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
8201    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
8202    Except for the CODE and operand count field, other storage for the
8203    object is initialized to zeros.  */
8204
8205 tree
8206 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
8207 {
8208   tree t;
8209   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
8210
8211   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
8212   gcc_assert (len >= 1);
8213
8214 #ifdef GATHER_STATISTICS
8215   tree_node_counts[(int) e_kind]++;
8216   tree_node_sizes[(int) e_kind] += length;
8217 #endif
8218
8219   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
8220
8221   memset (t, 0, length);
8222
8223   TREE_SET_CODE (t, code);
8224
8225   /* Can't use TREE_OPERAND to store the length because if checking is
8226      enabled, it will try to check the length before we store it.  :-P  */
8227   t->exp.operands[0] = build_int_cst (sizetype, len);
8228
8229   return t;
8230 }
8231
8232
8233 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE
8234    and FN and a null static chain slot.  ARGLIST is a TREE_LIST of the
8235    arguments.  */
8236
8237 tree
8238 build_call_list (tree return_type, tree fn, tree arglist)
8239 {
8240   tree t;
8241   int i;
8242
8243   t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
8244   TREE_TYPE (t) = return_type;
8245   CALL_EXPR_FN (t) = fn;
8246   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
8247   for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
8248     CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
8249   process_call_operands (t);
8250   return t;
8251 }
8252
8253 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
8254    FN and a null static chain slot.  NARGS is the number of call arguments
8255    which are specified as "..." arguments.  */
8256
8257 tree
8258 build_call_nary (tree return_type, tree fn, int nargs, ...)
8259 {
8260   tree ret;
8261   va_list args;
8262   va_start (args, nargs);
8263   ret = build_call_valist (return_type, fn, nargs, args);
8264   va_end (args);
8265   return ret;
8266 }
8267
8268 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
8269    FN and a null static chain slot.  NARGS is the number of call arguments
8270    which are specified as a va_list ARGS.  */
8271
8272 tree
8273 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
8274 {
8275   tree t;
8276   int i;
8277
8278   t = build_vl_exp (CALL_EXPR, nargs + 3);
8279   TREE_TYPE (t) = return_type;
8280   CALL_EXPR_FN (t) = fn;
8281   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
8282   for (i = 0; i < nargs; i++)
8283     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
8284   process_call_operands (t);
8285   return t;
8286 }
8287
8288 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
8289    FN and a null static chain slot.  NARGS is the number of call arguments
8290    which are specified as a tree array ARGS.  */
8291
8292 tree
8293 build_call_array (tree return_type, tree fn, int nargs, const tree *args)
8294 {
8295   tree t;
8296   int i;
8297
8298   t = build_vl_exp (CALL_EXPR, nargs + 3);
8299   TREE_TYPE (t) = return_type;
8300   CALL_EXPR_FN (t) = fn;
8301   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
8302   for (i = 0; i < nargs; i++)
8303     CALL_EXPR_ARG (t, i) = args[i];
8304   process_call_operands (t);
8305   return t;
8306 }
8307
8308 /* Like build_call_array, but takes a VEC.  */
8309
8310 tree
8311 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
8312 {
8313   tree ret, t;
8314   unsigned int ix;
8315
8316   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
8317   TREE_TYPE (ret) = return_type;
8318   CALL_EXPR_FN (ret) = fn;
8319   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
8320   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
8321     CALL_EXPR_ARG (ret, ix) = t;
8322   process_call_operands (ret);
8323   return ret;
8324 }
8325
8326
8327 /* Returns true if it is possible to prove that the index of
8328    an array access REF (an ARRAY_REF expression) falls into the
8329    array bounds.  */
8330
8331 bool
8332 in_array_bounds_p (tree ref)
8333 {
8334   tree idx = TREE_OPERAND (ref, 1);
8335   tree min, max;
8336
8337   if (TREE_CODE (idx) != INTEGER_CST)
8338     return false;
8339
8340   min = array_ref_low_bound (ref);
8341   max = array_ref_up_bound (ref);
8342   if (!min
8343       || !max
8344       || TREE_CODE (min) != INTEGER_CST
8345       || TREE_CODE (max) != INTEGER_CST)
8346     return false;
8347
8348   if (tree_int_cst_lt (idx, min)
8349       || tree_int_cst_lt (max, idx))
8350     return false;
8351
8352   return true;
8353 }
8354
8355 /* Returns true if it is possible to prove that the range of
8356    an array access REF (an ARRAY_RANGE_REF expression) falls
8357    into the array bounds.  */
8358
8359 bool
8360 range_in_array_bounds_p (tree ref)
8361 {
8362   tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
8363   tree range_min, range_max, min, max;
8364
8365   range_min = TYPE_MIN_VALUE (domain_type);
8366   range_max = TYPE_MAX_VALUE (domain_type);
8367   if (!range_min
8368       || !range_max
8369       || TREE_CODE (range_min) != INTEGER_CST
8370       || TREE_CODE (range_max) != INTEGER_CST)
8371     return false;
8372
8373   min = array_ref_low_bound (ref);
8374   max = array_ref_up_bound (ref);
8375   if (!min
8376       || !max
8377       || TREE_CODE (min) != INTEGER_CST
8378       || TREE_CODE (max) != INTEGER_CST)
8379     return false;
8380
8381   if (tree_int_cst_lt (range_min, min)
8382       || tree_int_cst_lt (max, range_max))
8383     return false;
8384
8385   return true;
8386 }
8387
8388 /* Return true if T (assumed to be a DECL) must be assigned a memory
8389    location.  */
8390
8391 bool
8392 needs_to_live_in_memory (const_tree t)
8393 {
8394   if (TREE_CODE (t) == SSA_NAME)
8395     t = SSA_NAME_VAR (t);
8396
8397   return (TREE_ADDRESSABLE (t)
8398           || is_global_var (t)
8399           || (TREE_CODE (t) == RESULT_DECL
8400               && aggregate_value_p (t, current_function_decl)));
8401 }
8402
8403 /* There are situations in which a language considers record types
8404    compatible which have different field lists.  Decide if two fields
8405    are compatible.  It is assumed that the parent records are compatible.  */
8406
8407 bool
8408 fields_compatible_p (const_tree f1, const_tree f2)
8409 {
8410   if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
8411                         DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
8412     return false;
8413
8414   if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
8415                         DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
8416     return false;
8417
8418   if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
8419     return false;
8420
8421   return true;
8422 }
8423
8424 /* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
8425
8426 tree
8427 find_compatible_field (tree record, tree orig_field)
8428 {
8429   tree f;
8430
8431   for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
8432     if (TREE_CODE (f) == FIELD_DECL
8433         && fields_compatible_p (f, orig_field))
8434       return f;
8435
8436   /* ??? Why isn't this on the main fields list?  */
8437   f = TYPE_VFIELD (record);
8438   if (f && TREE_CODE (f) == FIELD_DECL
8439       && fields_compatible_p (f, orig_field))
8440     return f;
8441
8442   /* ??? We should abort here, but Java appears to do Bad Things
8443      with inherited fields.  */
8444   return orig_field;
8445 }
8446
8447 /* Return value of a constant X and sign-extend it.  */
8448
8449 HOST_WIDE_INT
8450 int_cst_value (const_tree x)
8451 {
8452   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
8453   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
8454
8455   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
8456   gcc_assert (TREE_INT_CST_HIGH (x) == 0
8457               || TREE_INT_CST_HIGH (x) == -1);
8458
8459   if (bits < HOST_BITS_PER_WIDE_INT)
8460     {
8461       bool negative = ((val >> (bits - 1)) & 1) != 0;
8462       if (negative)
8463         val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
8464       else
8465         val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
8466     }
8467
8468   return val;
8469 }
8470
8471 /* If TYPE is an integral type, return an equivalent type which is
8472     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
8473     return TYPE itself.  */
8474
8475 tree
8476 signed_or_unsigned_type_for (int unsignedp, tree type)
8477 {
8478   tree t = type;
8479   if (POINTER_TYPE_P (type))
8480     t = size_type_node;
8481
8482   if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
8483     return t;
8484
8485   return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
8486 }
8487
8488 /* Returns unsigned variant of TYPE.  */
8489
8490 tree
8491 unsigned_type_for (tree type)
8492 {
8493   return signed_or_unsigned_type_for (1, type);
8494 }
8495
8496 /* Returns signed variant of TYPE.  */
8497
8498 tree
8499 signed_type_for (tree type)
8500 {
8501   return signed_or_unsigned_type_for (0, type);
8502 }
8503
8504 /* Returns the largest value obtainable by casting something in INNER type to
8505    OUTER type.  */
8506
8507 tree
8508 upper_bound_in_type (tree outer, tree inner)
8509 {
8510   unsigned HOST_WIDE_INT lo, hi;
8511   unsigned int det = 0;
8512   unsigned oprec = TYPE_PRECISION (outer);
8513   unsigned iprec = TYPE_PRECISION (inner);
8514   unsigned prec;
8515
8516   /* Compute a unique number for every combination.  */
8517   det |= (oprec > iprec) ? 4 : 0;
8518   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
8519   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
8520
8521   /* Determine the exponent to use.  */
8522   switch (det)
8523     {
8524     case 0:
8525     case 1:
8526       /* oprec <= iprec, outer: signed, inner: don't care.  */
8527       prec = oprec - 1;
8528       break;
8529     case 2:
8530     case 3:
8531       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
8532       prec = oprec;
8533       break;
8534     case 4:
8535       /* oprec > iprec, outer: signed, inner: signed.  */
8536       prec = iprec - 1;
8537       break;
8538     case 5:
8539       /* oprec > iprec, outer: signed, inner: unsigned.  */
8540       prec = iprec;
8541       break;
8542     case 6:
8543       /* oprec > iprec, outer: unsigned, inner: signed.  */
8544       prec = oprec;
8545       break;
8546     case 7:
8547       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
8548       prec = iprec;
8549       break;
8550     default:
8551       gcc_unreachable ();
8552     }
8553
8554   /* Compute 2^^prec - 1.  */
8555   if (prec <= HOST_BITS_PER_WIDE_INT)
8556     {
8557       hi = 0;
8558       lo = ((~(unsigned HOST_WIDE_INT) 0)
8559             >> (HOST_BITS_PER_WIDE_INT - prec));
8560     }
8561   else
8562     {
8563       hi = ((~(unsigned HOST_WIDE_INT) 0)
8564             >> (2 * HOST_BITS_PER_WIDE_INT - prec));
8565       lo = ~(unsigned HOST_WIDE_INT) 0;
8566     }
8567
8568   return build_int_cst_wide (outer, lo, hi);
8569 }
8570
8571 /* Returns the smallest value obtainable by casting something in INNER type to
8572    OUTER type.  */
8573
8574 tree
8575 lower_bound_in_type (tree outer, tree inner)
8576 {
8577   unsigned HOST_WIDE_INT lo, hi;
8578   unsigned oprec = TYPE_PRECISION (outer);
8579   unsigned iprec = TYPE_PRECISION (inner);
8580
8581   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
8582      and obtain 0.  */
8583   if (TYPE_UNSIGNED (outer)
8584       /* If we are widening something of an unsigned type, OUTER type
8585          contains all values of INNER type.  In particular, both INNER
8586          and OUTER types have zero in common.  */
8587       || (oprec > iprec && TYPE_UNSIGNED (inner)))
8588     lo = hi = 0;
8589   else
8590     {
8591       /* If we are widening a signed type to another signed type, we
8592          want to obtain -2^^(iprec-1).  If we are keeping the
8593          precision or narrowing to a signed type, we want to obtain
8594          -2^(oprec-1).  */
8595       unsigned prec = oprec > iprec ? iprec : oprec;
8596
8597       if (prec <= HOST_BITS_PER_WIDE_INT)
8598         {
8599           hi = ~(unsigned HOST_WIDE_INT) 0;
8600           lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
8601         }
8602       else
8603         {
8604           hi = ((~(unsigned HOST_WIDE_INT) 0)
8605                 << (prec - HOST_BITS_PER_WIDE_INT - 1));
8606           lo = 0;
8607         }
8608     }
8609
8610   return build_int_cst_wide (outer, lo, hi);
8611 }
8612
8613 /* Return nonzero if two operands that are suitable for PHI nodes are
8614    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
8615    SSA_NAME or invariant.  Note that this is strictly an optimization.
8616    That is, callers of this function can directly call operand_equal_p
8617    and get the same result, only slower.  */
8618
8619 int
8620 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
8621 {
8622   if (arg0 == arg1)
8623     return 1;
8624   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
8625     return 0;
8626   return operand_equal_p (arg0, arg1, 0);
8627 }
8628
8629 /* Returns number of zeros at the end of binary representation of X.
8630
8631    ??? Use ffs if available?  */
8632
8633 tree
8634 num_ending_zeros (const_tree x)
8635 {
8636   unsigned HOST_WIDE_INT fr, nfr;
8637   unsigned num, abits;
8638   tree type = TREE_TYPE (x);
8639
8640   if (TREE_INT_CST_LOW (x) == 0)
8641     {
8642       num = HOST_BITS_PER_WIDE_INT;
8643       fr = TREE_INT_CST_HIGH (x);
8644     }
8645   else
8646     {
8647       num = 0;
8648       fr = TREE_INT_CST_LOW (x);
8649     }
8650
8651   for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
8652     {
8653       nfr = fr >> abits;
8654       if (nfr << abits == fr)
8655         {
8656           num += abits;
8657           fr = nfr;
8658         }
8659     }
8660
8661   if (num > TYPE_PRECISION (type))
8662     num = TYPE_PRECISION (type);
8663
8664   return build_int_cst_type (type, num);
8665 }
8666
8667
8668 #define WALK_SUBTREE(NODE)                              \
8669   do                                                    \
8670     {                                                   \
8671       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
8672       if (result)                                       \
8673         return result;                                  \
8674     }                                                   \
8675   while (0)
8676
8677 /* This is a subroutine of walk_tree that walks field of TYPE that are to
8678    be walked whenever a type is seen in the tree.  Rest of operands and return
8679    value are as for walk_tree.  */
8680
8681 static tree
8682 walk_type_fields (tree type, walk_tree_fn func, void *data,
8683                   struct pointer_set_t *pset, walk_tree_lh lh)
8684 {
8685   tree result = NULL_TREE;
8686
8687   switch (TREE_CODE (type))
8688     {
8689     case POINTER_TYPE:
8690     case REFERENCE_TYPE:
8691       /* We have to worry about mutually recursive pointers.  These can't
8692          be written in C.  They can in Ada.  It's pathological, but
8693          there's an ACATS test (c38102a) that checks it.  Deal with this
8694          by checking if we're pointing to another pointer, that one
8695          points to another pointer, that one does too, and we have no htab.
8696          If so, get a hash table.  We check three levels deep to avoid
8697          the cost of the hash table if we don't need one.  */
8698       if (POINTER_TYPE_P (TREE_TYPE (type))
8699           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
8700           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
8701           && !pset)
8702         {
8703           result = walk_tree_without_duplicates (&TREE_TYPE (type),
8704                                                  func, data);
8705           if (result)
8706             return result;
8707
8708           break;
8709         }
8710
8711       /* ... fall through ... */
8712
8713     case COMPLEX_TYPE:
8714       WALK_SUBTREE (TREE_TYPE (type));
8715       break;
8716
8717     case METHOD_TYPE:
8718       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
8719
8720       /* Fall through.  */
8721
8722     case FUNCTION_TYPE:
8723       WALK_SUBTREE (TREE_TYPE (type));
8724       {
8725         tree arg;
8726
8727         /* We never want to walk into default arguments.  */
8728         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
8729           WALK_SUBTREE (TREE_VALUE (arg));
8730       }
8731       break;
8732
8733     case ARRAY_TYPE:
8734       /* Don't follow this nodes's type if a pointer for fear that
8735          we'll have infinite recursion.  If we have a PSET, then we
8736          need not fear.  */
8737       if (pset
8738           || (!POINTER_TYPE_P (TREE_TYPE (type))
8739               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
8740         WALK_SUBTREE (TREE_TYPE (type));
8741       WALK_SUBTREE (TYPE_DOMAIN (type));
8742       break;
8743
8744     case OFFSET_TYPE:
8745       WALK_SUBTREE (TREE_TYPE (type));
8746       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
8747       break;
8748
8749     default:
8750       break;
8751     }
8752
8753   return NULL_TREE;
8754 }
8755
8756 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
8757    called with the DATA and the address of each sub-tree.  If FUNC returns a
8758    non-NULL value, the traversal is stopped, and the value returned by FUNC
8759    is returned.  If PSET is non-NULL it is used to record the nodes visited,
8760    and to avoid visiting a node more than once.  */
8761
8762 tree
8763 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
8764              struct pointer_set_t *pset, walk_tree_lh lh)
8765 {
8766   enum tree_code code;
8767   int walk_subtrees;
8768   tree result;
8769
8770 #define WALK_SUBTREE_TAIL(NODE)                         \
8771   do                                                    \
8772     {                                                   \
8773        tp = & (NODE);                                   \
8774        goto tail_recurse;                               \
8775     }                                                   \
8776   while (0)
8777
8778  tail_recurse:
8779   /* Skip empty subtrees.  */
8780   if (!*tp)
8781     return NULL_TREE;
8782
8783   /* Don't walk the same tree twice, if the user has requested
8784      that we avoid doing so.  */
8785   if (pset && pointer_set_insert (pset, *tp))
8786     return NULL_TREE;
8787
8788   /* Call the function.  */
8789   walk_subtrees = 1;
8790   result = (*func) (tp, &walk_subtrees, data);
8791
8792   /* If we found something, return it.  */
8793   if (result)
8794     return result;
8795
8796   code = TREE_CODE (*tp);
8797
8798   /* Even if we didn't, FUNC may have decided that there was nothing
8799      interesting below this point in the tree.  */
8800   if (!walk_subtrees)
8801     {
8802       /* But we still need to check our siblings.  */
8803       if (code == TREE_LIST)
8804         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
8805       else if (code == OMP_CLAUSE)
8806         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
8807       else
8808         return NULL_TREE;
8809     }
8810
8811   if (lh)
8812     {
8813       result = (*lh) (tp, &walk_subtrees, func, data, pset);
8814       if (result || !walk_subtrees)
8815         return result;
8816     }
8817
8818   switch (code)
8819     {
8820     case ERROR_MARK:
8821     case IDENTIFIER_NODE:
8822     case INTEGER_CST:
8823     case REAL_CST:
8824     case FIXED_CST:
8825     case VECTOR_CST:
8826     case STRING_CST:
8827     case BLOCK:
8828     case PLACEHOLDER_EXPR:
8829     case SSA_NAME:
8830     case FIELD_DECL:
8831     case RESULT_DECL:
8832       /* None of these have subtrees other than those already walked
8833          above.  */
8834       break;
8835
8836     case TREE_LIST:
8837       WALK_SUBTREE (TREE_VALUE (*tp));
8838       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
8839       break;
8840
8841     case TREE_VEC:
8842       {
8843         int len = TREE_VEC_LENGTH (*tp);
8844
8845         if (len == 0)
8846           break;
8847
8848         /* Walk all elements but the first.  */
8849         while (--len)
8850           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
8851
8852         /* Now walk the first one as a tail call.  */
8853         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
8854       }
8855
8856     case COMPLEX_CST:
8857       WALK_SUBTREE (TREE_REALPART (*tp));
8858       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
8859
8860     case CONSTRUCTOR:
8861       {
8862         unsigned HOST_WIDE_INT idx;
8863         constructor_elt *ce;
8864
8865         for (idx = 0;
8866              VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
8867              idx++)
8868           WALK_SUBTREE (ce->value);
8869       }
8870       break;
8871
8872     case SAVE_EXPR:
8873       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
8874
8875     case BIND_EXPR:
8876       {
8877         tree decl;
8878         for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
8879           {
8880             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
8881                into declarations that are just mentioned, rather than
8882                declared; they don't really belong to this part of the tree.
8883                And, we can see cycles: the initializer for a declaration
8884                can refer to the declaration itself.  */
8885             WALK_SUBTREE (DECL_INITIAL (decl));
8886             WALK_SUBTREE (DECL_SIZE (decl));
8887             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
8888           }
8889         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
8890       }
8891
8892     case STATEMENT_LIST:
8893       {
8894         tree_stmt_iterator i;
8895         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
8896           WALK_SUBTREE (*tsi_stmt_ptr (i));
8897       }
8898       break;
8899
8900     case OMP_CLAUSE:
8901       switch (OMP_CLAUSE_CODE (*tp))
8902         {
8903         case OMP_CLAUSE_PRIVATE:
8904         case OMP_CLAUSE_SHARED:
8905         case OMP_CLAUSE_FIRSTPRIVATE:
8906         case OMP_CLAUSE_COPYIN:
8907         case OMP_CLAUSE_COPYPRIVATE:
8908         case OMP_CLAUSE_IF:
8909         case OMP_CLAUSE_NUM_THREADS:
8910         case OMP_CLAUSE_SCHEDULE:
8911           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
8912           /* FALLTHRU */
8913
8914         case OMP_CLAUSE_NOWAIT:
8915         case OMP_CLAUSE_ORDERED:
8916         case OMP_CLAUSE_DEFAULT:
8917         case OMP_CLAUSE_UNTIED:
8918           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
8919
8920         case OMP_CLAUSE_LASTPRIVATE:
8921           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
8922           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
8923           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
8924
8925         case OMP_CLAUSE_COLLAPSE:
8926           {
8927             int i;
8928             for (i = 0; i < 3; i++)
8929               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
8930             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
8931           }
8932
8933         case OMP_CLAUSE_REDUCTION:
8934           {
8935             int i;
8936             for (i = 0; i < 4; i++)
8937               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
8938             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
8939           }
8940
8941         default:
8942           gcc_unreachable ();
8943         }
8944       break;
8945
8946     case TARGET_EXPR:
8947       {
8948         int i, len;
8949
8950         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
8951            But, we only want to walk once.  */
8952         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
8953         for (i = 0; i < len; ++i)
8954           WALK_SUBTREE (TREE_OPERAND (*tp, i));
8955         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
8956       }
8957
8958     case CHANGE_DYNAMIC_TYPE_EXPR:
8959       WALK_SUBTREE (CHANGE_DYNAMIC_TYPE_NEW_TYPE (*tp));
8960       WALK_SUBTREE_TAIL (CHANGE_DYNAMIC_TYPE_LOCATION (*tp));
8961
8962     case DECL_EXPR:
8963       /* If this is a TYPE_DECL, walk into the fields of the type that it's
8964          defining.  We only want to walk into these fields of a type in this
8965          case and not in the general case of a mere reference to the type.
8966
8967          The criterion is as follows: if the field can be an expression, it
8968          must be walked only here.  This should be in keeping with the fields
8969          that are directly gimplified in gimplify_type_sizes in order for the
8970          mark/copy-if-shared/unmark machinery of the gimplifier to work with
8971          variable-sized types.
8972
8973          Note that DECLs get walked as part of processing the BIND_EXPR.  */
8974       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
8975         {
8976           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
8977           if (TREE_CODE (*type_p) == ERROR_MARK)
8978             return NULL_TREE;
8979
8980           /* Call the function for the type.  See if it returns anything or
8981              doesn't want us to continue.  If we are to continue, walk both
8982              the normal fields and those for the declaration case.  */
8983           result = (*func) (type_p, &walk_subtrees, data);
8984           if (result || !walk_subtrees)
8985             return result;
8986
8987           result = walk_type_fields (*type_p, func, data, pset, lh);
8988           if (result)
8989             return result;
8990
8991           /* If this is a record type, also walk the fields.  */
8992           if (TREE_CODE (*type_p) == RECORD_TYPE
8993               || TREE_CODE (*type_p) == UNION_TYPE
8994               || TREE_CODE (*type_p) == QUAL_UNION_TYPE)
8995             {
8996               tree field;
8997
8998               for (field = TYPE_FIELDS (*type_p); field;
8999                    field = TREE_CHAIN (field))
9000                 {
9001                   /* We'd like to look at the type of the field, but we can
9002                      easily get infinite recursion.  So assume it's pointed
9003                      to elsewhere in the tree.  Also, ignore things that
9004                      aren't fields.  */
9005                   if (TREE_CODE (field) != FIELD_DECL)
9006                     continue;
9007
9008                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
9009                   WALK_SUBTREE (DECL_SIZE (field));
9010                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
9011                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
9012                     WALK_SUBTREE (DECL_QUALIFIER (field));
9013                 }
9014             }
9015
9016           /* Same for scalar types.  */
9017           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
9018                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
9019                    || TREE_CODE (*type_p) == INTEGER_TYPE
9020                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
9021                    || TREE_CODE (*type_p) == REAL_TYPE)
9022             {
9023               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
9024               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
9025             }
9026
9027           WALK_SUBTREE (TYPE_SIZE (*type_p));
9028           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
9029         }
9030       /* FALLTHRU */
9031
9032     default:
9033       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
9034         {
9035           int i, len;
9036
9037           /* Walk over all the sub-trees of this operand.  */
9038           len = TREE_OPERAND_LENGTH (*tp);
9039
9040           /* Go through the subtrees.  We need to do this in forward order so
9041              that the scope of a FOR_EXPR is handled properly.  */
9042           if (len)
9043             {
9044               for (i = 0; i < len - 1; ++i)
9045                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
9046               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
9047             }
9048         }
9049       /* If this is a type, walk the needed fields in the type.  */
9050       else if (TYPE_P (*tp))
9051         return walk_type_fields (*tp, func, data, pset, lh);
9052       break;
9053     }
9054
9055   /* We didn't find what we were looking for.  */
9056   return NULL_TREE;
9057
9058 #undef WALK_SUBTREE_TAIL
9059 }
9060 #undef WALK_SUBTREE
9061
9062 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
9063
9064 tree
9065 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
9066                                 walk_tree_lh lh)
9067 {
9068   tree result;
9069   struct pointer_set_t *pset;
9070
9071   pset = pointer_set_create ();
9072   result = walk_tree_1 (tp, func, data, pset, lh);
9073   pointer_set_destroy (pset);
9074   return result;
9075 }
9076
9077
9078 tree *
9079 tree_block (tree t)
9080 {
9081   char const c = TREE_CODE_CLASS (TREE_CODE (t));
9082
9083   if (IS_EXPR_CODE_CLASS (c))
9084     return &t->exp.block;
9085   gcc_unreachable ();
9086   return NULL;
9087 }
9088
9089 /* Build and return a TREE_LIST of arguments in the CALL_EXPR exp.
9090    FIXME: don't use this function.  It exists for compatibility with
9091    the old representation of CALL_EXPRs where a list was used to hold the
9092    arguments.  Places that currently extract the arglist from a CALL_EXPR
9093    ought to be rewritten to use the CALL_EXPR itself.  */
9094 tree
9095 call_expr_arglist (tree exp)
9096 {
9097   tree arglist = NULL_TREE;
9098   int i;
9099   for (i = call_expr_nargs (exp) - 1; i >= 0; i--)
9100     arglist = tree_cons (NULL_TREE, CALL_EXPR_ARG (exp, i), arglist);
9101   return arglist;
9102 }
9103
9104
9105 /* Create a nameless artificial label and put it in the current function
9106    context.  Returns the newly created label.  */
9107
9108 tree
9109 create_artificial_label (void)
9110 {
9111   tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
9112
9113   DECL_ARTIFICIAL (lab) = 1;
9114   DECL_IGNORED_P (lab) = 1;
9115   DECL_CONTEXT (lab) = current_function_decl;
9116   return lab;
9117 }
9118
9119 /*  Given a tree, try to return a useful variable name that we can use
9120     to prefix a temporary that is being assigned the value of the tree.
9121     I.E. given  <temp> = &A, return A.  */
9122
9123 const char *
9124 get_name (tree t)
9125 {
9126   tree stripped_decl;
9127
9128   stripped_decl = t;
9129   STRIP_NOPS (stripped_decl);
9130   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
9131     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
9132   else
9133     {
9134       switch (TREE_CODE (stripped_decl))
9135         {
9136         case ADDR_EXPR:
9137           return get_name (TREE_OPERAND (stripped_decl, 0));
9138         default:
9139           return NULL;
9140         }
9141     }
9142 }
9143
9144 /* Return true if TYPE has a variable argument list.  */
9145
9146 bool
9147 stdarg_p (tree fntype)
9148 {
9149   function_args_iterator args_iter;
9150   tree n = NULL_TREE, t;
9151
9152   if (!fntype)
9153     return false;
9154
9155   FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
9156     {
9157       n = t;
9158     }
9159
9160   return n != NULL_TREE && n != void_type_node;
9161 }
9162
9163 /* Return true if TYPE has a prototype.  */
9164
9165 bool
9166 prototype_p (tree fntype)
9167 {
9168   tree t;
9169
9170   gcc_assert (fntype != NULL_TREE);
9171
9172   t = TYPE_ARG_TYPES (fntype);
9173   return (t != NULL_TREE);
9174 }
9175
9176 /* If BLOCK is inlined from an __attribute__((__artificial__))
9177    routine, return pointer to location from where it has been
9178    called.  */
9179 location_t *
9180 block_nonartificial_location (tree block)
9181 {
9182   location_t *ret = NULL;
9183
9184   while (block && TREE_CODE (block) == BLOCK
9185          && BLOCK_ABSTRACT_ORIGIN (block))
9186     {
9187       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
9188
9189       while (TREE_CODE (ao) == BLOCK
9190              && BLOCK_ABSTRACT_ORIGIN (ao)
9191              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
9192         ao = BLOCK_ABSTRACT_ORIGIN (ao);
9193
9194       if (TREE_CODE (ao) == FUNCTION_DECL)
9195         {
9196           /* If AO is an artificial inline, point RET to the
9197              call site locus at which it has been inlined and continue
9198              the loop, in case AO's caller is also an artificial
9199              inline.  */
9200           if (DECL_DECLARED_INLINE_P (ao)
9201               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
9202             ret = &BLOCK_SOURCE_LOCATION (block);
9203           else
9204             break;
9205         }
9206       else if (TREE_CODE (ao) != BLOCK)
9207         break;
9208
9209       block = BLOCK_SUPERCONTEXT (block);
9210     }
9211   return ret;
9212 }
9213
9214
9215 /* If EXP is inlined from an __attribute__((__artificial__))
9216    function, return the location of the original call expression.  */
9217
9218 location_t
9219 tree_nonartificial_location (tree exp)
9220 {
9221   tree block = TREE_BLOCK (exp);
9222
9223   while (block
9224          && TREE_CODE (block) == BLOCK
9225          && BLOCK_ABSTRACT_ORIGIN (block))
9226     {
9227       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
9228
9229       do
9230         {
9231           if (TREE_CODE (ao) == FUNCTION_DECL
9232               && DECL_DECLARED_INLINE_P (ao)
9233               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
9234             return BLOCK_SOURCE_LOCATION (block);
9235           else if (TREE_CODE (ao) == BLOCK
9236                    && BLOCK_SUPERCONTEXT (ao) != ao)
9237             ao = BLOCK_SUPERCONTEXT (ao);
9238           else
9239             break;
9240         }
9241       while (ao);
9242
9243       block = BLOCK_SUPERCONTEXT (block);
9244     }
9245
9246   return EXPR_LOCATION (exp);
9247 }
9248
9249
9250 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
9251    nodes.  */
9252
9253 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
9254
9255 static hashval_t
9256 cl_option_hash_hash (const void *x)
9257 {
9258   const_tree const t = (const_tree) x;
9259   const char *p;
9260   size_t i;
9261   size_t len = 0;
9262   hashval_t hash = 0;
9263
9264   if (TREE_CODE (t) == OPTIMIZATION_NODE)
9265     {
9266       p = (const char *)TREE_OPTIMIZATION (t);
9267       len = sizeof (struct cl_optimization);
9268     }
9269
9270   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
9271     {
9272       p = (const char *)TREE_TARGET_OPTION (t);
9273       len = sizeof (struct cl_target_option);
9274     }
9275
9276   else
9277     gcc_unreachable ();
9278
9279   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
9280      something else.  */
9281   for (i = 0; i < len; i++)
9282     if (p[i])
9283       hash = (hash << 4) ^ ((i << 2) | p[i]);
9284
9285   return hash;
9286 }
9287
9288 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
9289    TARGET_OPTION tree node) is the same as that given by *Y, which is the
9290    same.  */
9291
9292 static int
9293 cl_option_hash_eq (const void *x, const void *y)
9294 {
9295   const_tree const xt = (const_tree) x;
9296   const_tree const yt = (const_tree) y;
9297   const char *xp;
9298   const char *yp;
9299   size_t len;
9300
9301   if (TREE_CODE (xt) != TREE_CODE (yt))
9302     return 0;
9303
9304   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
9305     {
9306       xp = (const char *)TREE_OPTIMIZATION (xt);
9307       yp = (const char *)TREE_OPTIMIZATION (yt);
9308       len = sizeof (struct cl_optimization);
9309     }
9310
9311   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
9312     {
9313       xp = (const char *)TREE_TARGET_OPTION (xt);
9314       yp = (const char *)TREE_TARGET_OPTION (yt);
9315       len = sizeof (struct cl_target_option);
9316     }
9317
9318   else
9319     gcc_unreachable ();
9320
9321   return (memcmp (xp, yp, len) == 0);
9322 }
9323
9324 /* Build an OPTIMIZATION_NODE based on the current options.  */
9325
9326 tree
9327 build_optimization_node (void)
9328 {
9329   tree t;
9330   void **slot;
9331
9332   /* Use the cache of optimization nodes.  */
9333
9334   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node));
9335
9336   slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
9337   t = (tree) *slot;
9338   if (!t)
9339     {
9340       /* Insert this one into the hash table.  */
9341       t = cl_optimization_node;
9342       *slot = t;
9343
9344       /* Make a new node for next time round.  */
9345       cl_optimization_node = make_node (OPTIMIZATION_NODE);
9346     }
9347
9348   return t;
9349 }
9350
9351 /* Build a TARGET_OPTION_NODE based on the current options.  */
9352
9353 tree
9354 build_target_option_node (void)
9355 {
9356   tree t;
9357   void **slot;
9358
9359   /* Use the cache of optimization nodes.  */
9360
9361   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node));
9362
9363   slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
9364   t = (tree) *slot;
9365   if (!t)
9366     {
9367       /* Insert this one into the hash table.  */
9368       t = cl_target_option_node;
9369       *slot = t;
9370
9371       /* Make a new node for next time round.  */
9372       cl_target_option_node = make_node (TARGET_OPTION_NODE);
9373     }
9374
9375   return t;
9376 }
9377
9378 /* Determine the "ultimate origin" of a block.  The block may be an inlined
9379    instance of an inlined instance of a block which is local to an inline
9380    function, so we have to trace all of the way back through the origin chain
9381    to find out what sort of node actually served as the original seed for the
9382    given block.  */
9383
9384 tree
9385 block_ultimate_origin (const_tree block)
9386 {
9387   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
9388
9389   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
9390      nodes in the function to point to themselves; ignore that if
9391      we're trying to output the abstract instance of this function.  */
9392   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
9393     return NULL_TREE;
9394
9395   if (immediate_origin == NULL_TREE)
9396     return NULL_TREE;
9397   else
9398     {
9399       tree ret_val;
9400       tree lookahead = immediate_origin;
9401
9402       do
9403         {
9404           ret_val = lookahead;
9405           lookahead = (TREE_CODE (ret_val) == BLOCK
9406                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
9407         }
9408       while (lookahead != NULL && lookahead != ret_val);
9409
9410       /* The block's abstract origin chain may not be the *ultimate* origin of
9411          the block. It could lead to a DECL that has an abstract origin set.
9412          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
9413          will give us if it has one).  Note that DECL's abstract origins are
9414          supposed to be the most distant ancestor (or so decl_ultimate_origin
9415          claims), so we don't need to loop following the DECL origins.  */
9416       if (DECL_P (ret_val))
9417         return DECL_ORIGIN (ret_val);
9418
9419       return ret_val;
9420     }
9421 }
9422
9423 /* Return true if T1 and T2 are equivalent lists.  */
9424
9425 bool
9426 list_equal_p (const_tree t1, const_tree t2)
9427 {
9428   for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
9429     if (TREE_VALUE (t1) != TREE_VALUE (t2))
9430       return false;
9431   return !t1 && !t2;
9432 }
9433
9434
9435 #include "gt-tree.h"