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