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