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