gcc/tree.c

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