gcc/tree.c

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