gcc/tree.c

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