gcc/tree.c

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