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