gcc/tree.c

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