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