gcc/tree.c

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