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