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