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