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   TYPE_USER_ALIGN (t) = 1;
6688
6689   return t;
6690 }
6691
6692 /* Create a new distinct copy of TYPE.  The new type is made its own
6693    MAIN_VARIANT. If TYPE requires structural equality checks, the
6694    resulting type requires structural equality checks; otherwise, its
6695    TYPE_CANONICAL points to itself. */
6696
6697 tree
6698 build_distinct_type_copy (tree type)
6699 {
6700   tree t = copy_node (type);
6701
6702   TYPE_POINTER_TO (t) = 0;
6703   TYPE_REFERENCE_TO (t) = 0;
6704
6705   /* Set the canonical type either to a new equivalence class, or
6706      propagate the need for structural equality checks. */
6707   if (TYPE_STRUCTURAL_EQUALITY_P (type))
6708     SET_TYPE_STRUCTURAL_EQUALITY (t);
6709   else
6710     TYPE_CANONICAL (t) = t;
6711
6712   /* Make it its own variant.  */
6713   TYPE_MAIN_VARIANT (t) = t;
6714   TYPE_NEXT_VARIANT (t) = 0;
6715
6716   /* We do not record methods in type copies nor variants
6717      so we do not need to keep them up to date when new method
6718      is inserted.  */
6719   if (RECORD_OR_UNION_TYPE_P (t))
6720     TYPE_METHODS (t) = NULL_TREE;
6721
6722   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6723      whose TREE_TYPE is not t.  This can also happen in the Ada
6724      frontend when using subtypes.  */
6725
6726   return t;
6727 }
6728
6729 /* Create a new variant of TYPE, equivalent but distinct.  This is so
6730    the caller can modify it. TYPE_CANONICAL for the return type will
6731    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6732    are considered equal by the language itself (or that both types
6733    require structural equality checks). */
6734
6735 tree
6736 build_variant_type_copy (tree type)
6737 {
6738   tree t, m = TYPE_MAIN_VARIANT (type);
6739
6740   t = build_distinct_type_copy (type);
6741
6742   /* Since we're building a variant, assume that it is a non-semantic
6743      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6744   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
6745   /* Type variants have no alias set defined.  */
6746   TYPE_ALIAS_SET (t) = -1;
6747
6748   /* Add the new type to the chain of variants of TYPE.  */
6749   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
6750   TYPE_NEXT_VARIANT (m) = t;
6751   TYPE_MAIN_VARIANT (t) = m;
6752
6753   return t;
6754 }
6755 \f
6756 /* Return true if the from tree in both tree maps are equal.  */
6757
6758 int
6759 tree_map_base_eq (const void *va, const void *vb)
6760 {
6761   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
6762     *const b = (const struct tree_map_base *) vb;
6763   return (a->from == b->from);
6764 }
6765
6766 /* Hash a from tree in a tree_base_map.  */
6767
6768 unsigned int
6769 tree_map_base_hash (const void *item)
6770 {
6771   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
6772 }
6773
6774 /* Return true if this tree map structure is marked for garbage collection
6775    purposes.  We simply return true if the from tree is marked, so that this
6776    structure goes away when the from tree goes away.  */
6777
6778 int
6779 tree_map_base_marked_p (const void *p)
6780 {
6781   return ggc_marked_p (((const struct tree_map_base *) p)->from);
6782 }
6783
6784 /* Hash a from tree in a tree_map.  */
6785
6786 unsigned int
6787 tree_map_hash (const void *item)
6788 {
6789   return (((const struct tree_map *) item)->hash);
6790 }
6791
6792 /* Hash a from tree in a tree_decl_map.  */
6793
6794 unsigned int
6795 tree_decl_map_hash (const void *item)
6796 {
6797   return DECL_UID (((const struct tree_decl_map *) item)->base.from);
6798 }
6799
6800 /* Return the initialization priority for DECL.  */
6801
6802 priority_type
6803 decl_init_priority_lookup (tree decl)
6804 {
6805   symtab_node *snode = symtab_node::get (decl);
6806
6807   if (!snode)
6808     return DEFAULT_INIT_PRIORITY;
6809   return
6810     snode->get_init_priority ();
6811 }
6812
6813 /* Return the finalization priority for DECL.  */
6814
6815 priority_type
6816 decl_fini_priority_lookup (tree decl)
6817 {
6818   cgraph_node *node = cgraph_node::get (decl);
6819
6820   if (!node)
6821     return DEFAULT_INIT_PRIORITY;
6822   return
6823     node->get_fini_priority ();
6824 }
6825
6826 /* Set the initialization priority for DECL to PRIORITY.  */
6827
6828 void
6829 decl_init_priority_insert (tree decl, priority_type priority)
6830 {
6831   struct symtab_node *snode;
6832
6833   if (priority == DEFAULT_INIT_PRIORITY)
6834     {
6835       snode = symtab_node::get (decl);
6836       if (!snode)
6837         return;
6838     }
6839   else if (VAR_P (decl))
6840     snode = varpool_node::get_create (decl);
6841   else
6842     snode = cgraph_node::get_create (decl);
6843   snode->set_init_priority (priority);
6844 }
6845
6846 /* Set the finalization priority for DECL to PRIORITY.  */
6847
6848 void
6849 decl_fini_priority_insert (tree decl, priority_type priority)
6850 {
6851   struct cgraph_node *node;
6852
6853   if (priority == DEFAULT_INIT_PRIORITY)
6854     {
6855       node = cgraph_node::get (decl);
6856       if (!node)
6857         return;
6858     }
6859   else
6860     node = cgraph_node::get_create (decl);
6861   node->set_fini_priority (priority);
6862 }
6863
6864 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
6865
6866 static void
6867 print_debug_expr_statistics (void)
6868 {
6869   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
6870            (long) debug_expr_for_decl->size (),
6871            (long) debug_expr_for_decl->elements (),
6872            debug_expr_for_decl->collisions ());
6873 }
6874
6875 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
6876
6877 static void
6878 print_value_expr_statistics (void)
6879 {
6880   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
6881            (long) value_expr_for_decl->size (),
6882            (long) value_expr_for_decl->elements (),
6883            value_expr_for_decl->collisions ());
6884 }
6885
6886 /* Lookup a debug expression for FROM, and return it if we find one.  */
6887
6888 tree
6889 decl_debug_expr_lookup (tree from)
6890 {
6891   struct tree_decl_map *h, in;
6892   in.base.from = from;
6893
6894   h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6895   if (h)
6896     return h->to;
6897   return NULL_TREE;
6898 }
6899
6900 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
6901
6902 void
6903 decl_debug_expr_insert (tree from, tree to)
6904 {
6905   struct tree_decl_map *h;
6906
6907   h = ggc_alloc<tree_decl_map> ();
6908   h->base.from = from;
6909   h->to = to;
6910   *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6911 }
6912
6913 /* Lookup a value expression for FROM, and return it if we find one.  */
6914
6915 tree
6916 decl_value_expr_lookup (tree from)
6917 {
6918   struct tree_decl_map *h, in;
6919   in.base.from = from;
6920
6921   h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6922   if (h)
6923     return h->to;
6924   return NULL_TREE;
6925 }
6926
6927 /* Insert a mapping FROM->TO in the value expression hashtable.  */
6928
6929 void
6930 decl_value_expr_insert (tree from, tree to)
6931 {
6932   struct tree_decl_map *h;
6933
6934   h = ggc_alloc<tree_decl_map> ();
6935   h->base.from = from;
6936   h->to = to;
6937   *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6938 }
6939
6940 /* Lookup a vector of debug arguments for FROM, and return it if we
6941    find one.  */
6942
6943 vec<tree, va_gc> **
6944 decl_debug_args_lookup (tree from)
6945 {
6946   struct tree_vec_map *h, in;
6947
6948   if (!DECL_HAS_DEBUG_ARGS_P (from))
6949     return NULL;
6950   gcc_checking_assert (debug_args_for_decl != NULL);
6951   in.base.from = from;
6952   h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from));
6953   if (h)
6954     return &h->to;
6955   return NULL;
6956 }
6957
6958 /* Insert a mapping FROM->empty vector of debug arguments in the value
6959    expression hashtable.  */
6960
6961 vec<tree, va_gc> **
6962 decl_debug_args_insert (tree from)
6963 {
6964   struct tree_vec_map *h;
6965   tree_vec_map **loc;
6966
6967   if (DECL_HAS_DEBUG_ARGS_P (from))
6968     return decl_debug_args_lookup (from);
6969   if (debug_args_for_decl == NULL)
6970     debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64);
6971   h = ggc_alloc<tree_vec_map> ();
6972   h->base.from = from;
6973   h->to = NULL;
6974   loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT);
6975   *loc = h;
6976   DECL_HAS_DEBUG_ARGS_P (from) = 1;
6977   return &h->to;
6978 }
6979
6980 /* Hashing of types so that we don't make duplicates.
6981    The entry point is `type_hash_canon'.  */
6982
6983 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6984    with types in the TREE_VALUE slots), by adding the hash codes
6985    of the individual types.  */
6986
6987 static void
6988 type_hash_list (const_tree list, inchash::hash &hstate)
6989 {
6990   const_tree tail;
6991
6992   for (tail = list; tail; tail = TREE_CHAIN (tail))
6993     if (TREE_VALUE (tail) != error_mark_node)
6994       hstate.add_object (TYPE_HASH (TREE_VALUE (tail)));
6995 }
6996
6997 /* These are the Hashtable callback functions.  */
6998
6999 /* Returns true iff the types are equivalent.  */
7000
7001 bool
7002 type_cache_hasher::equal (type_hash *a, type_hash *b)
7003 {
7004   /* First test the things that are the same for all types.  */
7005   if (a->hash != b->hash
7006       || TREE_CODE (a->type) != TREE_CODE (b->type)
7007       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
7008       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
7009                                  TYPE_ATTRIBUTES (b->type))
7010       || (TREE_CODE (a->type) != COMPLEX_TYPE
7011           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
7012     return 0;
7013
7014   /* Be careful about comparing arrays before and after the element type
7015      has been completed; don't compare TYPE_ALIGN unless both types are
7016      complete.  */
7017   if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
7018       && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
7019           || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
7020     return 0;
7021
7022   switch (TREE_CODE (a->type))
7023     {
7024     case VOID_TYPE:
7025     case COMPLEX_TYPE:
7026     case POINTER_TYPE:
7027     case REFERENCE_TYPE:
7028     case NULLPTR_TYPE:
7029       return 1;
7030
7031     case VECTOR_TYPE:
7032       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
7033
7034     case ENUMERAL_TYPE:
7035       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
7036           && !(TYPE_VALUES (a->type)
7037                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
7038                && TYPE_VALUES (b->type)
7039                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
7040                && type_list_equal (TYPE_VALUES (a->type),
7041                                    TYPE_VALUES (b->type))))
7042         return 0;
7043
7044       /* fall through */
7045
7046     case INTEGER_TYPE:
7047     case REAL_TYPE:
7048     case BOOLEAN_TYPE:
7049       if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
7050         return false;
7051       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
7052                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
7053                                       TYPE_MAX_VALUE (b->type)))
7054               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
7055                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
7056                                          TYPE_MIN_VALUE (b->type))));
7057
7058     case FIXED_POINT_TYPE:
7059       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
7060
7061     case OFFSET_TYPE:
7062       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
7063
7064     case METHOD_TYPE:
7065       if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
7066           && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
7067               || (TYPE_ARG_TYPES (a->type)
7068                   && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
7069                   && TYPE_ARG_TYPES (b->type)
7070                   && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
7071                   && type_list_equal (TYPE_ARG_TYPES (a->type),
7072                                       TYPE_ARG_TYPES (b->type)))))
7073         break;
7074       return 0;
7075     case ARRAY_TYPE:
7076       return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
7077
7078     case RECORD_TYPE:
7079     case UNION_TYPE:
7080     case QUAL_UNION_TYPE:
7081       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
7082               || (TYPE_FIELDS (a->type)
7083                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
7084                   && TYPE_FIELDS (b->type)
7085                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
7086                   && type_list_equal (TYPE_FIELDS (a->type),
7087                                       TYPE_FIELDS (b->type))));
7088
7089     case FUNCTION_TYPE:
7090       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
7091           || (TYPE_ARG_TYPES (a->type)
7092               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
7093               && TYPE_ARG_TYPES (b->type)
7094               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
7095               && type_list_equal (TYPE_ARG_TYPES (a->type),
7096                                   TYPE_ARG_TYPES (b->type))))
7097         break;
7098       return 0;
7099
7100     default:
7101       return 0;
7102     }
7103
7104   if (lang_hooks.types.type_hash_eq != NULL)
7105     return lang_hooks.types.type_hash_eq (a->type, b->type);
7106
7107   return 1;
7108 }
7109
7110 /* Given TYPE, and HASHCODE its hash code, return the canonical
7111    object for an identical type if one already exists.
7112    Otherwise, return TYPE, and record it as the canonical object.
7113
7114    To use this function, first create a type of the sort you want.
7115    Then compute its hash code from the fields of the type that
7116    make it different from other similar types.
7117    Then call this function and use the value.  */
7118
7119 tree
7120 type_hash_canon (unsigned int hashcode, tree type)
7121 {
7122   type_hash in;
7123   type_hash **loc;
7124
7125   /* The hash table only contains main variants, so ensure that's what we're
7126      being passed.  */
7127   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
7128
7129   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
7130      must call that routine before comparing TYPE_ALIGNs.  */
7131   layout_type (type);
7132
7133   in.hash = hashcode;
7134   in.type = type;
7135
7136   loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT);
7137   if (*loc)
7138     {
7139       tree t1 = ((type_hash *) *loc)->type;
7140       gcc_assert (TYPE_MAIN_VARIANT (t1) == t1);
7141       free_node (type);
7142       return t1;
7143     }
7144   else
7145     {
7146       struct type_hash *h;
7147
7148       h = ggc_alloc<type_hash> ();
7149       h->hash = hashcode;
7150       h->type = type;
7151       *loc = h;
7152
7153       return type;
7154     }
7155 }
7156
7157 static void
7158 print_type_hash_statistics (void)
7159 {
7160   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
7161            (long) type_hash_table->size (),
7162            (long) type_hash_table->elements (),
7163            type_hash_table->collisions ());
7164 }
7165
7166 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
7167    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
7168    by adding the hash codes of the individual attributes.  */
7169
7170 static void
7171 attribute_hash_list (const_tree list, inchash::hash &hstate)
7172 {
7173   const_tree tail;
7174
7175   for (tail = list; tail; tail = TREE_CHAIN (tail))
7176     /* ??? Do we want to add in TREE_VALUE too? */
7177     hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (tail)));
7178 }
7179
7180 /* Given two lists of attributes, return true if list l2 is
7181    equivalent to l1.  */
7182
7183 int
7184 attribute_list_equal (const_tree l1, const_tree l2)
7185 {
7186   if (l1 == l2)
7187     return 1;
7188
7189   return attribute_list_contained (l1, l2)
7190          && attribute_list_contained (l2, l1);
7191 }
7192
7193 /* Given two lists of attributes, return true if list L2 is
7194    completely contained within L1.  */
7195 /* ??? This would be faster if attribute names were stored in a canonicalized
7196    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
7197    must be used to show these elements are equivalent (which they are).  */
7198 /* ??? It's not clear that attributes with arguments will always be handled
7199    correctly.  */
7200
7201 int
7202 attribute_list_contained (const_tree l1, const_tree l2)
7203 {
7204   const_tree t1, t2;
7205
7206   /* First check the obvious, maybe the lists are identical.  */
7207   if (l1 == l2)
7208     return 1;
7209
7210   /* Maybe the lists are similar.  */
7211   for (t1 = l1, t2 = l2;
7212        t1 != 0 && t2 != 0
7213         && get_attribute_name (t1) == get_attribute_name (t2)
7214         && TREE_VALUE (t1) == TREE_VALUE (t2);
7215        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
7216     ;
7217
7218   /* Maybe the lists are equal.  */
7219   if (t1 == 0 && t2 == 0)
7220     return 1;
7221
7222   for (; t2 != 0; t2 = TREE_CHAIN (t2))
7223     {
7224       const_tree attr;
7225       /* This CONST_CAST is okay because lookup_attribute does not
7226          modify its argument and the return value is assigned to a
7227          const_tree.  */
7228       for (attr = lookup_ident_attribute (get_attribute_name (t2),
7229                                           CONST_CAST_TREE (l1));
7230            attr != NULL_TREE && !attribute_value_equal (t2, attr);
7231            attr = lookup_ident_attribute (get_attribute_name (t2),
7232                                           TREE_CHAIN (attr)))
7233         ;
7234
7235       if (attr == NULL_TREE)
7236         return 0;
7237     }
7238
7239   return 1;
7240 }
7241
7242 /* Given two lists of types
7243    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
7244    return 1 if the lists contain the same types in the same order.
7245    Also, the TREE_PURPOSEs must match.  */
7246
7247 int
7248 type_list_equal (const_tree l1, const_tree l2)
7249 {
7250   const_tree t1, t2;
7251
7252   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
7253     if (TREE_VALUE (t1) != TREE_VALUE (t2)
7254         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
7255             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
7256                   && (TREE_TYPE (TREE_PURPOSE (t1))
7257                       == TREE_TYPE (TREE_PURPOSE (t2))))))
7258       return 0;
7259
7260   return t1 == t2;
7261 }
7262
7263 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
7264    given by TYPE.  If the argument list accepts variable arguments,
7265    then this function counts only the ordinary arguments.  */
7266
7267 int
7268 type_num_arguments (const_tree type)
7269 {
7270   int i = 0;
7271   tree t;
7272
7273   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
7274     /* If the function does not take a variable number of arguments,
7275        the last element in the list will have type `void'.  */
7276     if (VOID_TYPE_P (TREE_VALUE (t)))
7277       break;
7278     else
7279       ++i;
7280
7281   return i;
7282 }
7283
7284 /* Nonzero if integer constants T1 and T2
7285    represent the same constant value.  */
7286
7287 int
7288 tree_int_cst_equal (const_tree t1, const_tree t2)
7289 {
7290   if (t1 == t2)
7291     return 1;
7292
7293   if (t1 == 0 || t2 == 0)
7294     return 0;
7295
7296   if (TREE_CODE (t1) == INTEGER_CST
7297       && TREE_CODE (t2) == INTEGER_CST
7298       && wi::to_widest (t1) == wi::to_widest (t2))
7299     return 1;
7300
7301   return 0;
7302 }
7303
7304 /* Return true if T is an INTEGER_CST whose numerical value (extended
7305    according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.  */
7306
7307 bool
7308 tree_fits_shwi_p (const_tree t)
7309 {
7310   return (t != NULL_TREE
7311           && TREE_CODE (t) == INTEGER_CST
7312           && wi::fits_shwi_p (wi::to_widest (t)));
7313 }
7314
7315 /* Return true if T is an INTEGER_CST whose numerical value (extended
7316    according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.  */
7317
7318 bool
7319 tree_fits_uhwi_p (const_tree t)
7320 {
7321   return (t != NULL_TREE
7322           && TREE_CODE (t) == INTEGER_CST
7323           && wi::fits_uhwi_p (wi::to_widest (t)));
7324 }
7325
7326 /* T is an INTEGER_CST whose numerical value (extended according to
7327    TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.  Return that
7328    HOST_WIDE_INT.  */
7329
7330 HOST_WIDE_INT
7331 tree_to_shwi (const_tree t)
7332 {
7333   gcc_assert (tree_fits_shwi_p (t));
7334   return TREE_INT_CST_LOW (t);
7335 }
7336
7337 /* T is an INTEGER_CST whose numerical value (extended according to
7338    TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.  Return that
7339    HOST_WIDE_INT.  */
7340
7341 unsigned HOST_WIDE_INT
7342 tree_to_uhwi (const_tree t)
7343 {
7344   gcc_assert (tree_fits_uhwi_p (t));
7345   return TREE_INT_CST_LOW (t);
7346 }
7347
7348 /* Return the most significant (sign) bit of T.  */
7349
7350 int
7351 tree_int_cst_sign_bit (const_tree t)
7352 {
7353   unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
7354
7355   return wi::extract_uhwi (t, bitno, 1);
7356 }
7357
7358 /* Return an indication of the sign of the integer constant T.
7359    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7360    Note that -1 will never be returned if T's type is unsigned.  */
7361
7362 int
7363 tree_int_cst_sgn (const_tree t)
7364 {
7365   if (wi::eq_p (t, 0))
7366     return 0;
7367   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
7368     return 1;
7369   else if (wi::neg_p (t))
7370     return -1;
7371   else
7372     return 1;
7373 }
7374
7375 /* Return the minimum number of bits needed to represent VALUE in a
7376    signed or unsigned type, UNSIGNEDP says which.  */
7377
7378 unsigned int
7379 tree_int_cst_min_precision (tree value, signop sgn)
7380 {
7381   /* If the value is negative, compute its negative minus 1.  The latter
7382      adjustment is because the absolute value of the largest negative value
7383      is one larger than the largest positive value.  This is equivalent to
7384      a bit-wise negation, so use that operation instead.  */
7385
7386   if (tree_int_cst_sgn (value) < 0)
7387     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
7388
7389   /* Return the number of bits needed, taking into account the fact
7390      that we need one more bit for a signed than unsigned type.
7391      If value is 0 or -1, the minimum precision is 1 no matter
7392      whether unsignedp is true or false.  */
7393
7394   if (integer_zerop (value))
7395     return 1;
7396   else
7397     return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
7398 }
7399
7400 /* Return truthvalue of whether T1 is the same tree structure as T2.
7401    Return 1 if they are the same.
7402    Return 0 if they are understandably different.
7403    Return -1 if either contains tree structure not understood by
7404    this function.  */
7405
7406 int
7407 simple_cst_equal (const_tree t1, const_tree t2)
7408 {
7409   enum tree_code code1, code2;
7410   int cmp;
7411   int i;
7412
7413   if (t1 == t2)
7414     return 1;
7415   if (t1 == 0 || t2 == 0)
7416     return 0;
7417
7418   code1 = TREE_CODE (t1);
7419   code2 = TREE_CODE (t2);
7420
7421   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
7422     {
7423       if (CONVERT_EXPR_CODE_P (code2)
7424           || code2 == NON_LVALUE_EXPR)
7425         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7426       else
7427         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
7428     }
7429
7430   else if (CONVERT_EXPR_CODE_P (code2)
7431            || code2 == NON_LVALUE_EXPR)
7432     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
7433
7434   if (code1 != code2)
7435     return 0;
7436
7437   switch (code1)
7438     {
7439     case INTEGER_CST:
7440       return wi::to_widest (t1) == wi::to_widest (t2);
7441
7442     case REAL_CST:
7443       return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
7444
7445     case FIXED_CST:
7446       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
7447
7448     case STRING_CST:
7449       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
7450               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
7451                          TREE_STRING_LENGTH (t1)));
7452
7453     case CONSTRUCTOR:
7454       {
7455         unsigned HOST_WIDE_INT idx;
7456         vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
7457         vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
7458
7459         if (vec_safe_length (v1) != vec_safe_length (v2))
7460           return false;
7461
7462         for (idx = 0; idx < vec_safe_length (v1); ++idx)
7463           /* ??? Should we handle also fields here? */
7464           if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
7465             return false;
7466         return true;
7467       }
7468
7469     case SAVE_EXPR:
7470       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7471
7472     case CALL_EXPR:
7473       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
7474       if (cmp <= 0)
7475         return cmp;
7476       if (call_expr_nargs (t1) != call_expr_nargs (t2))
7477         return 0;
7478       {
7479         const_tree arg1, arg2;
7480         const_call_expr_arg_iterator iter1, iter2;
7481         for (arg1 = first_const_call_expr_arg (t1, &iter1),
7482                arg2 = first_const_call_expr_arg (t2, &iter2);
7483              arg1 && arg2;
7484              arg1 = next_const_call_expr_arg (&iter1),
7485                arg2 = next_const_call_expr_arg (&iter2))
7486           {
7487             cmp = simple_cst_equal (arg1, arg2);
7488             if (cmp <= 0)
7489               return cmp;
7490           }
7491         return arg1 == arg2;
7492       }
7493
7494     case TARGET_EXPR:
7495       /* Special case: if either target is an unallocated VAR_DECL,
7496          it means that it's going to be unified with whatever the
7497          TARGET_EXPR is really supposed to initialize, so treat it
7498          as being equivalent to anything.  */
7499       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
7500            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
7501            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
7502           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
7503               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
7504               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
7505         cmp = 1;
7506       else
7507         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7508
7509       if (cmp <= 0)
7510         return cmp;
7511
7512       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
7513
7514     case WITH_CLEANUP_EXPR:
7515       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7516       if (cmp <= 0)
7517         return cmp;
7518
7519       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
7520
7521     case COMPONENT_REF:
7522       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
7523         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7524
7525       return 0;
7526
7527     case VAR_DECL:
7528     case PARM_DECL:
7529     case CONST_DECL:
7530     case FUNCTION_DECL:
7531       return 0;
7532
7533     default:
7534       break;
7535     }
7536
7537   /* This general rule works for most tree codes.  All exceptions should be
7538      handled above.  If this is a language-specific tree code, we can't
7539      trust what might be in the operand, so say we don't know
7540      the situation.  */
7541   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
7542     return -1;
7543
7544   switch (TREE_CODE_CLASS (code1))
7545     {
7546     case tcc_unary:
7547     case tcc_binary:
7548     case tcc_comparison:
7549     case tcc_expression:
7550     case tcc_reference:
7551     case tcc_statement:
7552       cmp = 1;
7553       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
7554         {
7555           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
7556           if (cmp <= 0)
7557             return cmp;
7558         }
7559
7560       return cmp;
7561
7562     default:
7563       return -1;
7564     }
7565 }
7566
7567 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7568    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7569    than U, respectively.  */
7570
7571 int
7572 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
7573 {
7574   if (tree_int_cst_sgn (t) < 0)
7575     return -1;
7576   else if (!tree_fits_uhwi_p (t))
7577     return 1;
7578   else if (TREE_INT_CST_LOW (t) == u)
7579     return 0;
7580   else if (TREE_INT_CST_LOW (t) < u)
7581     return -1;
7582   else
7583     return 1;
7584 }
7585
7586 /* Return true if SIZE represents a constant size that is in bounds of
7587    what the middle-end and the backend accepts (covering not more than
7588    half of the address-space).  */
7589
7590 bool
7591 valid_constant_size_p (const_tree size)
7592 {
7593   if (! tree_fits_uhwi_p (size)
7594       || TREE_OVERFLOW (size)
7595       || tree_int_cst_sign_bit (size) != 0)
7596     return false;
7597   return true;
7598 }
7599
7600 /* Return the precision of the type, or for a complex or vector type the
7601    precision of the type of its elements.  */
7602
7603 unsigned int
7604 element_precision (const_tree type)
7605 {
7606   if (!TYPE_P (type))
7607     type = TREE_TYPE (type);
7608   enum tree_code code = TREE_CODE (type);
7609   if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
7610     type = TREE_TYPE (type);
7611
7612   return TYPE_PRECISION (type);
7613 }
7614
7615 /* Return true if CODE represents an associative tree code.  Otherwise
7616    return false.  */
7617 bool
7618 associative_tree_code (enum tree_code code)
7619 {
7620   switch (code)
7621     {
7622     case BIT_IOR_EXPR:
7623     case BIT_AND_EXPR:
7624     case BIT_XOR_EXPR:
7625     case PLUS_EXPR:
7626     case MULT_EXPR:
7627     case MIN_EXPR:
7628     case MAX_EXPR:
7629       return true;
7630
7631     default:
7632       break;
7633     }
7634   return false;
7635 }
7636
7637 /* Return true if CODE represents a commutative tree code.  Otherwise
7638    return false.  */
7639 bool
7640 commutative_tree_code (enum tree_code code)
7641 {
7642   switch (code)
7643     {
7644     case PLUS_EXPR:
7645     case MULT_EXPR:
7646     case MULT_HIGHPART_EXPR:
7647     case MIN_EXPR:
7648     case MAX_EXPR:
7649     case BIT_IOR_EXPR:
7650     case BIT_XOR_EXPR:
7651     case BIT_AND_EXPR:
7652     case NE_EXPR:
7653     case EQ_EXPR:
7654     case UNORDERED_EXPR:
7655     case ORDERED_EXPR:
7656     case UNEQ_EXPR:
7657     case LTGT_EXPR:
7658     case TRUTH_AND_EXPR:
7659     case TRUTH_XOR_EXPR:
7660     case TRUTH_OR_EXPR:
7661     case WIDEN_MULT_EXPR:
7662     case VEC_WIDEN_MULT_HI_EXPR:
7663     case VEC_WIDEN_MULT_LO_EXPR:
7664     case VEC_WIDEN_MULT_EVEN_EXPR:
7665     case VEC_WIDEN_MULT_ODD_EXPR:
7666       return true;
7667
7668     default:
7669       break;
7670     }
7671   return false;
7672 }
7673
7674 /* Return true if CODE represents a ternary tree code for which the
7675    first two operands are commutative.  Otherwise return false.  */
7676 bool
7677 commutative_ternary_tree_code (enum tree_code code)
7678 {
7679   switch (code)
7680     {
7681     case WIDEN_MULT_PLUS_EXPR:
7682     case WIDEN_MULT_MINUS_EXPR:
7683     case DOT_PROD_EXPR:
7684     case FMA_EXPR:
7685       return true;
7686
7687     default:
7688       break;
7689     }
7690   return false;
7691 }
7692
7693 /* Returns true if CODE can overflow.  */
7694
7695 bool
7696 operation_can_overflow (enum tree_code code)
7697 {
7698   switch (code)
7699     {
7700     case PLUS_EXPR:
7701     case MINUS_EXPR:
7702     case MULT_EXPR:
7703     case LSHIFT_EXPR:
7704       /* Can overflow in various ways.  */
7705       return true;
7706     case TRUNC_DIV_EXPR:
7707     case EXACT_DIV_EXPR:
7708     case FLOOR_DIV_EXPR:
7709     case CEIL_DIV_EXPR:
7710       /* For INT_MIN / -1.  */
7711       return true;
7712     case NEGATE_EXPR:
7713     case ABS_EXPR:
7714       /* For -INT_MIN.  */
7715       return true;
7716     default:
7717       /* These operators cannot overflow.  */
7718       return false;
7719     }
7720 }
7721
7722 /* Returns true if CODE operating on operands of type TYPE doesn't overflow, or
7723    ftrapv doesn't generate trapping insns for CODE.  */
7724
7725 bool
7726 operation_no_trapping_overflow (tree type, enum tree_code code)
7727 {
7728   gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type));
7729
7730   /* We don't generate instructions that trap on overflow for complex or vector
7731      types.  */
7732   if (!INTEGRAL_TYPE_P (type))
7733     return true;
7734
7735   if (!TYPE_OVERFLOW_TRAPS (type))
7736     return true;
7737
7738   switch (code)
7739     {
7740     case PLUS_EXPR:
7741     case MINUS_EXPR:
7742     case MULT_EXPR:
7743     case NEGATE_EXPR:
7744     case ABS_EXPR:
7745       /* These operators can overflow, and -ftrapv generates trapping code for
7746          these.  */
7747       return false;
7748     case TRUNC_DIV_EXPR:
7749     case EXACT_DIV_EXPR:
7750     case FLOOR_DIV_EXPR:
7751     case CEIL_DIV_EXPR:
7752     case LSHIFT_EXPR:
7753       /* These operators can overflow, but -ftrapv does not generate trapping
7754          code for these.  */
7755       return true;
7756     default:
7757       /* These operators cannot overflow.  */
7758       return true;
7759     }
7760 }
7761
7762 namespace inchash
7763 {
7764
7765 /* Generate a hash value for an expression.  This can be used iteratively
7766    by passing a previous result as the HSTATE argument.
7767
7768    This function is intended to produce the same hash for expressions which
7769    would compare equal using operand_equal_p.  */
7770 void
7771 add_expr (const_tree t, inchash::hash &hstate, unsigned int flags)
7772 {
7773   int i;
7774   enum tree_code code;
7775   enum tree_code_class tclass;
7776
7777   if (t == NULL_TREE || t == error_mark_node)
7778     {
7779       hstate.merge_hash (0);
7780       return;
7781     }
7782
7783   if (!(flags & OEP_ADDRESS_OF))
7784     STRIP_NOPS (t);
7785
7786   code = TREE_CODE (t);
7787
7788   switch (code)
7789     {
7790     /* Alas, constants aren't shared, so we can't rely on pointer
7791        identity.  */
7792     case VOID_CST:
7793       hstate.merge_hash (0);
7794       return;
7795     case INTEGER_CST:
7796       gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7797       for (i = 0; i < TREE_INT_CST_EXT_NUNITS (t); i++)
7798         hstate.add_wide_int (TREE_INT_CST_ELT (t, i));
7799       return;
7800     case REAL_CST:
7801       {
7802         unsigned int val2;
7803         if (!HONOR_SIGNED_ZEROS (t) && real_zerop (t))
7804           val2 = rvc_zero;
7805         else
7806           val2 = real_hash (TREE_REAL_CST_PTR (t));
7807         hstate.merge_hash (val2);
7808         return;
7809       }
7810     case FIXED_CST:
7811       {
7812         unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
7813         hstate.merge_hash (val2);
7814         return;
7815       }
7816     case STRING_CST:
7817       hstate.add ((const void *) TREE_STRING_POINTER (t),
7818                   TREE_STRING_LENGTH (t));
7819       return;
7820     case COMPLEX_CST:
7821       inchash::add_expr (TREE_REALPART (t), hstate, flags);
7822       inchash::add_expr (TREE_IMAGPART (t), hstate, flags);
7823       return;
7824     case VECTOR_CST:
7825       {
7826         unsigned i;
7827         for (i = 0; i < VECTOR_CST_NELTS (t); ++i)
7828           inchash::add_expr (VECTOR_CST_ELT (t, i), hstate, flags);
7829         return;
7830       }
7831     case SSA_NAME:
7832       /* We can just compare by pointer.  */
7833       hstate.add_wide_int (SSA_NAME_VERSION (t));
7834       return;
7835     case PLACEHOLDER_EXPR:
7836       /* The node itself doesn't matter.  */
7837       return;
7838     case BLOCK:
7839     case OMP_CLAUSE:
7840       /* Ignore.  */
7841       return;
7842     case TREE_LIST:
7843       /* A list of expressions, for a CALL_EXPR or as the elements of a
7844          VECTOR_CST.  */
7845       for (; t; t = TREE_CHAIN (t))
7846         inchash::add_expr (TREE_VALUE (t), hstate, flags);
7847       return;
7848     case CONSTRUCTOR:
7849       {
7850         unsigned HOST_WIDE_INT idx;
7851         tree field, value;
7852         flags &= ~OEP_ADDRESS_OF;
7853         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
7854           {
7855             inchash::add_expr (field, hstate, flags);
7856             inchash::add_expr (value, hstate, flags);
7857           }
7858         return;
7859       }
7860     case STATEMENT_LIST:
7861       {
7862         tree_stmt_iterator i;
7863         for (i = tsi_start (CONST_CAST_TREE (t));
7864              !tsi_end_p (i); tsi_next (&i))
7865           inchash::add_expr (tsi_stmt (i), hstate, flags);
7866         return;
7867       }
7868     case FUNCTION_DECL:
7869       /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7870          Otherwise nodes that compare equal according to operand_equal_p might
7871          get different hash codes.  However, don't do this for machine specific
7872          or front end builtins, since the function code is overloaded in those
7873          cases.  */
7874       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
7875           && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
7876         {
7877           t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
7878           code = TREE_CODE (t);
7879         }
7880       /* FALL THROUGH */
7881     default:
7882       tclass = TREE_CODE_CLASS (code);
7883
7884       if (tclass == tcc_declaration)
7885         {
7886           /* DECL's have a unique ID */
7887           hstate.add_wide_int (DECL_UID (t));
7888         }
7889       else if (tclass == tcc_comparison && !commutative_tree_code (code))
7890         {
7891           /* For comparisons that can be swapped, use the lower
7892              tree code.  */
7893           enum tree_code ccode = swap_tree_comparison (code);
7894           if (code < ccode)
7895             ccode = code;
7896           hstate.add_object (ccode);
7897           inchash::add_expr (TREE_OPERAND (t, ccode != code), hstate, flags);
7898           inchash::add_expr (TREE_OPERAND (t, ccode == code), hstate, flags);
7899         }
7900       else if (CONVERT_EXPR_CODE_P (code))
7901         {
7902           /* NOP_EXPR and CONVERT_EXPR are considered equal by
7903              operand_equal_p.  */
7904           enum tree_code ccode = NOP_EXPR;
7905           hstate.add_object (ccode);
7906
7907           /* Don't hash the type, that can lead to having nodes which
7908              compare equal according to operand_equal_p, but which
7909              have different hash codes.  Make sure to include signedness
7910              in the hash computation.  */
7911           hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7912           inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
7913         }
7914       /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl.  */
7915       else if (code == MEM_REF
7916                && (flags & OEP_ADDRESS_OF) != 0
7917                && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
7918                && DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
7919                && integer_zerop (TREE_OPERAND (t, 1)))
7920         inchash::add_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0),
7921                            hstate, flags);
7922       /* Don't ICE on FE specific trees, or their arguments etc.
7923          during operand_equal_p hash verification.  */
7924       else if (!IS_EXPR_CODE_CLASS (tclass))
7925         gcc_assert (flags & OEP_HASH_CHECK);
7926       else
7927         {
7928           unsigned int sflags = flags;
7929
7930           hstate.add_object (code);
7931
7932           switch (code)
7933             {
7934             case ADDR_EXPR:
7935               gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7936               flags |= OEP_ADDRESS_OF;
7937               sflags = flags;
7938               break;
7939
7940             case INDIRECT_REF:
7941             case MEM_REF:
7942             case TARGET_MEM_REF:
7943               flags &= ~OEP_ADDRESS_OF;
7944               sflags = flags;
7945               break;
7946
7947             case ARRAY_REF:
7948             case ARRAY_RANGE_REF:
7949             case COMPONENT_REF:
7950             case BIT_FIELD_REF:
7951               sflags &= ~OEP_ADDRESS_OF;
7952               break;
7953
7954             case COND_EXPR:
7955               flags &= ~OEP_ADDRESS_OF;
7956               break;
7957
7958             case FMA_EXPR:
7959             case WIDEN_MULT_PLUS_EXPR:
7960             case WIDEN_MULT_MINUS_EXPR:
7961               {
7962                 /* The multiplication operands are commutative.  */
7963                 inchash::hash one, two;
7964                 inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
7965                 inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
7966                 hstate.add_commutative (one, two);
7967                 inchash::add_expr (TREE_OPERAND (t, 2), two, flags);
7968                 return;
7969               }
7970
7971             case CALL_EXPR:
7972               if (CALL_EXPR_FN (t) == NULL_TREE)
7973                 hstate.add_int (CALL_EXPR_IFN (t));
7974               break;
7975
7976             case TARGET_EXPR:
7977               /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT.
7978                  Usually different TARGET_EXPRs just should use
7979                  different temporaries in their slots.  */
7980               inchash::add_expr (TARGET_EXPR_SLOT (t), hstate, flags);
7981               return;
7982
7983             default:
7984               break;
7985             }
7986
7987           /* Don't hash the type, that can lead to having nodes which
7988              compare equal according to operand_equal_p, but which
7989              have different hash codes.  */
7990           if (code == NON_LVALUE_EXPR)
7991             {
7992               /* Make sure to include signness in the hash computation.  */
7993               hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7994               inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
7995             }
7996
7997           else if (commutative_tree_code (code))
7998             {
7999               /* It's a commutative expression.  We want to hash it the same
8000                  however it appears.  We do this by first hashing both operands
8001                  and then rehashing based on the order of their independent
8002                  hashes.  */
8003               inchash::hash one, two;
8004               inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
8005               inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
8006               hstate.add_commutative (one, two);
8007             }
8008           else
8009             for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
8010               inchash::add_expr (TREE_OPERAND (t, i), hstate,
8011                                  i == 0 ? flags : sflags);
8012         }
8013       return;
8014     }
8015 }
8016
8017 }
8018
8019 /* Constructors for pointer, array and function types.
8020    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
8021    constructed by language-dependent code, not here.)  */
8022
8023 /* Construct, lay out and return the type of pointers to TO_TYPE with
8024    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
8025    reference all of memory. If such a type has already been
8026    constructed, reuse it.  */
8027
8028 tree
8029 build_pointer_type_for_mode (tree to_type, machine_mode mode,
8030                              bool can_alias_all)
8031 {
8032   tree t;
8033   bool could_alias = can_alias_all;
8034
8035   if (to_type == error_mark_node)
8036     return error_mark_node;
8037
8038   /* If the pointed-to type has the may_alias attribute set, force
8039      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
8040   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
8041     can_alias_all = true;
8042
8043   /* In some cases, languages will have things that aren't a POINTER_TYPE
8044      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
8045      In that case, return that type without regard to the rest of our
8046      operands.
8047
8048      ??? This is a kludge, but consistent with the way this function has
8049      always operated and there doesn't seem to be a good way to avoid this
8050      at the moment.  */
8051   if (TYPE_POINTER_TO (to_type) != 0
8052       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
8053     return TYPE_POINTER_TO (to_type);
8054
8055   /* First, if we already have a type for pointers to TO_TYPE and it's
8056      the proper mode, use it.  */
8057   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
8058     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
8059       return t;
8060
8061   t = make_node (POINTER_TYPE);
8062
8063   TREE_TYPE (t) = to_type;
8064   SET_TYPE_MODE (t, mode);
8065   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
8066   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
8067   TYPE_POINTER_TO (to_type) = t;
8068
8069   /* During LTO we do not set TYPE_CANONICAL of pointers and references.  */
8070   if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
8071     SET_TYPE_STRUCTURAL_EQUALITY (t);
8072   else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
8073     TYPE_CANONICAL (t)
8074       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
8075                                      mode, false);
8076
8077   /* Lay out the type.  This function has many callers that are concerned
8078      with expression-construction, and this simplifies them all.  */
8079   layout_type (t);
8080
8081   return t;
8082 }
8083
8084 /* By default build pointers in ptr_mode.  */
8085
8086 tree
8087 build_pointer_type (tree to_type)
8088 {
8089   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
8090                                               : TYPE_ADDR_SPACE (to_type);
8091   machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
8092   return build_pointer_type_for_mode (to_type, pointer_mode, false);
8093 }
8094
8095 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
8096
8097 tree
8098 build_reference_type_for_mode (tree to_type, machine_mode mode,
8099                                bool can_alias_all)
8100 {
8101   tree t;
8102   bool could_alias = can_alias_all;
8103
8104   if (to_type == error_mark_node)
8105     return error_mark_node;
8106
8107   /* If the pointed-to type has the may_alias attribute set, force
8108      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
8109   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
8110     can_alias_all = true;
8111
8112   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
8113      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
8114      In that case, return that type without regard to the rest of our
8115      operands.
8116
8117      ??? This is a kludge, but consistent with the way this function has
8118      always operated and there doesn't seem to be a good way to avoid this
8119      at the moment.  */
8120   if (TYPE_REFERENCE_TO (to_type) != 0
8121       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
8122     return TYPE_REFERENCE_TO (to_type);
8123
8124   /* First, if we already have a type for pointers to TO_TYPE and it's
8125      the proper mode, use it.  */
8126   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
8127     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
8128       return t;
8129
8130   t = make_node (REFERENCE_TYPE);
8131
8132   TREE_TYPE (t) = to_type;
8133   SET_TYPE_MODE (t, mode);
8134   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
8135   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
8136   TYPE_REFERENCE_TO (to_type) = t;
8137
8138   /* During LTO we do not set TYPE_CANONICAL of pointers and references.  */
8139   if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
8140     SET_TYPE_STRUCTURAL_EQUALITY (t);
8141   else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
8142     TYPE_CANONICAL (t)
8143       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
8144                                        mode, false);
8145
8146   layout_type (t);
8147
8148   return t;
8149 }
8150
8151
8152 /* Build the node for the type of references-to-TO_TYPE by default
8153    in ptr_mode.  */
8154
8155 tree
8156 build_reference_type (tree to_type)
8157 {
8158   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
8159                                               : TYPE_ADDR_SPACE (to_type);
8160   machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
8161   return build_reference_type_for_mode (to_type, pointer_mode, false);
8162 }
8163
8164 #define MAX_INT_CACHED_PREC \
8165   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8166 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
8167
8168 /* Builds a signed or unsigned integer type of precision PRECISION.
8169    Used for C bitfields whose precision does not match that of
8170    built-in target types.  */
8171 tree
8172 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
8173                                 int unsignedp)
8174 {
8175   tree itype, ret;
8176
8177   if (unsignedp)
8178     unsignedp = MAX_INT_CACHED_PREC + 1;
8179
8180   if (precision <= MAX_INT_CACHED_PREC)
8181     {
8182       itype = nonstandard_integer_type_cache[precision + unsignedp];
8183       if (itype)
8184         return itype;
8185     }
8186
8187   itype = make_node (INTEGER_TYPE);
8188   TYPE_PRECISION (itype) = precision;
8189
8190   if (unsignedp)
8191     fixup_unsigned_type (itype);
8192   else
8193     fixup_signed_type (itype);
8194
8195   ret = itype;
8196   if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype)))
8197     ret = type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype)), itype);
8198   if (precision <= MAX_INT_CACHED_PREC)
8199     nonstandard_integer_type_cache[precision + unsignedp] = ret;
8200
8201   return ret;
8202 }
8203
8204 #define MAX_BOOL_CACHED_PREC \
8205   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8206 static GTY(()) tree nonstandard_boolean_type_cache[MAX_BOOL_CACHED_PREC + 1];
8207
8208 /* Builds a boolean type of precision PRECISION.
8209    Used for boolean vectors to choose proper vector element size.  */
8210 tree
8211 build_nonstandard_boolean_type (unsigned HOST_WIDE_INT precision)
8212 {
8213   tree type;
8214
8215   if (precision <= MAX_BOOL_CACHED_PREC)
8216     {
8217       type = nonstandard_boolean_type_cache[precision];
8218       if (type)
8219         return type;
8220     }
8221
8222   type = make_node (BOOLEAN_TYPE);
8223   TYPE_PRECISION (type) = precision;
8224   fixup_signed_type (type);
8225
8226   if (precision <= MAX_INT_CACHED_PREC)
8227     nonstandard_boolean_type_cache[precision] = type;
8228
8229   return type;
8230 }
8231
8232 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
8233    or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL.  If SHARED
8234    is true, reuse such a type that has already been constructed.  */
8235
8236 static tree
8237 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
8238 {
8239   tree itype = make_node (INTEGER_TYPE);
8240   inchash::hash hstate;
8241
8242   TREE_TYPE (itype) = type;
8243
8244   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
8245   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
8246
8247   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
8248   SET_TYPE_MODE (itype, TYPE_MODE (type));
8249   TYPE_SIZE (itype) = TYPE_SIZE (type);
8250   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
8251   SET_TYPE_ALIGN (itype, TYPE_ALIGN (type));
8252   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
8253
8254   if (!shared)
8255     return itype;
8256
8257   if ((TYPE_MIN_VALUE (itype)
8258        && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
8259       || (TYPE_MAX_VALUE (itype)
8260           && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
8261     {
8262       /* Since we cannot reliably merge this type, we need to compare it using
8263          structural equality checks.  */
8264       SET_TYPE_STRUCTURAL_EQUALITY (itype);
8265       return itype;
8266     }
8267
8268   inchash::add_expr (TYPE_MIN_VALUE (itype), hstate);
8269   inchash::add_expr (TYPE_MAX_VALUE (itype), hstate);
8270   hstate.merge_hash (TYPE_HASH (type));
8271   itype = type_hash_canon (hstate.end (), itype);
8272
8273   return itype;
8274 }
8275
8276 /* Wrapper around build_range_type_1 with SHARED set to true.  */
8277
8278 tree
8279 build_range_type (tree type, tree lowval, tree highval)
8280 {
8281   return build_range_type_1 (type, lowval, highval, true);
8282 }
8283
8284 /* Wrapper around build_range_type_1 with SHARED set to false.  */
8285
8286 tree
8287 build_nonshared_range_type (tree type, tree lowval, tree highval)
8288 {
8289   return build_range_type_1 (type, lowval, highval, false);
8290 }
8291
8292 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
8293    MAXVAL should be the maximum value in the domain
8294    (one less than the length of the array).
8295
8296    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
8297    We don't enforce this limit, that is up to caller (e.g. language front end).
8298    The limit exists because the result is a signed type and we don't handle
8299    sizes that use more than one HOST_WIDE_INT.  */
8300
8301 tree
8302 build_index_type (tree maxval)
8303 {
8304   return build_range_type (sizetype, size_zero_node, maxval);
8305 }
8306
8307 /* Return true if the debug information for TYPE, a subtype, should be emitted
8308    as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
8309    high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
8310    debug info and doesn't reflect the source code.  */
8311
8312 bool
8313 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
8314 {
8315   tree base_type = TREE_TYPE (type), low, high;
8316
8317   /* Subrange types have a base type which is an integral type.  */
8318   if (!INTEGRAL_TYPE_P (base_type))
8319     return false;
8320
8321   /* Get the real bounds of the subtype.  */
8322   if (lang_hooks.types.get_subrange_bounds)
8323     lang_hooks.types.get_subrange_bounds (type, &low, &high);
8324   else
8325     {
8326       low = TYPE_MIN_VALUE (type);
8327       high = TYPE_MAX_VALUE (type);
8328     }
8329
8330   /* If the type and its base type have the same representation and the same
8331      name, then the type is not a subrange but a copy of the base type.  */
8332   if ((TREE_CODE (base_type) == INTEGER_TYPE
8333        || TREE_CODE (base_type) == BOOLEAN_TYPE)
8334       && int_size_in_bytes (type) == int_size_in_bytes (base_type)
8335       && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
8336       && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))
8337       && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type))
8338     return false;
8339
8340   if (lowval)
8341     *lowval = low;
8342   if (highval)
8343     *highval = high;
8344   return true;
8345 }
8346
8347 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
8348    and number of elements specified by the range of values of INDEX_TYPE.
8349    If SHARED is true, reuse such a type that has already been constructed.  */
8350
8351 static tree
8352 build_array_type_1 (tree elt_type, tree index_type, bool shared)
8353 {
8354   tree t;
8355
8356   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
8357     {
8358       error ("arrays of functions are not meaningful");
8359       elt_type = integer_type_node;
8360     }
8361
8362   t = make_node (ARRAY_TYPE);
8363   TREE_TYPE (t) = elt_type;
8364   TYPE_DOMAIN (t) = index_type;
8365   TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
8366   layout_type (t);
8367
8368   /* If the element type is incomplete at this point we get marked for
8369      structural equality.  Do not record these types in the canonical
8370      type hashtable.  */
8371   if (TYPE_STRUCTURAL_EQUALITY_P (t))
8372     return t;
8373
8374   if (shared)
8375     {
8376       inchash::hash hstate;
8377       hstate.add_object (TYPE_HASH (elt_type));
8378       if (index_type)
8379         hstate.add_object (TYPE_HASH (index_type));
8380       t = type_hash_canon (hstate.end (), t);
8381     }
8382
8383   if (TYPE_CANONICAL (t) == t)
8384     {
8385       if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
8386           || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))
8387           || in_lto_p)
8388         SET_TYPE_STRUCTURAL_EQUALITY (t);
8389       else if (TYPE_CANONICAL (elt_type) != elt_type
8390                || (index_type && TYPE_CANONICAL (index_type) != index_type))
8391         TYPE_CANONICAL (t)
8392           = build_array_type_1 (TYPE_CANONICAL (elt_type),
8393                                 index_type
8394                                 ? TYPE_CANONICAL (index_type) : NULL_TREE,
8395                                 shared);
8396     }
8397
8398   return t;
8399 }
8400
8401 /* Wrapper around build_array_type_1 with SHARED set to true.  */
8402
8403 tree
8404 build_array_type (tree elt_type, tree index_type)
8405 {
8406   return build_array_type_1 (elt_type, index_type, true);
8407 }
8408
8409 /* Wrapper around build_array_type_1 with SHARED set to false.  */
8410
8411 tree
8412 build_nonshared_array_type (tree elt_type, tree index_type)
8413 {
8414   return build_array_type_1 (elt_type, index_type, false);
8415 }
8416
8417 /* Return a representation of ELT_TYPE[NELTS], using indices of type
8418    sizetype.  */
8419
8420 tree
8421 build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts)
8422 {
8423   return build_array_type (elt_type, build_index_type (size_int (nelts - 1)));
8424 }
8425
8426 /* Recursively examines the array elements of TYPE, until a non-array
8427    element type is found.  */
8428
8429 tree
8430 strip_array_types (tree type)
8431 {
8432   while (TREE_CODE (type) == ARRAY_TYPE)
8433     type = TREE_TYPE (type);
8434
8435   return type;
8436 }
8437
8438 /* Computes the canonical argument types from the argument type list
8439    ARGTYPES.
8440
8441    Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
8442    on entry to this function, or if any of the ARGTYPES are
8443    structural.
8444
8445    Upon return, *ANY_NONCANONICAL_P will be true iff either it was
8446    true on entry to this function, or if any of the ARGTYPES are
8447    non-canonical.
8448
8449    Returns a canonical argument list, which may be ARGTYPES when the
8450    canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
8451    true) or would not differ from ARGTYPES.  */
8452
8453 static tree
8454 maybe_canonicalize_argtypes (tree argtypes,
8455                              bool *any_structural_p,
8456                              bool *any_noncanonical_p)
8457 {
8458   tree arg;
8459   bool any_noncanonical_argtypes_p = false;
8460
8461   for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
8462     {
8463       if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
8464         /* Fail gracefully by stating that the type is structural.  */
8465         *any_structural_p = true;
8466       else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
8467         *any_structural_p = true;
8468       else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
8469                || TREE_PURPOSE (arg))
8470         /* If the argument has a default argument, we consider it
8471            non-canonical even though the type itself is canonical.
8472            That way, different variants of function and method types
8473            with default arguments will all point to the variant with
8474            no defaults as their canonical type.  */
8475         any_noncanonical_argtypes_p = true;
8476     }
8477
8478   if (*any_structural_p)
8479     return argtypes;
8480
8481   if (any_noncanonical_argtypes_p)
8482     {
8483       /* Build the canonical list of argument types.  */
8484       tree canon_argtypes = NULL_TREE;
8485       bool is_void = false;
8486
8487       for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
8488         {
8489           if (arg == void_list_node)
8490             is_void = true;
8491           else
8492             canon_argtypes = tree_cons (NULL_TREE,
8493                                         TYPE_CANONICAL (TREE_VALUE (arg)),
8494                                         canon_argtypes);
8495         }
8496
8497       canon_argtypes = nreverse (canon_argtypes);
8498       if (is_void)
8499         canon_argtypes = chainon (canon_argtypes, void_list_node);
8500
8501       /* There is a non-canonical type.  */
8502       *any_noncanonical_p = true;
8503       return canon_argtypes;
8504     }
8505
8506   /* The canonical argument types are the same as ARGTYPES.  */
8507   return argtypes;
8508 }
8509
8510 /* Construct, lay out and return
8511    the type of functions returning type VALUE_TYPE
8512    given arguments of types ARG_TYPES.
8513    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8514    are data type nodes for the arguments of the function.
8515    If such a type has already been constructed, reuse it.  */
8516
8517 tree
8518 build_function_type (tree value_type, tree arg_types)
8519 {
8520   tree t;
8521   inchash::hash hstate;
8522   bool any_structural_p, any_noncanonical_p;
8523   tree canon_argtypes;
8524
8525   if (TREE_CODE (value_type) == FUNCTION_TYPE)
8526     {
8527       error ("function return type cannot be function");
8528       value_type = integer_type_node;
8529     }
8530
8531   /* Make a node of the sort we want.  */
8532   t = make_node (FUNCTION_TYPE);
8533   TREE_TYPE (t) = value_type;
8534   TYPE_ARG_TYPES (t) = arg_types;
8535
8536   /* If we already have such a type, use the old one.  */
8537   hstate.add_object (TYPE_HASH (value_type));
8538   type_hash_list (arg_types, hstate);
8539   t = type_hash_canon (hstate.end (), t);
8540
8541   /* Set up the canonical type. */
8542   any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
8543   any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
8544   canon_argtypes = maybe_canonicalize_argtypes (arg_types,
8545                                                 &any_structural_p,
8546                                                 &any_noncanonical_p);
8547   if (any_structural_p)
8548     SET_TYPE_STRUCTURAL_EQUALITY (t);
8549   else if (any_noncanonical_p)
8550     TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
8551                                               canon_argtypes);
8552
8553   if (!COMPLETE_TYPE_P (t))
8554     layout_type (t);
8555   return t;
8556 }
8557
8558 /* Build a function type.  The RETURN_TYPE is the type returned by the
8559    function.  If VAARGS is set, no void_type_node is appended to the
8560    list.  ARGP must be always be terminated be a NULL_TREE.  */
8561
8562 static tree
8563 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
8564 {
8565   tree t, args, last;
8566
8567   t = va_arg (argp, tree);
8568   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
8569     args = tree_cons (NULL_TREE, t, args);
8570
8571   if (vaargs)
8572     {
8573       last = args;
8574       if (args != NULL_TREE)
8575         args = nreverse (args);
8576       gcc_assert (last != void_list_node);
8577     }
8578   else if (args == NULL_TREE)
8579     args = void_list_node;
8580   else
8581     {
8582       last = args;
8583       args = nreverse (args);
8584       TREE_CHAIN (last) = void_list_node;
8585     }
8586   args = build_function_type (return_type, args);
8587
8588   return args;
8589 }
8590
8591 /* Build a function type.  The RETURN_TYPE is the type returned by the
8592    function.  If additional arguments are provided, they are
8593    additional argument types.  The list of argument types must always
8594    be terminated by NULL_TREE.  */
8595
8596 tree
8597 build_function_type_list (tree return_type, ...)
8598 {
8599   tree args;
8600   va_list p;
8601
8602   va_start (p, return_type);
8603   args = build_function_type_list_1 (false, return_type, p);
8604   va_end (p);
8605   return args;
8606 }
8607
8608 /* Build a variable argument function type.  The RETURN_TYPE is the
8609    type returned by the function.  If additional arguments are provided,
8610    they are additional argument types.  The list of argument types must
8611    always be terminated by NULL_TREE.  */
8612
8613 tree
8614 build_varargs_function_type_list (tree return_type, ...)
8615 {
8616   tree args;
8617   va_list p;
8618
8619   va_start (p, return_type);
8620   args = build_function_type_list_1 (true, return_type, p);
8621   va_end (p);
8622
8623   return args;
8624 }
8625
8626 /* Build a function type.  RETURN_TYPE is the type returned by the
8627    function; VAARGS indicates whether the function takes varargs.  The
8628    function takes N named arguments, the types of which are provided in
8629    ARG_TYPES.  */
8630
8631 static tree
8632 build_function_type_array_1 (bool vaargs, tree return_type, int n,
8633                              tree *arg_types)
8634 {
8635   int i;
8636   tree t = vaargs ? NULL_TREE : void_list_node;
8637
8638   for (i = n - 1; i >= 0; i--)
8639     t = tree_cons (NULL_TREE, arg_types[i], t);
8640
8641   return build_function_type (return_type, t);
8642 }
8643
8644 /* Build a function type.  RETURN_TYPE is the type returned by the
8645    function.  The function takes N named arguments, the types of which
8646    are provided in ARG_TYPES.  */
8647
8648 tree
8649 build_function_type_array (tree return_type, int n, tree *arg_types)
8650 {
8651   return build_function_type_array_1 (false, return_type, n, arg_types);
8652 }
8653
8654 /* Build a variable argument function type.  RETURN_TYPE is the type
8655    returned by the function.  The function takes N named arguments, the
8656    types of which are provided in ARG_TYPES.  */
8657
8658 tree
8659 build_varargs_function_type_array (tree return_type, int n, tree *arg_types)
8660 {
8661   return build_function_type_array_1 (true, return_type, n, arg_types);
8662 }
8663
8664 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
8665    and ARGTYPES (a TREE_LIST) are the return type and arguments types
8666    for the method.  An implicit additional parameter (of type
8667    pointer-to-BASETYPE) is added to the ARGTYPES.  */
8668
8669 tree
8670 build_method_type_directly (tree basetype,
8671                             tree rettype,
8672                             tree argtypes)
8673 {
8674   tree t;
8675   tree ptype;
8676   inchash::hash hstate;
8677   bool any_structural_p, any_noncanonical_p;
8678   tree canon_argtypes;
8679
8680   /* Make a node of the sort we want.  */
8681   t = make_node (METHOD_TYPE);
8682
8683   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8684   TREE_TYPE (t) = rettype;
8685   ptype = build_pointer_type (basetype);
8686
8687   /* The actual arglist for this function includes a "hidden" argument
8688      which is "this".  Put it into the list of argument types.  */
8689   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
8690   TYPE_ARG_TYPES (t) = argtypes;
8691
8692   /* If we already have such a type, use the old one.  */
8693   hstate.add_object (TYPE_HASH (basetype));
8694   hstate.add_object (TYPE_HASH (rettype));
8695   type_hash_list (argtypes, hstate);
8696   t = type_hash_canon (hstate.end (), t);
8697
8698   /* Set up the canonical type. */
8699   any_structural_p
8700     = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8701        || TYPE_STRUCTURAL_EQUALITY_P (rettype));
8702   any_noncanonical_p
8703     = (TYPE_CANONICAL (basetype) != basetype
8704        || TYPE_CANONICAL (rettype) != rettype);
8705   canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
8706                                                 &any_structural_p,
8707                                                 &any_noncanonical_p);
8708   if (any_structural_p)
8709     SET_TYPE_STRUCTURAL_EQUALITY (t);
8710   else if (any_noncanonical_p)
8711     TYPE_CANONICAL (t)
8712       = build_method_type_directly (TYPE_CANONICAL (basetype),
8713                                     TYPE_CANONICAL (rettype),
8714                                     canon_argtypes);
8715   if (!COMPLETE_TYPE_P (t))
8716     layout_type (t);
8717
8718   return t;
8719 }
8720
8721 /* Construct, lay out and return the type of methods belonging to class
8722    BASETYPE and whose arguments and values are described by TYPE.
8723    If that type exists already, reuse it.
8724    TYPE must be a FUNCTION_TYPE node.  */
8725
8726 tree
8727 build_method_type (tree basetype, tree type)
8728 {
8729   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
8730
8731   return build_method_type_directly (basetype,
8732                                      TREE_TYPE (type),
8733                                      TYPE_ARG_TYPES (type));
8734 }
8735
8736 /* Construct, lay out and return the type of offsets to a value
8737    of type TYPE, within an object of type BASETYPE.
8738    If a suitable offset type exists already, reuse it.  */
8739
8740 tree
8741 build_offset_type (tree basetype, tree type)
8742 {
8743   tree t;
8744   inchash::hash hstate;
8745
8746   /* Make a node of the sort we want.  */
8747   t = make_node (OFFSET_TYPE);
8748
8749   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8750   TREE_TYPE (t) = type;
8751
8752   /* If we already have such a type, use the old one.  */
8753   hstate.add_object (TYPE_HASH (basetype));
8754   hstate.add_object (TYPE_HASH (type));
8755   t = type_hash_canon (hstate.end (), t);
8756
8757   if (!COMPLETE_TYPE_P (t))
8758     layout_type (t);
8759
8760   if (TYPE_CANONICAL (t) == t)
8761     {
8762       if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8763           || TYPE_STRUCTURAL_EQUALITY_P (type))
8764         SET_TYPE_STRUCTURAL_EQUALITY (t);
8765       else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
8766                || TYPE_CANONICAL (type) != type)
8767         TYPE_CANONICAL (t)
8768           = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
8769                                TYPE_CANONICAL (type));
8770     }
8771
8772   return t;
8773 }
8774
8775 /* Create a complex type whose components are COMPONENT_TYPE.
8776
8777    If NAMED is true, the type is given a TYPE_NAME.  We do not always
8778    do so because this creates a DECL node and thus make the DECL_UIDs
8779    dependent on the type canonicalization hashtable, which is GC-ed,
8780    so the DECL_UIDs would not be stable wrt garbage collection.  */
8781
8782 tree
8783 build_complex_type (tree component_type, bool named)
8784 {
8785   tree t;
8786   inchash::hash hstate;
8787
8788   gcc_assert (INTEGRAL_TYPE_P (component_type)
8789               || SCALAR_FLOAT_TYPE_P (component_type)
8790               || FIXED_POINT_TYPE_P (component_type));
8791
8792   /* Make a node of the sort we want.  */
8793   t = make_node (COMPLEX_TYPE);
8794
8795   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
8796
8797   /* If we already have such a type, use the old one.  */
8798   hstate.add_object (TYPE_HASH (component_type));
8799   t = type_hash_canon (hstate.end (), t);
8800
8801   if (!COMPLETE_TYPE_P (t))
8802     layout_type (t);
8803
8804   if (TYPE_CANONICAL (t) == t)
8805     {
8806       if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
8807         SET_TYPE_STRUCTURAL_EQUALITY (t);
8808       else if (TYPE_CANONICAL (component_type) != component_type)
8809         TYPE_CANONICAL (t)
8810           = build_complex_type (TYPE_CANONICAL (component_type), named);
8811     }
8812
8813   /* We need to create a name, since complex is a fundamental type.  */
8814   if (!TYPE_NAME (t) && named)
8815     {
8816       const char *name;
8817       if (component_type == char_type_node)
8818         name = "complex char";
8819       else if (component_type == signed_char_type_node)
8820         name = "complex signed char";
8821       else if (component_type == unsigned_char_type_node)
8822         name = "complex unsigned char";
8823       else if (component_type == short_integer_type_node)
8824         name = "complex short int";
8825       else if (component_type == short_unsigned_type_node)
8826         name = "complex short unsigned int";
8827       else if (component_type == integer_type_node)
8828         name = "complex int";
8829       else if (component_type == unsigned_type_node)
8830         name = "complex unsigned int";
8831       else if (component_type == long_integer_type_node)
8832         name = "complex long int";
8833       else if (component_type == long_unsigned_type_node)
8834         name = "complex long unsigned int";
8835       else if (component_type == long_long_integer_type_node)
8836         name = "complex long long int";
8837       else if (component_type == long_long_unsigned_type_node)
8838         name = "complex long long unsigned int";
8839       else
8840         name = 0;
8841
8842       if (name != 0)
8843         TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
8844                                     get_identifier (name), t);
8845     }
8846
8847   return build_qualified_type (t, TYPE_QUALS (component_type));
8848 }
8849
8850 /* If TYPE is a real or complex floating-point type and the target
8851    does not directly support arithmetic on TYPE then return the wider
8852    type to be used for arithmetic on TYPE.  Otherwise, return
8853    NULL_TREE.  */
8854
8855 tree
8856 excess_precision_type (tree type)
8857 {
8858   /* The target can give two different responses to the question of
8859      which excess precision mode it would like depending on whether we
8860      are in -fexcess-precision=standard or -fexcess-precision=fast.  */
8861
8862   enum excess_precision_type requested_type
8863     = (flag_excess_precision == EXCESS_PRECISION_FAST
8864        ? EXCESS_PRECISION_TYPE_FAST
8865        : EXCESS_PRECISION_TYPE_STANDARD);
8866
8867   enum flt_eval_method target_flt_eval_method
8868     = targetm.c.excess_precision (requested_type);
8869
8870   /* The target should not ask for unpredictable float evaluation (though
8871      it might advertise that implicitly the evaluation is unpredictable,
8872      but we don't care about that here, it will have been reported
8873      elsewhere).  If it does ask for unpredictable evaluation, we have
8874      nothing to do here.  */
8875   gcc_assert (target_flt_eval_method != FLT_EVAL_METHOD_UNPREDICTABLE);
8876
8877   /* Nothing to do.  The target has asked for all types we know about
8878      to be computed with their native precision and range.  */
8879   if (target_flt_eval_method == FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16)
8880     return NULL_TREE;
8881
8882   /* The target will promote this type in a target-dependent way, so excess
8883      precision ought to leave it alone.  */
8884   if (targetm.promoted_type (type) != NULL_TREE)
8885     return NULL_TREE;
8886
8887   machine_mode float16_type_mode = (float16_type_node
8888                                     ? TYPE_MODE (float16_type_node)
8889                                     : VOIDmode);
8890   machine_mode float_type_mode = TYPE_MODE (float_type_node);
8891   machine_mode double_type_mode = TYPE_MODE (double_type_node);
8892
8893   switch (TREE_CODE (type))
8894     {
8895     case REAL_TYPE:
8896       {
8897         machine_mode type_mode = TYPE_MODE (type);
8898         switch (target_flt_eval_method)
8899           {
8900           case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8901             if (type_mode == float16_type_mode)
8902               return float_type_node;
8903             break;
8904           case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8905             if (type_mode == float16_type_mode
8906                 || type_mode == float_type_mode)
8907               return double_type_node;
8908             break;
8909           case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8910             if (type_mode == float16_type_mode
8911                 || type_mode == float_type_mode
8912                 || type_mode == double_type_mode)
8913               return long_double_type_node;
8914             break;
8915           default:
8916             gcc_unreachable ();
8917           }
8918         break;
8919       }
8920     case COMPLEX_TYPE:
8921       {
8922         if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
8923           return NULL_TREE;
8924         machine_mode type_mode = TYPE_MODE (TREE_TYPE (type));
8925         switch (target_flt_eval_method)
8926           {
8927           case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8928             if (type_mode == float16_type_mode)
8929               return complex_float_type_node;
8930             break;
8931           case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8932             if (type_mode == float16_type_mode
8933                 || type_mode == float_type_mode)
8934               return complex_double_type_node;
8935             break;
8936           case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8937             if (type_mode == float16_type_mode
8938                 || type_mode == float_type_mode
8939                 || type_mode == double_type_mode)
8940               return complex_long_double_type_node;
8941             break;
8942           default:
8943             gcc_unreachable ();
8944           }
8945         break;
8946       }
8947     default:
8948       break;
8949     }
8950
8951   return NULL_TREE;
8952 }
8953 \f
8954 /* Return OP, stripped of any conversions to wider types as much as is safe.
8955    Converting the value back to OP's type makes a value equivalent to OP.
8956
8957    If FOR_TYPE is nonzero, we return a value which, if converted to
8958    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8959
8960    OP must have integer, real or enumeral type.  Pointers are not allowed!
8961
8962    There are some cases where the obvious value we could return
8963    would regenerate to OP if converted to OP's type,
8964    but would not extend like OP to wider types.
8965    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8966    For example, if OP is (unsigned short)(signed char)-1,
8967    we avoid returning (signed char)-1 if FOR_TYPE is int,
8968    even though extending that to an unsigned short would regenerate OP,
8969    since the result of extending (signed char)-1 to (int)
8970    is different from (int) OP.  */
8971
8972 tree
8973 get_unwidened (tree op, tree for_type)
8974 {
8975   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
8976   tree type = TREE_TYPE (op);
8977   unsigned final_prec
8978     = TYPE_PRECISION (for_type != 0 ? for_type : type);
8979   int uns
8980     = (for_type != 0 && for_type != type
8981        && final_prec > TYPE_PRECISION (type)
8982        && TYPE_UNSIGNED (type));
8983   tree win = op;
8984
8985   while (CONVERT_EXPR_P (op))
8986     {
8987       int bitschange;
8988
8989       /* TYPE_PRECISION on vector types has different meaning
8990          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
8991          so avoid them here.  */
8992       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
8993         break;
8994
8995       bitschange = TYPE_PRECISION (TREE_TYPE (op))
8996                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
8997
8998       /* Truncations are many-one so cannot be removed.
8999          Unless we are later going to truncate down even farther.  */
9000       if (bitschange < 0
9001           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
9002         break;
9003
9004       /* See what's inside this conversion.  If we decide to strip it,
9005          we will set WIN.  */
9006       op = TREE_OPERAND (op, 0);
9007
9008       /* If we have not stripped any zero-extensions (uns is 0),
9009          we can strip any kind of extension.
9010          If we have previously stripped a zero-extension,
9011          only zero-extensions can safely be stripped.
9012          Any extension can be stripped if the bits it would produce
9013          are all going to be discarded later by truncating to FOR_TYPE.  */
9014
9015       if (bitschange > 0)
9016         {
9017           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
9018             win = op;
9019           /* TYPE_UNSIGNED says whether this is a zero-extension.
9020              Let's avoid computing it if it does not affect WIN
9021              and if UNS will not be needed again.  */
9022           if ((uns
9023                || CONVERT_EXPR_P (op))
9024               && TYPE_UNSIGNED (TREE_TYPE (op)))
9025             {
9026               uns = 1;
9027               win = op;
9028             }
9029         }
9030     }
9031
9032   /* If we finally reach a constant see if it fits in for_type and
9033      in that case convert it.  */
9034   if (for_type
9035       && TREE_CODE (win) == INTEGER_CST
9036       && TREE_TYPE (win) != for_type
9037       && int_fits_type_p (win, for_type))
9038     win = fold_convert (for_type, win);
9039
9040   return win;
9041 }
9042 \f
9043 /* Return OP or a simpler expression for a narrower value
9044    which can be sign-extended or zero-extended to give back OP.
9045    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
9046    or 0 if the value should be sign-extended.  */
9047
9048 tree
9049 get_narrower (tree op, int *unsignedp_ptr)
9050 {
9051   int uns = 0;
9052   int first = 1;
9053   tree win = op;
9054   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
9055
9056   while (TREE_CODE (op) == NOP_EXPR)
9057     {
9058       int bitschange
9059         = (TYPE_PRECISION (TREE_TYPE (op))
9060            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
9061
9062       /* Truncations are many-one so cannot be removed.  */
9063       if (bitschange < 0)
9064         break;
9065
9066       /* See what's inside this conversion.  If we decide to strip it,
9067          we will set WIN.  */
9068
9069       if (bitschange > 0)
9070         {
9071           op = TREE_OPERAND (op, 0);
9072           /* An extension: the outermost one can be stripped,
9073              but remember whether it is zero or sign extension.  */
9074           if (first)
9075             uns = TYPE_UNSIGNED (TREE_TYPE (op));
9076           /* Otherwise, if a sign extension has been stripped,
9077              only sign extensions can now be stripped;
9078              if a zero extension has been stripped, only zero-extensions.  */
9079           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
9080             break;
9081           first = 0;
9082         }
9083       else /* bitschange == 0 */
9084         {
9085           /* A change in nominal type can always be stripped, but we must
9086              preserve the unsignedness.  */
9087           if (first)
9088             uns = TYPE_UNSIGNED (TREE_TYPE (op));
9089           first = 0;
9090           op = TREE_OPERAND (op, 0);
9091           /* Keep trying to narrow, but don't assign op to win if it
9092              would turn an integral type into something else.  */
9093           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
9094             continue;
9095         }
9096
9097       win = op;
9098     }
9099
9100   if (TREE_CODE (op) == COMPONENT_REF
9101       /* Since type_for_size always gives an integer type.  */
9102       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
9103       && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
9104       /* Ensure field is laid out already.  */
9105       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
9106       && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
9107     {
9108       unsigned HOST_WIDE_INT innerprec
9109         = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1)));
9110       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
9111                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
9112       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
9113
9114       /* We can get this structure field in a narrower type that fits it,
9115          but the resulting extension to its nominal type (a fullword type)
9116          must satisfy the same conditions as for other extensions.
9117
9118          Do this only for fields that are aligned (not bit-fields),
9119          because when bit-field insns will be used there is no
9120          advantage in doing this.  */
9121
9122       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
9123           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
9124           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
9125           && type != 0)
9126         {
9127           if (first)
9128             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
9129           win = fold_convert (type, op);
9130         }
9131     }
9132
9133   *unsignedp_ptr = uns;
9134   return win;
9135 }
9136 \f
9137 /* Return true if integer constant C has a value that is permissible
9138    for TYPE, an integral type.  */
9139
9140 bool
9141 int_fits_type_p (const_tree c, const_tree type)
9142 {
9143   tree type_low_bound, type_high_bound;
9144   bool ok_for_low_bound, ok_for_high_bound;
9145   signop sgn_c = TYPE_SIGN (TREE_TYPE (c));
9146
9147   /* Non-standard boolean types can have arbitrary precision but various
9148      transformations assume that they can only take values 0 and +/-1.  */
9149   if (TREE_CODE (type) == BOOLEAN_TYPE)
9150     return wi::fits_to_boolean_p (c, type);
9151
9152 retry:
9153   type_low_bound = TYPE_MIN_VALUE (type);
9154   type_high_bound = TYPE_MAX_VALUE (type);
9155
9156   /* If at least one bound of the type is a constant integer, we can check
9157      ourselves and maybe make a decision. If no such decision is possible, but
9158      this type is a subtype, try checking against that.  Otherwise, use
9159      fits_to_tree_p, which checks against the precision.
9160
9161      Compute the status for each possibly constant bound, and return if we see
9162      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
9163      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
9164      for "constant known to fit".  */
9165
9166   /* Check if c >= type_low_bound.  */
9167   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
9168     {
9169       if (tree_int_cst_lt (c, type_low_bound))
9170         return false;
9171       ok_for_low_bound = true;
9172     }
9173   else
9174     ok_for_low_bound = false;
9175
9176   /* Check if c <= type_high_bound.  */
9177   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
9178     {
9179       if (tree_int_cst_lt (type_high_bound, c))
9180         return false;
9181       ok_for_high_bound = true;
9182     }
9183   else
9184     ok_for_high_bound = false;
9185
9186   /* If the constant fits both bounds, the result is known.  */
9187   if (ok_for_low_bound && ok_for_high_bound)
9188     return true;
9189
9190   /* Perform some generic filtering which may allow making a decision
9191      even if the bounds are not constant.  First, negative integers
9192      never fit in unsigned types, */
9193   if (TYPE_UNSIGNED (type) && sgn_c == SIGNED && wi::neg_p (c))
9194     return false;
9195
9196   /* Second, narrower types always fit in wider ones.  */
9197   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
9198     return true;
9199
9200   /* Third, unsigned integers with top bit set never fit signed types.  */
9201   if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED)
9202     {
9203       int prec = GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c))) - 1;
9204       if (prec < TYPE_PRECISION (TREE_TYPE (c)))
9205         {
9206           /* When a tree_cst is converted to a wide-int, the precision
9207              is taken from the type.  However, if the precision of the
9208              mode underneath the type is smaller than that, it is
9209              possible that the value will not fit.  The test below
9210              fails if any bit is set between the sign bit of the
9211              underlying mode and the top bit of the type.  */
9212           if (wi::ne_p (wi::zext (c, prec - 1), c))
9213             return false;
9214         }
9215       else if (wi::neg_p (c))
9216         return false;
9217     }
9218
9219   /* If we haven't been able to decide at this point, there nothing more we
9220      can check ourselves here.  Look at the base type if we have one and it
9221      has the same precision.  */
9222   if (TREE_CODE (type) == INTEGER_TYPE
9223       && TREE_TYPE (type) != 0
9224       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
9225     {
9226       type = TREE_TYPE (type);
9227       goto retry;
9228     }
9229
9230   /* Or to fits_to_tree_p, if nothing else.  */
9231   return wi::fits_to_tree_p (c, type);
9232 }
9233
9234 /* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
9235    bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
9236    represented (assuming two's-complement arithmetic) within the bit
9237    precision of the type are returned instead.  */
9238
9239 void
9240 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
9241 {
9242   if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
9243       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
9244     wi::to_mpz (TYPE_MIN_VALUE (type), min, TYPE_SIGN (type));
9245   else
9246     {
9247       if (TYPE_UNSIGNED (type))
9248         mpz_set_ui (min, 0);
9249       else
9250         {
9251           wide_int mn = wi::min_value (TYPE_PRECISION (type), SIGNED);
9252           wi::to_mpz (mn, min, SIGNED);
9253         }
9254     }
9255
9256   if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
9257       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
9258     wi::to_mpz (TYPE_MAX_VALUE (type), max, TYPE_SIGN (type));
9259   else
9260     {
9261       wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
9262       wi::to_mpz (mn, max, TYPE_SIGN (type));
9263     }
9264 }
9265
9266 /* Return true if VAR is an automatic variable defined in function FN.  */
9267
9268 bool
9269 auto_var_in_fn_p (const_tree var, const_tree fn)
9270 {
9271   return (DECL_P (var) && DECL_CONTEXT (var) == fn
9272           && ((((VAR_P (var) && ! DECL_EXTERNAL (var))
9273                 || TREE_CODE (var) == PARM_DECL)
9274                && ! TREE_STATIC (var))
9275               || TREE_CODE (var) == LABEL_DECL
9276               || TREE_CODE (var) == RESULT_DECL));
9277 }
9278
9279 /* Subprogram of following function.  Called by walk_tree.
9280
9281    Return *TP if it is an automatic variable or parameter of the
9282    function passed in as DATA.  */
9283
9284 static tree
9285 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
9286 {
9287   tree fn = (tree) data;
9288
9289   if (TYPE_P (*tp))
9290     *walk_subtrees = 0;
9291
9292   else if (DECL_P (*tp)
9293            && auto_var_in_fn_p (*tp, fn))
9294     return *tp;
9295
9296   return NULL_TREE;
9297 }
9298
9299 /* Returns true if T is, contains, or refers to a type with variable
9300    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
9301    arguments, but not the return type.  If FN is nonzero, only return
9302    true if a modifier of the type or position of FN is a variable or
9303    parameter inside FN.
9304
9305    This concept is more general than that of C99 'variably modified types':
9306    in C99, a struct type is never variably modified because a VLA may not
9307    appear as a structure member.  However, in GNU C code like:
9308
9309      struct S { int i[f()]; };
9310
9311    is valid, and other languages may define similar constructs.  */
9312
9313 bool
9314 variably_modified_type_p (tree type, tree fn)
9315 {
9316   tree t;
9317
9318 /* Test if T is either variable (if FN is zero) or an expression containing
9319    a variable in FN.  If TYPE isn't gimplified, return true also if
9320    gimplify_one_sizepos would gimplify the expression into a local
9321    variable.  */
9322 #define RETURN_TRUE_IF_VAR(T)                                           \
9323   do { tree _t = (T);                                                   \
9324     if (_t != NULL_TREE                                                 \
9325         && _t != error_mark_node                                        \
9326         && TREE_CODE (_t) != INTEGER_CST                                \
9327         && TREE_CODE (_t) != PLACEHOLDER_EXPR                           \
9328         && (!fn                                                         \
9329             || (!TYPE_SIZES_GIMPLIFIED (type)                           \
9330                 && !is_gimple_sizepos (_t))                             \
9331             || walk_tree (&_t, find_var_from_fn, fn, NULL)))            \
9332       return true;  } while (0)
9333
9334   if (type == error_mark_node)
9335     return false;
9336
9337   /* If TYPE itself has variable size, it is variably modified.  */
9338   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
9339   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
9340
9341   switch (TREE_CODE (type))
9342     {
9343     case POINTER_TYPE:
9344     case REFERENCE_TYPE:
9345     case VECTOR_TYPE:
9346       if (variably_modified_type_p (TREE_TYPE (type), fn))
9347         return true;
9348       break;
9349
9350     case FUNCTION_TYPE:
9351     case METHOD_TYPE:
9352       /* If TYPE is a function type, it is variably modified if the
9353          return type is variably modified.  */
9354       if (variably_modified_type_p (TREE_TYPE (type), fn))
9355           return true;
9356       break;
9357
9358     case INTEGER_TYPE:
9359     case REAL_TYPE:
9360     case FIXED_POINT_TYPE:
9361     case ENUMERAL_TYPE:
9362     case BOOLEAN_TYPE:
9363       /* Scalar types are variably modified if their end points
9364          aren't constant.  */
9365       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
9366       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
9367       break;
9368
9369     case RECORD_TYPE:
9370     case UNION_TYPE:
9371     case QUAL_UNION_TYPE:
9372       /* We can't see if any of the fields are variably-modified by the
9373          definition we normally use, since that would produce infinite
9374          recursion via pointers.  */
9375       /* This is variably modified if some field's type is.  */
9376       for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
9377         if (TREE_CODE (t) == FIELD_DECL)
9378           {
9379             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
9380             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
9381             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
9382
9383             if (TREE_CODE (type) == QUAL_UNION_TYPE)
9384               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
9385           }
9386       break;
9387
9388     case ARRAY_TYPE:
9389       /* Do not call ourselves to avoid infinite recursion.  This is
9390          variably modified if the element type is.  */
9391       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
9392       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
9393       break;
9394
9395     default:
9396       break;
9397     }
9398
9399   /* The current language may have other cases to check, but in general,
9400      all other types are not variably modified.  */
9401   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
9402
9403 #undef RETURN_TRUE_IF_VAR
9404 }
9405
9406 /* Given a DECL or TYPE, return the scope in which it was declared, or
9407    NULL_TREE if there is no containing scope.  */
9408
9409 tree
9410 get_containing_scope (const_tree t)
9411 {
9412   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
9413 }
9414
9415 /* Return the innermost context enclosing DECL that is
9416    a FUNCTION_DECL, or zero if none.  */
9417
9418 tree
9419 decl_function_context (const_tree decl)
9420 {
9421   tree context;
9422
9423   if (TREE_CODE (decl) == ERROR_MARK)
9424     return 0;
9425
9426   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
9427      where we look up the function at runtime.  Such functions always take
9428      a first argument of type 'pointer to real context'.
9429
9430      C++ should really be fixed to use DECL_CONTEXT for the real context,
9431      and use something else for the "virtual context".  */
9432   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
9433     context
9434       = TYPE_MAIN_VARIANT
9435         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
9436   else
9437     context = DECL_CONTEXT (decl);
9438
9439   while (context && TREE_CODE (context) != FUNCTION_DECL)
9440     {
9441       if (TREE_CODE (context) == BLOCK)
9442         context = BLOCK_SUPERCONTEXT (context);
9443       else
9444         context = get_containing_scope (context);
9445     }
9446
9447   return context;
9448 }
9449
9450 /* Return the innermost context enclosing DECL that is
9451    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
9452    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
9453
9454 tree
9455 decl_type_context (const_tree decl)
9456 {
9457   tree context = DECL_CONTEXT (decl);
9458
9459   while (context)
9460     switch (TREE_CODE (context))
9461       {
9462       case NAMESPACE_DECL:
9463       case TRANSLATION_UNIT_DECL:
9464         return NULL_TREE;
9465
9466       case RECORD_TYPE:
9467       case UNION_TYPE:
9468       case QUAL_UNION_TYPE:
9469         return context;
9470
9471       case TYPE_DECL:
9472       case FUNCTION_DECL:
9473         context = DECL_CONTEXT (context);
9474         break;
9475
9476       case BLOCK:
9477         context = BLOCK_SUPERCONTEXT (context);
9478         break;
9479
9480       default:
9481         gcc_unreachable ();
9482       }
9483
9484   return NULL_TREE;
9485 }
9486
9487 /* CALL is a CALL_EXPR.  Return the declaration for the function
9488    called, or NULL_TREE if the called function cannot be
9489    determined.  */
9490
9491 tree
9492 get_callee_fndecl (const_tree call)
9493 {
9494   tree addr;
9495
9496   if (call == error_mark_node)
9497     return error_mark_node;
9498
9499   /* It's invalid to call this function with anything but a
9500      CALL_EXPR.  */
9501   gcc_assert (TREE_CODE (call) == CALL_EXPR);
9502
9503   /* The first operand to the CALL is the address of the function
9504      called.  */
9505   addr = CALL_EXPR_FN (call);
9506
9507   /* If there is no function, return early.  */
9508   if (addr == NULL_TREE)
9509     return NULL_TREE;
9510
9511   STRIP_NOPS (addr);
9512
9513   /* If this is a readonly function pointer, extract its initial value.  */
9514   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
9515       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
9516       && DECL_INITIAL (addr))
9517     addr = DECL_INITIAL (addr);
9518
9519   /* If the address is just `&f' for some function `f', then we know
9520      that `f' is being called.  */
9521   if (TREE_CODE (addr) == ADDR_EXPR
9522       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
9523     return TREE_OPERAND (addr, 0);
9524
9525   /* We couldn't figure out what was being called.  */
9526   return NULL_TREE;
9527 }
9528
9529 /* If CALL_EXPR CALL calls a normal built-in function or an internal function,
9530    return the associated function code, otherwise return CFN_LAST.  */
9531
9532 combined_fn
9533 get_call_combined_fn (const_tree call)
9534 {
9535   /* It's invalid to call this function with anything but a CALL_EXPR.  */
9536   gcc_assert (TREE_CODE (call) == CALL_EXPR);
9537
9538   if (!CALL_EXPR_FN (call))
9539     return as_combined_fn (CALL_EXPR_IFN (call));
9540
9541   tree fndecl = get_callee_fndecl (call);
9542   if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
9543     return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
9544
9545   return CFN_LAST;
9546 }
9547
9548 #define TREE_MEM_USAGE_SPACES 40
9549
9550 /* Print debugging information about tree nodes generated during the compile,
9551    and any language-specific information.  */
9552
9553 void
9554 dump_tree_statistics (void)
9555 {
9556   if (GATHER_STATISTICS)
9557     {
9558       int i;
9559       int total_nodes, total_bytes;
9560       fprintf (stderr, "\nKind                   Nodes      Bytes\n");
9561       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9562       total_nodes = total_bytes = 0;
9563       for (i = 0; i < (int) all_kinds; i++)
9564         {
9565           fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
9566                    tree_node_counts[i], tree_node_sizes[i]);
9567           total_nodes += tree_node_counts[i];
9568           total_bytes += tree_node_sizes[i];
9569         }
9570       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9571       fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
9572       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9573       fprintf (stderr, "Code                   Nodes\n");
9574       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9575       for (i = 0; i < (int) MAX_TREE_CODES; i++)
9576         fprintf (stderr, "%-32s %7d\n", get_tree_code_name ((enum tree_code) i),
9577                  tree_code_counts[i]);
9578       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9579       fprintf (stderr, "\n");
9580       ssanames_print_statistics ();
9581       fprintf (stderr, "\n");
9582       phinodes_print_statistics ();
9583       fprintf (stderr, "\n");
9584     }
9585   else
9586     fprintf (stderr, "(No per-node statistics)\n");
9587
9588   print_type_hash_statistics ();
9589   print_debug_expr_statistics ();
9590   print_value_expr_statistics ();
9591   lang_hooks.print_statistics ();
9592 }
9593 \f
9594 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9595
9596 /* Generate a crc32 of a byte.  */
9597
9598 static unsigned
9599 crc32_unsigned_bits (unsigned chksum, unsigned value, unsigned bits)
9600 {
9601   unsigned ix;
9602
9603   for (ix = bits; ix--; value <<= 1)
9604     {
9605       unsigned feedback;
9606
9607       feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
9608       chksum <<= 1;
9609       chksum ^= feedback;
9610     }
9611   return chksum;
9612 }
9613
9614 /* Generate a crc32 of a 32-bit unsigned.  */
9615
9616 unsigned
9617 crc32_unsigned (unsigned chksum, unsigned value)
9618 {
9619   return crc32_unsigned_bits (chksum, value, 32);
9620 }
9621
9622 /* Generate a crc32 of a byte.  */
9623
9624 unsigned
9625 crc32_byte (unsigned chksum, char byte)
9626 {
9627   return crc32_unsigned_bits (chksum, (unsigned) byte << 24, 8);
9628 }
9629
9630 /* Generate a crc32 of a string.  */
9631
9632 unsigned
9633 crc32_string (unsigned chksum, const char *string)
9634 {
9635   do
9636     {
9637       chksum = crc32_byte (chksum, *string);
9638     }
9639   while (*string++);
9640   return chksum;
9641 }
9642
9643 /* P is a string that will be used in a symbol.  Mask out any characters
9644    that are not valid in that context.  */
9645
9646 void
9647 clean_symbol_name (char *p)
9648 {
9649   for (; *p; p++)
9650     if (! (ISALNUM (*p)
9651 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
9652             || *p == '$'
9653 #endif
9654 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
9655             || *p == '.'
9656 #endif
9657            ))
9658       *p = '_';
9659 }
9660
9661 /* For anonymous aggregate types, we need some sort of name to
9662    hold on to.  In practice, this should not appear, but it should
9663    not be harmful if it does.  */
9664 bool
9665 anon_aggrname_p(const_tree id_node)
9666 {
9667 #ifndef NO_DOT_IN_LABEL
9668  return (IDENTIFIER_POINTER (id_node)[0] == '.'
9669          && IDENTIFIER_POINTER (id_node)[1] == '_');
9670 #else /* NO_DOT_IN_LABEL */
9671 #ifndef NO_DOLLAR_IN_LABEL
9672   return (IDENTIFIER_POINTER (id_node)[0] == '$' \
9673           && IDENTIFIER_POINTER (id_node)[1] == '_');
9674 #else /* NO_DOLLAR_IN_LABEL */
9675 #define ANON_AGGRNAME_PREFIX "__anon_"
9676   return (!strncmp (IDENTIFIER_POINTER (id_node), ANON_AGGRNAME_PREFIX,
9677                     sizeof (ANON_AGGRNAME_PREFIX) - 1));
9678 #endif  /* NO_DOLLAR_IN_LABEL */
9679 #endif  /* NO_DOT_IN_LABEL */
9680 }
9681
9682 /* Return a format for an anonymous aggregate name.  */
9683 const char *
9684 anon_aggrname_format()
9685 {
9686 #ifndef NO_DOT_IN_LABEL
9687  return "._%d";
9688 #else /* NO_DOT_IN_LABEL */
9689 #ifndef NO_DOLLAR_IN_LABEL
9690   return "$_%d";
9691 #else /* NO_DOLLAR_IN_LABEL */
9692   return "__anon_%d";
9693 #endif  /* NO_DOLLAR_IN_LABEL */
9694 #endif  /* NO_DOT_IN_LABEL */
9695 }
9696
9697 /* Generate a name for a special-purpose function.
9698    The generated name may need to be unique across the whole link.
9699    Changes to this function may also require corresponding changes to
9700    xstrdup_mask_random.
9701    TYPE is some string to identify the purpose of this function to the
9702    linker or collect2; it must start with an uppercase letter,
9703    one of:
9704    I - for constructors
9705    D - for destructors
9706    N - for C++ anonymous namespaces
9707    F - for DWARF unwind frame information.  */
9708
9709 tree
9710 get_file_function_name (const char *type)
9711 {
9712   char *buf;
9713   const char *p;
9714   char *q;
9715
9716   /* If we already have a name we know to be unique, just use that.  */
9717   if (first_global_object_name)
9718     p = q = ASTRDUP (first_global_object_name);
9719   /* If the target is handling the constructors/destructors, they
9720      will be local to this file and the name is only necessary for
9721      debugging purposes.
9722      We also assign sub_I and sub_D sufixes to constructors called from
9723      the global static constructors.  These are always local.  */
9724   else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
9725            || (strncmp (type, "sub_", 4) == 0
9726                && (type[4] == 'I' || type[4] == 'D')))
9727     {
9728       const char *file = main_input_filename;
9729       if (! file)
9730         file = LOCATION_FILE (input_location);
9731       /* Just use the file's basename, because the full pathname
9732          might be quite long.  */
9733       p = q = ASTRDUP (lbasename (file));
9734     }
9735   else
9736     {
9737       /* Otherwise, the name must be unique across the entire link.
9738          We don't have anything that we know to be unique to this translation
9739          unit, so use what we do have and throw in some randomness.  */
9740       unsigned len;
9741       const char *name = weak_global_object_name;
9742       const char *file = main_input_filename;
9743
9744       if (! name)
9745         name = "";
9746       if (! file)
9747         file = LOCATION_FILE (input_location);
9748
9749       len = strlen (file);
9750       q = (char *) alloca (9 + 19 + len + 1);
9751       memcpy (q, file, len + 1);
9752
9753       snprintf (q + len, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
9754                 crc32_string (0, name), get_random_seed (false));
9755
9756       p = q;
9757     }
9758
9759   clean_symbol_name (q);
9760   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
9761                          + strlen (type));
9762
9763   /* Set up the name of the file-level functions we may need.
9764      Use a global object (which is already required to be unique over
9765      the program) rather than the file name (which imposes extra
9766      constraints).  */
9767   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
9768
9769   return get_identifier (buf);
9770 }
9771 \f
9772 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9773
9774 /* Complain that the tree code of NODE does not match the expected 0
9775    terminated list of trailing codes. The trailing code list can be
9776    empty, for a more vague error message.  FILE, LINE, and FUNCTION
9777    are of the caller.  */
9778
9779 void
9780 tree_check_failed (const_tree node, const char *file,
9781                    int line, const char *function, ...)
9782 {
9783   va_list args;
9784   const char *buffer;
9785   unsigned length = 0;
9786   enum tree_code code;
9787
9788   va_start (args, function);
9789   while ((code = (enum tree_code) va_arg (args, int)))
9790     length += 4 + strlen (get_tree_code_name (code));
9791   va_end (args);
9792   if (length)
9793     {
9794       char *tmp;
9795       va_start (args, function);
9796       length += strlen ("expected ");
9797       buffer = tmp = (char *) alloca (length);
9798       length = 0;
9799       while ((code = (enum tree_code) va_arg (args, int)))
9800         {
9801           const char *prefix = length ? " or " : "expected ";
9802
9803           strcpy (tmp + length, prefix);
9804           length += strlen (prefix);
9805           strcpy (tmp + length, get_tree_code_name (code));
9806           length += strlen (get_tree_code_name (code));
9807         }
9808       va_end (args);
9809     }
9810   else
9811     buffer = "unexpected node";
9812
9813   internal_error ("tree check: %s, have %s in %s, at %s:%d",
9814                   buffer, get_tree_code_name (TREE_CODE (node)),
9815                   function, trim_filename (file), line);
9816 }
9817
9818 /* Complain that the tree code of NODE does match the expected 0
9819    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9820    the caller.  */
9821
9822 void
9823 tree_not_check_failed (const_tree node, const char *file,
9824                        int line, const char *function, ...)
9825 {
9826   va_list args;
9827   char *buffer;
9828   unsigned length = 0;
9829   enum tree_code code;
9830
9831   va_start (args, function);
9832   while ((code = (enum tree_code) va_arg (args, int)))
9833     length += 4 + strlen (get_tree_code_name (code));
9834   va_end (args);
9835   va_start (args, function);
9836   buffer = (char *) alloca (length);
9837   length = 0;
9838   while ((code = (enum tree_code) va_arg (args, int)))
9839     {
9840       if (length)
9841         {
9842           strcpy (buffer + length, " or ");
9843           length += 4;
9844         }
9845       strcpy (buffer + length, get_tree_code_name (code));
9846       length += strlen (get_tree_code_name (code));
9847     }
9848   va_end (args);
9849
9850   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9851                   buffer, get_tree_code_name (TREE_CODE (node)),
9852                   function, trim_filename (file), line);
9853 }
9854
9855 /* Similar to tree_check_failed, except that we check for a class of tree
9856    code, given in CL.  */
9857
9858 void
9859 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
9860                          const char *file, int line, const char *function)
9861 {
9862   internal_error
9863     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9864      TREE_CODE_CLASS_STRING (cl),
9865      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9866      get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9867 }
9868
9869 /* Similar to tree_check_failed, except that instead of specifying a
9870    dozen codes, use the knowledge that they're all sequential.  */
9871
9872 void
9873 tree_range_check_failed (const_tree node, const char *file, int line,
9874                          const char *function, enum tree_code c1,
9875                          enum tree_code c2)
9876 {
9877   char *buffer;
9878   unsigned length = 0;
9879   unsigned int c;
9880
9881   for (c = c1; c <= c2; ++c)
9882     length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
9883
9884   length += strlen ("expected ");
9885   buffer = (char *) alloca (length);
9886   length = 0;
9887
9888   for (c = c1; c <= c2; ++c)
9889     {
9890       const char *prefix = length ? " or " : "expected ";
9891
9892       strcpy (buffer + length, prefix);
9893       length += strlen (prefix);
9894       strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
9895       length += strlen (get_tree_code_name ((enum tree_code) c));
9896     }
9897
9898   internal_error ("tree check: %s, have %s in %s, at %s:%d",
9899                   buffer, get_tree_code_name (TREE_CODE (node)),
9900                   function, trim_filename (file), line);
9901 }
9902
9903
9904 /* Similar to tree_check_failed, except that we check that a tree does
9905    not have the specified code, given in CL.  */
9906
9907 void
9908 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
9909                              const char *file, int line, const char *function)
9910 {
9911   internal_error
9912     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9913      TREE_CODE_CLASS_STRING (cl),
9914      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9915      get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9916 }
9917
9918
9919 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
9920
9921 void
9922 omp_clause_check_failed (const_tree node, const char *file, int line,
9923                          const char *function, enum omp_clause_code code)
9924 {
9925   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9926                   omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
9927                   function, trim_filename (file), line);
9928 }
9929
9930
9931 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
9932
9933 void
9934 omp_clause_range_check_failed (const_tree node, const char *file, int line,
9935                                const char *function, enum omp_clause_code c1,
9936                                enum omp_clause_code c2)
9937 {
9938   char *buffer;
9939   unsigned length = 0;
9940   unsigned int c;
9941
9942   for (c = c1; c <= c2; ++c)
9943     length += 4 + strlen (omp_clause_code_name[c]);
9944
9945   length += strlen ("expected ");
9946   buffer = (char *) alloca (length);
9947   length = 0;
9948
9949   for (c = c1; c <= c2; ++c)
9950     {
9951       const char *prefix = length ? " or " : "expected ";
9952
9953       strcpy (buffer + length, prefix);
9954       length += strlen (prefix);
9955       strcpy (buffer + length, omp_clause_code_name[c]);
9956       length += strlen (omp_clause_code_name[c]);
9957     }
9958
9959   internal_error ("tree check: %s, have %s in %s, at %s:%d",
9960                   buffer, omp_clause_code_name[TREE_CODE (node)],
9961                   function, trim_filename (file), line);
9962 }
9963
9964
9965 #undef DEFTREESTRUCT
9966 #define DEFTREESTRUCT(VAL, NAME) NAME,
9967
9968 static const char *ts_enum_names[] = {
9969 #include "treestruct.def"
9970 };
9971 #undef DEFTREESTRUCT
9972
9973 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9974
9975 /* Similar to tree_class_check_failed, except that we check for
9976    whether CODE contains the tree structure identified by EN.  */
9977
9978 void
9979 tree_contains_struct_check_failed (const_tree node,
9980                                    const enum tree_node_structure_enum en,
9981                                    const char *file, int line,
9982                                    const char *function)
9983 {
9984   internal_error
9985     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9986      TS_ENUM_NAME (en),
9987      get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9988 }
9989
9990
9991 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
9992    (dynamically sized) vector.  */
9993
9994 void
9995 tree_int_cst_elt_check_failed (int idx, int len, const char *file, int line,
9996                                const char *function)
9997 {
9998   internal_error
9999     ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
10000      idx + 1, len, function, trim_filename (file), line);
10001 }
10002
10003 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
10004    (dynamically sized) vector.  */
10005
10006 void
10007 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
10008                            const char *function)
10009 {
10010   internal_error
10011     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
10012      idx + 1, len, function, trim_filename (file), line);
10013 }
10014
10015 /* Similar to above, except that the check is for the bounds of the operand
10016    vector of an expression node EXP.  */
10017
10018 void
10019 tree_operand_check_failed (int idx, const_tree exp, const char *file,
10020                            int line, const char *function)
10021 {
10022   enum tree_code code = TREE_CODE (exp);
10023   internal_error
10024     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
10025      idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
10026      function, trim_filename (file), line);
10027 }
10028
10029 /* Similar to above, except that the check is for the number of
10030    operands of an OMP_CLAUSE node.  */
10031
10032 void
10033 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
10034                                  int line, const char *function)
10035 {
10036   internal_error
10037     ("tree check: accessed operand %d of omp_clause %s with %d operands "
10038      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
10039      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
10040      trim_filename (file), line);
10041 }
10042 #endif /* ENABLE_TREE_CHECKING */
10043 \f
10044 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
10045    and mapped to the machine mode MODE.  Initialize its fields and build
10046    the information necessary for debugging output.  */
10047
10048 static tree
10049 make_vector_type (tree innertype, int nunits, machine_mode mode)
10050 {
10051   tree t;
10052   inchash::hash hstate;
10053   tree mv_innertype = TYPE_MAIN_VARIANT (innertype);
10054
10055   t = make_node (VECTOR_TYPE);
10056   TREE_TYPE (t) = mv_innertype;
10057   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
10058   SET_TYPE_MODE (t, mode);
10059
10060   if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p)
10061     SET_TYPE_STRUCTURAL_EQUALITY (t);
10062   else if ((TYPE_CANONICAL (mv_innertype) != innertype
10063             || mode != VOIDmode)
10064            && !VECTOR_BOOLEAN_TYPE_P (t))
10065     TYPE_CANONICAL (t)
10066       = make_vector_type (TYPE_CANONICAL (mv_innertype), nunits, VOIDmode);
10067
10068   layout_type (t);
10069
10070   hstate.add_wide_int (VECTOR_TYPE);
10071   hstate.add_wide_int (nunits);
10072   hstate.add_wide_int (mode);
10073   hstate.add_object (TYPE_HASH (TREE_TYPE (t)));
10074   t = type_hash_canon (hstate.end (), t);
10075
10076   /* We have built a main variant, based on the main variant of the
10077      inner type. Use it to build the variant we return.  */
10078   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
10079       && TREE_TYPE (t) != innertype)
10080     return build_type_attribute_qual_variant (t,
10081                                               TYPE_ATTRIBUTES (innertype),
10082                                               TYPE_QUALS (innertype));
10083
10084   return t;
10085 }
10086
10087 static tree
10088 make_or_reuse_type (unsigned size, int unsignedp)
10089 {
10090   int i;
10091
10092   if (size == INT_TYPE_SIZE)
10093     return unsignedp ? unsigned_type_node : integer_type_node;
10094   if (size == CHAR_TYPE_SIZE)
10095     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
10096   if (size == SHORT_TYPE_SIZE)
10097     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
10098   if (size == LONG_TYPE_SIZE)
10099     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
10100   if (size == LONG_LONG_TYPE_SIZE)
10101     return (unsignedp ? long_long_unsigned_type_node
10102             : long_long_integer_type_node);
10103
10104   for (i = 0; i < NUM_INT_N_ENTS; i ++)
10105     if (size == int_n_data[i].bitsize
10106         && int_n_enabled_p[i])
10107       return (unsignedp ? int_n_trees[i].unsigned_type
10108               : int_n_trees[i].signed_type);
10109
10110   if (unsignedp)
10111     return make_unsigned_type (size);
10112   else
10113     return make_signed_type (size);
10114 }
10115
10116 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
10117
10118 static tree
10119 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
10120 {
10121   if (satp)
10122     {
10123       if (size == SHORT_FRACT_TYPE_SIZE)
10124         return unsignedp ? sat_unsigned_short_fract_type_node
10125                          : sat_short_fract_type_node;
10126       if (size == FRACT_TYPE_SIZE)
10127         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
10128       if (size == LONG_FRACT_TYPE_SIZE)
10129         return unsignedp ? sat_unsigned_long_fract_type_node
10130                          : sat_long_fract_type_node;
10131       if (size == LONG_LONG_FRACT_TYPE_SIZE)
10132         return unsignedp ? sat_unsigned_long_long_fract_type_node
10133                          : sat_long_long_fract_type_node;
10134     }
10135   else
10136     {
10137       if (size == SHORT_FRACT_TYPE_SIZE)
10138         return unsignedp ? unsigned_short_fract_type_node
10139                          : short_fract_type_node;
10140       if (size == FRACT_TYPE_SIZE)
10141         return unsignedp ? unsigned_fract_type_node : fract_type_node;
10142       if (size == LONG_FRACT_TYPE_SIZE)
10143         return unsignedp ? unsigned_long_fract_type_node
10144                          : long_fract_type_node;
10145       if (size == LONG_LONG_FRACT_TYPE_SIZE)
10146         return unsignedp ? unsigned_long_long_fract_type_node
10147                          : long_long_fract_type_node;
10148     }
10149
10150   return make_fract_type (size, unsignedp, satp);
10151 }
10152
10153 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
10154
10155 static tree
10156 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
10157 {
10158   if (satp)
10159     {
10160       if (size == SHORT_ACCUM_TYPE_SIZE)
10161         return unsignedp ? sat_unsigned_short_accum_type_node
10162                          : sat_short_accum_type_node;
10163       if (size == ACCUM_TYPE_SIZE)
10164         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
10165       if (size == LONG_ACCUM_TYPE_SIZE)
10166         return unsignedp ? sat_unsigned_long_accum_type_node
10167                          : sat_long_accum_type_node;
10168       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
10169         return unsignedp ? sat_unsigned_long_long_accum_type_node
10170                          : sat_long_long_accum_type_node;
10171     }
10172   else
10173     {
10174       if (size == SHORT_ACCUM_TYPE_SIZE)
10175         return unsignedp ? unsigned_short_accum_type_node
10176                          : short_accum_type_node;
10177       if (size == ACCUM_TYPE_SIZE)
10178         return unsignedp ? unsigned_accum_type_node : accum_type_node;
10179       if (size == LONG_ACCUM_TYPE_SIZE)
10180         return unsignedp ? unsigned_long_accum_type_node
10181                          : long_accum_type_node;
10182       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
10183         return unsignedp ? unsigned_long_long_accum_type_node
10184                          : long_long_accum_type_node;
10185     }
10186
10187   return make_accum_type (size, unsignedp, satp);
10188 }
10189
10190
10191 /* Create an atomic variant node for TYPE.  This routine is called
10192    during initialization of data types to create the 5 basic atomic
10193    types. The generic build_variant_type function requires these to
10194    already be set up in order to function properly, so cannot be
10195    called from there.  If ALIGN is non-zero, then ensure alignment is
10196    overridden to this value.  */
10197
10198 static tree
10199 build_atomic_base (tree type, unsigned int align)
10200 {
10201   tree t;
10202
10203   /* Make sure its not already registered.  */
10204   if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC)))
10205     return t;
10206
10207   t = build_variant_type_copy (type);
10208   set_type_quals (t, TYPE_QUAL_ATOMIC);
10209
10210   if (align)
10211     SET_TYPE_ALIGN (t, align);
10212
10213   return t;
10214 }
10215
10216 /* Information about the _FloatN and _FloatNx types.  This must be in
10217    the same order as the corresponding TI_* enum values.  */
10218 const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES] =
10219   {
10220     { 16, false },
10221     { 32, false },
10222     { 64, false },
10223     { 128, false },
10224     { 32, true },
10225     { 64, true },
10226     { 128, true },
10227   };
10228
10229
10230 /* Create nodes for all integer types (and error_mark_node) using the sizes
10231    of C datatypes.  SIGNED_CHAR specifies whether char is signed.  */
10232
10233 void
10234 build_common_tree_nodes (bool signed_char)
10235 {
10236   int i;
10237
10238   error_mark_node = make_node (ERROR_MARK);
10239   TREE_TYPE (error_mark_node) = error_mark_node;
10240
10241   initialize_sizetypes ();
10242
10243   /* Define both `signed char' and `unsigned char'.  */
10244   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
10245   TYPE_STRING_FLAG (signed_char_type_node) = 1;
10246   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
10247   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
10248
10249   /* Define `char', which is like either `signed char' or `unsigned char'
10250      but not the same as either.  */
10251   char_type_node
10252     = (signed_char
10253        ? make_signed_type (CHAR_TYPE_SIZE)
10254        : make_unsigned_type (CHAR_TYPE_SIZE));
10255   TYPE_STRING_FLAG (char_type_node) = 1;
10256
10257   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
10258   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
10259   integer_type_node = make_signed_type (INT_TYPE_SIZE);
10260   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
10261   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
10262   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
10263   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
10264   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
10265
10266   for (i = 0; i < NUM_INT_N_ENTS; i ++)
10267     {
10268       int_n_trees[i].signed_type = make_signed_type (int_n_data[i].bitsize);
10269       int_n_trees[i].unsigned_type = make_unsigned_type (int_n_data[i].bitsize);
10270       TYPE_SIZE (int_n_trees[i].signed_type) = bitsize_int (int_n_data[i].bitsize);
10271       TYPE_SIZE (int_n_trees[i].unsigned_type) = bitsize_int (int_n_data[i].bitsize);
10272
10273       if (int_n_data[i].bitsize > LONG_LONG_TYPE_SIZE
10274           && int_n_enabled_p[i])
10275         {
10276           integer_types[itk_intN_0 + i * 2] = int_n_trees[i].signed_type;
10277           integer_types[itk_unsigned_intN_0 + i * 2] = int_n_trees[i].unsigned_type;
10278         }
10279     }
10280
10281   /* Define a boolean type.  This type only represents boolean values but
10282      may be larger than char depending on the value of BOOL_TYPE_SIZE.  */
10283   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
10284   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
10285   TYPE_PRECISION (boolean_type_node) = 1;
10286   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
10287
10288   /* Define what type to use for size_t.  */
10289   if (strcmp (SIZE_TYPE, "unsigned int") == 0)
10290     size_type_node = unsigned_type_node;
10291   else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
10292     size_type_node = long_unsigned_type_node;
10293   else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
10294     size_type_node = long_long_unsigned_type_node;
10295   else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
10296     size_type_node = short_unsigned_type_node;
10297   else
10298     {
10299       int i;
10300
10301       size_type_node = NULL_TREE;
10302       for (i = 0; i < NUM_INT_N_ENTS; i++)
10303         if (int_n_enabled_p[i])
10304           {
10305             char name[50];
10306             sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
10307
10308             if (strcmp (name, SIZE_TYPE) == 0)
10309               {
10310                 size_type_node = int_n_trees[i].unsigned_type;
10311               }
10312           }
10313       if (size_type_node == NULL_TREE)
10314         gcc_unreachable ();
10315     }
10316
10317   /* Define what type to use for ptrdiff_t.  */
10318   if (strcmp (PTRDIFF_TYPE, "int") == 0)
10319     ptrdiff_type_node = integer_type_node;
10320   else if (strcmp (PTRDIFF_TYPE, "long int") == 0)
10321     ptrdiff_type_node = long_integer_type_node;
10322   else if (strcmp (PTRDIFF_TYPE, "long long int") == 0)
10323     ptrdiff_type_node = long_long_integer_type_node;
10324   else if (strcmp (PTRDIFF_TYPE, "short int") == 0)
10325     ptrdiff_type_node = short_integer_type_node;
10326   else
10327     {
10328       ptrdiff_type_node = NULL_TREE;
10329       for (int i = 0; i < NUM_INT_N_ENTS; i++)
10330         if (int_n_enabled_p[i])
10331           {
10332             char name[50];
10333             sprintf (name, "__int%d", int_n_data[i].bitsize);
10334             if (strcmp (name, PTRDIFF_TYPE) == 0)
10335               ptrdiff_type_node = int_n_trees[i].signed_type;
10336           }
10337       if (ptrdiff_type_node == NULL_TREE)
10338         gcc_unreachable ();
10339     }
10340
10341   /* Fill in the rest of the sized types.  Reuse existing type nodes
10342      when possible.  */
10343   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
10344   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
10345   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
10346   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
10347   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
10348
10349   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
10350   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
10351   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
10352   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
10353   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
10354
10355   /* Don't call build_qualified type for atomics.  That routine does
10356      special processing for atomics, and until they are initialized
10357      it's better not to make that call.
10358
10359      Check to see if there is a target override for atomic types.  */
10360
10361   atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node,
10362                                         targetm.atomic_align_for_mode (QImode));
10363   atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node,
10364                                         targetm.atomic_align_for_mode (HImode));
10365   atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node,
10366                                         targetm.atomic_align_for_mode (SImode));
10367   atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node,
10368                                         targetm.atomic_align_for_mode (DImode));
10369   atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node,
10370                                         targetm.atomic_align_for_mode (TImode));
10371
10372   access_public_node = get_identifier ("public");
10373   access_protected_node = get_identifier ("protected");
10374   access_private_node = get_identifier ("private");
10375
10376   /* Define these next since types below may used them.  */
10377   integer_zero_node = build_int_cst (integer_type_node, 0);
10378   integer_one_node = build_int_cst (integer_type_node, 1);
10379   integer_three_node = build_int_cst (integer_type_node, 3);
10380   integer_minus_one_node = build_int_cst (integer_type_node, -1);
10381
10382   size_zero_node = size_int (0);
10383   size_one_node = size_int (1);
10384   bitsize_zero_node = bitsize_int (0);
10385   bitsize_one_node = bitsize_int (1);
10386   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
10387
10388   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
10389   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
10390
10391   void_type_node = make_node (VOID_TYPE);
10392   layout_type (void_type_node);
10393
10394   pointer_bounds_type_node = targetm.chkp_bound_type ();
10395
10396   /* We are not going to have real types in C with less than byte alignment,
10397      so we might as well not have any types that claim to have it.  */
10398   SET_TYPE_ALIGN (void_type_node, BITS_PER_UNIT);
10399   TYPE_USER_ALIGN (void_type_node) = 0;
10400
10401   void_node = make_node (VOID_CST);
10402   TREE_TYPE (void_node) = void_type_node;
10403
10404   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
10405   layout_type (TREE_TYPE (null_pointer_node));
10406
10407   ptr_type_node = build_pointer_type (void_type_node);
10408   const_ptr_type_node
10409     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
10410   fileptr_type_node = ptr_type_node;
10411   const_tm_ptr_type_node = const_ptr_type_node;
10412
10413   pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1);
10414
10415   float_type_node = make_node (REAL_TYPE);
10416   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
10417   layout_type (float_type_node);
10418
10419   double_type_node = make_node (REAL_TYPE);
10420   TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
10421   layout_type (double_type_node);
10422
10423   long_double_type_node = make_node (REAL_TYPE);
10424   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
10425   layout_type (long_double_type_node);
10426
10427   for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
10428     {
10429       int n = floatn_nx_types[i].n;
10430       bool extended = floatn_nx_types[i].extended;
10431       machine_mode mode = targetm.floatn_mode (n, extended);
10432       if (mode == VOIDmode)
10433         continue;
10434       int precision = GET_MODE_PRECISION (mode);
10435       /* Work around the rs6000 KFmode having precision 113 not
10436          128.  */
10437       const struct real_format *fmt = REAL_MODE_FORMAT (mode);
10438       gcc_assert (fmt->b == 2 && fmt->emin + fmt->emax == 3);
10439       int min_precision = fmt->p + ceil_log2 (fmt->emax - fmt->emin);
10440       if (!extended)
10441         gcc_assert (min_precision == n);
10442       if (precision < min_precision)
10443         precision = min_precision;
10444       FLOATN_NX_TYPE_NODE (i) = make_node (REAL_TYPE);
10445       TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i)) = precision;
10446       layout_type (FLOATN_NX_TYPE_NODE (i));
10447       SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode);
10448     }
10449
10450   float_ptr_type_node = build_pointer_type (float_type_node);
10451   double_ptr_type_node = build_pointer_type (double_type_node);
10452   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
10453   integer_ptr_type_node = build_pointer_type (integer_type_node);
10454
10455   /* Fixed size integer types.  */
10456   uint16_type_node = make_or_reuse_type (16, 1);
10457   uint32_type_node = make_or_reuse_type (32, 1);
10458   uint64_type_node = make_or_reuse_type (64, 1);
10459
10460   /* Decimal float types. */
10461   dfloat32_type_node = make_node (REAL_TYPE);
10462   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
10463   SET_TYPE_MODE (dfloat32_type_node, SDmode);
10464   layout_type (dfloat32_type_node);
10465   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
10466
10467   dfloat64_type_node = make_node (REAL_TYPE);
10468   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
10469   SET_TYPE_MODE (dfloat64_type_node, DDmode);
10470   layout_type (dfloat64_type_node);
10471   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
10472
10473   dfloat128_type_node = make_node (REAL_TYPE);
10474   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
10475   SET_TYPE_MODE (dfloat128_type_node, TDmode);
10476   layout_type (dfloat128_type_node);
10477   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
10478
10479   complex_integer_type_node = build_complex_type (integer_type_node, true);
10480   complex_float_type_node = build_complex_type (float_type_node, true);
10481   complex_double_type_node = build_complex_type (double_type_node, true);
10482   complex_long_double_type_node = build_complex_type (long_double_type_node,
10483                                                       true);
10484
10485   for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
10486     {
10487       if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
10488         COMPLEX_FLOATN_NX_TYPE_NODE (i)
10489           = build_complex_type (FLOATN_NX_TYPE_NODE (i));
10490     }
10491
10492 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
10493 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
10494   sat_ ## KIND ## _type_node = \
10495     make_sat_signed_ ## KIND ## _type (SIZE); \
10496   sat_unsigned_ ## KIND ## _type_node = \
10497     make_sat_unsigned_ ## KIND ## _type (SIZE); \
10498   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10499   unsigned_ ## KIND ## _type_node = \
10500     make_unsigned_ ## KIND ## _type (SIZE);
10501
10502 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
10503   sat_ ## WIDTH ## KIND ## _type_node = \
10504     make_sat_signed_ ## KIND ## _type (SIZE); \
10505   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
10506     make_sat_unsigned_ ## KIND ## _type (SIZE); \
10507   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10508   unsigned_ ## WIDTH ## KIND ## _type_node = \
10509     make_unsigned_ ## KIND ## _type (SIZE);
10510
10511 /* Make fixed-point type nodes based on four different widths.  */
10512 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
10513   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
10514   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
10515   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
10516   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
10517
10518 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
10519 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
10520   NAME ## _type_node = \
10521     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
10522   u ## NAME ## _type_node = \
10523     make_or_reuse_unsigned_ ## KIND ## _type \
10524       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
10525   sat_ ## NAME ## _type_node = \
10526     make_or_reuse_sat_signed_ ## KIND ## _type \
10527       (GET_MODE_BITSIZE (MODE ## mode)); \
10528   sat_u ## NAME ## _type_node = \
10529     make_or_reuse_sat_unsigned_ ## KIND ## _type \
10530       (GET_MODE_BITSIZE (U ## MODE ## mode));
10531
10532   /* Fixed-point type and mode nodes.  */
10533   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
10534   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
10535   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
10536   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
10537   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
10538   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
10539   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
10540   MAKE_FIXED_MODE_NODE (accum, ha, HA)
10541   MAKE_FIXED_MODE_NODE (accum, sa, SA)
10542   MAKE_FIXED_MODE_NODE (accum, da, DA)
10543   MAKE_FIXED_MODE_NODE (accum, ta, TA)
10544
10545   {
10546     tree t = targetm.build_builtin_va_list ();
10547
10548     /* Many back-ends define record types without setting TYPE_NAME.
10549        If we copied the record type here, we'd keep the original
10550        record type without a name.  This breaks name mangling.  So,
10551        don't copy record types and let c_common_nodes_and_builtins()
10552        declare the type to be __builtin_va_list.  */
10553     if (TREE_CODE (t) != RECORD_TYPE)
10554       t = build_variant_type_copy (t);
10555
10556     va_list_type_node = t;
10557   }
10558 }
10559
10560 /* Modify DECL for given flags.
10561    TM_PURE attribute is set only on types, so the function will modify
10562    DECL's type when ECF_TM_PURE is used.  */
10563
10564 void
10565 set_call_expr_flags (tree decl, int flags)
10566 {
10567   if (flags & ECF_NOTHROW)
10568     TREE_NOTHROW (decl) = 1;
10569   if (flags & ECF_CONST)
10570     TREE_READONLY (decl) = 1;
10571   if (flags & ECF_PURE)
10572     DECL_PURE_P (decl) = 1;
10573   if (flags & ECF_LOOPING_CONST_OR_PURE)
10574     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
10575   if (flags & ECF_NOVOPS)
10576     DECL_IS_NOVOPS (decl) = 1;
10577   if (flags & ECF_NORETURN)
10578     TREE_THIS_VOLATILE (decl) = 1;
10579   if (flags & ECF_MALLOC)
10580     DECL_IS_MALLOC (decl) = 1;
10581   if (flags & ECF_RETURNS_TWICE)
10582     DECL_IS_RETURNS_TWICE (decl) = 1;
10583   if (flags & ECF_LEAF)
10584     DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
10585                                         NULL, DECL_ATTRIBUTES (decl));
10586   if (flags & ECF_RET1)
10587     DECL_ATTRIBUTES (decl)
10588       = tree_cons (get_identifier ("fn spec"),
10589                    build_tree_list (NULL_TREE, build_string (1, "1")),
10590                    DECL_ATTRIBUTES (decl));
10591   if ((flags & ECF_TM_PURE) && flag_tm)
10592     apply_tm_attr (decl, get_identifier ("transaction_pure"));
10593   /* Looping const or pure is implied by noreturn.
10594      There is currently no way to declare looping const or looping pure alone.  */
10595   gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE)
10596               || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE))));
10597 }
10598
10599
10600 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
10601
10602 static void
10603 local_define_builtin (const char *name, tree type, enum built_in_function code,
10604                       const char *library_name, int ecf_flags)
10605 {
10606   tree decl;
10607
10608   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
10609                                library_name, NULL_TREE);
10610   set_call_expr_flags (decl, ecf_flags);
10611
10612   set_builtin_decl (code, decl, true);
10613 }
10614
10615 /* Call this function after instantiating all builtins that the language
10616    front end cares about.  This will build the rest of the builtins
10617    and internal functions that are relied upon by the tree optimizers and
10618    the middle-end.  */
10619
10620 void
10621 build_common_builtin_nodes (void)
10622 {
10623   tree tmp, ftype;
10624   int ecf_flags;
10625
10626   if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE)
10627       || !builtin_decl_explicit_p (BUILT_IN_ABORT))
10628     {
10629       ftype = build_function_type (void_type_node, void_list_node);
10630       if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE))
10631         local_define_builtin ("__builtin_unreachable", ftype,
10632                               BUILT_IN_UNREACHABLE,
10633                               "__builtin_unreachable",
10634                               ECF_NOTHROW | ECF_LEAF | ECF_NORETURN
10635                               | ECF_CONST);
10636       if (!builtin_decl_explicit_p (BUILT_IN_ABORT))
10637         local_define_builtin ("__builtin_abort", ftype, BUILT_IN_ABORT,
10638                               "abort",
10639                               ECF_LEAF | ECF_NORETURN | ECF_CONST);
10640     }
10641
10642   if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
10643       || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10644     {
10645       ftype = build_function_type_list (ptr_type_node,
10646                                         ptr_type_node, const_ptr_type_node,
10647                                         size_type_node, NULL_TREE);
10648
10649       if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
10650         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
10651                               "memcpy", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10652       if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10653         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
10654                               "memmove", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10655     }
10656
10657   if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
10658     {
10659       ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10660                                         const_ptr_type_node, size_type_node,
10661                                         NULL_TREE);
10662       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
10663                             "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10664     }
10665
10666   if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
10667     {
10668       ftype = build_function_type_list (ptr_type_node,
10669                                         ptr_type_node, integer_type_node,
10670                                         size_type_node, NULL_TREE);
10671       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
10672                             "memset", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10673     }
10674
10675   /* If we're checking the stack, `alloca' can throw.  */
10676   const int alloca_flags
10677     = ECF_MALLOC | ECF_LEAF | (flag_stack_check ? 0 : ECF_NOTHROW);
10678
10679   if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
10680     {
10681       ftype = build_function_type_list (ptr_type_node,
10682                                         size_type_node, NULL_TREE);
10683       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
10684                             "alloca", alloca_flags);
10685     }
10686
10687   ftype = build_function_type_list (ptr_type_node, size_type_node,
10688                                     size_type_node, NULL_TREE);
10689   local_define_builtin ("__builtin_alloca_with_align", ftype,
10690                         BUILT_IN_ALLOCA_WITH_ALIGN,
10691                         "__builtin_alloca_with_align",
10692                         alloca_flags);
10693
10694   ftype = build_function_type_list (void_type_node,
10695                                     ptr_type_node, ptr_type_node,
10696                                     ptr_type_node, NULL_TREE);
10697   local_define_builtin ("__builtin_init_trampoline", ftype,
10698                         BUILT_IN_INIT_TRAMPOLINE,
10699                         "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
10700   local_define_builtin ("__builtin_init_heap_trampoline", ftype,
10701                         BUILT_IN_INIT_HEAP_TRAMPOLINE,
10702                         "__builtin_init_heap_trampoline",
10703                         ECF_NOTHROW | ECF_LEAF);
10704   local_define_builtin ("__builtin_init_descriptor", ftype,
10705                         BUILT_IN_INIT_DESCRIPTOR,
10706                         "__builtin_init_descriptor", ECF_NOTHROW | ECF_LEAF);
10707
10708   ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
10709   local_define_builtin ("__builtin_adjust_trampoline", ftype,
10710                         BUILT_IN_ADJUST_TRAMPOLINE,
10711                         "__builtin_adjust_trampoline",
10712                         ECF_CONST | ECF_NOTHROW);
10713   local_define_builtin ("__builtin_adjust_descriptor", ftype,
10714                         BUILT_IN_ADJUST_DESCRIPTOR,
10715                         "__builtin_adjust_descriptor",
10716                         ECF_CONST | ECF_NOTHROW);
10717
10718   ftype = build_function_type_list (void_type_node,
10719                                     ptr_type_node, ptr_type_node, NULL_TREE);
10720   local_define_builtin ("__builtin_nonlocal_goto", ftype,
10721                         BUILT_IN_NONLOCAL_GOTO,
10722                         "__builtin_nonlocal_goto",
10723                         ECF_NORETURN | ECF_NOTHROW);
10724
10725   ftype = build_function_type_list (void_type_node,
10726                                     ptr_type_node, ptr_type_node, NULL_TREE);
10727   local_define_builtin ("__builtin_setjmp_setup", ftype,
10728                         BUILT_IN_SETJMP_SETUP,
10729                         "__builtin_setjmp_setup", ECF_NOTHROW);
10730
10731   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10732   local_define_builtin ("__builtin_setjmp_receiver", ftype,
10733                         BUILT_IN_SETJMP_RECEIVER,
10734                         "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF);
10735
10736   ftype = build_function_type_list (ptr_type_node, NULL_TREE);
10737   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
10738                         "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
10739
10740   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10741   local_define_builtin ("__builtin_stack_restore", ftype,
10742                         BUILT_IN_STACK_RESTORE,
10743                         "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
10744
10745   ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10746                                     const_ptr_type_node, size_type_node,
10747                                     NULL_TREE);
10748   local_define_builtin ("__builtin_memcmp_eq", ftype, BUILT_IN_MEMCMP_EQ,
10749                         "__builtin_memcmp_eq",
10750                         ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10751
10752   /* If there's a possibility that we might use the ARM EABI, build the
10753     alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
10754   if (targetm.arm_eabi_unwinder)
10755     {
10756       ftype = build_function_type_list (void_type_node, NULL_TREE);
10757       local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
10758                             BUILT_IN_CXA_END_CLEANUP,
10759                             "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
10760     }
10761
10762   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10763   local_define_builtin ("__builtin_unwind_resume", ftype,
10764                         BUILT_IN_UNWIND_RESUME,
10765                         ((targetm_common.except_unwind_info (&global_options)
10766                           == UI_SJLJ)
10767                          ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10768                         ECF_NORETURN);
10769
10770   if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
10771     {
10772       ftype = build_function_type_list (ptr_type_node, integer_type_node,
10773                                         NULL_TREE);
10774       local_define_builtin ("__builtin_return_address", ftype,
10775                             BUILT_IN_RETURN_ADDRESS,
10776                             "__builtin_return_address",
10777                             ECF_NOTHROW);
10778     }
10779
10780   if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
10781       || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10782     {
10783       ftype = build_function_type_list (void_type_node, ptr_type_node,
10784                                         ptr_type_node, NULL_TREE);
10785       if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
10786         local_define_builtin ("__cyg_profile_func_enter", ftype,
10787                               BUILT_IN_PROFILE_FUNC_ENTER,
10788                               "__cyg_profile_func_enter", 0);
10789       if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10790         local_define_builtin ("__cyg_profile_func_exit", ftype,
10791                               BUILT_IN_PROFILE_FUNC_EXIT,
10792                               "__cyg_profile_func_exit", 0);
10793     }
10794
10795   /* The exception object and filter values from the runtime.  The argument
10796      must be zero before exception lowering, i.e. from the front end.  After
10797      exception lowering, it will be the region number for the exception
10798      landing pad.  These functions are PURE instead of CONST to prevent
10799      them from being hoisted past the exception edge that will initialize
10800      its value in the landing pad.  */
10801   ftype = build_function_type_list (ptr_type_node,
10802                                     integer_type_node, NULL_TREE);
10803   ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
10804   /* Only use TM_PURE if we have TM language support.  */
10805   if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
10806     ecf_flags |= ECF_TM_PURE;
10807   local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
10808                         "__builtin_eh_pointer", ecf_flags);
10809
10810   tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
10811   ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
10812   local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
10813                         "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10814
10815   ftype = build_function_type_list (void_type_node,
10816                                     integer_type_node, integer_type_node,
10817                                     NULL_TREE);
10818   local_define_builtin ("__builtin_eh_copy_values", ftype,
10819                         BUILT_IN_EH_COPY_VALUES,
10820                         "__builtin_eh_copy_values", ECF_NOTHROW);
10821
10822   /* Complex multiplication and division.  These are handled as builtins
10823      rather than optabs because emit_library_call_value doesn't support
10824      complex.  Further, we can do slightly better with folding these
10825      beasties if the real and complex parts of the arguments are separate.  */
10826   {
10827     int mode;
10828
10829     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
10830       {
10831         char mode_name_buf[4], *q;
10832         const char *p;
10833         enum built_in_function mcode, dcode;
10834         tree type, inner_type;
10835         const char *prefix = "__";
10836
10837         if (targetm.libfunc_gnu_prefix)
10838           prefix = "__gnu_";
10839
10840         type = lang_hooks.types.type_for_mode ((machine_mode) mode, 0);
10841         if (type == NULL)
10842           continue;
10843         inner_type = TREE_TYPE (type);
10844
10845         ftype = build_function_type_list (type, inner_type, inner_type,
10846                                           inner_type, inner_type, NULL_TREE);
10847
10848         mcode = ((enum built_in_function)
10849                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10850         dcode = ((enum built_in_function)
10851                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10852
10853         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
10854           *q = TOLOWER (*p);
10855         *q = '\0';
10856
10857         built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3",
10858                                         NULL);
10859         local_define_builtin (built_in_names[mcode], ftype, mcode,
10860                               built_in_names[mcode],
10861                               ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10862
10863         built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3",
10864                                         NULL);
10865         local_define_builtin (built_in_names[dcode], ftype, dcode,
10866                               built_in_names[dcode],
10867                               ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10868       }
10869   }
10870
10871   init_internal_fns ();
10872 }
10873
10874 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
10875    better way.
10876
10877    If we requested a pointer to a vector, build up the pointers that
10878    we stripped off while looking for the inner type.  Similarly for
10879    return values from functions.
10880
10881    The argument TYPE is the top of the chain, and BOTTOM is the
10882    new type which we will point to.  */
10883
10884 tree
10885 reconstruct_complex_type (tree type, tree bottom)
10886 {
10887   tree inner, outer;
10888
10889   if (TREE_CODE (type) == POINTER_TYPE)
10890     {
10891       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10892       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
10893                                            TYPE_REF_CAN_ALIAS_ALL (type));
10894     }
10895   else if (TREE_CODE (type) == REFERENCE_TYPE)
10896     {
10897       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10898       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
10899                                              TYPE_REF_CAN_ALIAS_ALL (type));
10900     }
10901   else if (TREE_CODE (type) == ARRAY_TYPE)
10902     {
10903       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10904       outer = build_array_type (inner, TYPE_DOMAIN (type));
10905     }
10906   else if (TREE_CODE (type) == FUNCTION_TYPE)
10907     {
10908       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10909       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
10910     }
10911   else if (TREE_CODE (type) == METHOD_TYPE)
10912     {
10913       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10914       /* The build_method_type_directly() routine prepends 'this' to argument list,
10915          so we must compensate by getting rid of it.  */
10916       outer
10917         = build_method_type_directly
10918             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
10919              inner,
10920              TREE_CHAIN (TYPE_ARG_TYPES (type)));
10921     }
10922   else if (TREE_CODE (type) == OFFSET_TYPE)
10923     {
10924       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10925       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
10926     }
10927   else
10928     return bottom;
10929
10930   return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
10931                                             TYPE_QUALS (type));
10932 }
10933
10934 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10935    the inner type.  */
10936 tree
10937 build_vector_type_for_mode (tree innertype, machine_mode mode)
10938 {
10939   int nunits;
10940
10941   switch (GET_MODE_CLASS (mode))
10942     {
10943     case MODE_VECTOR_INT:
10944     case MODE_VECTOR_FLOAT:
10945     case MODE_VECTOR_FRACT:
10946     case MODE_VECTOR_UFRACT:
10947     case MODE_VECTOR_ACCUM:
10948     case MODE_VECTOR_UACCUM:
10949       nunits = GET_MODE_NUNITS (mode);
10950       break;
10951
10952     case MODE_INT:
10953       /* Check that there are no leftover bits.  */
10954       gcc_assert (GET_MODE_BITSIZE (mode)
10955                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
10956
10957       nunits = GET_MODE_BITSIZE (mode)
10958                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
10959       break;
10960
10961     default:
10962       gcc_unreachable ();
10963     }
10964
10965   return make_vector_type (innertype, nunits, mode);
10966 }
10967
10968 /* Similarly, but takes the inner type and number of units, which must be
10969    a power of two.  */
10970
10971 tree
10972 build_vector_type (tree innertype, int nunits)
10973 {
10974   return make_vector_type (innertype, nunits, VOIDmode);
10975 }
10976
10977 /* Build truth vector with specified length and number of units.  */
10978
10979 tree
10980 build_truth_vector_type (unsigned nunits, unsigned vector_size)
10981 {
10982   machine_mode mask_mode = targetm.vectorize.get_mask_mode (nunits,
10983                                                             vector_size);
10984
10985   gcc_assert (mask_mode != VOIDmode);
10986
10987   unsigned HOST_WIDE_INT vsize;
10988   if (mask_mode == BLKmode)
10989     vsize = vector_size * BITS_PER_UNIT;
10990   else
10991     vsize = GET_MODE_BITSIZE (mask_mode);
10992
10993   unsigned HOST_WIDE_INT esize = vsize / nunits;
10994   gcc_assert (esize * nunits == vsize);
10995
10996   tree bool_type = build_nonstandard_boolean_type (esize);
10997
10998   return make_vector_type (bool_type, nunits, mask_mode);
10999 }
11000
11001 /* Returns a vector type corresponding to a comparison of VECTYPE.  */
11002
11003 tree
11004 build_same_sized_truth_vector_type (tree vectype)
11005 {
11006   if (VECTOR_BOOLEAN_TYPE_P (vectype))
11007     return vectype;
11008
11009   unsigned HOST_WIDE_INT size = GET_MODE_SIZE (TYPE_MODE (vectype));
11010
11011   if (!size)
11012     size = tree_to_uhwi (TYPE_SIZE_UNIT (vectype));
11013
11014   return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype), size);
11015 }
11016
11017 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set.  */
11018
11019 tree
11020 build_opaque_vector_type (tree innertype, int nunits)
11021 {
11022   tree t = make_vector_type (innertype, nunits, VOIDmode);
11023   tree cand;
11024   /* We always build the non-opaque variant before the opaque one,
11025      so if it already exists, it is TYPE_NEXT_VARIANT of this one.  */
11026   cand = TYPE_NEXT_VARIANT (t);
11027   if (cand
11028       && TYPE_VECTOR_OPAQUE (cand)
11029       && check_qualified_type (cand, t, TYPE_QUALS (t)))
11030     return cand;
11031   /* Othewise build a variant type and make sure to queue it after
11032      the non-opaque type.  */
11033   cand = build_distinct_type_copy (t);
11034   TYPE_VECTOR_OPAQUE (cand) = true;
11035   TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
11036   TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
11037   TYPE_NEXT_VARIANT (t) = cand;
11038   TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
11039   return cand;
11040 }
11041
11042
11043 /* Given an initializer INIT, return TRUE if INIT is zero or some
11044    aggregate of zeros.  Otherwise return FALSE.  */
11045 bool
11046 initializer_zerop (const_tree init)
11047 {
11048   tree elt;
11049
11050   STRIP_NOPS (init);
11051
11052   switch (TREE_CODE (init))
11053     {
11054     case INTEGER_CST:
11055       return integer_zerop (init);
11056
11057     case REAL_CST:
11058       /* ??? Note that this is not correct for C4X float formats.  There,
11059          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
11060          negative exponent.  */
11061       return real_zerop (init)
11062         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
11063
11064     case FIXED_CST:
11065       return fixed_zerop (init);
11066
11067     case COMPLEX_CST:
11068       return integer_zerop (init)
11069         || (real_zerop (init)
11070             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
11071             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
11072
11073     case VECTOR_CST:
11074       {
11075         unsigned i;
11076         for (i = 0; i < VECTOR_CST_NELTS (init); ++i)
11077           if (!initializer_zerop (VECTOR_CST_ELT (init, i)))
11078             return false;
11079         return true;
11080       }
11081
11082     case CONSTRUCTOR:
11083       {
11084         unsigned HOST_WIDE_INT idx;
11085
11086         if (TREE_CLOBBER_P (init))
11087           return false;
11088         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
11089           if (!initializer_zerop (elt))
11090             return false;
11091         return true;
11092       }
11093
11094     case STRING_CST:
11095       {
11096         int i;
11097
11098         /* We need to loop through all elements to handle cases like
11099            "\0" and "\0foobar".  */
11100         for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
11101           if (TREE_STRING_POINTER (init)[i] != '\0')
11102             return false;
11103
11104         return true;
11105       }
11106
11107     default:
11108       return false;
11109     }
11110 }
11111
11112 /* Check if vector VEC consists of all the equal elements and
11113    that the number of elements corresponds to the type of VEC.
11114    The function returns first element of the vector
11115    or NULL_TREE if the vector is not uniform.  */
11116 tree
11117 uniform_vector_p (const_tree vec)
11118 {
11119   tree first, t;
11120   unsigned i;
11121
11122   if (vec == NULL_TREE)
11123     return NULL_TREE;
11124
11125   gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
11126
11127   if (TREE_CODE (vec) == VECTOR_CST)
11128     {
11129       first = VECTOR_CST_ELT (vec, 0);
11130       for (i = 1; i < VECTOR_CST_NELTS (vec); ++i)
11131         if (!operand_equal_p (first, VECTOR_CST_ELT (vec, i), 0))
11132           return NULL_TREE;
11133
11134       return first;
11135     }
11136
11137   else if (TREE_CODE (vec) == CONSTRUCTOR)
11138     {
11139       first = error_mark_node;
11140
11141       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t)
11142         {
11143           if (i == 0)
11144             {
11145               first = t;
11146               continue;
11147             }
11148           if (!operand_equal_p (first, t, 0))
11149             return NULL_TREE;
11150         }
11151       if (i != TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)))
11152         return NULL_TREE;
11153
11154       return first;
11155     }
11156
11157   return NULL_TREE;
11158 }
11159
11160 /* Build an empty statement at location LOC.  */
11161
11162 tree
11163 build_empty_stmt (location_t loc)
11164 {
11165   tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
11166   SET_EXPR_LOCATION (t, loc);
11167   return t;
11168 }
11169
11170
11171 /* Build an OpenMP clause with code CODE.  LOC is the location of the
11172    clause.  */
11173
11174 tree
11175 build_omp_clause (location_t loc, enum omp_clause_code code)
11176 {
11177   tree t;
11178   int size, length;
11179
11180   length = omp_clause_num_ops[code];
11181   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
11182
11183   record_node_allocation_statistics (OMP_CLAUSE, size);
11184
11185   t = (tree) ggc_internal_alloc (size);
11186   memset (t, 0, size);
11187   TREE_SET_CODE (t, OMP_CLAUSE);
11188   OMP_CLAUSE_SET_CODE (t, code);
11189   OMP_CLAUSE_LOCATION (t) = loc;
11190
11191   return t;
11192 }
11193
11194 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
11195    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
11196    Except for the CODE and operand count field, other storage for the
11197    object is initialized to zeros.  */
11198
11199 tree
11200 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
11201 {
11202   tree t;
11203   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
11204
11205   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
11206   gcc_assert (len >= 1);
11207
11208   record_node_allocation_statistics (code, length);
11209
11210   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
11211
11212   TREE_SET_CODE (t, code);
11213
11214   /* Can't use TREE_OPERAND to store the length because if checking is
11215      enabled, it will try to check the length before we store it.  :-P  */
11216   t->exp.operands[0] = build_int_cst (sizetype, len);
11217
11218   return t;
11219 }
11220
11221 /* Helper function for build_call_* functions; build a CALL_EXPR with
11222    indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
11223    the argument slots.  */
11224
11225 static tree
11226 build_call_1 (tree return_type, tree fn, int nargs)
11227 {
11228   tree t;
11229
11230   t = build_vl_exp (CALL_EXPR, nargs + 3);
11231   TREE_TYPE (t) = return_type;
11232   CALL_EXPR_FN (t) = fn;
11233   CALL_EXPR_STATIC_CHAIN (t) = NULL;
11234
11235   return t;
11236 }
11237
11238 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11239    FN and a null static chain slot.  NARGS is the number of call arguments
11240    which are specified as "..." arguments.  */
11241
11242 tree
11243 build_call_nary (tree return_type, tree fn, int nargs, ...)
11244 {
11245   tree ret;
11246   va_list args;
11247   va_start (args, nargs);
11248   ret = build_call_valist (return_type, fn, nargs, args);
11249   va_end (args);
11250   return ret;
11251 }
11252
11253 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11254    FN and a null static chain slot.  NARGS is the number of call arguments
11255    which are specified as a va_list ARGS.  */
11256
11257 tree
11258 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
11259 {
11260   tree t;
11261   int i;
11262
11263   t = build_call_1 (return_type, fn, nargs);
11264   for (i = 0; i < nargs; i++)
11265     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
11266   process_call_operands (t);
11267   return t;
11268 }
11269
11270 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11271    FN and a null static chain slot.  NARGS is the number of call arguments
11272    which are specified as a tree array ARGS.  */
11273
11274 tree
11275 build_call_array_loc (location_t loc, tree return_type, tree fn,
11276                       int nargs, const tree *args)
11277 {
11278   tree t;
11279   int i;
11280
11281   t = build_call_1 (return_type, fn, nargs);
11282   for (i = 0; i < nargs; i++)
11283     CALL_EXPR_ARG (t, i) = args[i];
11284   process_call_operands (t);
11285   SET_EXPR_LOCATION (t, loc);
11286   return t;
11287 }
11288
11289 /* Like build_call_array, but takes a vec.  */
11290
11291 tree
11292 build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args)
11293 {
11294   tree ret, t;
11295   unsigned int ix;
11296
11297   ret = build_call_1 (return_type, fn, vec_safe_length (args));
11298   FOR_EACH_VEC_SAFE_ELT (args, ix, t)
11299     CALL_EXPR_ARG (ret, ix) = t;
11300   process_call_operands (ret);
11301   return ret;
11302 }
11303
11304 /* Conveniently construct a function call expression.  FNDECL names the
11305    function to be called and N arguments are passed in the array
11306    ARGARRAY.  */
11307
11308 tree
11309 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
11310 {
11311   tree fntype = TREE_TYPE (fndecl);
11312   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11313
11314   return fold_build_call_array_loc (loc, TREE_TYPE (fntype), fn, n, argarray);
11315 }
11316
11317 /* Conveniently construct a function call expression.  FNDECL names the
11318    function to be called and the arguments are passed in the vector
11319    VEC.  */
11320
11321 tree
11322 build_call_expr_loc_vec (location_t loc, tree fndecl, vec<tree, va_gc> *vec)
11323 {
11324   return build_call_expr_loc_array (loc, fndecl, vec_safe_length (vec),
11325                                     vec_safe_address (vec));
11326 }
11327
11328
11329 /* Conveniently construct a function call expression.  FNDECL names the
11330    function to be called, N is the number of arguments, and the "..."
11331    parameters are the argument expressions.  */
11332
11333 tree
11334 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
11335 {
11336   va_list ap;
11337   tree *argarray = XALLOCAVEC (tree, n);
11338   int i;
11339
11340   va_start (ap, n);
11341   for (i = 0; i < n; i++)
11342     argarray[i] = va_arg (ap, tree);
11343   va_end (ap);
11344   return build_call_expr_loc_array (loc, fndecl, n, argarray);
11345 }
11346
11347 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
11348    varargs macros aren't supported by all bootstrap compilers.  */
11349
11350 tree
11351 build_call_expr (tree fndecl, int n, ...)
11352 {
11353   va_list ap;
11354   tree *argarray = XALLOCAVEC (tree, n);
11355   int i;
11356
11357   va_start (ap, n);
11358   for (i = 0; i < n; i++)
11359     argarray[i] = va_arg (ap, tree);
11360   va_end (ap);
11361   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
11362 }
11363
11364 /* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return
11365    type TYPE.  This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL.
11366    It will get gimplified later into an ordinary internal function.  */
11367
11368 tree
11369 build_call_expr_internal_loc_array (location_t loc, internal_fn ifn,
11370                                     tree type, int n, const tree *args)
11371 {
11372   tree t = build_call_1 (type, NULL_TREE, n);
11373   for (int i = 0; i < n; ++i)
11374     CALL_EXPR_ARG (t, i) = args[i];
11375   SET_EXPR_LOCATION (t, loc);
11376   CALL_EXPR_IFN (t) = ifn;
11377   return t;
11378 }
11379
11380 /* Build internal call expression.  This is just like CALL_EXPR, except
11381    its CALL_EXPR_FN is NULL.  It will get gimplified later into ordinary
11382    internal function.  */
11383
11384 tree
11385 build_call_expr_internal_loc (location_t loc, enum internal_fn ifn,
11386                               tree type, int n, ...)
11387 {
11388   va_list ap;
11389   tree *argarray = XALLOCAVEC (tree, n);
11390   int i;
11391
11392   va_start (ap, n);
11393   for (i = 0; i < n; i++)
11394     argarray[i] = va_arg (ap, tree);
11395   va_end (ap);
11396   return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
11397 }
11398
11399 /* Return a function call to FN, if the target is guaranteed to support it,
11400    or null otherwise.
11401
11402    N is the number of arguments, passed in the "...", and TYPE is the
11403    type of the return value.  */
11404
11405 tree
11406 maybe_build_call_expr_loc (location_t loc, combined_fn fn, tree type,
11407                            int n, ...)
11408 {
11409   va_list ap;
11410   tree *argarray = XALLOCAVEC (tree, n);
11411   int i;
11412
11413   va_start (ap, n);
11414   for (i = 0; i < n; i++)
11415     argarray[i] = va_arg (ap, tree);
11416   va_end (ap);
11417   if (internal_fn_p (fn))
11418     {
11419       internal_fn ifn = as_internal_fn (fn);
11420       if (direct_internal_fn_p (ifn))
11421         {
11422           tree_pair types = direct_internal_fn_types (ifn, type, argarray);
11423           if (!direct_internal_fn_supported_p (ifn, types,
11424                                                OPTIMIZE_FOR_BOTH))
11425             return NULL_TREE;
11426         }
11427       return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
11428     }
11429   else
11430     {
11431       tree fndecl = builtin_decl_implicit (as_builtin_fn (fn));
11432       if (!fndecl)
11433         return NULL_TREE;
11434       return build_call_expr_loc_array (loc, fndecl, n, argarray);
11435     }
11436 }
11437
11438 /* Create a new constant string literal and return a char* pointer to it.
11439    The STRING_CST value is the LEN characters at STR.  */
11440 tree
11441 build_string_literal (int len, const char *str)
11442 {
11443   tree t, elem, index, type;
11444
11445   t = build_string (len, str);
11446   elem = build_type_variant (char_type_node, 1, 0);
11447   index = build_index_type (size_int (len - 1));
11448   type = build_array_type (elem, index);
11449   TREE_TYPE (t) = type;
11450   TREE_CONSTANT (t) = 1;
11451   TREE_READONLY (t) = 1;
11452   TREE_STATIC (t) = 1;
11453
11454   type = build_pointer_type (elem);
11455   t = build1 (ADDR_EXPR, type,
11456               build4 (ARRAY_REF, elem,
11457                       t, integer_zero_node, NULL_TREE, NULL_TREE));
11458   return t;
11459 }
11460
11461
11462
11463 /* Return true if T (assumed to be a DECL) must be assigned a memory
11464    location.  */
11465
11466 bool
11467 needs_to_live_in_memory (const_tree t)
11468 {
11469   return (TREE_ADDRESSABLE (t)
11470           || is_global_var (t)
11471           || (TREE_CODE (t) == RESULT_DECL
11472               && !DECL_BY_REFERENCE (t)
11473               && aggregate_value_p (t, current_function_decl)));
11474 }
11475
11476 /* Return value of a constant X and sign-extend it.  */
11477
11478 HOST_WIDE_INT
11479 int_cst_value (const_tree x)
11480 {
11481   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
11482   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
11483
11484   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
11485   gcc_assert (cst_and_fits_in_hwi (x));
11486
11487   if (bits < HOST_BITS_PER_WIDE_INT)
11488     {
11489       bool negative = ((val >> (bits - 1)) & 1) != 0;
11490       if (negative)
11491         val |= HOST_WIDE_INT_M1U << (bits - 1) << 1;
11492       else
11493         val &= ~(HOST_WIDE_INT_M1U << (bits - 1) << 1);
11494     }
11495
11496   return val;
11497 }
11498
11499 /* If TYPE is an integral or pointer type, return an integer type with
11500    the same precision which is unsigned iff UNSIGNEDP is true, or itself
11501    if TYPE is already an integer type of signedness UNSIGNEDP.  */
11502
11503 tree
11504 signed_or_unsigned_type_for (int unsignedp, tree type)
11505 {
11506   if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp)
11507     return type;
11508
11509   if (TREE_CODE (type) == VECTOR_TYPE)
11510     {
11511       tree inner = TREE_TYPE (type);
11512       tree inner2 = signed_or_unsigned_type_for (unsignedp, inner);
11513       if (!inner2)
11514         return NULL_TREE;
11515       if (inner == inner2)
11516         return type;
11517       return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
11518     }
11519
11520   if (!INTEGRAL_TYPE_P (type)
11521       && !POINTER_TYPE_P (type)
11522       && TREE_CODE (type) != OFFSET_TYPE)
11523     return NULL_TREE;
11524
11525   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
11526 }
11527
11528 /* If TYPE is an integral or pointer type, return an integer type with
11529    the same precision which is unsigned, or itself if TYPE is already an
11530    unsigned integer type.  */
11531
11532 tree
11533 unsigned_type_for (tree type)
11534 {
11535   return signed_or_unsigned_type_for (1, type);
11536 }
11537
11538 /* If TYPE is an integral or pointer type, return an integer type with
11539    the same precision which is signed, or itself if TYPE is already a
11540    signed integer type.  */
11541
11542 tree
11543 signed_type_for (tree type)
11544 {
11545   return signed_or_unsigned_type_for (0, type);
11546 }
11547
11548 /* If TYPE is a vector type, return a signed integer vector type with the
11549    same width and number of subparts. Otherwise return boolean_type_node.  */
11550
11551 tree
11552 truth_type_for (tree type)
11553 {
11554   if (TREE_CODE (type) == VECTOR_TYPE)
11555     {
11556       if (VECTOR_BOOLEAN_TYPE_P (type))
11557         return type;
11558       return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type),
11559                                       GET_MODE_SIZE (TYPE_MODE (type)));
11560     }
11561   else
11562     return boolean_type_node;
11563 }
11564
11565 /* Returns the largest value obtainable by casting something in INNER type to
11566    OUTER type.  */
11567
11568 tree
11569 upper_bound_in_type (tree outer, tree inner)
11570 {
11571   unsigned int det = 0;
11572   unsigned oprec = TYPE_PRECISION (outer);
11573   unsigned iprec = TYPE_PRECISION (inner);
11574   unsigned prec;
11575
11576   /* Compute a unique number for every combination.  */
11577   det |= (oprec > iprec) ? 4 : 0;
11578   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
11579   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
11580
11581   /* Determine the exponent to use.  */
11582   switch (det)
11583     {
11584     case 0:
11585     case 1:
11586       /* oprec <= iprec, outer: signed, inner: don't care.  */
11587       prec = oprec - 1;
11588       break;
11589     case 2:
11590     case 3:
11591       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
11592       prec = oprec;
11593       break;
11594     case 4:
11595       /* oprec > iprec, outer: signed, inner: signed.  */
11596       prec = iprec - 1;
11597       break;
11598     case 5:
11599       /* oprec > iprec, outer: signed, inner: unsigned.  */
11600       prec = iprec;
11601       break;
11602     case 6:
11603       /* oprec > iprec, outer: unsigned, inner: signed.  */
11604       prec = oprec;
11605       break;
11606     case 7:
11607       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
11608       prec = iprec;
11609       break;
11610     default:
11611       gcc_unreachable ();
11612     }
11613
11614   return wide_int_to_tree (outer,
11615                            wi::mask (prec, false, TYPE_PRECISION (outer)));
11616 }
11617
11618 /* Returns the smallest value obtainable by casting something in INNER type to
11619    OUTER type.  */
11620
11621 tree
11622 lower_bound_in_type (tree outer, tree inner)
11623 {
11624   unsigned oprec = TYPE_PRECISION (outer);
11625   unsigned iprec = TYPE_PRECISION (inner);
11626
11627   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
11628      and obtain 0.  */
11629   if (TYPE_UNSIGNED (outer)
11630       /* If we are widening something of an unsigned type, OUTER type
11631          contains all values of INNER type.  In particular, both INNER
11632          and OUTER types have zero in common.  */
11633       || (oprec > iprec && TYPE_UNSIGNED (inner)))
11634     return build_int_cst (outer, 0);
11635   else
11636     {
11637       /* If we are widening a signed type to another signed type, we
11638          want to obtain -2^^(iprec-1).  If we are keeping the
11639          precision or narrowing to a signed type, we want to obtain
11640          -2^(oprec-1).  */
11641       unsigned prec = oprec > iprec ? iprec : oprec;
11642       return wide_int_to_tree (outer,
11643                                wi::mask (prec - 1, true,
11644                                          TYPE_PRECISION (outer)));
11645     }
11646 }
11647
11648 /* Return nonzero if two operands that are suitable for PHI nodes are
11649    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
11650    SSA_NAME or invariant.  Note that this is strictly an optimization.
11651    That is, callers of this function can directly call operand_equal_p
11652    and get the same result, only slower.  */
11653
11654 int
11655 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
11656 {
11657   if (arg0 == arg1)
11658     return 1;
11659   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
11660     return 0;
11661   return operand_equal_p (arg0, arg1, 0);
11662 }
11663
11664 /* Returns number of zeros at the end of binary representation of X.  */
11665
11666 tree
11667 num_ending_zeros (const_tree x)
11668 {
11669   return build_int_cst (TREE_TYPE (x), wi::ctz (x));
11670 }
11671
11672
11673 #define WALK_SUBTREE(NODE)                              \
11674   do                                                    \
11675     {                                                   \
11676       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
11677       if (result)                                       \
11678         return result;                                  \
11679     }                                                   \
11680   while (0)
11681
11682 /* This is a subroutine of walk_tree that walks field of TYPE that are to
11683    be walked whenever a type is seen in the tree.  Rest of operands and return
11684    value are as for walk_tree.  */
11685
11686 static tree
11687 walk_type_fields (tree type, walk_tree_fn func, void *data,
11688                   hash_set<tree> *pset, walk_tree_lh lh)
11689 {
11690   tree result = NULL_TREE;
11691
11692   switch (TREE_CODE (type))
11693     {
11694     case POINTER_TYPE:
11695     case REFERENCE_TYPE:
11696     case VECTOR_TYPE:
11697       /* We have to worry about mutually recursive pointers.  These can't
11698          be written in C.  They can in Ada.  It's pathological, but
11699          there's an ACATS test (c38102a) that checks it.  Deal with this
11700          by checking if we're pointing to another pointer, that one
11701          points to another pointer, that one does too, and we have no htab.
11702          If so, get a hash table.  We check three levels deep to avoid
11703          the cost of the hash table if we don't need one.  */
11704       if (POINTER_TYPE_P (TREE_TYPE (type))
11705           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
11706           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
11707           && !pset)
11708         {
11709           result = walk_tree_without_duplicates (&TREE_TYPE (type),
11710                                                  func, data);
11711           if (result)
11712             return result;
11713
11714           break;
11715         }
11716
11717       /* fall through */
11718
11719     case COMPLEX_TYPE:
11720       WALK_SUBTREE (TREE_TYPE (type));
11721       break;
11722
11723     case METHOD_TYPE:
11724       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
11725
11726       /* Fall through.  */
11727
11728     case FUNCTION_TYPE:
11729       WALK_SUBTREE (TREE_TYPE (type));
11730       {
11731         tree arg;
11732
11733         /* We never want to walk into default arguments.  */
11734         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
11735           WALK_SUBTREE (TREE_VALUE (arg));
11736       }
11737       break;
11738
11739     case ARRAY_TYPE:
11740       /* Don't follow this nodes's type if a pointer for fear that
11741          we'll have infinite recursion.  If we have a PSET, then we
11742          need not fear.  */
11743       if (pset
11744           || (!POINTER_TYPE_P (TREE_TYPE (type))
11745               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
11746         WALK_SUBTREE (TREE_TYPE (type));
11747       WALK_SUBTREE (TYPE_DOMAIN (type));
11748       break;
11749
11750     case OFFSET_TYPE:
11751       WALK_SUBTREE (TREE_TYPE (type));
11752       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
11753       break;
11754
11755     default:
11756       break;
11757     }
11758
11759   return NULL_TREE;
11760 }
11761
11762 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
11763    called with the DATA and the address of each sub-tree.  If FUNC returns a
11764    non-NULL value, the traversal is stopped, and the value returned by FUNC
11765    is returned.  If PSET is non-NULL it is used to record the nodes visited,
11766    and to avoid visiting a node more than once.  */
11767
11768 tree
11769 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
11770              hash_set<tree> *pset, walk_tree_lh lh)
11771 {
11772   enum tree_code code;
11773   int walk_subtrees;
11774   tree result;
11775
11776 #define WALK_SUBTREE_TAIL(NODE)                         \
11777   do                                                    \
11778     {                                                   \
11779        tp = & (NODE);                                   \
11780        goto tail_recurse;                               \
11781     }                                                   \
11782   while (0)
11783
11784  tail_recurse:
11785   /* Skip empty subtrees.  */
11786   if (!*tp)
11787     return NULL_TREE;
11788
11789   /* Don't walk the same tree twice, if the user has requested
11790      that we avoid doing so.  */
11791   if (pset && pset->add (*tp))
11792     return NULL_TREE;
11793
11794   /* Call the function.  */
11795   walk_subtrees = 1;
11796   result = (*func) (tp, &walk_subtrees, data);
11797
11798   /* If we found something, return it.  */
11799   if (result)
11800     return result;
11801
11802   code = TREE_CODE (*tp);
11803
11804   /* Even if we didn't, FUNC may have decided that there was nothing
11805      interesting below this point in the tree.  */
11806   if (!walk_subtrees)
11807     {
11808       /* But we still need to check our siblings.  */
11809       if (code == TREE_LIST)
11810         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11811       else if (code == OMP_CLAUSE)
11812         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11813       else
11814         return NULL_TREE;
11815     }
11816
11817   if (lh)
11818     {
11819       result = (*lh) (tp, &walk_subtrees, func, data, pset);
11820       if (result || !walk_subtrees)
11821         return result;
11822     }
11823
11824   switch (code)
11825     {
11826     case ERROR_MARK:
11827     case IDENTIFIER_NODE:
11828     case INTEGER_CST:
11829     case REAL_CST:
11830     case FIXED_CST:
11831     case VECTOR_CST:
11832     case STRING_CST:
11833     case BLOCK:
11834     case PLACEHOLDER_EXPR:
11835     case SSA_NAME:
11836     case FIELD_DECL:
11837     case RESULT_DECL:
11838       /* None of these have subtrees other than those already walked
11839          above.  */
11840       break;
11841
11842     case TREE_LIST:
11843       WALK_SUBTREE (TREE_VALUE (*tp));
11844       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11845       break;
11846
11847     case TREE_VEC:
11848       {
11849         int len = TREE_VEC_LENGTH (*tp);
11850
11851         if (len == 0)
11852           break;
11853
11854         /* Walk all elements but the first.  */
11855         while (--len)
11856           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
11857
11858         /* Now walk the first one as a tail call.  */
11859         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
11860       }
11861
11862     case COMPLEX_CST:
11863       WALK_SUBTREE (TREE_REALPART (*tp));
11864       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
11865
11866     case CONSTRUCTOR:
11867       {
11868         unsigned HOST_WIDE_INT idx;
11869         constructor_elt *ce;
11870
11871         for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
11872              idx++)
11873           WALK_SUBTREE (ce->value);
11874       }
11875       break;
11876
11877     case SAVE_EXPR:
11878       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
11879
11880     case BIND_EXPR:
11881       {
11882         tree decl;
11883         for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
11884           {
11885             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
11886                into declarations that are just mentioned, rather than
11887                declared; they don't really belong to this part of the tree.
11888                And, we can see cycles: the initializer for a declaration
11889                can refer to the declaration itself.  */
11890             WALK_SUBTREE (DECL_INITIAL (decl));
11891             WALK_SUBTREE (DECL_SIZE (decl));
11892             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
11893           }
11894         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
11895       }
11896
11897     case STATEMENT_LIST:
11898       {
11899         tree_stmt_iterator i;
11900         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
11901           WALK_SUBTREE (*tsi_stmt_ptr (i));
11902       }
11903       break;
11904
11905     case OMP_CLAUSE:
11906       switch (OMP_CLAUSE_CODE (*tp))
11907         {
11908         case OMP_CLAUSE_GANG:
11909         case OMP_CLAUSE__GRIDDIM_:
11910           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11911           /* FALLTHRU */
11912
11913         case OMP_CLAUSE_ASYNC:
11914         case OMP_CLAUSE_WAIT:
11915         case OMP_CLAUSE_WORKER:
11916         case OMP_CLAUSE_VECTOR:
11917         case OMP_CLAUSE_NUM_GANGS:
11918         case OMP_CLAUSE_NUM_WORKERS:
11919         case OMP_CLAUSE_VECTOR_LENGTH:
11920         case OMP_CLAUSE_PRIVATE:
11921         case OMP_CLAUSE_SHARED:
11922         case OMP_CLAUSE_FIRSTPRIVATE:
11923         case OMP_CLAUSE_COPYIN:
11924         case OMP_CLAUSE_COPYPRIVATE:
11925         case OMP_CLAUSE_FINAL:
11926         case OMP_CLAUSE_IF:
11927         case OMP_CLAUSE_NUM_THREADS:
11928         case OMP_CLAUSE_SCHEDULE:
11929         case OMP_CLAUSE_UNIFORM:
11930         case OMP_CLAUSE_DEPEND:
11931         case OMP_CLAUSE_NUM_TEAMS:
11932         case OMP_CLAUSE_THREAD_LIMIT:
11933         case OMP_CLAUSE_DEVICE:
11934         case OMP_CLAUSE_DIST_SCHEDULE:
11935         case OMP_CLAUSE_SAFELEN:
11936         case OMP_CLAUSE_SIMDLEN:
11937         case OMP_CLAUSE_ORDERED:
11938         case OMP_CLAUSE_PRIORITY:
11939         case OMP_CLAUSE_GRAINSIZE:
11940         case OMP_CLAUSE_NUM_TASKS:
11941         case OMP_CLAUSE_HINT:
11942         case OMP_CLAUSE_TO_DECLARE:
11943         case OMP_CLAUSE_LINK:
11944         case OMP_CLAUSE_USE_DEVICE_PTR:
11945         case OMP_CLAUSE_IS_DEVICE_PTR:
11946         case OMP_CLAUSE__LOOPTEMP_:
11947         case OMP_CLAUSE__SIMDUID_:
11948         case OMP_CLAUSE__CILK_FOR_COUNT_:
11949           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
11950           /* FALLTHRU */
11951
11952         case OMP_CLAUSE_INDEPENDENT:
11953         case OMP_CLAUSE_NOWAIT:
11954         case OMP_CLAUSE_DEFAULT:
11955         case OMP_CLAUSE_UNTIED:
11956         case OMP_CLAUSE_MERGEABLE:
11957         case OMP_CLAUSE_PROC_BIND:
11958         case OMP_CLAUSE_INBRANCH:
11959         case OMP_CLAUSE_NOTINBRANCH:
11960         case OMP_CLAUSE_FOR:
11961         case OMP_CLAUSE_PARALLEL:
11962         case OMP_CLAUSE_SECTIONS:
11963         case OMP_CLAUSE_TASKGROUP:
11964         case OMP_CLAUSE_NOGROUP:
11965         case OMP_CLAUSE_THREADS:
11966         case OMP_CLAUSE_SIMD:
11967         case OMP_CLAUSE_DEFAULTMAP:
11968         case OMP_CLAUSE_AUTO:
11969         case OMP_CLAUSE_SEQ:
11970         case OMP_CLAUSE_TILE:
11971         case OMP_CLAUSE__SIMT_:
11972           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11973
11974         case OMP_CLAUSE_LASTPRIVATE:
11975           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11976           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
11977           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11978
11979         case OMP_CLAUSE_COLLAPSE:
11980           {
11981             int i;
11982             for (i = 0; i < 3; i++)
11983               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11984             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11985           }
11986
11987         case OMP_CLAUSE_LINEAR:
11988           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11989           WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp));
11990           WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp));
11991           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11992
11993         case OMP_CLAUSE_ALIGNED:
11994         case OMP_CLAUSE_FROM:
11995         case OMP_CLAUSE_TO:
11996         case OMP_CLAUSE_MAP:
11997         case OMP_CLAUSE__CACHE_:
11998           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11999           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
12000           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12001
12002         case OMP_CLAUSE_REDUCTION:
12003           {
12004             int i;
12005             for (i = 0; i < 5; i++)
12006               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
12007             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12008           }
12009
12010         default:
12011           gcc_unreachable ();
12012         }
12013       break;
12014
12015     case TARGET_EXPR:
12016       {
12017         int i, len;
12018
12019         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
12020            But, we only want to walk once.  */
12021         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
12022         for (i = 0; i < len; ++i)
12023           WALK_SUBTREE (TREE_OPERAND (*tp, i));
12024         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
12025       }
12026
12027     case DECL_EXPR:
12028       /* If this is a TYPE_DECL, walk into the fields of the type that it's
12029          defining.  We only want to walk into these fields of a type in this
12030          case and not in the general case of a mere reference to the type.
12031
12032          The criterion is as follows: if the field can be an expression, it
12033          must be walked only here.  This should be in keeping with the fields
12034          that are directly gimplified in gimplify_type_sizes in order for the
12035          mark/copy-if-shared/unmark machinery of the gimplifier to work with
12036          variable-sized types.
12037
12038          Note that DECLs get walked as part of processing the BIND_EXPR.  */
12039       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
12040         {
12041           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
12042           if (TREE_CODE (*type_p) == ERROR_MARK)
12043             return NULL_TREE;
12044
12045           /* Call the function for the type.  See if it returns anything or
12046              doesn't want us to continue.  If we are to continue, walk both
12047              the normal fields and those for the declaration case.  */
12048           result = (*func) (type_p, &walk_subtrees, data);
12049           if (result || !walk_subtrees)
12050             return result;
12051
12052           /* But do not walk a pointed-to type since it may itself need to
12053              be walked in the declaration case if it isn't anonymous.  */
12054           if (!POINTER_TYPE_P (*type_p))
12055             {
12056               result = walk_type_fields (*type_p, func, data, pset, lh);
12057               if (result)
12058                 return result;
12059             }
12060
12061           /* If this is a record type, also walk the fields.  */
12062           if (RECORD_OR_UNION_TYPE_P (*type_p))
12063             {
12064               tree field;
12065
12066               for (field = TYPE_FIELDS (*type_p); field;
12067                    field = DECL_CHAIN (field))
12068                 {
12069                   /* We'd like to look at the type of the field, but we can
12070                      easily get infinite recursion.  So assume it's pointed
12071                      to elsewhere in the tree.  Also, ignore things that
12072                      aren't fields.  */
12073                   if (TREE_CODE (field) != FIELD_DECL)
12074                     continue;
12075
12076                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
12077                   WALK_SUBTREE (DECL_SIZE (field));
12078                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
12079                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
12080                     WALK_SUBTREE (DECL_QUALIFIER (field));
12081                 }
12082             }
12083
12084           /* Same for scalar types.  */
12085           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
12086                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
12087                    || TREE_CODE (*type_p) == INTEGER_TYPE
12088                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
12089                    || TREE_CODE (*type_p) == REAL_TYPE)
12090             {
12091               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
12092               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
12093             }
12094
12095           WALK_SUBTREE (TYPE_SIZE (*type_p));
12096           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
12097         }
12098       /* FALLTHRU */
12099
12100     default:
12101       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
12102         {
12103           int i, len;
12104
12105           /* Walk over all the sub-trees of this operand.  */
12106           len = TREE_OPERAND_LENGTH (*tp);
12107
12108           /* Go through the subtrees.  We need to do this in forward order so
12109              that the scope of a FOR_EXPR is handled properly.  */
12110           if (len)
12111             {
12112               for (i = 0; i < len - 1; ++i)
12113                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
12114               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
12115             }
12116         }
12117       /* If this is a type, walk the needed fields in the type.  */
12118       else if (TYPE_P (*tp))
12119         return walk_type_fields (*tp, func, data, pset, lh);
12120       break;
12121     }
12122
12123   /* We didn't find what we were looking for.  */
12124   return NULL_TREE;
12125
12126 #undef WALK_SUBTREE_TAIL
12127 }
12128 #undef WALK_SUBTREE
12129
12130 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
12131
12132 tree
12133 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
12134                                 walk_tree_lh lh)
12135 {
12136   tree result;
12137
12138   hash_set<tree> pset;
12139   result = walk_tree_1 (tp, func, data, &pset, lh);
12140   return result;
12141 }
12142
12143
12144 tree
12145 tree_block (tree t)
12146 {
12147   const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
12148
12149   if (IS_EXPR_CODE_CLASS (c))
12150     return LOCATION_BLOCK (t->exp.locus);
12151   gcc_unreachable ();
12152   return NULL;
12153 }
12154
12155 void
12156 tree_set_block (tree t, tree b)
12157 {
12158   const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
12159
12160   if (IS_EXPR_CODE_CLASS (c))
12161     {
12162       t->exp.locus = set_block (t->exp.locus, b);
12163     }
12164   else
12165     gcc_unreachable ();
12166 }
12167
12168 /* Create a nameless artificial label and put it in the current
12169    function context.  The label has a location of LOC.  Returns the
12170    newly created label.  */
12171
12172 tree
12173 create_artificial_label (location_t loc)
12174 {
12175   tree lab = build_decl (loc,
12176                          LABEL_DECL, NULL_TREE, void_type_node);
12177
12178   DECL_ARTIFICIAL (lab) = 1;
12179   DECL_IGNORED_P (lab) = 1;
12180   DECL_CONTEXT (lab) = current_function_decl;
12181   return lab;
12182 }
12183
12184 /*  Given a tree, try to return a useful variable name that we can use
12185     to prefix a temporary that is being assigned the value of the tree.
12186     I.E. given  <temp> = &A, return A.  */
12187
12188 const char *
12189 get_name (tree t)
12190 {
12191   tree stripped_decl;
12192
12193   stripped_decl = t;
12194   STRIP_NOPS (stripped_decl);
12195   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
12196     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
12197   else if (TREE_CODE (stripped_decl) == SSA_NAME)
12198     {
12199       tree name = SSA_NAME_IDENTIFIER (stripped_decl);
12200       if (!name)
12201         return NULL;
12202       return IDENTIFIER_POINTER (name);
12203     }
12204   else
12205     {
12206       switch (TREE_CODE (stripped_decl))
12207         {
12208         case ADDR_EXPR:
12209           return get_name (TREE_OPERAND (stripped_decl, 0));
12210         default:
12211           return NULL;
12212         }
12213     }
12214 }
12215
12216 /* Return true if TYPE has a variable argument list.  */
12217
12218 bool
12219 stdarg_p (const_tree fntype)
12220 {
12221   function_args_iterator args_iter;
12222   tree n = NULL_TREE, t;
12223
12224   if (!fntype)
12225     return false;
12226
12227   FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
12228     {
12229       n = t;
12230     }
12231
12232   return n != NULL_TREE && n != void_type_node;
12233 }
12234
12235 /* Return true if TYPE has a prototype.  */
12236
12237 bool
12238 prototype_p (const_tree fntype)
12239 {
12240   tree t;
12241
12242   gcc_assert (fntype != NULL_TREE);
12243
12244   t = TYPE_ARG_TYPES (fntype);
12245   return (t != NULL_TREE);
12246 }
12247
12248 /* If BLOCK is inlined from an __attribute__((__artificial__))
12249    routine, return pointer to location from where it has been
12250    called.  */
12251 location_t *
12252 block_nonartificial_location (tree block)
12253 {
12254   location_t *ret = NULL;
12255
12256   while (block && TREE_CODE (block) == BLOCK
12257          && BLOCK_ABSTRACT_ORIGIN (block))
12258     {
12259       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
12260
12261       while (TREE_CODE (ao) == BLOCK
12262              && BLOCK_ABSTRACT_ORIGIN (ao)
12263              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
12264         ao = BLOCK_ABSTRACT_ORIGIN (ao);
12265
12266       if (TREE_CODE (ao) == FUNCTION_DECL)
12267         {
12268           /* If AO is an artificial inline, point RET to the
12269              call site locus at which it has been inlined and continue
12270              the loop, in case AO's caller is also an artificial
12271              inline.  */
12272           if (DECL_DECLARED_INLINE_P (ao)
12273               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
12274             ret = &BLOCK_SOURCE_LOCATION (block);
12275           else
12276             break;
12277         }
12278       else if (TREE_CODE (ao) != BLOCK)
12279         break;
12280
12281       block = BLOCK_SUPERCONTEXT (block);
12282     }
12283   return ret;
12284 }
12285
12286
12287 /* If EXP is inlined from an __attribute__((__artificial__))
12288    function, return the location of the original call expression.  */
12289
12290 location_t
12291 tree_nonartificial_location (tree exp)
12292 {
12293   location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
12294
12295   if (loc)
12296     return *loc;
12297   else
12298     return EXPR_LOCATION (exp);
12299 }
12300
12301
12302 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
12303    nodes.  */
12304
12305 /* Return the hash code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
12306
12307 hashval_t
12308 cl_option_hasher::hash (tree x)
12309 {
12310   const_tree const t = x;
12311   const char *p;
12312   size_t i;
12313   size_t len = 0;
12314   hashval_t hash = 0;
12315
12316   if (TREE_CODE (t) == OPTIMIZATION_NODE)
12317     {
12318       p = (const char *)TREE_OPTIMIZATION (t);
12319       len = sizeof (struct cl_optimization);
12320     }
12321
12322   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
12323     return cl_target_option_hash (TREE_TARGET_OPTION (t));
12324
12325   else
12326     gcc_unreachable ();
12327
12328   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
12329      something else.  */
12330   for (i = 0; i < len; i++)
12331     if (p[i])
12332       hash = (hash << 4) ^ ((i << 2) | p[i]);
12333
12334   return hash;
12335 }
12336
12337 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
12338    TARGET_OPTION tree node) is the same as that given by *Y, which is the
12339    same.  */
12340
12341 bool
12342 cl_option_hasher::equal (tree x, tree y)
12343 {
12344   const_tree const xt = x;
12345   const_tree const yt = y;
12346   const char *xp;
12347   const char *yp;
12348   size_t len;
12349
12350   if (TREE_CODE (xt) != TREE_CODE (yt))
12351     return 0;
12352
12353   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
12354     {
12355       xp = (const char *)TREE_OPTIMIZATION (xt);
12356       yp = (const char *)TREE_OPTIMIZATION (yt);
12357       len = sizeof (struct cl_optimization);
12358     }
12359
12360   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
12361     {
12362       return cl_target_option_eq (TREE_TARGET_OPTION (xt),
12363                                   TREE_TARGET_OPTION (yt));
12364     }
12365
12366   else
12367     gcc_unreachable ();
12368
12369   return (memcmp (xp, yp, len) == 0);
12370 }
12371
12372 /* Build an OPTIMIZATION_NODE based on the options in OPTS.  */
12373
12374 tree
12375 build_optimization_node (struct gcc_options *opts)
12376 {
12377   tree t;
12378
12379   /* Use the cache of optimization nodes.  */
12380
12381   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
12382                         opts);
12383
12384   tree *slot = cl_option_hash_table->find_slot (cl_optimization_node, INSERT);
12385   t = *slot;
12386   if (!t)
12387     {
12388       /* Insert this one into the hash table.  */
12389       t = cl_optimization_node;
12390       *slot = t;
12391
12392       /* Make a new node for next time round.  */
12393       cl_optimization_node = make_node (OPTIMIZATION_NODE);
12394     }
12395
12396   return t;
12397 }
12398
12399 /* Build a TARGET_OPTION_NODE based on the options in OPTS.  */
12400
12401 tree
12402 build_target_option_node (struct gcc_options *opts)
12403 {
12404   tree t;
12405
12406   /* Use the cache of optimization nodes.  */
12407
12408   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
12409                          opts);
12410
12411   tree *slot = cl_option_hash_table->find_slot (cl_target_option_node, INSERT);
12412   t = *slot;
12413   if (!t)
12414     {
12415       /* Insert this one into the hash table.  */
12416       t = cl_target_option_node;
12417       *slot = t;
12418
12419       /* Make a new node for next time round.  */
12420       cl_target_option_node = make_node (TARGET_OPTION_NODE);
12421     }
12422
12423   return t;
12424 }
12425
12426 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
12427    so that they aren't saved during PCH writing.  */
12428
12429 void
12430 prepare_target_option_nodes_for_pch (void)
12431 {
12432   hash_table<cl_option_hasher>::iterator iter = cl_option_hash_table->begin ();
12433   for (; iter != cl_option_hash_table->end (); ++iter)
12434     if (TREE_CODE (*iter) == TARGET_OPTION_NODE)
12435       TREE_TARGET_GLOBALS (*iter) = NULL;
12436 }
12437
12438 /* Determine the "ultimate origin" of a block.  The block may be an inlined
12439    instance of an inlined instance of a block which is local to an inline
12440    function, so we have to trace all of the way back through the origin chain
12441    to find out what sort of node actually served as the original seed for the
12442    given block.  */
12443
12444 tree
12445 block_ultimate_origin (const_tree block)
12446 {
12447   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
12448
12449   /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
12450      we're trying to output the abstract instance of this function.  */
12451   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
12452     return NULL_TREE;
12453
12454   if (immediate_origin == NULL_TREE)
12455     return NULL_TREE;
12456   else
12457     {
12458       tree ret_val;
12459       tree lookahead = immediate_origin;
12460
12461       do
12462         {
12463           ret_val = lookahead;
12464           lookahead = (TREE_CODE (ret_val) == BLOCK
12465                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
12466         }
12467       while (lookahead != NULL && lookahead != ret_val);
12468
12469       /* The block's abstract origin chain may not be the *ultimate* origin of
12470          the block. It could lead to a DECL that has an abstract origin set.
12471          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
12472          will give us if it has one).  Note that DECL's abstract origins are
12473          supposed to be the most distant ancestor (or so decl_ultimate_origin
12474          claims), so we don't need to loop following the DECL origins.  */
12475       if (DECL_P (ret_val))
12476         return DECL_ORIGIN (ret_val);
12477
12478       return ret_val;
12479     }
12480 }
12481
12482 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
12483    no instruction.  */
12484
12485 bool
12486 tree_nop_conversion_p (const_tree outer_type, const_tree inner_type)
12487 {
12488   /* Do not strip casts into or out of differing address spaces.  */
12489   if (POINTER_TYPE_P (outer_type)
12490       && TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) != ADDR_SPACE_GENERIC)
12491     {
12492       if (!POINTER_TYPE_P (inner_type)
12493           || (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
12494               != TYPE_ADDR_SPACE (TREE_TYPE (inner_type))))
12495         return false;
12496     }
12497   else if (POINTER_TYPE_P (inner_type)
12498            && TYPE_ADDR_SPACE (TREE_TYPE (inner_type)) != ADDR_SPACE_GENERIC)
12499     {
12500       /* We already know that outer_type is not a pointer with
12501          a non-generic address space.  */
12502       return false;
12503     }
12504
12505   /* Use precision rather then machine mode when we can, which gives
12506      the correct answer even for submode (bit-field) types.  */
12507   if ((INTEGRAL_TYPE_P (outer_type)
12508        || POINTER_TYPE_P (outer_type)
12509        || TREE_CODE (outer_type) == OFFSET_TYPE)
12510       && (INTEGRAL_TYPE_P (inner_type)
12511           || POINTER_TYPE_P (inner_type)
12512           || TREE_CODE (inner_type) == OFFSET_TYPE))
12513     return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
12514
12515   /* Otherwise fall back on comparing machine modes (e.g. for
12516      aggregate types, floats).  */
12517   return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
12518 }
12519
12520 /* Return true iff conversion in EXP generates no instruction.  Mark
12521    it inline so that we fully inline into the stripping functions even
12522    though we have two uses of this function.  */
12523
12524 static inline bool
12525 tree_nop_conversion (const_tree exp)
12526 {
12527   tree outer_type, inner_type;
12528
12529   if (!CONVERT_EXPR_P (exp)
12530       && TREE_CODE (exp) != NON_LVALUE_EXPR)
12531     return false;
12532   if (TREE_OPERAND (exp, 0) == error_mark_node)
12533     return false;
12534
12535   outer_type = TREE_TYPE (exp);
12536   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12537
12538   if (!inner_type)
12539     return false;
12540
12541   return tree_nop_conversion_p (outer_type, inner_type);
12542 }
12543
12544 /* Return true iff conversion in EXP generates no instruction.  Don't
12545    consider conversions changing the signedness.  */
12546
12547 static bool
12548 tree_sign_nop_conversion (const_tree exp)
12549 {
12550   tree outer_type, inner_type;
12551
12552   if (!tree_nop_conversion (exp))
12553     return false;
12554
12555   outer_type = TREE_TYPE (exp);
12556   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12557
12558   return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
12559           && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
12560 }
12561
12562 /* Strip conversions from EXP according to tree_nop_conversion and
12563    return the resulting expression.  */
12564
12565 tree
12566 tree_strip_nop_conversions (tree exp)
12567 {
12568   while (tree_nop_conversion (exp))
12569     exp = TREE_OPERAND (exp, 0);
12570   return exp;
12571 }
12572
12573 /* Strip conversions from EXP according to tree_sign_nop_conversion
12574    and return the resulting expression.  */
12575
12576 tree
12577 tree_strip_sign_nop_conversions (tree exp)
12578 {
12579   while (tree_sign_nop_conversion (exp))
12580     exp = TREE_OPERAND (exp, 0);
12581   return exp;
12582 }
12583
12584 /* Avoid any floating point extensions from EXP.  */
12585 tree
12586 strip_float_extensions (tree exp)
12587 {
12588   tree sub, expt, subt;
12589
12590   /*  For floating point constant look up the narrowest type that can hold
12591       it properly and handle it like (type)(narrowest_type)constant.
12592       This way we can optimize for instance a=a*2.0 where "a" is float
12593       but 2.0 is double constant.  */
12594   if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
12595     {
12596       REAL_VALUE_TYPE orig;
12597       tree type = NULL;
12598
12599       orig = TREE_REAL_CST (exp);
12600       if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
12601           && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
12602         type = float_type_node;
12603       else if (TYPE_PRECISION (TREE_TYPE (exp))
12604                > TYPE_PRECISION (double_type_node)
12605                && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
12606         type = double_type_node;
12607       if (type)
12608         return build_real_truncate (type, orig);
12609     }
12610
12611   if (!CONVERT_EXPR_P (exp))
12612     return exp;
12613
12614   sub = TREE_OPERAND (exp, 0);
12615   subt = TREE_TYPE (sub);
12616   expt = TREE_TYPE (exp);
12617
12618   if (!FLOAT_TYPE_P (subt))
12619     return exp;
12620
12621   if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
12622     return exp;
12623
12624   if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
12625     return exp;
12626
12627   return strip_float_extensions (sub);
12628 }
12629
12630 /* Strip out all handled components that produce invariant
12631    offsets.  */
12632
12633 const_tree
12634 strip_invariant_refs (const_tree op)
12635 {
12636   while (handled_component_p (op))
12637     {
12638       switch (TREE_CODE (op))
12639         {
12640         case ARRAY_REF:
12641         case ARRAY_RANGE_REF:
12642           if (!is_gimple_constant (TREE_OPERAND (op, 1))
12643               || TREE_OPERAND (op, 2) != NULL_TREE
12644               || TREE_OPERAND (op, 3) != NULL_TREE)
12645             return NULL;
12646           break;
12647
12648         case COMPONENT_REF:
12649           if (TREE_OPERAND (op, 2) != NULL_TREE)
12650             return NULL;
12651           break;
12652
12653         default:;
12654         }
12655       op = TREE_OPERAND (op, 0);
12656     }
12657
12658   return op;
12659 }
12660
12661 static GTY(()) tree gcc_eh_personality_decl;
12662
12663 /* Return the GCC personality function decl.  */
12664
12665 tree
12666 lhd_gcc_personality (void)
12667 {
12668   if (!gcc_eh_personality_decl)
12669     gcc_eh_personality_decl = build_personality_function ("gcc");
12670   return gcc_eh_personality_decl;
12671 }
12672
12673 /* TARGET is a call target of GIMPLE call statement
12674    (obtained by gimple_call_fn).  Return true if it is
12675    OBJ_TYPE_REF representing an virtual call of C++ method.
12676    (As opposed to OBJ_TYPE_REF representing objc calls
12677    through a cast where middle-end devirtualization machinery
12678    can't apply.) */
12679
12680 bool
12681 virtual_method_call_p (const_tree target)
12682 {
12683   if (TREE_CODE (target) != OBJ_TYPE_REF)
12684     return false;
12685   tree t = TREE_TYPE (target);
12686   gcc_checking_assert (TREE_CODE (t) == POINTER_TYPE);
12687   t = TREE_TYPE (t);
12688   if (TREE_CODE (t) == FUNCTION_TYPE)
12689     return false;
12690   gcc_checking_assert (TREE_CODE (t) == METHOD_TYPE);
12691   /* If we do not have BINFO associated, it means that type was built
12692      without devirtualization enabled.  Do not consider this a virtual
12693      call.  */
12694   if (!TYPE_BINFO (obj_type_ref_class (target)))
12695     return false;
12696   return true;
12697 }
12698
12699 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to.  */
12700
12701 tree
12702 obj_type_ref_class (const_tree ref)
12703 {
12704   gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
12705   ref = TREE_TYPE (ref);
12706   gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12707   ref = TREE_TYPE (ref);
12708   /* We look for type THIS points to.  ObjC also builds
12709      OBJ_TYPE_REF with non-method calls, Their first parameter
12710      ID however also corresponds to class type. */
12711   gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
12712                        || TREE_CODE (ref) == FUNCTION_TYPE);
12713   ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
12714   gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12715   return TREE_TYPE (ref);
12716 }
12717
12718 /* Lookup sub-BINFO of BINFO of TYPE at offset POS.  */
12719
12720 static tree
12721 lookup_binfo_at_offset (tree binfo, tree type, HOST_WIDE_INT pos)
12722 {
12723   unsigned int i;
12724   tree base_binfo, b;
12725
12726   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12727     if (pos == tree_to_shwi (BINFO_OFFSET (base_binfo))
12728         && types_same_for_odr (TREE_TYPE (base_binfo), type))
12729       return base_binfo;
12730     else if ((b = lookup_binfo_at_offset (base_binfo, type, pos)) != NULL)
12731       return b;
12732   return NULL;
12733 }
12734
12735 /* Try to find a base info of BINFO that would have its field decl at offset
12736    OFFSET within the BINFO type and which is of EXPECTED_TYPE.  If it can be
12737    found, return, otherwise return NULL_TREE.  */
12738
12739 tree
12740 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
12741 {
12742   tree type = BINFO_TYPE (binfo);
12743
12744   while (true)
12745     {
12746       HOST_WIDE_INT pos, size;
12747       tree fld;
12748       int i;
12749
12750       if (types_same_for_odr (type, expected_type))
12751           return binfo;
12752       if (offset < 0)
12753         return NULL_TREE;
12754
12755       for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
12756         {
12757           if (TREE_CODE (fld) != FIELD_DECL || !DECL_ARTIFICIAL (fld))
12758             continue;
12759
12760           pos = int_bit_position (fld);
12761           size = tree_to_uhwi (DECL_SIZE (fld));
12762           if (pos <= offset && (pos + size) > offset)
12763             break;
12764         }
12765       if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
12766         return NULL_TREE;
12767
12768       /* Offset 0 indicates the primary base, whose vtable contents are
12769          represented in the binfo for the derived class.  */
12770       else if (offset != 0)
12771         {
12772           tree found_binfo = NULL, base_binfo;
12773           /* Offsets in BINFO are in bytes relative to the whole structure
12774              while POS is in bits relative to the containing field.  */
12775           int binfo_offset = (tree_to_shwi (BINFO_OFFSET (binfo)) + pos
12776                              / BITS_PER_UNIT);
12777
12778           for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12779             if (tree_to_shwi (BINFO_OFFSET (base_binfo)) == binfo_offset
12780                 && types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld)))
12781               {
12782                 found_binfo = base_binfo;
12783                 break;
12784               }
12785           if (found_binfo)
12786             binfo = found_binfo;
12787           else
12788             binfo = lookup_binfo_at_offset (binfo, TREE_TYPE (fld),
12789                                             binfo_offset);
12790          }
12791
12792       type = TREE_TYPE (fld);
12793       offset -= pos;
12794     }
12795 }
12796
12797 /* Returns true if X is a typedef decl.  */
12798
12799 bool
12800 is_typedef_decl (const_tree x)
12801 {
12802   return (x && TREE_CODE (x) == TYPE_DECL
12803           && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
12804 }
12805
12806 /* Returns true iff TYPE is a type variant created for a typedef. */
12807
12808 bool
12809 typedef_variant_p (const_tree type)
12810 {
12811   return is_typedef_decl (TYPE_NAME (type));
12812 }
12813
12814 /* Warn about a use of an identifier which was marked deprecated.  */
12815 void
12816 warn_deprecated_use (tree node, tree attr)
12817 {
12818   const char *msg;
12819
12820   if (node == 0 || !warn_deprecated_decl)
12821     return;
12822
12823   if (!attr)
12824     {
12825       if (DECL_P (node))
12826         attr = DECL_ATTRIBUTES (node);
12827       else if (TYPE_P (node))
12828         {
12829           tree decl = TYPE_STUB_DECL (node);
12830           if (decl)
12831             attr = lookup_attribute ("deprecated",
12832                                      TYPE_ATTRIBUTES (TREE_TYPE (decl)));
12833         }
12834     }
12835
12836   if (attr)
12837     attr = lookup_attribute ("deprecated", attr);
12838
12839   if (attr)
12840     msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
12841   else
12842     msg = NULL;
12843
12844   bool w;
12845   if (DECL_P (node))
12846     {
12847       if (msg)
12848         w = warning (OPT_Wdeprecated_declarations,
12849                      "%qD is deprecated: %s", node, msg);
12850       else
12851         w = warning (OPT_Wdeprecated_declarations,
12852                      "%qD is deprecated", node);
12853       if (w)
12854         inform (DECL_SOURCE_LOCATION (node), "declared here");
12855     }
12856   else if (TYPE_P (node))
12857     {
12858       tree what = NULL_TREE;
12859       tree decl = TYPE_STUB_DECL (node);
12860
12861       if (TYPE_NAME (node))
12862         {
12863           if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
12864             what = TYPE_NAME (node);
12865           else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
12866                    && DECL_NAME (TYPE_NAME (node)))
12867             what = DECL_NAME (TYPE_NAME (node));
12868         }
12869
12870       if (decl)
12871         {
12872           if (what)
12873             {
12874               if (msg)
12875                 w = warning (OPT_Wdeprecated_declarations,
12876                              "%qE is deprecated: %s", what, msg);
12877               else
12878                 w = warning (OPT_Wdeprecated_declarations,
12879                              "%qE is deprecated", what);
12880             }
12881           else
12882             {
12883               if (msg)
12884                 w = warning (OPT_Wdeprecated_declarations,
12885                              "type is deprecated: %s", msg);
12886               else
12887                 w = warning (OPT_Wdeprecated_declarations,
12888                              "type is deprecated");
12889             }
12890           if (w)
12891             inform (DECL_SOURCE_LOCATION (decl), "declared here");
12892         }
12893       else
12894         {
12895           if (what)
12896             {
12897               if (msg)
12898                 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
12899                          what, msg);
12900               else
12901                 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
12902             }
12903           else
12904             {
12905               if (msg)
12906                 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
12907                          msg);
12908               else
12909                 warning (OPT_Wdeprecated_declarations, "type is deprecated");
12910             }
12911         }
12912     }
12913 }
12914
12915 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12916    somewhere in it.  */
12917
12918 bool
12919 contains_bitfld_component_ref_p (const_tree ref)
12920 {
12921   while (handled_component_p (ref))
12922     {
12923       if (TREE_CODE (ref) == COMPONENT_REF
12924           && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
12925         return true;
12926       ref = TREE_OPERAND (ref, 0);
12927     }
12928
12929   return false;
12930 }
12931
12932 /* Try to determine whether a TRY_CATCH expression can fall through.
12933    This is a subroutine of block_may_fallthru.  */
12934
12935 static bool
12936 try_catch_may_fallthru (const_tree stmt)
12937 {
12938   tree_stmt_iterator i;
12939
12940   /* If the TRY block can fall through, the whole TRY_CATCH can
12941      fall through.  */
12942   if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
12943     return true;
12944
12945   i = tsi_start (TREE_OPERAND (stmt, 1));
12946   switch (TREE_CODE (tsi_stmt (i)))
12947     {
12948     case CATCH_EXPR:
12949       /* We expect to see a sequence of CATCH_EXPR trees, each with a
12950          catch expression and a body.  The whole TRY_CATCH may fall
12951          through iff any of the catch bodies falls through.  */
12952       for (; !tsi_end_p (i); tsi_next (&i))
12953         {
12954           if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
12955             return true;
12956         }
12957       return false;
12958
12959     case EH_FILTER_EXPR:
12960       /* The exception filter expression only matters if there is an
12961          exception.  If the exception does not match EH_FILTER_TYPES,
12962          we will execute EH_FILTER_FAILURE, and we will fall through
12963          if that falls through.  If the exception does match
12964          EH_FILTER_TYPES, the stack unwinder will continue up the
12965          stack, so we will not fall through.  We don't know whether we
12966          will throw an exception which matches EH_FILTER_TYPES or not,
12967          so we just ignore EH_FILTER_TYPES and assume that we might
12968          throw an exception which doesn't match.  */
12969       return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
12970
12971     default:
12972       /* This case represents statements to be executed when an
12973          exception occurs.  Those statements are implicitly followed
12974          by a RESX statement to resume execution after the exception.
12975          So in this case the TRY_CATCH never falls through.  */
12976       return false;
12977     }
12978 }
12979
12980 /* Try to determine if we can fall out of the bottom of BLOCK.  This guess
12981    need not be 100% accurate; simply be conservative and return true if we
12982    don't know.  This is used only to avoid stupidly generating extra code.
12983    If we're wrong, we'll just delete the extra code later.  */
12984
12985 bool
12986 block_may_fallthru (const_tree block)
12987 {
12988   /* This CONST_CAST is okay because expr_last returns its argument
12989      unmodified and we assign it to a const_tree.  */
12990   const_tree stmt = expr_last (CONST_CAST_TREE (block));
12991
12992   switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
12993     {
12994     case GOTO_EXPR:
12995     case RETURN_EXPR:
12996       /* Easy cases.  If the last statement of the block implies
12997          control transfer, then we can't fall through.  */
12998       return false;
12999
13000     case SWITCH_EXPR:
13001       /* If SWITCH_LABELS is set, this is lowered, and represents a
13002          branch to a selected label and hence can not fall through.
13003          Otherwise SWITCH_BODY is set, and the switch can fall
13004          through.  */
13005       return SWITCH_LABELS (stmt) == NULL_TREE;
13006
13007     case COND_EXPR:
13008       if (block_may_fallthru (COND_EXPR_THEN (stmt)))
13009         return true;
13010       return block_may_fallthru (COND_EXPR_ELSE (stmt));
13011
13012     case BIND_EXPR:
13013       return block_may_fallthru (BIND_EXPR_BODY (stmt));
13014
13015     case TRY_CATCH_EXPR:
13016       return try_catch_may_fallthru (stmt);
13017
13018     case TRY_FINALLY_EXPR:
13019       /* The finally clause is always executed after the try clause,
13020          so if it does not fall through, then the try-finally will not
13021          fall through.  Otherwise, if the try clause does not fall
13022          through, then when the finally clause falls through it will
13023          resume execution wherever the try clause was going.  So the
13024          whole try-finally will only fall through if both the try
13025          clause and the finally clause fall through.  */
13026       return (block_may_fallthru (TREE_OPERAND (stmt, 0))
13027               && block_may_fallthru (TREE_OPERAND (stmt, 1)));
13028
13029     case MODIFY_EXPR:
13030       if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
13031         stmt = TREE_OPERAND (stmt, 1);
13032       else
13033         return true;
13034       /* FALLTHRU */
13035
13036     case CALL_EXPR:
13037       /* Functions that do not return do not fall through.  */
13038       return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
13039
13040     case CLEANUP_POINT_EXPR:
13041       return block_may_fallthru (TREE_OPERAND (stmt, 0));
13042
13043     case TARGET_EXPR:
13044       return block_may_fallthru (TREE_OPERAND (stmt, 1));
13045
13046     case ERROR_MARK:
13047       return true;
13048
13049     default:
13050       return lang_hooks.block_may_fallthru (stmt);
13051     }
13052 }
13053
13054 /* True if we are using EH to handle cleanups.  */
13055 static bool using_eh_for_cleanups_flag = false;
13056
13057 /* This routine is called from front ends to indicate eh should be used for
13058    cleanups.  */
13059 void
13060 using_eh_for_cleanups (void)
13061 {
13062   using_eh_for_cleanups_flag = true;
13063 }
13064
13065 /* Query whether EH is used for cleanups.  */
13066 bool
13067 using_eh_for_cleanups_p (void)
13068 {
13069   return using_eh_for_cleanups_flag;
13070 }
13071
13072 /* Wrapper for tree_code_name to ensure that tree code is valid */
13073 const char *
13074 get_tree_code_name (enum tree_code code)
13075 {
13076   const char *invalid = "<invalid tree code>";
13077
13078   if (code >= MAX_TREE_CODES)
13079     return invalid;
13080
13081   return tree_code_name[code];
13082 }
13083
13084 /* Drops the TREE_OVERFLOW flag from T.  */
13085
13086 tree
13087 drop_tree_overflow (tree t)
13088 {
13089   gcc_checking_assert (TREE_OVERFLOW (t));
13090
13091   /* For tree codes with a sharing machinery re-build the result.  */
13092   if (TREE_CODE (t) == INTEGER_CST)
13093     return wide_int_to_tree (TREE_TYPE (t), t);
13094
13095   /* Otherwise, as all tcc_constants are possibly shared, copy the node
13096      and drop the flag.  */
13097   t = copy_node (t);
13098   TREE_OVERFLOW (t) = 0;
13099   return t;
13100 }
13101
13102 /* Given a memory reference expression T, return its base address.
13103    The base address of a memory reference expression is the main
13104    object being referenced.  For instance, the base address for
13105    'array[i].fld[j]' is 'array'.  You can think of this as stripping
13106    away the offset part from a memory address.
13107
13108    This function calls handled_component_p to strip away all the inner
13109    parts of the memory reference until it reaches the base object.  */
13110
13111 tree
13112 get_base_address (tree t)
13113 {
13114   while (handled_component_p (t))
13115     t = TREE_OPERAND (t, 0);
13116
13117   if ((TREE_CODE (t) == MEM_REF
13118        || TREE_CODE (t) == TARGET_MEM_REF)
13119       && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
13120     t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
13121
13122   /* ???  Either the alias oracle or all callers need to properly deal
13123      with WITH_SIZE_EXPRs before we can look through those.  */
13124   if (TREE_CODE (t) == WITH_SIZE_EXPR)
13125     return NULL_TREE;
13126
13127   return t;
13128 }
13129
13130 /* Return a tree of sizetype representing the size, in bytes, of the element
13131    of EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
13132
13133 tree
13134 array_ref_element_size (tree exp)
13135 {
13136   tree aligned_size = TREE_OPERAND (exp, 3);
13137   tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)));
13138   location_t loc = EXPR_LOCATION (exp);
13139
13140   /* If a size was specified in the ARRAY_REF, it's the size measured
13141      in alignment units of the element type.  So multiply by that value.  */
13142   if (aligned_size)
13143     {
13144       /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13145          sizetype from another type of the same width and signedness.  */
13146       if (TREE_TYPE (aligned_size) != sizetype)
13147         aligned_size = fold_convert_loc (loc, sizetype, aligned_size);
13148       return size_binop_loc (loc, MULT_EXPR, aligned_size,
13149                              size_int (TYPE_ALIGN_UNIT (elmt_type)));
13150     }
13151
13152   /* Otherwise, take the size from that of the element type.  Substitute
13153      any PLACEHOLDER_EXPR that we have.  */
13154   else
13155     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type), exp);
13156 }
13157
13158 /* Return a tree representing the lower bound of the array mentioned in
13159    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
13160
13161 tree
13162 array_ref_low_bound (tree exp)
13163 {
13164   tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
13165
13166   /* If a lower bound is specified in EXP, use it.  */
13167   if (TREE_OPERAND (exp, 2))
13168     return TREE_OPERAND (exp, 2);
13169
13170   /* Otherwise, if there is a domain type and it has a lower bound, use it,
13171      substituting for a PLACEHOLDER_EXPR as needed.  */
13172   if (domain_type && TYPE_MIN_VALUE (domain_type))
13173     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type), exp);
13174
13175   /* Otherwise, return a zero of the appropriate type.  */
13176   return build_int_cst (TREE_TYPE (TREE_OPERAND (exp, 1)), 0);
13177 }
13178
13179 /* Return a tree representing the upper bound of the array mentioned in
13180    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
13181
13182 tree
13183 array_ref_up_bound (tree exp)
13184 {
13185   tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
13186
13187   /* If there is a domain type and it has an upper bound, use it, substituting
13188      for a PLACEHOLDER_EXPR as needed.  */
13189   if (domain_type && TYPE_MAX_VALUE (domain_type))
13190     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type), exp);
13191
13192   /* Otherwise fail.  */
13193   return NULL_TREE;
13194 }
13195
13196 /* Returns true if REF is an array reference to an array at the end of
13197    a structure.  If this is the case, the array may be allocated larger
13198    than its upper bound implies.  When ALLOW_COMPREF is true considers
13199    REF when it's a COMPONENT_REF in addition ARRAY_REF and
13200    ARRAY_RANGE_REF.  */
13201
13202 bool
13203 array_at_struct_end_p (tree ref, bool allow_compref)
13204 {
13205   if (TREE_CODE (ref) != ARRAY_REF
13206       && TREE_CODE (ref) != ARRAY_RANGE_REF
13207       && (!allow_compref || TREE_CODE (ref) != COMPONENT_REF))
13208     return false;
13209
13210   while (handled_component_p (ref))
13211     {
13212       /* If the reference chain contains a component reference to a
13213          non-union type and there follows another field the reference
13214          is not at the end of a structure.  */
13215       if (TREE_CODE (ref) == COMPONENT_REF
13216           && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0))) == RECORD_TYPE)
13217         {
13218           tree nextf = DECL_CHAIN (TREE_OPERAND (ref, 1));
13219           while (nextf && TREE_CODE (nextf) != FIELD_DECL)
13220             nextf = DECL_CHAIN (nextf);
13221           if (nextf)
13222             return false;
13223         }
13224
13225       ref = TREE_OPERAND (ref, 0);
13226     }
13227
13228   tree size = NULL;
13229
13230   if (TREE_CODE (ref) == MEM_REF
13231       && TREE_CODE (TREE_OPERAND (ref, 0)) == ADDR_EXPR)
13232     {
13233       size = TYPE_SIZE (TREE_TYPE (ref));
13234       ref = TREE_OPERAND (TREE_OPERAND (ref, 0), 0);
13235     }
13236
13237   /* If the reference is based on a declared entity, the size of the array
13238      is constrained by its given domain.  (Do not trust commons PR/69368).  */
13239   if (DECL_P (ref)
13240       /* Be sure the size of MEM_REF target match.  For example:
13241
13242            char buf[10];
13243            struct foo *str = (struct foo *)&buf;
13244
13245            str->trailin_array[2] = 1;
13246
13247          is valid because BUF allocate enough space.  */
13248
13249       && (!size || (DECL_SIZE (ref) != NULL
13250                     && operand_equal_p (DECL_SIZE (ref), size, 0)))
13251       && !(flag_unconstrained_commons
13252            && VAR_P (ref) && DECL_COMMON (ref)))
13253     return false;
13254
13255   return true;
13256 }
13257
13258 /* Return a tree representing the offset, in bytes, of the field referenced
13259    by EXP.  This does not include any offset in DECL_FIELD_BIT_OFFSET.  */
13260
13261 tree
13262 component_ref_field_offset (tree exp)
13263 {
13264   tree aligned_offset = TREE_OPERAND (exp, 2);
13265   tree field = TREE_OPERAND (exp, 1);
13266   location_t loc = EXPR_LOCATION (exp);
13267
13268   /* If an offset was specified in the COMPONENT_REF, it's the offset measured
13269      in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT.  So multiply by that
13270      value.  */
13271   if (aligned_offset)
13272     {
13273       /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13274          sizetype from another type of the same width and signedness.  */
13275       if (TREE_TYPE (aligned_offset) != sizetype)
13276         aligned_offset = fold_convert_loc (loc, sizetype, aligned_offset);
13277       return size_binop_loc (loc, MULT_EXPR, aligned_offset,
13278                              size_int (DECL_OFFSET_ALIGN (field)
13279                                        / BITS_PER_UNIT));
13280     }
13281
13282   /* Otherwise, take the offset from that of the field.  Substitute
13283      any PLACEHOLDER_EXPR that we have.  */
13284   else
13285     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field), exp);
13286 }
13287
13288 /* Return the machine mode of T.  For vectors, returns the mode of the
13289    inner type.  The main use case is to feed the result to HONOR_NANS,
13290    avoiding the BLKmode that a direct TYPE_MODE (T) might return.  */
13291
13292 machine_mode
13293 element_mode (const_tree t)
13294 {
13295   if (!TYPE_P (t))
13296     t = TREE_TYPE (t);
13297   if (VECTOR_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)
13298     t = TREE_TYPE (t);
13299   return TYPE_MODE (t);
13300 }
13301
13302
13303 /* Veirfy that basic properties of T match TV and thus T can be a variant of
13304    TV.  TV should be the more specified variant (i.e. the main variant).  */
13305
13306 static bool
13307 verify_type_variant (const_tree t, tree tv)
13308 {
13309   /* Type variant can differ by:
13310
13311      - TYPE_QUALS: TYPE_READONLY, TYPE_VOLATILE, TYPE_ATOMIC, TYPE_RESTRICT,
13312                    ENCODE_QUAL_ADDR_SPACE.
13313      - main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P
13314        in this case some values may not be set in the variant types
13315        (see TYPE_COMPLETE_P checks).
13316      - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type
13317      - by TYPE_NAME and attributes (i.e. when variant originate by typedef)
13318      - TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants)
13319      - by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN
13320      - during LTO by TYPE_CONTEXT if type is TYPE_FILE_SCOPE_P
13321        this is necessary to make it possible to merge types form different TUs
13322      - arrays, pointers and references may have TREE_TYPE that is a variant
13323        of TREE_TYPE of their main variants.
13324      - aggregates may have new TYPE_FIELDS list that list variants of
13325        the main variant TYPE_FIELDS.
13326      - vector types may differ by TYPE_VECTOR_OPAQUE
13327      - TYPE_METHODS is always NULL for variant types and maintained for
13328        main variant only.
13329    */
13330
13331   /* Convenience macro for matching individual fields.  */
13332 #define verify_variant_match(flag)                                          \
13333   do {                                                                      \
13334     if (flag (tv) != flag (t))                                              \
13335       {                                                                     \
13336         error ("type variant differs by " #flag ".");                       \
13337         debug_tree (tv);                                                    \
13338         return false;                                                       \
13339       }                                                                     \
13340   } while (false)
13341
13342   /* tree_base checks.  */
13343
13344   verify_variant_match (TREE_CODE);
13345   /* FIXME: Ada builds non-artificial variants of artificial types.  */
13346   if (TYPE_ARTIFICIAL (tv) && 0)
13347     verify_variant_match (TYPE_ARTIFICIAL);
13348   if (POINTER_TYPE_P (tv))
13349     verify_variant_match (TYPE_REF_CAN_ALIAS_ALL);
13350   /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build.  */
13351   verify_variant_match (TYPE_UNSIGNED);
13352   verify_variant_match (TYPE_PACKED);
13353   if (TREE_CODE (t) == REFERENCE_TYPE)
13354     verify_variant_match (TYPE_REF_IS_RVALUE);
13355   if (AGGREGATE_TYPE_P (t))
13356     verify_variant_match (TYPE_REVERSE_STORAGE_ORDER);
13357   else
13358     verify_variant_match (TYPE_SATURATING);
13359   /* FIXME: This check trigger during libstdc++ build.  */
13360   if (RECORD_OR_UNION_TYPE_P (t) && COMPLETE_TYPE_P (t) && 0)
13361     verify_variant_match (TYPE_FINAL_P);
13362
13363   /* tree_type_common checks.  */
13364
13365   if (COMPLETE_TYPE_P (t))
13366     {
13367       verify_variant_match (TYPE_MODE);
13368       if (TREE_CODE (TYPE_SIZE (t)) != PLACEHOLDER_EXPR
13369           && TREE_CODE (TYPE_SIZE (tv)) != PLACEHOLDER_EXPR)
13370         verify_variant_match (TYPE_SIZE);
13371       if (TREE_CODE (TYPE_SIZE_UNIT (t)) != PLACEHOLDER_EXPR
13372           && TREE_CODE (TYPE_SIZE_UNIT (tv)) != PLACEHOLDER_EXPR
13373           && TYPE_SIZE_UNIT (t) != TYPE_SIZE_UNIT (tv))
13374         {
13375           gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t),
13376                                         TYPE_SIZE_UNIT (tv), 0));
13377           error ("type variant has different TYPE_SIZE_UNIT");
13378           debug_tree (tv);
13379           error ("type variant's TYPE_SIZE_UNIT");
13380           debug_tree (TYPE_SIZE_UNIT (tv));
13381           error ("type's TYPE_SIZE_UNIT");
13382           debug_tree (TYPE_SIZE_UNIT (t));
13383           return false;
13384         }
13385     }
13386   verify_variant_match (TYPE_PRECISION);
13387   verify_variant_match (TYPE_NEEDS_CONSTRUCTING);
13388   if (RECORD_OR_UNION_TYPE_P (t))
13389     verify_variant_match (TYPE_TRANSPARENT_AGGR);
13390   else if (TREE_CODE (t) == ARRAY_TYPE)
13391     verify_variant_match (TYPE_NONALIASED_COMPONENT);
13392   /* During LTO we merge variant lists from diferent translation units
13393      that may differ BY TYPE_CONTEXT that in turn may point
13394      to TRANSLATION_UNIT_DECL.
13395      Ada also builds variants of types with different TYPE_CONTEXT.   */
13396   if ((!in_lto_p || !TYPE_FILE_SCOPE_P (t)) && 0)
13397     verify_variant_match (TYPE_CONTEXT);
13398   verify_variant_match (TYPE_STRING_FLAG);
13399   if (TYPE_ALIAS_SET_KNOWN_P (t))
13400     {
13401       error ("type variant with TYPE_ALIAS_SET_KNOWN_P");
13402       debug_tree (tv);
13403       return false;
13404     }
13405
13406   /* tree_type_non_common checks.  */
13407
13408   /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13409      and dangle the pointer from time to time.  */
13410   if (RECORD_OR_UNION_TYPE_P (t) && TYPE_VFIELD (t) != TYPE_VFIELD (tv)
13411       && (in_lto_p || !TYPE_VFIELD (tv)
13412           || TREE_CODE (TYPE_VFIELD (tv)) != TREE_LIST))
13413     {
13414       error ("type variant has different TYPE_VFIELD");
13415       debug_tree (tv);
13416       return false;
13417     }
13418   if ((TREE_CODE (t) == ENUMERAL_TYPE && COMPLETE_TYPE_P (t))
13419        || TREE_CODE (t) == INTEGER_TYPE
13420        || TREE_CODE (t) == BOOLEAN_TYPE
13421        || TREE_CODE (t) == REAL_TYPE
13422        || TREE_CODE (t) == FIXED_POINT_TYPE)
13423     {
13424       verify_variant_match (TYPE_MAX_VALUE);
13425       verify_variant_match (TYPE_MIN_VALUE);
13426     }
13427   if (TREE_CODE (t) == METHOD_TYPE)
13428     verify_variant_match (TYPE_METHOD_BASETYPE);
13429   if (RECORD_OR_UNION_TYPE_P (t) && TYPE_METHODS (t))
13430     {
13431       error ("type variant has TYPE_METHODS");
13432       debug_tree (tv);
13433       return false;
13434     }
13435   if (TREE_CODE (t) == OFFSET_TYPE)
13436     verify_variant_match (TYPE_OFFSET_BASETYPE);
13437   if (TREE_CODE (t) == ARRAY_TYPE)
13438     verify_variant_match (TYPE_ARRAY_MAX_SIZE);
13439   /* FIXME: Be lax and allow TYPE_BINFO to be missing in variant types
13440      or even type's main variant.  This is needed to make bootstrap pass
13441      and the bug seems new in GCC 5.
13442      C++ FE should be updated to make this consistent and we should check
13443      that TYPE_BINFO is always NULL for !COMPLETE_TYPE_P and otherwise there
13444      is a match with main variant.
13445
13446      Also disable the check for Java for now because of parser hack that builds
13447      first an dummy BINFO and then sometimes replace it by real BINFO in some
13448      of the copies.  */
13449   if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t) && TYPE_BINFO (tv)
13450       && TYPE_BINFO (t) != TYPE_BINFO (tv)
13451       /* FIXME: Java sometimes keep dump TYPE_BINFOs on variant types.
13452          Since there is no cheap way to tell C++/Java type w/o LTO, do checking
13453          at LTO time only.  */
13454       && (in_lto_p && odr_type_p (t)))
13455     {
13456       error ("type variant has different TYPE_BINFO");
13457       debug_tree (tv);
13458       error ("type variant's TYPE_BINFO");
13459       debug_tree (TYPE_BINFO (tv));
13460       error ("type's TYPE_BINFO");
13461       debug_tree (TYPE_BINFO (t));
13462       return false;
13463     }
13464
13465   /* Check various uses of TYPE_VALUES_RAW.  */
13466   if (TREE_CODE (t) == ENUMERAL_TYPE)
13467     verify_variant_match (TYPE_VALUES);
13468   else if (TREE_CODE (t) == ARRAY_TYPE)
13469     verify_variant_match (TYPE_DOMAIN);
13470   /* Permit incomplete variants of complete type.  While FEs may complete
13471      all variants, this does not happen for C++ templates in all cases.  */
13472   else if (RECORD_OR_UNION_TYPE_P (t)
13473            && COMPLETE_TYPE_P (t)
13474            && TYPE_FIELDS (t) != TYPE_FIELDS (tv))
13475     {
13476       tree f1, f2;
13477
13478       /* Fortran builds qualified variants as new records with items of
13479          qualified type. Verify that they looks same.  */
13480       for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (tv);
13481            f1 && f2;
13482            f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13483         if (TREE_CODE (f1) != FIELD_DECL || TREE_CODE (f2) != FIELD_DECL
13484             || (TYPE_MAIN_VARIANT (TREE_TYPE (f1))
13485                  != TYPE_MAIN_VARIANT (TREE_TYPE (f2))
13486                 /* FIXME: gfc_nonrestricted_type builds all types as variants
13487                    with exception of pointer types.  It deeply copies the type
13488                    which means that we may end up with a variant type
13489                    referring non-variant pointer.  We may change it to
13490                    produce types as variants, too, like
13491                    objc_get_protocol_qualified_type does.  */
13492                 && !POINTER_TYPE_P (TREE_TYPE (f1)))
13493             || DECL_FIELD_OFFSET (f1) != DECL_FIELD_OFFSET (f2)
13494             || DECL_FIELD_BIT_OFFSET (f1) != DECL_FIELD_BIT_OFFSET (f2))
13495           break;
13496       if (f1 || f2)
13497         {
13498           error ("type variant has different TYPE_FIELDS");
13499           debug_tree (tv);
13500           error ("first mismatch is field");
13501           debug_tree (f1);
13502           error ("and field");
13503           debug_tree (f2);
13504           return false;
13505         }
13506     }
13507   else if ((TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE))
13508     verify_variant_match (TYPE_ARG_TYPES);
13509   /* For C++ the qualified variant of array type is really an array type
13510      of qualified TREE_TYPE.
13511      objc builds variants of pointer where pointer to type is a variant, too
13512      in objc_get_protocol_qualified_type.  */
13513   if (TREE_TYPE (t) != TREE_TYPE (tv)
13514       && ((TREE_CODE (t) != ARRAY_TYPE
13515            && !POINTER_TYPE_P (t))
13516           || TYPE_MAIN_VARIANT (TREE_TYPE (t))
13517              != TYPE_MAIN_VARIANT (TREE_TYPE (tv))))
13518     {
13519       error ("type variant has different TREE_TYPE");
13520       debug_tree (tv);
13521       error ("type variant's TREE_TYPE");
13522       debug_tree (TREE_TYPE (tv));
13523       error ("type's TREE_TYPE");
13524       debug_tree (TREE_TYPE (t));
13525       return false;
13526     }
13527   if (type_with_alias_set_p (t)
13528       && !gimple_canonical_types_compatible_p (t, tv, false))
13529     {
13530       error ("type is not compatible with its variant");
13531       debug_tree (tv);
13532       error ("type variant's TREE_TYPE");
13533       debug_tree (TREE_TYPE (tv));
13534       error ("type's TREE_TYPE");
13535       debug_tree (TREE_TYPE (t));
13536       return false;
13537     }
13538   return true;
13539 #undef verify_variant_match
13540 }
13541
13542
13543 /* The TYPE_CANONICAL merging machinery.  It should closely resemble
13544    the middle-end types_compatible_p function.  It needs to avoid
13545    claiming types are different for types that should be treated
13546    the same with respect to TBAA.  Canonical types are also used
13547    for IL consistency checks via the useless_type_conversion_p
13548    predicate which does not handle all type kinds itself but falls
13549    back to pointer-comparison of TYPE_CANONICAL for aggregates
13550    for example.  */
13551
13552 /* Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical
13553    type calculation because we need to allow inter-operability between signed
13554    and unsigned variants.  */
13555
13556 bool
13557 type_with_interoperable_signedness (const_tree type)
13558 {
13559   /* Fortran standard require C_SIGNED_CHAR to be interoperable with both
13560      signed char and unsigned char.  Similarly fortran FE builds
13561      C_SIZE_T as signed type, while C defines it unsigned.  */
13562
13563   return tree_code_for_canonical_type_merging (TREE_CODE (type))
13564            == INTEGER_TYPE
13565          && (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node)
13566              || TYPE_PRECISION (type) == TYPE_PRECISION (size_type_node));
13567 }
13568
13569 /* Return true iff T1 and T2 are structurally identical for what
13570    TBAA is concerned.
13571    This function is used both by lto.c canonical type merging and by the
13572    verifier.  If TRUST_TYPE_CANONICAL we do not look into structure of types
13573    that have TYPE_CANONICAL defined and assume them equivalent.  This is useful
13574    only for LTO because only in these cases TYPE_CANONICAL equivalence
13575    correspond to one defined by gimple_canonical_types_compatible_p.  */
13576
13577 bool
13578 gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
13579                                      bool trust_type_canonical)
13580 {
13581   /* Type variants should be same as the main variant.  When not doing sanity
13582      checking to verify this fact, go to main variants and save some work.  */
13583   if (trust_type_canonical)
13584     {
13585       t1 = TYPE_MAIN_VARIANT (t1);
13586       t2 = TYPE_MAIN_VARIANT (t2);
13587     }
13588
13589   /* Check first for the obvious case of pointer identity.  */
13590   if (t1 == t2)
13591     return true;
13592
13593   /* Check that we have two types to compare.  */
13594   if (t1 == NULL_TREE || t2 == NULL_TREE)
13595     return false;
13596
13597   /* We consider complete types always compatible with incomplete type.
13598      This does not make sense for canonical type calculation and thus we
13599      need to ensure that we are never called on it.
13600
13601      FIXME: For more correctness the function probably should have three modes
13602         1) mode assuming that types are complete mathcing their structure
13603         2) mode allowing incomplete types but producing equivalence classes
13604            and thus ignoring all info from complete types
13605         3) mode allowing incomplete types to match complete but checking
13606            compatibility between complete types.
13607
13608      1 and 2 can be used for canonical type calculation. 3 is the real
13609      definition of type compatibility that can be used i.e. for warnings during
13610      declaration merging.  */
13611
13612   gcc_assert (!trust_type_canonical
13613               || (type_with_alias_set_p (t1) && type_with_alias_set_p (t2)));
13614   /* If the types have been previously registered and found equal
13615      they still are.  */
13616
13617   if (TYPE_CANONICAL (t1) && TYPE_CANONICAL (t2)
13618       && trust_type_canonical)
13619     {
13620       /* Do not use TYPE_CANONICAL of pointer types.  For LTO streamed types
13621          they are always NULL, but they are set to non-NULL for types
13622          constructed by build_pointer_type and variants.  In this case the
13623          TYPE_CANONICAL is more fine grained than the equivalnce we test (where
13624          all pointers are considered equal.  Be sure to not return false
13625          negatives.  */
13626       gcc_checking_assert (canonical_type_used_p (t1)
13627                            && canonical_type_used_p (t2));
13628       return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
13629     }
13630
13631   /* Can't be the same type if the types don't have the same code.  */
13632   enum tree_code code = tree_code_for_canonical_type_merging (TREE_CODE (t1));
13633   if (code != tree_code_for_canonical_type_merging (TREE_CODE (t2)))
13634     return false;
13635
13636   /* Qualifiers do not matter for canonical type comparison purposes.  */
13637
13638   /* Void types and nullptr types are always the same.  */
13639   if (TREE_CODE (t1) == VOID_TYPE
13640       || TREE_CODE (t1) == NULLPTR_TYPE)
13641     return true;
13642
13643   /* Can't be the same type if they have different mode.  */
13644   if (TYPE_MODE (t1) != TYPE_MODE (t2))
13645     return false;
13646
13647   /* Non-aggregate types can be handled cheaply.  */
13648   if (INTEGRAL_TYPE_P (t1)
13649       || SCALAR_FLOAT_TYPE_P (t1)
13650       || FIXED_POINT_TYPE_P (t1)
13651       || TREE_CODE (t1) == VECTOR_TYPE
13652       || TREE_CODE (t1) == COMPLEX_TYPE
13653       || TREE_CODE (t1) == OFFSET_TYPE
13654       || POINTER_TYPE_P (t1))
13655     {
13656       /* Can't be the same type if they have different recision.  */
13657       if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2))
13658         return false;
13659
13660       /* In some cases the signed and unsigned types are required to be
13661          inter-operable.  */
13662       if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2)
13663           && !type_with_interoperable_signedness (t1))
13664         return false;
13665
13666       /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
13667          interoperable with "signed char".  Unless all frontends are revisited
13668          to agree on these types, we must ignore the flag completely.  */
13669
13670       /* Fortran standard define C_PTR type that is compatible with every
13671          C pointer.  For this reason we need to glob all pointers into one.
13672          Still pointers in different address spaces are not compatible.  */
13673       if (POINTER_TYPE_P (t1))
13674         {
13675           if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
13676               != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
13677             return false;
13678         }
13679
13680       /* Tail-recurse to components.  */
13681       if (TREE_CODE (t1) == VECTOR_TYPE
13682           || TREE_CODE (t1) == COMPLEX_TYPE)
13683         return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
13684                                                     TREE_TYPE (t2),
13685                                                     trust_type_canonical);
13686
13687       return true;
13688     }
13689
13690   /* Do type-specific comparisons.  */
13691   switch (TREE_CODE (t1))
13692     {
13693     case ARRAY_TYPE:
13694       /* Array types are the same if the element types are the same and
13695          the number of elements are the same.  */
13696       if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13697                                                 trust_type_canonical)
13698           || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
13699           || TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2)
13700           || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
13701         return false;
13702       else
13703         {
13704           tree i1 = TYPE_DOMAIN (t1);
13705           tree i2 = TYPE_DOMAIN (t2);
13706
13707           /* For an incomplete external array, the type domain can be
13708              NULL_TREE.  Check this condition also.  */
13709           if (i1 == NULL_TREE && i2 == NULL_TREE)
13710             return true;
13711           else if (i1 == NULL_TREE || i2 == NULL_TREE)
13712             return false;
13713           else
13714             {
13715               tree min1 = TYPE_MIN_VALUE (i1);
13716               tree min2 = TYPE_MIN_VALUE (i2);
13717               tree max1 = TYPE_MAX_VALUE (i1);
13718               tree max2 = TYPE_MAX_VALUE (i2);
13719
13720               /* The minimum/maximum values have to be the same.  */
13721               if ((min1 == min2
13722                    || (min1 && min2
13723                        && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
13724                             && TREE_CODE (min2) == PLACEHOLDER_EXPR)
13725                            || operand_equal_p (min1, min2, 0))))
13726                   && (max1 == max2
13727                       || (max1 && max2
13728                           && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
13729                                && TREE_CODE (max2) == PLACEHOLDER_EXPR)
13730                               || operand_equal_p (max1, max2, 0)))))
13731                 return true;
13732               else
13733                 return false;
13734             }
13735         }
13736
13737     case METHOD_TYPE:
13738     case FUNCTION_TYPE:
13739       /* Function types are the same if the return type and arguments types
13740          are the same.  */
13741       if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13742                                                 trust_type_canonical))
13743         return false;
13744
13745       if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
13746         return true;
13747       else
13748         {
13749           tree parms1, parms2;
13750
13751           for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
13752                parms1 && parms2;
13753                parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
13754             {
13755               if (!gimple_canonical_types_compatible_p
13756                      (TREE_VALUE (parms1), TREE_VALUE (parms2),
13757                       trust_type_canonical))
13758                 return false;
13759             }
13760
13761           if (parms1 || parms2)
13762             return false;
13763
13764           return true;
13765         }
13766
13767     case RECORD_TYPE:
13768     case UNION_TYPE:
13769     case QUAL_UNION_TYPE:
13770       {
13771         tree f1, f2;
13772
13773         /* Don't try to compare variants of an incomplete type, before
13774            TYPE_FIELDS has been copied around.  */
13775         if (!COMPLETE_TYPE_P (t1) && !COMPLETE_TYPE_P (t2))
13776           return true;
13777
13778
13779         if (TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2))
13780           return false;
13781
13782         /* For aggregate types, all the fields must be the same.  */
13783         for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
13784              f1 || f2;
13785              f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13786           {
13787             /* Skip non-fields and zero-sized fields.  */
13788             while (f1 && (TREE_CODE (f1) != FIELD_DECL
13789                           || (DECL_SIZE (f1)
13790                               && integer_zerop (DECL_SIZE (f1)))))
13791               f1 = TREE_CHAIN (f1);
13792             while (f2 && (TREE_CODE (f2) != FIELD_DECL
13793                           || (DECL_SIZE (f2)
13794                               && integer_zerop (DECL_SIZE (f2)))))
13795               f2 = TREE_CHAIN (f2);
13796             if (!f1 || !f2)
13797               break;
13798             /* The fields must have the same name, offset and type.  */
13799             if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
13800                 || !gimple_compare_field_offset (f1, f2)
13801                 || !gimple_canonical_types_compatible_p
13802                       (TREE_TYPE (f1), TREE_TYPE (f2),
13803                        trust_type_canonical))
13804               return false;
13805           }
13806
13807         /* If one aggregate has more fields than the other, they
13808            are not the same.  */
13809         if (f1 || f2)
13810           return false;
13811
13812         return true;
13813       }
13814
13815     default:
13816       /* Consider all types with language specific trees in them mutually
13817          compatible.  This is executed only from verify_type and false
13818          positives can be tolerated.  */
13819       gcc_assert (!in_lto_p);
13820       return true;
13821     }
13822 }
13823
13824 /* Verify type T.  */
13825
13826 void
13827 verify_type (const_tree t)
13828 {
13829   bool error_found = false;
13830   tree mv = TYPE_MAIN_VARIANT (t);
13831   if (!mv)
13832     {
13833       error ("Main variant is not defined");
13834       error_found = true;
13835     }
13836   else if (mv != TYPE_MAIN_VARIANT (mv))
13837     {
13838       error ("TYPE_MAIN_VARIANT has different TYPE_MAIN_VARIANT");
13839       debug_tree (mv);
13840       error_found = true;
13841     }
13842   else if (t != mv && !verify_type_variant (t, mv))
13843     error_found = true;
13844
13845   tree ct = TYPE_CANONICAL (t);
13846   if (!ct)
13847     ;
13848   else if (TYPE_CANONICAL (t) != ct)
13849     {
13850       error ("TYPE_CANONICAL has different TYPE_CANONICAL");
13851       debug_tree (ct);
13852       error_found = true;
13853     }
13854   /* Method and function types can not be used to address memory and thus
13855      TYPE_CANONICAL really matters only for determining useless conversions.
13856
13857      FIXME: C++ FE produce declarations of builtin functions that are not
13858      compatible with main variants.  */
13859   else if (TREE_CODE (t) == FUNCTION_TYPE)
13860     ;
13861   else if (t != ct
13862            /* FIXME: gimple_canonical_types_compatible_p can not compare types
13863               with variably sized arrays because their sizes possibly
13864               gimplified to different variables.  */
13865            && !variably_modified_type_p (ct, NULL)
13866            && !gimple_canonical_types_compatible_p (t, ct, false))
13867     {
13868       error ("TYPE_CANONICAL is not compatible");
13869       debug_tree (ct);
13870       error_found = true;
13871     }
13872
13873   if (COMPLETE_TYPE_P (t) && TYPE_CANONICAL (t)
13874       && TYPE_MODE (t) != TYPE_MODE (TYPE_CANONICAL (t)))
13875     {
13876       error ("TYPE_MODE of TYPE_CANONICAL is not compatible");
13877       debug_tree (ct);
13878       error_found = true;
13879     }
13880   /* FIXME: this is violated by the C++ FE as discussed in PR70029, when
13881      FUNCTION_*_QUALIFIED flags are set.  */
13882   if (0 && TYPE_MAIN_VARIANT (t) == t && ct && TYPE_MAIN_VARIANT (ct) != ct)
13883    {
13884       error ("TYPE_CANONICAL of main variant is not main variant");
13885       debug_tree (ct);
13886       debug_tree (TYPE_MAIN_VARIANT (ct));
13887       error_found = true;
13888    }
13889
13890
13891   /* Check various uses of TYPE_MINVAL.  */
13892   if (RECORD_OR_UNION_TYPE_P (t))
13893     {
13894       /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13895          and danagle the pointer from time to time.  */
13896       if (TYPE_VFIELD (t)
13897           && TREE_CODE (TYPE_VFIELD (t)) != FIELD_DECL
13898           && TREE_CODE (TYPE_VFIELD (t)) != TREE_LIST)
13899         {
13900           error ("TYPE_VFIELD is not FIELD_DECL nor TREE_LIST");
13901           debug_tree (TYPE_VFIELD (t));
13902           error_found = true;
13903         }
13904     }
13905   else if (TREE_CODE (t) == POINTER_TYPE)
13906     {
13907       if (TYPE_NEXT_PTR_TO (t)
13908           && TREE_CODE (TYPE_NEXT_PTR_TO (t)) != POINTER_TYPE)
13909         {
13910           error ("TYPE_NEXT_PTR_TO is not POINTER_TYPE");
13911           debug_tree (TYPE_NEXT_PTR_TO (t));
13912           error_found = true;
13913         }
13914     }
13915   else if (TREE_CODE (t) == REFERENCE_TYPE)
13916     {
13917       if (TYPE_NEXT_REF_TO (t)
13918           && TREE_CODE (TYPE_NEXT_REF_TO (t)) != REFERENCE_TYPE)
13919         {
13920           error ("TYPE_NEXT_REF_TO is not REFERENCE_TYPE");
13921           debug_tree (TYPE_NEXT_REF_TO (t));
13922           error_found = true;
13923         }
13924     }
13925   else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
13926            || TREE_CODE (t) == FIXED_POINT_TYPE)
13927     {
13928       /* FIXME: The following check should pass:
13929           useless_type_conversion_p (const_cast <tree> (t),
13930                                      TREE_TYPE (TYPE_MIN_VALUE (t))
13931          but does not for C sizetypes in LTO.  */
13932     }
13933   /* Java uses TYPE_MINVAL for TYPE_ARGUMENT_SIGNATURE.  */
13934   else if (TYPE_MINVAL (t)
13935            && ((TREE_CODE (t) != METHOD_TYPE && TREE_CODE (t) != FUNCTION_TYPE)
13936                || in_lto_p))
13937     {
13938       error ("TYPE_MINVAL non-NULL");
13939       debug_tree (TYPE_MINVAL (t));
13940       error_found = true;
13941     }
13942
13943   /* Check various uses of TYPE_MAXVAL.  */
13944   if (RECORD_OR_UNION_TYPE_P (t))
13945     {
13946       if (TYPE_METHODS (t) && TREE_CODE (TYPE_METHODS (t)) != FUNCTION_DECL
13947           && TREE_CODE (TYPE_METHODS (t)) != TEMPLATE_DECL
13948           && TYPE_METHODS (t) != error_mark_node)
13949         {
13950           error ("TYPE_METHODS is not FUNCTION_DECL, TEMPLATE_DECL nor error_mark_node");
13951           debug_tree (TYPE_METHODS (t));
13952           error_found = true;
13953         }
13954     }
13955   else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
13956     {
13957       if (TYPE_METHOD_BASETYPE (t)
13958           && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != RECORD_TYPE
13959           && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != UNION_TYPE)
13960         {
13961           error ("TYPE_METHOD_BASETYPE is not record nor union");
13962           debug_tree (TYPE_METHOD_BASETYPE (t));
13963           error_found = true;
13964         }
13965     }
13966   else if (TREE_CODE (t) == OFFSET_TYPE)
13967     {
13968       if (TYPE_OFFSET_BASETYPE (t)
13969           && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != RECORD_TYPE
13970           && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != UNION_TYPE)
13971         {
13972           error ("TYPE_OFFSET_BASETYPE is not record nor union");
13973           debug_tree (TYPE_OFFSET_BASETYPE (t));
13974           error_found = true;
13975         }
13976     }
13977   else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
13978            || TREE_CODE (t) == FIXED_POINT_TYPE)
13979     {
13980       /* FIXME: The following check should pass:
13981           useless_type_conversion_p (const_cast <tree> (t),
13982                                      TREE_TYPE (TYPE_MAX_VALUE (t))
13983          but does not for C sizetypes in LTO.  */
13984     }
13985   else if (TREE_CODE (t) == ARRAY_TYPE)
13986     {
13987       if (TYPE_ARRAY_MAX_SIZE (t)
13988           && TREE_CODE (TYPE_ARRAY_MAX_SIZE (t)) != INTEGER_CST)
13989         {
13990           error ("TYPE_ARRAY_MAX_SIZE not INTEGER_CST");
13991           debug_tree (TYPE_ARRAY_MAX_SIZE (t));
13992           error_found = true;
13993         }
13994     }
13995   else if (TYPE_MAXVAL (t))
13996     {
13997       error ("TYPE_MAXVAL non-NULL");
13998       debug_tree (TYPE_MAXVAL (t));
13999       error_found = true;
14000     }
14001
14002   /* Check various uses of TYPE_BINFO.  */
14003   if (RECORD_OR_UNION_TYPE_P (t))
14004     {
14005       if (!TYPE_BINFO (t))
14006         ;
14007       else if (TREE_CODE (TYPE_BINFO (t)) != TREE_BINFO)
14008         {
14009           error ("TYPE_BINFO is not TREE_BINFO");
14010           debug_tree (TYPE_BINFO (t));
14011           error_found = true;
14012         }
14013       /* FIXME: Java builds invalid empty binfos that do not have
14014          TREE_TYPE set.  */
14015       else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t) && 0)
14016         {
14017           error ("TYPE_BINFO type is not TYPE_MAIN_VARIANT");
14018           debug_tree (TREE_TYPE (TYPE_BINFO (t)));
14019           error_found = true;
14020         }
14021     }
14022   else if (TYPE_LANG_SLOT_1 (t) && in_lto_p)
14023     {
14024       error ("TYPE_LANG_SLOT_1 (binfo) field is non-NULL");
14025       debug_tree (TYPE_LANG_SLOT_1 (t));
14026       error_found = true;
14027     }
14028
14029   /* Check various uses of TYPE_VALUES_RAW.  */
14030   if (TREE_CODE (t) == ENUMERAL_TYPE)
14031     for (tree l = TYPE_VALUES (t); l; l = TREE_CHAIN (l))
14032       {
14033         tree value = TREE_VALUE (l);
14034         tree name = TREE_PURPOSE (l);
14035
14036         /* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
14037            CONST_DECL of ENUMERAL TYPE.  */
14038         if (TREE_CODE (value) != INTEGER_CST && TREE_CODE (value) != CONST_DECL)
14039           {
14040             error ("Enum value is not CONST_DECL or INTEGER_CST");
14041             debug_tree (value);
14042             debug_tree (name);
14043             error_found = true;
14044           }
14045         if (TREE_CODE (TREE_TYPE (value)) != INTEGER_TYPE
14046             && !useless_type_conversion_p (const_cast <tree> (t), TREE_TYPE (value)))
14047           {
14048             error ("Enum value type is not INTEGER_TYPE nor convertible to the enum");
14049             debug_tree (value);
14050             debug_tree (name);
14051             error_found = true;
14052           }
14053         if (TREE_CODE (name) != IDENTIFIER_NODE)
14054           {
14055             error ("Enum value name is not IDENTIFIER_NODE");
14056             debug_tree (value);
14057             debug_tree (name);
14058             error_found = true;
14059           }
14060       }
14061   else if (TREE_CODE (t) == ARRAY_TYPE)
14062     {
14063       if (TYPE_DOMAIN (t) && TREE_CODE (TYPE_DOMAIN (t)) != INTEGER_TYPE)
14064         {
14065           error ("Array TYPE_DOMAIN is not integer type");
14066           debug_tree (TYPE_DOMAIN (t));
14067           error_found = true;
14068         }
14069     }
14070   else if (RECORD_OR_UNION_TYPE_P (t))
14071     {
14072       if (TYPE_FIELDS (t) && !COMPLETE_TYPE_P (t) && in_lto_p)
14073         {
14074           error ("TYPE_FIELDS defined in incomplete type");
14075           error_found = true;
14076         }
14077       for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld))
14078         {
14079           /* TODO: verify properties of decls.  */
14080           if (TREE_CODE (fld) == FIELD_DECL)
14081             ;
14082           else if (TREE_CODE (fld) == TYPE_DECL)
14083             ;
14084           else if (TREE_CODE (fld) == CONST_DECL)
14085             ;
14086           else if (VAR_P (fld))
14087             ;
14088           else if (TREE_CODE (fld) == TEMPLATE_DECL)
14089             ;
14090           else if (TREE_CODE (fld) == USING_DECL)
14091             ;
14092           else
14093             {
14094               error ("Wrong tree in TYPE_FIELDS list");
14095               debug_tree (fld);
14096               error_found = true;
14097             }
14098         }
14099     }
14100   else if (TREE_CODE (t) == INTEGER_TYPE
14101            || TREE_CODE (t) == BOOLEAN_TYPE
14102            || TREE_CODE (t) == OFFSET_TYPE
14103            || TREE_CODE (t) == REFERENCE_TYPE
14104            || TREE_CODE (t) == NULLPTR_TYPE
14105            || TREE_CODE (t) == POINTER_TYPE)
14106     {
14107       if (TYPE_CACHED_VALUES_P (t) != (TYPE_CACHED_VALUES (t) != NULL))
14108         {
14109           error ("TYPE_CACHED_VALUES_P is %i while TYPE_CACHED_VALUES is %p",
14110                  TYPE_CACHED_VALUES_P (t), (void *)TYPE_CACHED_VALUES (t));
14111           error_found = true;
14112         }
14113       else if (TYPE_CACHED_VALUES_P (t) && TREE_CODE (TYPE_CACHED_VALUES (t)) != TREE_VEC)
14114         {
14115           error ("TYPE_CACHED_VALUES is not TREE_VEC");
14116           debug_tree (TYPE_CACHED_VALUES (t));
14117           error_found = true;
14118         }
14119       /* Verify just enough of cache to ensure that no one copied it to new type.
14120          All copying should go by copy_node that should clear it.  */
14121       else if (TYPE_CACHED_VALUES_P (t))
14122         {
14123           int i;
14124           for (i = 0; i < TREE_VEC_LENGTH (TYPE_CACHED_VALUES (t)); i++)
14125             if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)
14126                 && TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)) != t)
14127               {
14128                 error ("wrong TYPE_CACHED_VALUES entry");
14129                 debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i));
14130                 error_found = true;
14131                 break;
14132               }
14133         }
14134     }
14135   else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
14136     for (tree l = TYPE_ARG_TYPES (t); l; l = TREE_CHAIN (l))
14137       {
14138         /* C++ FE uses TREE_PURPOSE to store initial values.  */
14139         if (TREE_PURPOSE (l) && in_lto_p)
14140           {
14141             error ("TREE_PURPOSE is non-NULL in TYPE_ARG_TYPES list");
14142             debug_tree (l);
14143             error_found = true;
14144           }
14145         if (!TYPE_P (TREE_VALUE (l)))
14146           {
14147             error ("Wrong entry in TYPE_ARG_TYPES list");
14148             debug_tree (l);
14149             error_found = true;
14150           }
14151       }
14152   else if (!is_lang_specific (t) && TYPE_VALUES_RAW (t))
14153     {
14154       error ("TYPE_VALUES_RAW field is non-NULL");
14155       debug_tree (TYPE_VALUES_RAW (t));
14156       error_found = true;
14157     }
14158   if (TREE_CODE (t) != INTEGER_TYPE
14159       && TREE_CODE (t) != BOOLEAN_TYPE
14160       && TREE_CODE (t) != OFFSET_TYPE
14161       && TREE_CODE (t) != REFERENCE_TYPE
14162       && TREE_CODE (t) != NULLPTR_TYPE
14163       && TREE_CODE (t) != POINTER_TYPE
14164       && TYPE_CACHED_VALUES_P (t))
14165     {
14166       error ("TYPE_CACHED_VALUES_P is set while it should not");
14167       error_found = true;
14168     }
14169   if (TYPE_STRING_FLAG (t)
14170       && TREE_CODE (t) != ARRAY_TYPE && TREE_CODE (t) != INTEGER_TYPE)
14171     {
14172       error ("TYPE_STRING_FLAG is set on wrong type code");
14173       error_found = true;
14174     }
14175   else if (TYPE_STRING_FLAG (t))
14176     {
14177       const_tree b = t;
14178       if (TREE_CODE (b) == ARRAY_TYPE)
14179         b = TREE_TYPE (t);
14180       /* Java builds arrays with TYPE_STRING_FLAG of promoted_char_type
14181          that is 32bits.  */
14182       if (TREE_CODE (b) != INTEGER_TYPE)
14183         {
14184           error ("TYPE_STRING_FLAG is set on type that does not look like "
14185                  "char nor array of chars");
14186           error_found = true;
14187         }
14188     }
14189
14190   /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
14191      TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns
14192      of a type. */
14193   if (TREE_CODE (t) == METHOD_TYPE
14194       && TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t)) != TYPE_METHOD_BASETYPE (t))
14195     {
14196         error ("TYPE_METHOD_BASETYPE is not main variant");
14197         error_found = true;
14198     }
14199
14200   if (error_found)
14201     {
14202       debug_tree (const_cast <tree> (t));
14203       internal_error ("verify_type failed");
14204     }
14205 }
14206
14207
14208 /* Return true if ARG is marked with the nonnull attribute in the
14209    current function signature.  */
14210
14211 bool
14212 nonnull_arg_p (const_tree arg)
14213 {
14214   tree t, attrs, fntype;
14215   unsigned HOST_WIDE_INT arg_num;
14216
14217   gcc_assert (TREE_CODE (arg) == PARM_DECL
14218               && (POINTER_TYPE_P (TREE_TYPE (arg))
14219                   || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE));
14220
14221   /* The static chain decl is always non null.  */
14222   if (arg == cfun->static_chain_decl)
14223     return true;
14224
14225   /* THIS argument of method is always non-NULL.  */
14226   if (TREE_CODE (TREE_TYPE (cfun->decl)) == METHOD_TYPE
14227       && arg == DECL_ARGUMENTS (cfun->decl)
14228       && flag_delete_null_pointer_checks)
14229     return true;
14230
14231   /* Values passed by reference are always non-NULL.  */
14232   if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE
14233       && flag_delete_null_pointer_checks)
14234     return true;
14235
14236   fntype = TREE_TYPE (cfun->decl);
14237   for (attrs = TYPE_ATTRIBUTES (fntype); attrs; attrs = TREE_CHAIN (attrs))
14238     {
14239       attrs = lookup_attribute ("nonnull", attrs);
14240
14241       /* If "nonnull" wasn't specified, we know nothing about the argument.  */
14242       if (attrs == NULL_TREE)
14243         return false;
14244
14245       /* If "nonnull" applies to all the arguments, then ARG is non-null.  */
14246       if (TREE_VALUE (attrs) == NULL_TREE)
14247         return true;
14248
14249       /* Get the position number for ARG in the function signature.  */
14250       for (arg_num = 1, t = DECL_ARGUMENTS (cfun->decl);
14251            t;
14252            t = DECL_CHAIN (t), arg_num++)
14253         {
14254           if (t == arg)
14255             break;
14256         }
14257
14258       gcc_assert (t == arg);
14259
14260       /* Now see if ARG_NUM is mentioned in the nonnull list.  */
14261       for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
14262         {
14263           if (compare_tree_int (TREE_VALUE (t), arg_num) == 0)
14264             return true;
14265         }
14266     }
14267
14268   return false;
14269 }
14270
14271 /* Combine LOC and BLOCK to a combined adhoc loc, retaining any range
14272    information.  */
14273
14274 location_t
14275 set_block (location_t loc, tree block)
14276 {
14277   location_t pure_loc = get_pure_location (loc);
14278   source_range src_range = get_range_from_loc (line_table, loc);
14279   return COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, block);
14280 }
14281
14282 location_t
14283 set_source_range (tree expr, location_t start, location_t finish)
14284 {
14285   source_range src_range;
14286   src_range.m_start = start;
14287   src_range.m_finish = finish;
14288   return set_source_range (expr, src_range);
14289 }
14290
14291 location_t
14292 set_source_range (tree expr, source_range src_range)
14293 {
14294   if (!EXPR_P (expr))
14295     return UNKNOWN_LOCATION;
14296
14297   location_t pure_loc = get_pure_location (EXPR_LOCATION (expr));
14298   location_t adhoc = COMBINE_LOCATION_DATA (line_table,
14299                                             pure_loc,
14300                                             src_range,
14301                                             NULL);
14302   SET_EXPR_LOCATION (expr, adhoc);
14303   return adhoc;
14304 }
14305
14306 /* Return the name of combined function FN, for debugging purposes.  */
14307
14308 const char *
14309 combined_fn_name (combined_fn fn)
14310 {
14311   if (builtin_fn_p (fn))
14312     {
14313       tree fndecl = builtin_decl_explicit (as_builtin_fn (fn));
14314       return IDENTIFIER_POINTER (DECL_NAME (fndecl));
14315     }
14316   else
14317     return internal_fn_name (as_internal_fn (fn));
14318 }
14319
14320 /* Return a bitmap with a bit set corresponding to each argument in
14321    a function call type FNTYPE declared with attribute nonnull,
14322    or null if none of the function's argument are nonnull.  The caller
14323    must free the bitmap.  */
14324
14325 bitmap
14326 get_nonnull_args (const_tree fntype)
14327 {
14328   if (fntype == NULL_TREE)
14329     return NULL;
14330
14331   tree attrs = TYPE_ATTRIBUTES (fntype);
14332   if (!attrs)
14333     return NULL;
14334
14335   bitmap argmap = NULL;
14336
14337   /* A function declaration can specify multiple attribute nonnull,
14338      each with zero or more arguments.  The loop below creates a bitmap
14339      representing a union of all the arguments.  An empty (but non-null)
14340      bitmap means that all arguments have been declaraed nonnull.  */
14341   for ( ; attrs; attrs = TREE_CHAIN (attrs))
14342     {
14343       attrs = lookup_attribute ("nonnull", attrs);
14344       if (!attrs)
14345         break;
14346
14347       if (!argmap)
14348         argmap = BITMAP_ALLOC (NULL);
14349
14350       if (!TREE_VALUE (attrs))
14351         {
14352           /* Clear the bitmap in case a previous attribute nonnull
14353              set it and this one overrides it for all arguments.  */
14354           bitmap_clear (argmap);
14355           return argmap;
14356         }
14357
14358       /* Iterate over the indices of the format arguments declared nonnull
14359          and set a bit for each.  */
14360       for (tree idx = TREE_VALUE (attrs); idx; idx = TREE_CHAIN (idx))
14361         {
14362           unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (idx)) - 1;
14363           bitmap_set_bit (argmap, val);
14364         }
14365     }
14366
14367   return argmap;
14368 }
14369
14370 #if CHECKING_P
14371
14372 namespace selftest {
14373
14374 /* Selftests for tree.  */
14375
14376 /* Verify that integer constants are sane.  */
14377
14378 static void
14379 test_integer_constants ()
14380 {
14381   ASSERT_TRUE (integer_type_node != NULL);
14382   ASSERT_TRUE (build_int_cst (integer_type_node, 0) != NULL);
14383
14384   tree type = integer_type_node;
14385
14386   tree zero = build_zero_cst (type);
14387   ASSERT_EQ (INTEGER_CST, TREE_CODE (zero));
14388   ASSERT_EQ (type, TREE_TYPE (zero));
14389
14390   tree one = build_int_cst (type, 1);
14391   ASSERT_EQ (INTEGER_CST, TREE_CODE (one));
14392   ASSERT_EQ (type, TREE_TYPE (zero));
14393 }
14394
14395 /* Verify identifiers.  */
14396
14397 static void
14398 test_identifiers ()
14399 {
14400   tree identifier = get_identifier ("foo");
14401   ASSERT_EQ (3, IDENTIFIER_LENGTH (identifier));
14402   ASSERT_STREQ ("foo", IDENTIFIER_POINTER (identifier));
14403 }
14404
14405 /* Verify LABEL_DECL.  */
14406
14407 static void
14408 test_labels ()
14409 {
14410   tree identifier = get_identifier ("err");
14411   tree label_decl = build_decl (UNKNOWN_LOCATION, LABEL_DECL,
14412                                 identifier, void_type_node);
14413   ASSERT_EQ (-1, LABEL_DECL_UID (label_decl));
14414   ASSERT_FALSE (FORCED_LABEL (label_decl));
14415 }
14416
14417 /* Run all of the selftests within this file.  */
14418
14419 void
14420 tree_c_tests ()
14421 {
14422   test_integer_constants ();
14423   test_identifiers ();
14424   test_labels ();
14425 }
14426
14427 } // namespace selftest
14428
14429 #endif /* CHECKING_P */
14430
14431 #include "gt-tree.h"