gcc/tree.c

   1 /* Language-independent node constructors for parse phase of GNU compiler.
   2    Copyright (C) 1987-2017 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* This file contains the low level primitives for operating on tree nodes,
  21    including allocation, list operations, interning of identifiers,
  22    construction of data type nodes and statement nodes,
  23    and construction of type conversion nodes.  It also contains
  24    tables index by tree code that describe how to take apart
  25    nodes of that code.
  26
  27    It is intended to be language-independent but can occasionally
  28    calls language-dependent routines.  */
  29
  30 #include "config.h"
  31 #include "system.h"
  32 #include "coretypes.h"
  33 #include "backend.h"
  34 #include "target.h"
  35 #include "tree.h"
  36 #include "gimple.h"
  37 #include "tree-pass.h"
  38 #include "ssa.h"
  39 #include "cgraph.h"
  40 #include "diagnostic.h"
  41 #include "flags.h"
  42 #include "alias.h"
  43 #include "fold-const.h"
  44 #include "stor-layout.h"
  45 #include "calls.h"
  46 #include "attribs.h"
  47 #include "toplev.h" /* get_random_seed */
  48 #include "output.h"
  49 #include "common/common-target.h"
  50 #include "langhooks.h"
  51 #include "tree-inline.h"
  52 #include "tree-iterator.h"
  53 #include "internal-fn.h"
  54 #include "gimple-iterator.h"
  55 #include "gimplify.h"
  56 #include "tree-dfa.h"
  57 #include "params.h"
  58 #include "langhooks-def.h"
  59 #include "tree-diagnostic.h"
  60 #include "except.h"
  61 #include "builtins.h"
  62 #include "print-tree.h"
  63 #include "ipa-utils.h"
  64 #include "selftest.h"
  65
  66 /* Tree code classes.  */
  67
  68 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  69 #define END_OF_BASE_TREE_CODES tcc_exceptional,
  70
  71 const enum tree_code_class tree_code_type[] = {
  72 #include "all-tree.def"
  73 };
  74
  75 #undef DEFTREECODE
  76 #undef END_OF_BASE_TREE_CODES
  77
  78 /* Table indexed by tree code giving number of expression
  79    operands beyond the fixed part of the node structure.
  80    Not used for types or decls.  */
  81
  82 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  83 #define END_OF_BASE_TREE_CODES 0,
  84
  85 const unsigned char tree_code_length[] = {
  86 #include "all-tree.def"
  87 };
  88
  89 #undef DEFTREECODE
  90 #undef END_OF_BASE_TREE_CODES
  91
  92 /* Names of tree components.
  93    Used for printing out the tree and error messages.  */
  94 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
  95 #define END_OF_BASE_TREE_CODES "@dummy",
  96
  97 static const char *const tree_code_name[] = {
  98 #include "all-tree.def"
  99 };
 100
 101 #undef DEFTREECODE
 102 #undef END_OF_BASE_TREE_CODES
 103
 104 /* Each tree code class has an associated string representation.
 105    These must correspond to the tree_code_class entries.  */
 106
 107 const char *const tree_code_class_strings[] =
 108 {
 109   "exceptional",
 110   "constant",
 111   "type",
 112   "declaration",
 113   "reference",
 114   "comparison",
 115   "unary",
 116   "binary",
 117   "statement",
 118   "vl_exp",
 119   "expression"
 120 };
 121
 122 /* obstack.[ch] explicitly declined to prototype this.  */
 123 extern int _obstack_allocated_p (struct obstack *h, void *obj);
 124
 125 /* Statistics-gathering stuff.  */
 126
 127 static int tree_code_counts[MAX_TREE_CODES];
 128 int tree_node_counts[(int) all_kinds];
 129 int tree_node_sizes[(int) all_kinds];
 130
 131 /* Keep in sync with tree.h:enum tree_node_kind.  */
 132 static const char * const tree_node_kind_names[] = {
 133   "decls",
 134   "types",
 135   "blocks",
 136   "stmts",
 137   "refs",
 138   "exprs",
 139   "constants",
 140   "identifiers",
 141   "vecs",
 142   "binfos",
 143   "ssa names",
 144   "constructors",
 145   "random kinds",
 146   "lang_decl kinds",
 147   "lang_type kinds",
 148   "omp clauses",
 149 };
 150
 151 /* Unique id for next decl created.  */
 152 static GTY(()) int next_decl_uid;
 153 /* Unique id for next type created.  */
 154 static GTY(()) int next_type_uid = 1;
 155 /* Unique id for next debug decl created.  Use negative numbers,
 156    to catch erroneous uses.  */
 157 static GTY(()) int next_debug_decl_uid;
 158
 159 /* Since we cannot rehash a type after it is in the table, we have to
 160    keep the hash code.  */
 161
 162 struct GTY((for_user)) type_hash {
 163   unsigned long hash;
 164   tree type;
 165 };
 166
 167 /* Initial size of the hash table (rounded to next prime).  */
 168 #define TYPE_HASH_INITIAL_SIZE 1000
 169
 170 struct type_cache_hasher : ggc_cache_ptr_hash<type_hash>
 171 {
 172   static hashval_t hash (type_hash *t) { return t->hash; }
 173   static bool equal (type_hash *a, type_hash *b);
 174
 175   static int
 176   keep_cache_entry (type_hash *&t)
 177   {
 178     return ggc_marked_p (t->type);
 179   }
 180 };
 181
 182 /* Now here is the hash table.  When recording a type, it is added to
 183    the slot whose index is the hash code.  Note that the hash table is
 184    used for several kinds of types (function types, array types and
 185    array index range types, for now).  While all these live in the
 186    same table, they are completely independent, and the hash code is
 187    computed differently for each of these.  */
 188
 189 static GTY ((cache)) hash_table<type_cache_hasher> *type_hash_table;
 190
 191 /* Hash table and temporary node for larger integer const values.  */
 192 static GTY (()) tree int_cst_node;
 193
 194 struct int_cst_hasher : ggc_cache_ptr_hash<tree_node>
 195 {
 196   static hashval_t hash (tree t);
 197   static bool equal (tree x, tree y);
 198 };
 199
 200 static GTY ((cache)) hash_table<int_cst_hasher> *int_cst_hash_table;
 201
 202 /* Hash table for optimization flags and target option flags.  Use the same
 203    hash table for both sets of options.  Nodes for building the current
 204    optimization and target option nodes.  The assumption is most of the time
 205    the options created will already be in the hash table, so we avoid
 206    allocating and freeing up a node repeatably.  */
 207 static GTY (()) tree cl_optimization_node;
 208 static GTY (()) tree cl_target_option_node;
 209
 210 struct cl_option_hasher : ggc_cache_ptr_hash<tree_node>
 211 {
 212   static hashval_t hash (tree t);
 213   static bool equal (tree x, tree y);
 214 };
 215
 216 static GTY ((cache)) hash_table<cl_option_hasher> *cl_option_hash_table;
 217
 218 /* General tree->tree mapping  structure for use in hash tables.  */
 219
 220
 221 static GTY ((cache))
 222      hash_table<tree_decl_map_cache_hasher> *debug_expr_for_decl;
 223
 224 static GTY ((cache))
 225      hash_table<tree_decl_map_cache_hasher> *value_expr_for_decl;
 226
 227 struct tree_vec_map_cache_hasher : ggc_cache_ptr_hash<tree_vec_map>
 228 {
 229   static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
 230
 231   static bool
 232   equal (tree_vec_map *a, tree_vec_map *b)
 233   {
 234     return a->base.from == b->base.from;
 235   }
 236
 237   static int
 238   keep_cache_entry (tree_vec_map *&m)
 239   {
 240     return ggc_marked_p (m->base.from);
 241   }
 242 };
 243
 244 static GTY ((cache))
 245      hash_table<tree_vec_map_cache_hasher> *debug_args_for_decl;
 246
 247 static void set_type_quals (tree, int);
 248 static void print_type_hash_statistics (void);
 249 static void print_debug_expr_statistics (void);
 250 static void print_value_expr_statistics (void);
 251 static void type_hash_list (const_tree, inchash::hash &);
 252 static void attribute_hash_list (const_tree, inchash::hash &);
 253
 254 tree global_trees[TI_MAX];
 255 tree integer_types[itk_none];
 256
 257 bool int_n_enabled_p[NUM_INT_N_ENTS];
 258 struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS];
 259
 260 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
 261
 262 /* Number of operands for each OpenMP clause.  */
 263 unsigned const char omp_clause_num_ops[] =
 264 {
 265   0, /* OMP_CLAUSE_ERROR  */
 266   1, /* OMP_CLAUSE_PRIVATE  */
 267   1, /* OMP_CLAUSE_SHARED  */
 268   1, /* OMP_CLAUSE_FIRSTPRIVATE  */
 269   2, /* OMP_CLAUSE_LASTPRIVATE  */
 270   5, /* OMP_CLAUSE_REDUCTION  */
 271   1, /* OMP_CLAUSE_COPYIN  */
 272   1, /* OMP_CLAUSE_COPYPRIVATE  */
 273   3, /* OMP_CLAUSE_LINEAR  */
 274   2, /* OMP_CLAUSE_ALIGNED  */
 275   1, /* OMP_CLAUSE_DEPEND  */
 276   1, /* OMP_CLAUSE_UNIFORM  */
 277   1, /* OMP_CLAUSE_TO_DECLARE  */
 278   1, /* OMP_CLAUSE_LINK  */
 279   2, /* OMP_CLAUSE_FROM  */
 280   2, /* OMP_CLAUSE_TO  */
 281   2, /* OMP_CLAUSE_MAP  */
 282   1, /* OMP_CLAUSE_USE_DEVICE_PTR  */
 283   1, /* OMP_CLAUSE_IS_DEVICE_PTR  */
 284   2, /* OMP_CLAUSE__CACHE_  */
 285   2, /* OMP_CLAUSE_GANG  */
 286   1, /* OMP_CLAUSE_ASYNC  */
 287   1, /* OMP_CLAUSE_WAIT  */
 288   0, /* OMP_CLAUSE_AUTO  */
 289   0, /* OMP_CLAUSE_SEQ  */
 290   1, /* OMP_CLAUSE__LOOPTEMP_  */
 291   1, /* OMP_CLAUSE_IF  */
 292   1, /* OMP_CLAUSE_NUM_THREADS  */
 293   1, /* OMP_CLAUSE_SCHEDULE  */
 294   0, /* OMP_CLAUSE_NOWAIT  */
 295   1, /* OMP_CLAUSE_ORDERED  */
 296   0, /* OMP_CLAUSE_DEFAULT  */
 297   3, /* OMP_CLAUSE_COLLAPSE  */
 298   0, /* OMP_CLAUSE_UNTIED   */
 299   1, /* OMP_CLAUSE_FINAL  */
 300   0, /* OMP_CLAUSE_MERGEABLE  */
 301   1, /* OMP_CLAUSE_DEVICE  */
 302   1, /* OMP_CLAUSE_DIST_SCHEDULE  */
 303   0, /* OMP_CLAUSE_INBRANCH  */
 304   0, /* OMP_CLAUSE_NOTINBRANCH  */
 305   1, /* OMP_CLAUSE_NUM_TEAMS  */
 306   1, /* OMP_CLAUSE_THREAD_LIMIT  */
 307   0, /* OMP_CLAUSE_PROC_BIND  */
 308   1, /* OMP_CLAUSE_SAFELEN  */
 309   1, /* OMP_CLAUSE_SIMDLEN  */
 310   0, /* OMP_CLAUSE_FOR  */
 311   0, /* OMP_CLAUSE_PARALLEL  */
 312   0, /* OMP_CLAUSE_SECTIONS  */
 313   0, /* OMP_CLAUSE_TASKGROUP  */
 314   1, /* OMP_CLAUSE_PRIORITY  */
 315   1, /* OMP_CLAUSE_GRAINSIZE  */
 316   1, /* OMP_CLAUSE_NUM_TASKS  */
 317   0, /* OMP_CLAUSE_NOGROUP  */
 318   0, /* OMP_CLAUSE_THREADS  */
 319   0, /* OMP_CLAUSE_SIMD  */
 320   1, /* OMP_CLAUSE_HINT  */
 321   0, /* OMP_CLAUSE_DEFALTMAP  */
 322   1, /* OMP_CLAUSE__SIMDUID_  */
 323   0, /* OMP_CLAUSE__SIMT_  */
 324   1, /* OMP_CLAUSE__CILK_FOR_COUNT_  */
 325   0, /* OMP_CLAUSE_INDEPENDENT  */
 326   1, /* OMP_CLAUSE_WORKER  */
 327   1, /* OMP_CLAUSE_VECTOR  */
 328   1, /* OMP_CLAUSE_NUM_GANGS  */
 329   1, /* OMP_CLAUSE_NUM_WORKERS  */
 330   1, /* OMP_CLAUSE_VECTOR_LENGTH  */
 331   3, /* OMP_CLAUSE_TILE  */
 332   2, /* OMP_CLAUSE__GRIDDIM_  */
 333 };
 334
 335 const char * const omp_clause_code_name[] =
 336 {
 337   "error_clause",
 338   "private",
 339   "shared",
 340   "firstprivate",
 341   "lastprivate",
 342   "reduction",
 343   "copyin",
 344   "copyprivate",
 345   "linear",
 346   "aligned",
 347   "depend",
 348   "uniform",
 349   "to",
 350   "link",
 351   "from",
 352   "to",
 353   "map",
 354   "use_device_ptr",
 355   "is_device_ptr",
 356   "_cache_",
 357   "gang",
 358   "async",
 359   "wait",
 360   "auto",
 361   "seq",
 362   "_looptemp_",
 363   "if",
 364   "num_threads",
 365   "schedule",
 366   "nowait",
 367   "ordered",
 368   "default",
 369   "collapse",
 370   "untied",
 371   "final",
 372   "mergeable",
 373   "device",
 374   "dist_schedule",
 375   "inbranch",
 376   "notinbranch",
 377   "num_teams",
 378   "thread_limit",
 379   "proc_bind",
 380   "safelen",
 381   "simdlen",
 382   "for",
 383   "parallel",
 384   "sections",
 385   "taskgroup",
 386   "priority",
 387   "grainsize",
 388   "num_tasks",
 389   "nogroup",
 390   "threads",
 391   "simd",
 392   "hint",
 393   "defaultmap",
 394   "_simduid_",
 395   "_simt_",
 396   "_Cilk_for_count_",
 397   "independent",
 398   "worker",
 399   "vector",
 400   "num_gangs",
 401   "num_workers",
 402   "vector_length",
 403   "tile",
 404   "_griddim_"
 405 };
 406
 407
 408 /* Return the tree node structure used by tree code CODE.  */
 409
 410 static inline enum tree_node_structure_enum
 411 tree_node_structure_for_code (enum tree_code code)
 412 {
 413   switch (TREE_CODE_CLASS (code))
 414     {
 415     case tcc_declaration:
 416       {
 417         switch (code)
 418           {
 419           case FIELD_DECL:
 420             return TS_FIELD_DECL;
 421           case PARM_DECL:
 422             return TS_PARM_DECL;
 423           case VAR_DECL:
 424             return TS_VAR_DECL;
 425           case LABEL_DECL:
 426             return TS_LABEL_DECL;
 427           case RESULT_DECL:
 428             return TS_RESULT_DECL;
 429           case DEBUG_EXPR_DECL:
 430             return TS_DECL_WRTL;
 431           case CONST_DECL:
 432             return TS_CONST_DECL;
 433           case TYPE_DECL:
 434             return TS_TYPE_DECL;
 435           case FUNCTION_DECL:
 436             return TS_FUNCTION_DECL;
 437           case TRANSLATION_UNIT_DECL:
 438             return TS_TRANSLATION_UNIT_DECL;
 439           default:
 440             return TS_DECL_NON_COMMON;
 441           }
 442       }
 443     case tcc_type:
 444       return TS_TYPE_NON_COMMON;
 445     case tcc_reference:
 446     case tcc_comparison:
 447     case tcc_unary:
 448     case tcc_binary:
 449     case tcc_expression:
 450     case tcc_statement:
 451     case tcc_vl_exp:
 452       return TS_EXP;
 453     default:  /* tcc_constant and tcc_exceptional */
 454       break;
 455     }
 456   switch (code)
 457     {
 458       /* tcc_constant cases.  */
 459     case VOID_CST:              return TS_TYPED;
 460     case INTEGER_CST:           return TS_INT_CST;
 461     case REAL_CST:              return TS_REAL_CST;
 462     case FIXED_CST:             return TS_FIXED_CST;
 463     case COMPLEX_CST:           return TS_COMPLEX;
 464     case VECTOR_CST:            return TS_VECTOR;
 465     case STRING_CST:            return TS_STRING;
 466       /* tcc_exceptional cases.  */
 467     case ERROR_MARK:            return TS_COMMON;
 468     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
 469     case TREE_LIST:             return TS_LIST;
 470     case TREE_VEC:              return TS_VEC;
 471     case SSA_NAME:              return TS_SSA_NAME;
 472     case PLACEHOLDER_EXPR:      return TS_COMMON;
 473     case STATEMENT_LIST:        return TS_STATEMENT_LIST;
 474     case BLOCK:                 return TS_BLOCK;
 475     case CONSTRUCTOR:           return TS_CONSTRUCTOR;
 476     case TREE_BINFO:            return TS_BINFO;
 477     case OMP_CLAUSE:            return TS_OMP_CLAUSE;
 478     case OPTIMIZATION_NODE:     return TS_OPTIMIZATION;
 479     case TARGET_OPTION_NODE:    return TS_TARGET_OPTION;
 480
 481     default:
 482       gcc_unreachable ();
 483     }
 484 }
 485
 486
 487 /* Initialize tree_contains_struct to describe the hierarchy of tree
 488    nodes.  */
 489
 490 static void
 491 initialize_tree_contains_struct (void)
 492 {
 493   unsigned i;
 494
 495   for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
 496     {
 497       enum tree_code code;
 498       enum tree_node_structure_enum ts_code;
 499
 500       code = (enum tree_code) i;
 501       ts_code = tree_node_structure_for_code (code);
 502
 503       /* Mark the TS structure itself.  */
 504       tree_contains_struct[code][ts_code] = 1;
 505
 506       /* Mark all the structures that TS is derived from.  */
 507       switch (ts_code)
 508         {
 509         case TS_TYPED:
 510         case TS_BLOCK:
 511         case TS_OPTIMIZATION:
 512         case TS_TARGET_OPTION:
 513           MARK_TS_BASE (code);
 514           break;
 515
 516         case TS_COMMON:
 517         case TS_INT_CST:
 518         case TS_REAL_CST:
 519         case TS_FIXED_CST:
 520         case TS_VECTOR:
 521         case TS_STRING:
 522         case TS_COMPLEX:
 523         case TS_SSA_NAME:
 524         case TS_CONSTRUCTOR:
 525         case TS_EXP:
 526         case TS_STATEMENT_LIST:
 527           MARK_TS_TYPED (code);
 528           break;
 529
 530         case TS_IDENTIFIER:
 531         case TS_DECL_MINIMAL:
 532         case TS_TYPE_COMMON:
 533         case TS_LIST:
 534         case TS_VEC:
 535         case TS_BINFO:
 536         case TS_OMP_CLAUSE:
 537           MARK_TS_COMMON (code);
 538           break;
 539
 540         case TS_TYPE_WITH_LANG_SPECIFIC:
 541           MARK_TS_TYPE_COMMON (code);
 542           break;
 543
 544         case TS_TYPE_NON_COMMON:
 545           MARK_TS_TYPE_WITH_LANG_SPECIFIC (code);
 546           break;
 547
 548         case TS_DECL_COMMON:
 549           MARK_TS_DECL_MINIMAL (code);
 550           break;
 551
 552         case TS_DECL_WRTL:
 553         case TS_CONST_DECL:
 554           MARK_TS_DECL_COMMON (code);
 555           break;
 556
 557         case TS_DECL_NON_COMMON:
 558           MARK_TS_DECL_WITH_VIS (code);
 559           break;
 560
 561         case TS_DECL_WITH_VIS:
 562         case TS_PARM_DECL:
 563         case TS_LABEL_DECL:
 564         case TS_RESULT_DECL:
 565           MARK_TS_DECL_WRTL (code);
 566           break;
 567
 568         case TS_FIELD_DECL:
 569           MARK_TS_DECL_COMMON (code);
 570           break;
 571
 572         case TS_VAR_DECL:
 573           MARK_TS_DECL_WITH_VIS (code);
 574           break;
 575
 576         case TS_TYPE_DECL:
 577         case TS_FUNCTION_DECL:
 578           MARK_TS_DECL_NON_COMMON (code);
 579           break;
 580
 581         case TS_TRANSLATION_UNIT_DECL:
 582           MARK_TS_DECL_COMMON (code);
 583           break;
 584
 585         default:
 586           gcc_unreachable ();
 587         }
 588     }
 589
 590   /* Basic consistency checks for attributes used in fold.  */
 591   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
 592   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
 593   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
 594   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
 595   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
 596   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
 597   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
 598   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
 599   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
 600   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
 601   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
 602   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
 603   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
 604   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
 605   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
 606   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
 607   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
 608   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
 609   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
 610   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
 611   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
 612   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
 613   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
 614   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
 615   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
 616   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
 617   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
 618   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
 619   gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
 620   gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
 621   gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
 622   gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
 623   gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
 624   gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
 625   gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
 626   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
 627   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
 628   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
 629   gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
 630   gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
 631 }
 632
 633
 634 /* Init tree.c.  */
 635
 636 void
 637 init_ttree (void)
 638 {
 639   /* Initialize the hash table of types.  */
 640   type_hash_table
 641     = hash_table<type_cache_hasher>::create_ggc (TYPE_HASH_INITIAL_SIZE);
 642
 643   debug_expr_for_decl
 644     = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
 645
 646   value_expr_for_decl
 647     = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
 648
 649   int_cst_hash_table = hash_table<int_cst_hasher>::create_ggc (1024);
 650
 651   int_cst_node = make_int_cst (1, 1);
 652
 653   cl_option_hash_table = hash_table<cl_option_hasher>::create_ggc (64);
 654
 655   cl_optimization_node = make_node (OPTIMIZATION_NODE);
 656   cl_target_option_node = make_node (TARGET_OPTION_NODE);
 657
 658   /* Initialize the tree_contains_struct array.  */
 659   initialize_tree_contains_struct ();
 660   lang_hooks.init_ts ();
 661 }
 662
 663 \f
 664 /* The name of the object as the assembler will see it (but before any
 665    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
 666    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
 667 tree
 668 decl_assembler_name (tree decl)
 669 {
 670   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 671     lang_hooks.set_decl_assembler_name (decl);
 672   return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
 673 }
 674
 675 /* When the target supports COMDAT groups, this indicates which group the
 676    DECL is associated with.  This can be either an IDENTIFIER_NODE or a
 677    decl, in which case its DECL_ASSEMBLER_NAME identifies the group.  */
 678 tree
 679 decl_comdat_group (const_tree node)
 680 {
 681   struct symtab_node *snode = symtab_node::get (node);
 682   if (!snode)
 683     return NULL;
 684   return snode->get_comdat_group ();
 685 }
 686
 687 /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE.  */
 688 tree
 689 decl_comdat_group_id (const_tree node)
 690 {
 691   struct symtab_node *snode = symtab_node::get (node);
 692   if (!snode)
 693     return NULL;
 694   return snode->get_comdat_group_id ();
 695 }
 696
 697 /* When the target supports named section, return its name as IDENTIFIER_NODE
 698    or NULL if it is in no section.  */
 699 const char *
 700 decl_section_name (const_tree node)
 701 {
 702   struct symtab_node *snode = symtab_node::get (node);
 703   if (!snode)
 704     return NULL;
 705   return snode->get_section ();
 706 }
 707
 708 /* Set section name of NODE to VALUE (that is expected to be
 709    identifier node) */
 710 void
 711 set_decl_section_name (tree node, const char *value)
 712 {
 713   struct symtab_node *snode;
 714
 715   if (value == NULL)
 716     {
 717       snode = symtab_node::get (node);
 718       if (!snode)
 719         return;
 720     }
 721   else if (VAR_P (node))
 722     snode = varpool_node::get_create (node);
 723   else
 724     snode = cgraph_node::get_create (node);
 725   snode->set_section (value);
 726 }
 727
 728 /* Return TLS model of a variable NODE.  */
 729 enum tls_model
 730 decl_tls_model (const_tree node)
 731 {
 732   struct varpool_node *snode = varpool_node::get (node);
 733   if (!snode)
 734     return TLS_MODEL_NONE;
 735   return snode->tls_model;
 736 }
 737
 738 /* Set TLS model of variable NODE to MODEL.  */
 739 void
 740 set_decl_tls_model (tree node, enum tls_model model)
 741 {
 742   struct varpool_node *vnode;
 743
 744   if (model == TLS_MODEL_NONE)
 745     {
 746       vnode = varpool_node::get (node);
 747       if (!vnode)
 748         return;
 749     }
 750   else
 751     vnode = varpool_node::get_create (node);
 752   vnode->tls_model = model;
 753 }
 754
 755 /* Compute the number of bytes occupied by a tree with code CODE.
 756    This function cannot be used for nodes that have variable sizes,
 757    including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR.  */
 758 size_t
 759 tree_code_size (enum tree_code code)
 760 {
 761   switch (TREE_CODE_CLASS (code))
 762     {
 763     case tcc_declaration:  /* A decl node */
 764       {
 765         switch (code)
 766           {
 767           case FIELD_DECL:
 768             return sizeof (struct tree_field_decl);
 769           case PARM_DECL:
 770             return sizeof (struct tree_parm_decl);
 771           case VAR_DECL:
 772             return sizeof (struct tree_var_decl);
 773           case LABEL_DECL:
 774             return sizeof (struct tree_label_decl);
 775           case RESULT_DECL:
 776             return sizeof (struct tree_result_decl);
 777           case CONST_DECL:
 778             return sizeof (struct tree_const_decl);
 779           case TYPE_DECL:
 780             return sizeof (struct tree_type_decl);
 781           case FUNCTION_DECL:
 782             return sizeof (struct tree_function_decl);
 783           case DEBUG_EXPR_DECL:
 784             return sizeof (struct tree_decl_with_rtl);
 785           case TRANSLATION_UNIT_DECL:
 786             return sizeof (struct tree_translation_unit_decl);
 787           case NAMESPACE_DECL:
 788           case IMPORTED_DECL:
 789           case NAMELIST_DECL:
 790             return sizeof (struct tree_decl_non_common);
 791           default:
 792             return lang_hooks.tree_size (code);
 793           }
 794       }
 795
 796     case tcc_type:  /* a type node */
 797       return sizeof (struct tree_type_non_common);
 798
 799     case tcc_reference:   /* a reference */
 800     case tcc_expression:  /* an expression */
 801     case tcc_statement:   /* an expression with side effects */
 802     case tcc_comparison:  /* a comparison expression */
 803     case tcc_unary:       /* a unary arithmetic expression */
 804     case tcc_binary:      /* a binary arithmetic expression */
 805       return (sizeof (struct tree_exp)
 806               + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
 807
 808     case tcc_constant:  /* a constant */
 809       switch (code)
 810         {
 811         case VOID_CST:          return sizeof (struct tree_typed);
 812         case INTEGER_CST:       gcc_unreachable ();
 813         case REAL_CST:          return sizeof (struct tree_real_cst);
 814         case FIXED_CST:         return sizeof (struct tree_fixed_cst);
 815         case COMPLEX_CST:       return sizeof (struct tree_complex);
 816         case VECTOR_CST:        return sizeof (struct tree_vector);
 817         case STRING_CST:        gcc_unreachable ();
 818         default:
 819           return lang_hooks.tree_size (code);
 820         }
 821
 822     case tcc_exceptional:  /* something random, like an identifier.  */
 823       switch (code)
 824         {
 825         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
 826         case TREE_LIST:         return sizeof (struct tree_list);
 827
 828         case ERROR_MARK:
 829         case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
 830
 831         case TREE_VEC:
 832         case OMP_CLAUSE:        gcc_unreachable ();
 833
 834         case SSA_NAME:          return sizeof (struct tree_ssa_name);
 835
 836         case STATEMENT_LIST:    return sizeof (struct tree_statement_list);
 837         case BLOCK:             return sizeof (struct tree_block);
 838         case CONSTRUCTOR:       return sizeof (struct tree_constructor);
 839         case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
 840         case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
 841
 842         default:
 843           return lang_hooks.tree_size (code);
 844         }
 845
 846     default:
 847       gcc_unreachable ();
 848     }
 849 }
 850
 851 /* Compute the number of bytes occupied by NODE.  This routine only
 852    looks at TREE_CODE, except for those nodes that have variable sizes.  */
 853 size_t
 854 tree_size (const_tree node)
 855 {
 856   const enum tree_code code = TREE_CODE (node);
 857   switch (code)
 858     {
 859     case INTEGER_CST:
 860       return (sizeof (struct tree_int_cst)
 861               + (TREE_INT_CST_EXT_NUNITS (node) - 1) * sizeof (HOST_WIDE_INT));
 862
 863     case TREE_BINFO:
 864       return (offsetof (struct tree_binfo, base_binfos)
 865               + vec<tree, va_gc>
 866                   ::embedded_size (BINFO_N_BASE_BINFOS (node)));
 867
 868     case TREE_VEC:
 869       return (sizeof (struct tree_vec)
 870               + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
 871
 872     case VECTOR_CST:
 873       return (sizeof (struct tree_vector)
 874               + (TYPE_VECTOR_SUBPARTS (TREE_TYPE (node)) - 1) * sizeof (tree));
 875
 876     case STRING_CST:
 877       return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
 878
 879     case OMP_CLAUSE:
 880       return (sizeof (struct tree_omp_clause)
 881               + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
 882                 * sizeof (tree));
 883
 884     default:
 885       if (TREE_CODE_CLASS (code) == tcc_vl_exp)
 886         return (sizeof (struct tree_exp)
 887                 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
 888       else
 889         return tree_code_size (code);
 890     }
 891 }
 892
 893 /* Record interesting allocation statistics for a tree node with CODE
 894    and LENGTH.  */
 895
 896 static void
 897 record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED,
 898                                    size_t length ATTRIBUTE_UNUSED)
 899 {
 900   enum tree_code_class type = TREE_CODE_CLASS (code);
 901   tree_node_kind kind;
 902
 903   if (!GATHER_STATISTICS)
 904     return;
 905
 906   switch (type)
 907     {
 908     case tcc_declaration:  /* A decl node */
 909       kind = d_kind;
 910       break;
 911
 912     case tcc_type:  /* a type node */
 913       kind = t_kind;
 914       break;
 915
 916     case tcc_statement:  /* an expression with side effects */
 917       kind = s_kind;
 918       break;
 919
 920     case tcc_reference:  /* a reference */
 921       kind = r_kind;
 922       break;
 923
 924     case tcc_expression:  /* an expression */
 925     case tcc_comparison:  /* a comparison expression */
 926     case tcc_unary:  /* a unary arithmetic expression */
 927     case tcc_binary:  /* a binary arithmetic expression */
 928       kind = e_kind;
 929       break;
 930
 931     case tcc_constant:  /* a constant */
 932       kind = c_kind;
 933       break;
 934
 935     case tcc_exceptional:  /* something random, like an identifier.  */
 936       switch (code)
 937         {
 938         case IDENTIFIER_NODE:
 939           kind = id_kind;
 940           break;
 941
 942         case TREE_VEC:
 943           kind = vec_kind;
 944           break;
 945
 946         case TREE_BINFO:
 947           kind = binfo_kind;
 948           break;
 949
 950         case SSA_NAME:
 951           kind = ssa_name_kind;
 952           break;
 953
 954         case BLOCK:
 955           kind = b_kind;
 956           break;
 957
 958         case CONSTRUCTOR:
 959           kind = constr_kind;
 960           break;
 961
 962         case OMP_CLAUSE:
 963           kind = omp_clause_kind;
 964           break;
 965
 966         default:
 967           kind = x_kind;
 968           break;
 969         }
 970       break;
 971
 972     case tcc_vl_exp:
 973       kind = e_kind;
 974       break;
 975
 976     default:
 977       gcc_unreachable ();
 978     }
 979
 980   tree_code_counts[(int) code]++;
 981   tree_node_counts[(int) kind]++;
 982   tree_node_sizes[(int) kind] += length;
 983 }
 984
 985 /* Allocate and return a new UID from the DECL_UID namespace.  */
 986
 987 int
 988 allocate_decl_uid (void)
 989 {
 990   return next_decl_uid++;
 991 }
 992
 993 /* Return a newly allocated node of code CODE.  For decl and type
 994    nodes, some other fields are initialized.  The rest of the node is
 995    initialized to zero.  This function cannot be used for TREE_VEC,
 996    INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
 997    tree_code_size.
 998
 999    Achoo!  I got a code in the node.  */
1000
1001 tree
1002 make_node_stat (enum tree_code code MEM_STAT_DECL)
1003 {
1004   tree t;
1005   enum tree_code_class type = TREE_CODE_CLASS (code);
1006   size_t length = tree_code_size (code);
1007
1008   record_node_allocation_statistics (code, length);
1009
1010   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1011   TREE_SET_CODE (t, code);
1012
1013   switch (type)
1014     {
1015     case tcc_statement:
1016       TREE_SIDE_EFFECTS (t) = 1;
1017       break;
1018
1019     case tcc_declaration:
1020       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1021         {
1022           if (code == FUNCTION_DECL)
1023             {
1024               SET_DECL_ALIGN (t, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY));
1025               SET_DECL_MODE (t, FUNCTION_MODE);
1026             }
1027           else
1028             SET_DECL_ALIGN (t, 1);
1029         }
1030       DECL_SOURCE_LOCATION (t) = input_location;
1031       if (TREE_CODE (t) == DEBUG_EXPR_DECL)
1032         DECL_UID (t) = --next_debug_decl_uid;
1033       else
1034         {
1035           DECL_UID (t) = allocate_decl_uid ();
1036           SET_DECL_PT_UID (t, -1);
1037         }
1038       if (TREE_CODE (t) == LABEL_DECL)
1039         LABEL_DECL_UID (t) = -1;
1040
1041       break;
1042
1043     case tcc_type:
1044       TYPE_UID (t) = next_type_uid++;
1045       SET_TYPE_ALIGN (t, BITS_PER_UNIT);
1046       TYPE_USER_ALIGN (t) = 0;
1047       TYPE_MAIN_VARIANT (t) = t;
1048       TYPE_CANONICAL (t) = t;
1049
1050       /* Default to no attributes for type, but let target change that.  */
1051       TYPE_ATTRIBUTES (t) = NULL_TREE;
1052       targetm.set_default_type_attributes (t);
1053
1054       /* We have not yet computed the alias set for this type.  */
1055       TYPE_ALIAS_SET (t) = -1;
1056       break;
1057
1058     case tcc_constant:
1059       TREE_CONSTANT (t) = 1;
1060       break;
1061
1062     case tcc_expression:
1063       switch (code)
1064         {
1065         case INIT_EXPR:
1066         case MODIFY_EXPR:
1067         case VA_ARG_EXPR:
1068         case PREDECREMENT_EXPR:
1069         case PREINCREMENT_EXPR:
1070         case POSTDECREMENT_EXPR:
1071         case POSTINCREMENT_EXPR:
1072           /* All of these have side-effects, no matter what their
1073              operands are.  */
1074           TREE_SIDE_EFFECTS (t) = 1;
1075           break;
1076
1077         default:
1078           break;
1079         }
1080       break;
1081
1082     case tcc_exceptional:
1083       switch (code)
1084         {
1085         case TARGET_OPTION_NODE:
1086           TREE_TARGET_OPTION(t)
1087                             = ggc_cleared_alloc<struct cl_target_option> ();
1088           break;
1089
1090         case OPTIMIZATION_NODE:
1091           TREE_OPTIMIZATION (t)
1092                             = ggc_cleared_alloc<struct cl_optimization> ();
1093           break;
1094
1095         default:
1096           break;
1097         }
1098       break;
1099
1100     default:
1101       /* Other classes need no special treatment.  */
1102       break;
1103     }
1104
1105   return t;
1106 }
1107
1108 /* Free tree node.  */
1109
1110 void
1111 free_node (tree node)
1112 {
1113   enum tree_code code = TREE_CODE (node);
1114   if (GATHER_STATISTICS)
1115     {
1116       tree_code_counts[(int) TREE_CODE (node)]--;
1117       tree_node_counts[(int) t_kind]--;
1118       tree_node_sizes[(int) t_kind] -= tree_size (node);
1119     }
1120   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1121     vec_free (CONSTRUCTOR_ELTS (node));
1122   else if (code == BLOCK)
1123     vec_free (BLOCK_NONLOCALIZED_VARS (node));
1124   else if (code == TREE_BINFO)
1125     vec_free (BINFO_BASE_ACCESSES (node));
1126   ggc_free (node);
1127 }
1128 \f
1129 /* Return a new node with the same contents as NODE except that its
1130    TREE_CHAIN, if it has one, is zero and it has a fresh uid.  */
1131
1132 tree
1133 copy_node_stat (tree node MEM_STAT_DECL)
1134 {
1135   tree t;
1136   enum tree_code code = TREE_CODE (node);
1137   size_t length;
1138
1139   gcc_assert (code != STATEMENT_LIST);
1140
1141   length = tree_size (node);
1142   record_node_allocation_statistics (code, length);
1143   t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
1144   memcpy (t, node, length);
1145
1146   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1147     TREE_CHAIN (t) = 0;
1148   TREE_ASM_WRITTEN (t) = 0;
1149   TREE_VISITED (t) = 0;
1150
1151   if (TREE_CODE_CLASS (code) == tcc_declaration)
1152     {
1153       if (code == DEBUG_EXPR_DECL)
1154         DECL_UID (t) = --next_debug_decl_uid;
1155       else
1156         {
1157           DECL_UID (t) = allocate_decl_uid ();
1158           if (DECL_PT_UID_SET_P (node))
1159             SET_DECL_PT_UID (t, DECL_PT_UID (node));
1160         }
1161       if ((TREE_CODE (node) == PARM_DECL || VAR_P (node))
1162           && DECL_HAS_VALUE_EXPR_P (node))
1163         {
1164           SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
1165           DECL_HAS_VALUE_EXPR_P (t) = 1;
1166         }
1167       /* DECL_DEBUG_EXPR is copied explicitely by callers.  */
1168       if (VAR_P (node))
1169         {
1170           DECL_HAS_DEBUG_EXPR_P (t) = 0;
1171           t->decl_with_vis.symtab_node = NULL;
1172         }
1173       if (VAR_P (node) && DECL_HAS_INIT_PRIORITY_P (node))
1174         {
1175           SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
1176           DECL_HAS_INIT_PRIORITY_P (t) = 1;
1177         }
1178       if (TREE_CODE (node) == FUNCTION_DECL)
1179         {
1180           DECL_STRUCT_FUNCTION (t) = NULL;
1181           t->decl_with_vis.symtab_node = NULL;
1182         }
1183     }
1184   else if (TREE_CODE_CLASS (code) == tcc_type)
1185     {
1186       TYPE_UID (t) = next_type_uid++;
1187       /* The following is so that the debug code for
1188          the copy is different from the original type.
1189          The two statements usually duplicate each other
1190          (because they clear fields of the same union),
1191          but the optimizer should catch that.  */
1192       TYPE_SYMTAB_POINTER (t) = 0;
1193       TYPE_SYMTAB_ADDRESS (t) = 0;
1194
1195       /* Do not copy the values cache.  */
1196       if (TYPE_CACHED_VALUES_P (t))
1197         {
1198           TYPE_CACHED_VALUES_P (t) = 0;
1199           TYPE_CACHED_VALUES (t) = NULL_TREE;
1200         }
1201     }
1202     else if (code == TARGET_OPTION_NODE)
1203       {
1204         TREE_TARGET_OPTION (t) = ggc_alloc<struct cl_target_option>();
1205         memcpy (TREE_TARGET_OPTION (t), TREE_TARGET_OPTION (node),
1206                 sizeof (struct cl_target_option));
1207       }
1208     else if (code == OPTIMIZATION_NODE)
1209       {
1210         TREE_OPTIMIZATION (t) = ggc_alloc<struct cl_optimization>();
1211         memcpy (TREE_OPTIMIZATION (t), TREE_OPTIMIZATION (node),
1212                 sizeof (struct cl_optimization));
1213       }
1214
1215   return t;
1216 }
1217
1218 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1219    For example, this can copy a list made of TREE_LIST nodes.  */
1220
1221 tree
1222 copy_list (tree list)
1223 {
1224   tree head;
1225   tree prev, next;
1226
1227   if (list == 0)
1228     return 0;
1229
1230   head = prev = copy_node (list);
1231   next = TREE_CHAIN (list);
1232   while (next)
1233     {
1234       TREE_CHAIN (prev) = copy_node (next);
1235       prev = TREE_CHAIN (prev);
1236       next = TREE_CHAIN (next);
1237     }
1238   return head;
1239 }
1240
1241 \f
1242 /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
1243    INTEGER_CST with value CST and type TYPE.   */
1244
1245 static unsigned int
1246 get_int_cst_ext_nunits (tree type, const wide_int &cst)
1247 {
1248   gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type));
1249   /* We need extra HWIs if CST is an unsigned integer with its
1250      upper bit set.  */
1251   if (TYPE_UNSIGNED (type) && wi::neg_p (cst))
1252     return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1;
1253   return cst.get_len ();
1254 }
1255
1256 /* Return a new INTEGER_CST with value CST and type TYPE.  */
1257
1258 static tree
1259 build_new_int_cst (tree type, const wide_int &cst)
1260 {
1261   unsigned int len = cst.get_len ();
1262   unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1263   tree nt = make_int_cst (len, ext_len);
1264
1265   if (len < ext_len)
1266     {
1267       --ext_len;
1268       TREE_INT_CST_ELT (nt, ext_len)
1269         = zext_hwi (-1, cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1270       for (unsigned int i = len; i < ext_len; ++i)
1271         TREE_INT_CST_ELT (nt, i) = -1;
1272     }
1273   else if (TYPE_UNSIGNED (type)
1274            && cst.get_precision () < len * HOST_BITS_PER_WIDE_INT)
1275     {
1276       len--;
1277       TREE_INT_CST_ELT (nt, len)
1278         = zext_hwi (cst.elt (len),
1279                     cst.get_precision () % HOST_BITS_PER_WIDE_INT);
1280     }
1281
1282   for (unsigned int i = 0; i < len; i++)
1283     TREE_INT_CST_ELT (nt, i) = cst.elt (i);
1284   TREE_TYPE (nt) = type;
1285   return nt;
1286 }
1287
1288 /* Create an INT_CST node with a LOW value sign extended to TYPE.  */
1289
1290 tree
1291 build_int_cst (tree type, HOST_WIDE_INT low)
1292 {
1293   /* Support legacy code.  */
1294   if (!type)
1295     type = integer_type_node;
1296
1297   return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1298 }
1299
1300 tree
1301 build_int_cstu (tree type, unsigned HOST_WIDE_INT cst)
1302 {
1303   return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type)));
1304 }
1305
1306 /* Create an INT_CST node with a LOW value sign extended to TYPE.  */
1307
1308 tree
1309 build_int_cst_type (tree type, HOST_WIDE_INT low)
1310 {
1311   gcc_assert (type);
1312   return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type)));
1313 }
1314
1315 /* Constructs tree in type TYPE from with value given by CST.  Signedness
1316    of CST is assumed to be the same as the signedness of TYPE.  */
1317
1318 tree
1319 double_int_to_tree (tree type, double_int cst)
1320 {
1321   return wide_int_to_tree (type, widest_int::from (cst, TYPE_SIGN (type)));
1322 }
1323
1324 /* We force the wide_int CST to the range of the type TYPE by sign or
1325    zero extending it.  OVERFLOWABLE indicates if we are interested in
1326    overflow of the value, when >0 we are only interested in signed
1327    overflow, for <0 we are interested in any overflow.  OVERFLOWED
1328    indicates whether overflow has already occurred.  CONST_OVERFLOWED
1329    indicates whether constant overflow has already occurred.  We force
1330    T's value to be within range of T's type (by setting to 0 or 1 all
1331    the bits outside the type's range).  We set TREE_OVERFLOWED if,
1332         OVERFLOWED is nonzero,
1333         or OVERFLOWABLE is >0 and signed overflow occurs
1334         or OVERFLOWABLE is <0 and any overflow occurs
1335    We return a new tree node for the extended wide_int.  The node
1336    is shared if no overflow flags are set.  */
1337
1338
1339 tree
1340 force_fit_type (tree type, const wide_int_ref &cst,
1341                 int overflowable, bool overflowed)
1342 {
1343   signop sign = TYPE_SIGN (type);
1344
1345   /* If we need to set overflow flags, return a new unshared node.  */
1346   if (overflowed || !wi::fits_to_tree_p (cst, type))
1347     {
1348       if (overflowed
1349           || overflowable < 0
1350           || (overflowable > 0 && sign == SIGNED))
1351         {
1352           wide_int tmp = wide_int::from (cst, TYPE_PRECISION (type), sign);
1353           tree t = build_new_int_cst (type, tmp);
1354           TREE_OVERFLOW (t) = 1;
1355           return t;
1356         }
1357     }
1358
1359   /* Else build a shared node.  */
1360   return wide_int_to_tree (type, cst);
1361 }
1362
1363 /* These are the hash table functions for the hash table of INTEGER_CST
1364    nodes of a sizetype.  */
1365
1366 /* Return the hash code X, an INTEGER_CST.  */
1367
1368 hashval_t
1369 int_cst_hasher::hash (tree x)
1370 {
1371   const_tree const t = x;
1372   hashval_t code = TYPE_UID (TREE_TYPE (t));
1373   int i;
1374
1375   for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
1376     code = iterative_hash_host_wide_int (TREE_INT_CST_ELT(t, i), code);
1377
1378   return code;
1379 }
1380
1381 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1382    is the same as that given by *Y, which is the same.  */
1383
1384 bool
1385 int_cst_hasher::equal (tree x, tree y)
1386 {
1387   const_tree const xt = x;
1388   const_tree const yt = y;
1389
1390   if (TREE_TYPE (xt) != TREE_TYPE (yt)
1391       || TREE_INT_CST_NUNITS (xt) != TREE_INT_CST_NUNITS (yt)
1392       || TREE_INT_CST_EXT_NUNITS (xt) != TREE_INT_CST_EXT_NUNITS (yt))
1393     return false;
1394
1395   for (int i = 0; i < TREE_INT_CST_NUNITS (xt); i++)
1396     if (TREE_INT_CST_ELT (xt, i) != TREE_INT_CST_ELT (yt, i))
1397       return false;
1398
1399   return true;
1400 }
1401
1402 /* Create an INT_CST node of TYPE and value CST.
1403    The returned node is always shared.  For small integers we use a
1404    per-type vector cache, for larger ones we use a single hash table.
1405    The value is extended from its precision according to the sign of
1406    the type to be a multiple of HOST_BITS_PER_WIDE_INT.  This defines
1407    the upper bits and ensures that hashing and value equality based
1408    upon the underlying HOST_WIDE_INTs works without masking.  */
1409
1410 tree
1411 wide_int_to_tree (tree type, const wide_int_ref &pcst)
1412 {
1413   tree t;
1414   int ix = -1;
1415   int limit = 0;
1416
1417   gcc_assert (type);
1418   unsigned int prec = TYPE_PRECISION (type);
1419   signop sgn = TYPE_SIGN (type);
1420
1421   /* Verify that everything is canonical.  */
1422   int l = pcst.get_len ();
1423   if (l > 1)
1424     {
1425       if (pcst.elt (l - 1) == 0)
1426         gcc_checking_assert (pcst.elt (l - 2) < 0);
1427       if (pcst.elt (l - 1) == HOST_WIDE_INT_M1)
1428         gcc_checking_assert (pcst.elt (l - 2) >= 0);
1429     }
1430
1431   wide_int cst = wide_int::from (pcst, prec, sgn);
1432   unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
1433
1434   if (ext_len == 1)
1435     {
1436       /* We just need to store a single HOST_WIDE_INT.  */
1437       HOST_WIDE_INT hwi;
1438       if (TYPE_UNSIGNED (type))
1439         hwi = cst.to_uhwi ();
1440       else
1441         hwi = cst.to_shwi ();
1442
1443       switch (TREE_CODE (type))
1444         {
1445         case NULLPTR_TYPE:
1446           gcc_assert (hwi == 0);
1447           /* Fallthru.  */
1448
1449         case POINTER_TYPE:
1450         case REFERENCE_TYPE:
1451         case POINTER_BOUNDS_TYPE:
1452           /* Cache NULL pointer and zero bounds.  */
1453           if (hwi == 0)
1454             {
1455               limit = 1;
1456               ix = 0;
1457             }
1458           break;
1459
1460         case BOOLEAN_TYPE:
1461           /* Cache false or true.  */
1462           limit = 2;
1463           if (IN_RANGE (hwi, 0, 1))
1464             ix = hwi;
1465           break;
1466
1467         case INTEGER_TYPE:
1468         case OFFSET_TYPE:
1469           if (TYPE_SIGN (type) == UNSIGNED)
1470             {
1471               /* Cache [0, N).  */
1472               limit = INTEGER_SHARE_LIMIT;
1473               if (IN_RANGE (hwi, 0, INTEGER_SHARE_LIMIT - 1))
1474                 ix = hwi;
1475             }
1476           else
1477             {
1478               /* Cache [-1, N).  */
1479               limit = INTEGER_SHARE_LIMIT + 1;
1480               if (IN_RANGE (hwi, -1, INTEGER_SHARE_LIMIT - 1))
1481                 ix = hwi + 1;
1482             }
1483           break;
1484
1485         case ENUMERAL_TYPE:
1486           break;
1487
1488         default:
1489           gcc_unreachable ();
1490         }
1491
1492       if (ix >= 0)
1493         {
1494           /* Look for it in the type's vector of small shared ints.  */
1495           if (!TYPE_CACHED_VALUES_P (type))
1496             {
1497               TYPE_CACHED_VALUES_P (type) = 1;
1498               TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1499             }
1500
1501           t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1502           if (t)
1503             /* Make sure no one is clobbering the shared constant.  */
1504             gcc_checking_assert (TREE_TYPE (t) == type
1505                                  && TREE_INT_CST_NUNITS (t) == 1
1506                                  && TREE_INT_CST_OFFSET_NUNITS (t) == 1
1507                                  && TREE_INT_CST_EXT_NUNITS (t) == 1
1508                                  && TREE_INT_CST_ELT (t, 0) == hwi);
1509           else
1510             {
1511               /* Create a new shared int.  */
1512               t = build_new_int_cst (type, cst);
1513               TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1514             }
1515         }
1516       else
1517         {
1518           /* Use the cache of larger shared ints, using int_cst_node as
1519              a temporary.  */
1520
1521           TREE_INT_CST_ELT (int_cst_node, 0) = hwi;
1522           TREE_TYPE (int_cst_node) = type;
1523
1524           tree *slot = int_cst_hash_table->find_slot (int_cst_node, INSERT);
1525           t = *slot;
1526           if (!t)
1527             {
1528               /* Insert this one into the hash table.  */
1529               t = int_cst_node;
1530               *slot = t;
1531               /* Make a new node for next time round.  */
1532               int_cst_node = make_int_cst (1, 1);
1533             }
1534         }
1535     }
1536   else
1537     {
1538       /* The value either hashes properly or we drop it on the floor
1539          for the gc to take care of.  There will not be enough of them
1540          to worry about.  */
1541
1542       tree nt = build_new_int_cst (type, cst);
1543       tree *slot = int_cst_hash_table->find_slot (nt, INSERT);
1544       t = *slot;
1545       if (!t)
1546         {
1547           /* Insert this one into the hash table.  */
1548           t = nt;
1549           *slot = t;
1550         }
1551     }
1552
1553   return t;
1554 }
1555
1556 void
1557 cache_integer_cst (tree t)
1558 {
1559   tree type = TREE_TYPE (t);
1560   int ix = -1;
1561   int limit = 0;
1562   int prec = TYPE_PRECISION (type);
1563
1564   gcc_assert (!TREE_OVERFLOW (t));
1565
1566   switch (TREE_CODE (type))
1567     {
1568     case NULLPTR_TYPE:
1569       gcc_assert (integer_zerop (t));
1570       /* Fallthru.  */
1571
1572     case POINTER_TYPE:
1573     case REFERENCE_TYPE:
1574       /* Cache NULL pointer.  */
1575       if (integer_zerop (t))
1576         {
1577           limit = 1;
1578           ix = 0;
1579         }
1580       break;
1581
1582     case BOOLEAN_TYPE:
1583       /* Cache false or true.  */
1584       limit = 2;
1585       if (wi::ltu_p (t, 2))
1586         ix = TREE_INT_CST_ELT (t, 0);
1587       break;
1588
1589     case INTEGER_TYPE:
1590     case OFFSET_TYPE:
1591       if (TYPE_UNSIGNED (type))
1592         {
1593           /* Cache 0..N */
1594           limit = INTEGER_SHARE_LIMIT;
1595
1596           /* This is a little hokie, but if the prec is smaller than
1597              what is necessary to hold INTEGER_SHARE_LIMIT, then the
1598              obvious test will not get the correct answer.  */
1599           if (prec < HOST_BITS_PER_WIDE_INT)
1600             {
1601               if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
1602                 ix = tree_to_uhwi (t);
1603             }
1604           else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1605             ix = tree_to_uhwi (t);
1606         }
1607       else
1608         {
1609           /* Cache -1..N */
1610           limit = INTEGER_SHARE_LIMIT + 1;
1611
1612           if (integer_minus_onep (t))
1613             ix = 0;
1614           else if (!wi::neg_p (t))
1615             {
1616               if (prec < HOST_BITS_PER_WIDE_INT)
1617                 {
1618                   if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT)
1619                     ix = tree_to_shwi (t) + 1;
1620                 }
1621               else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
1622                 ix = tree_to_shwi (t) + 1;
1623             }
1624         }
1625       break;
1626
1627     case ENUMERAL_TYPE:
1628       break;
1629
1630     default:
1631       gcc_unreachable ();
1632     }
1633
1634   if (ix >= 0)
1635     {
1636       /* Look for it in the type's vector of small shared ints.  */
1637       if (!TYPE_CACHED_VALUES_P (type))
1638         {
1639           TYPE_CACHED_VALUES_P (type) = 1;
1640           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1641         }
1642
1643       gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
1644       TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1645     }
1646   else
1647     {
1648       /* Use the cache of larger shared ints.  */
1649       tree *slot = int_cst_hash_table->find_slot (t, INSERT);
1650       /* If there is already an entry for the number verify it's the
1651          same.  */
1652       if (*slot)
1653         gcc_assert (wi::eq_p (tree (*slot), t));
1654       else
1655         /* Otherwise insert this one into the hash table.  */
1656         *slot = t;
1657     }
1658 }
1659
1660
1661 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1662    and the rest are zeros.  */
1663
1664 tree
1665 build_low_bits_mask (tree type, unsigned bits)
1666 {
1667   gcc_assert (bits <= TYPE_PRECISION (type));
1668
1669   return wide_int_to_tree (type, wi::mask (bits, false,
1670                                            TYPE_PRECISION (type)));
1671 }
1672
1673 /* Checks that X is integer constant that can be expressed in (unsigned)
1674    HOST_WIDE_INT without loss of precision.  */
1675
1676 bool
1677 cst_and_fits_in_hwi (const_tree x)
1678 {
1679   return (TREE_CODE (x) == INTEGER_CST
1680           && (tree_fits_shwi_p (x) || tree_fits_uhwi_p (x)));
1681 }
1682
1683 /* Build a newly constructed VECTOR_CST node of length LEN.  */
1684
1685 tree
1686 make_vector_stat (unsigned len MEM_STAT_DECL)
1687 {
1688   tree t;
1689   unsigned length = (len - 1) * sizeof (tree) + sizeof (struct tree_vector);
1690
1691   record_node_allocation_statistics (VECTOR_CST, length);
1692
1693   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
1694
1695   TREE_SET_CODE (t, VECTOR_CST);
1696   TREE_CONSTANT (t) = 1;
1697
1698   return t;
1699 }
1700
1701 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1702    are in a list pointed to by VALS.  */
1703
1704 tree
1705 build_vector_stat (tree type, tree *vals MEM_STAT_DECL)
1706 {
1707   int over = 0;
1708   unsigned cnt = 0;
1709   tree v = make_vector (TYPE_VECTOR_SUBPARTS (type));
1710   TREE_TYPE (v) = type;
1711
1712   /* Iterate through elements and check for overflow.  */
1713   for (cnt = 0; cnt < TYPE_VECTOR_SUBPARTS (type); ++cnt)
1714     {
1715       tree value = vals[cnt];
1716
1717       VECTOR_CST_ELT (v, cnt) = value;
1718
1719       /* Don't crash if we get an address constant.  */
1720       if (!CONSTANT_CLASS_P (value))
1721         continue;
1722
1723       over |= TREE_OVERFLOW (value);
1724     }
1725
1726   TREE_OVERFLOW (v) = over;
1727   return v;
1728 }
1729
1730 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1731    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1732
1733 tree
1734 build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
1735 {
1736   tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
1737   unsigned HOST_WIDE_INT idx, pos = 0;
1738   tree value;
1739
1740   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1741     {
1742       if (TREE_CODE (value) == VECTOR_CST)
1743         for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i)
1744           vec[pos++] = VECTOR_CST_ELT (value, i);
1745       else
1746         vec[pos++] = value;
1747     }
1748   while (pos < TYPE_VECTOR_SUBPARTS (type))
1749     vec[pos++] = build_zero_cst (TREE_TYPE (type));
1750
1751   return build_vector (type, vec);
1752 }
1753
1754 /* Build a vector of type VECTYPE where all the elements are SCs.  */
1755 tree
1756 build_vector_from_val (tree vectype, tree sc)
1757 {
1758   int i, nunits = TYPE_VECTOR_SUBPARTS (vectype);
1759
1760   if (sc == error_mark_node)
1761     return sc;
1762
1763   /* Verify that the vector type is suitable for SC.  Note that there
1764      is some inconsistency in the type-system with respect to restrict
1765      qualifications of pointers.  Vector types always have a main-variant
1766      element type and the qualification is applied to the vector-type.
1767      So TREE_TYPE (vector-type) does not return a properly qualified
1768      vector element-type.  */
1769   gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
1770                                            TREE_TYPE (vectype)));
1771
1772   if (CONSTANT_CLASS_P (sc))
1773     {
1774       tree *v = XALLOCAVEC (tree, nunits);
1775       for (i = 0; i < nunits; ++i)
1776         v[i] = sc;
1777       return build_vector (vectype, v);
1778     }
1779   else
1780     {
1781       vec<constructor_elt, va_gc> *v;
1782       vec_alloc (v, nunits);
1783       for (i = 0; i < nunits; ++i)
1784         CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
1785       return build_constructor (vectype, v);
1786     }
1787 }
1788
1789 /* Something has messed with the elements of CONSTRUCTOR C after it was built;
1790    calculate TREE_CONSTANT and TREE_SIDE_EFFECTS.  */
1791
1792 void
1793 recompute_constructor_flags (tree c)
1794 {
1795   unsigned int i;
1796   tree val;
1797   bool constant_p = true;
1798   bool side_effects_p = false;
1799   vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
1800
1801   FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
1802     {
1803       /* Mostly ctors will have elts that don't have side-effects, so
1804          the usual case is to scan all the elements.  Hence a single
1805          loop for both const and side effects, rather than one loop
1806          each (with early outs).  */
1807       if (!TREE_CONSTANT (val))
1808         constant_p = false;
1809       if (TREE_SIDE_EFFECTS (val))
1810         side_effects_p = true;
1811     }
1812
1813   TREE_SIDE_EFFECTS (c) = side_effects_p;
1814   TREE_CONSTANT (c) = constant_p;
1815 }
1816
1817 /* Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for
1818    CONSTRUCTOR C.  */
1819
1820 void
1821 verify_constructor_flags (tree c)
1822 {
1823   unsigned int i;
1824   tree val;
1825   bool constant_p = TREE_CONSTANT (c);
1826   bool side_effects_p = TREE_SIDE_EFFECTS (c);
1827   vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
1828
1829   FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
1830     {
1831       if (constant_p && !TREE_CONSTANT (val))
1832         internal_error ("non-constant element in constant CONSTRUCTOR");
1833       if (!side_effects_p && TREE_SIDE_EFFECTS (val))
1834         internal_error ("side-effects element in no-side-effects CONSTRUCTOR");
1835     }
1836 }
1837
1838 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1839    are in the vec pointed to by VALS.  */
1840 tree
1841 build_constructor (tree type, vec<constructor_elt, va_gc> *vals)
1842 {
1843   tree c = make_node (CONSTRUCTOR);
1844
1845   TREE_TYPE (c) = type;
1846   CONSTRUCTOR_ELTS (c) = vals;
1847
1848   recompute_constructor_flags (c);
1849
1850   return c;
1851 }
1852
1853 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1854    INDEX and VALUE.  */
1855 tree
1856 build_constructor_single (tree type, tree index, tree value)
1857 {
1858   vec<constructor_elt, va_gc> *v;
1859   constructor_elt elt = {index, value};
1860
1861   vec_alloc (v, 1);
1862   v->quick_push (elt);
1863
1864   return build_constructor (type, v);
1865 }
1866
1867
1868 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1869    are in a list pointed to by VALS.  */
1870 tree
1871 build_constructor_from_list (tree type, tree vals)
1872 {
1873   tree t;
1874   vec<constructor_elt, va_gc> *v = NULL;
1875
1876   if (vals)
1877     {
1878       vec_alloc (v, list_length (vals));
1879       for (t = vals; t; t = TREE_CHAIN (t))
1880         CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
1881     }
1882
1883   return build_constructor (type, v);
1884 }
1885
1886 /* Return a new CONSTRUCTOR node whose type is TYPE.  NELTS is the number
1887    of elements, provided as index/value pairs.  */
1888
1889 tree
1890 build_constructor_va (tree type, int nelts, ...)
1891 {
1892   vec<constructor_elt, va_gc> *v = NULL;
1893   va_list p;
1894
1895   va_start (p, nelts);
1896   vec_alloc (v, nelts);
1897   while (nelts--)
1898     {
1899       tree index = va_arg (p, tree);
1900       tree value = va_arg (p, tree);
1901       CONSTRUCTOR_APPEND_ELT (v, index, value);
1902     }
1903   va_end (p);
1904   return build_constructor (type, v);
1905 }
1906
1907 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1908
1909 tree
1910 build_fixed (tree type, FIXED_VALUE_TYPE f)
1911 {
1912   tree v;
1913   FIXED_VALUE_TYPE *fp;
1914
1915   v = make_node (FIXED_CST);
1916   fp = ggc_alloc<fixed_value> ();
1917   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1918
1919   TREE_TYPE (v) = type;
1920   TREE_FIXED_CST_PTR (v) = fp;
1921   return v;
1922 }
1923
1924 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1925
1926 tree
1927 build_real (tree type, REAL_VALUE_TYPE d)
1928 {
1929   tree v;
1930   REAL_VALUE_TYPE *dp;
1931   int overflow = 0;
1932
1933   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1934      Consider doing it via real_convert now.  */
1935
1936   v = make_node (REAL_CST);
1937   dp = ggc_alloc<real_value> ();
1938   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1939
1940   TREE_TYPE (v) = type;
1941   TREE_REAL_CST_PTR (v) = dp;
1942   TREE_OVERFLOW (v) = overflow;
1943   return v;
1944 }
1945
1946 /* Like build_real, but first truncate D to the type.  */
1947
1948 tree
1949 build_real_truncate (tree type, REAL_VALUE_TYPE d)
1950 {
1951   return build_real (type, real_value_truncate (TYPE_MODE (type), d));
1952 }
1953
1954 /* Return a new REAL_CST node whose type is TYPE
1955    and whose value is the integer value of the INTEGER_CST node I.  */
1956
1957 REAL_VALUE_TYPE
1958 real_value_from_int_cst (const_tree type, const_tree i)
1959 {
1960   REAL_VALUE_TYPE d;
1961
1962   /* Clear all bits of the real value type so that we can later do
1963      bitwise comparisons to see if two values are the same.  */
1964   memset (&d, 0, sizeof d);
1965
1966   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, i,
1967                      TYPE_SIGN (TREE_TYPE (i)));
1968   return d;
1969 }
1970
1971 /* Given a tree representing an integer constant I, return a tree
1972    representing the same value as a floating-point constant of type TYPE.  */
1973
1974 tree
1975 build_real_from_int_cst (tree type, const_tree i)
1976 {
1977   tree v;
1978   int overflow = TREE_OVERFLOW (i);
1979
1980   v = build_real (type, real_value_from_int_cst (type, i));
1981
1982   TREE_OVERFLOW (v) |= overflow;
1983   return v;
1984 }
1985
1986 /* Return a newly constructed STRING_CST node whose value is
1987    the LEN characters at STR.
1988    Note that for a C string literal, LEN should include the trailing NUL.
1989    The TREE_TYPE is not initialized.  */
1990
1991 tree
1992 build_string (int len, const char *str)
1993 {
1994   tree s;
1995   size_t length;
1996
1997   /* Do not waste bytes provided by padding of struct tree_string.  */
1998   length = len + offsetof (struct tree_string, str) + 1;
1999
2000   record_node_allocation_statistics (STRING_CST, length);
2001
2002   s = (tree) ggc_internal_alloc (length);
2003
2004   memset (s, 0, sizeof (struct tree_typed));
2005   TREE_SET_CODE (s, STRING_CST);
2006   TREE_CONSTANT (s) = 1;
2007   TREE_STRING_LENGTH (s) = len;
2008   memcpy (s->string.str, str, len);
2009   s->string.str[len] = '\0';
2010
2011   return s;
2012 }
2013
2014 /* Return a newly constructed COMPLEX_CST node whose value is
2015    specified by the real and imaginary parts REAL and IMAG.
2016    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
2017    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
2018
2019 tree
2020 build_complex (tree type, tree real, tree imag)
2021 {
2022   tree t = make_node (COMPLEX_CST);
2023
2024   TREE_REALPART (t) = real;
2025   TREE_IMAGPART (t) = imag;
2026   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
2027   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
2028   return t;
2029 }
2030
2031 /* Build a complex (inf +- 0i), such as for the result of cproj.
2032    TYPE is the complex tree type of the result.  If NEG is true, the
2033    imaginary zero is negative.  */
2034
2035 tree
2036 build_complex_inf (tree type, bool neg)
2037 {
2038   REAL_VALUE_TYPE rinf, rzero = dconst0;
2039
2040   real_inf (&rinf);
2041   rzero.sign = neg;
2042   return build_complex (type, build_real (TREE_TYPE (type), rinf),
2043                         build_real (TREE_TYPE (type), rzero));
2044 }
2045
2046 /* Return the constant 1 in type TYPE.  If TYPE has several elements, each
2047    element is set to 1.  In particular, this is 1 + i for complex types.  */
2048
2049 tree
2050 build_each_one_cst (tree type)
2051 {
2052   if (TREE_CODE (type) == COMPLEX_TYPE)
2053     {
2054       tree scalar = build_one_cst (TREE_TYPE (type));
2055       return build_complex (type, scalar, scalar);
2056     }
2057   else
2058     return build_one_cst (type);
2059 }
2060
2061 /* Return a constant of arithmetic type TYPE which is the
2062    multiplicative identity of the set TYPE.  */
2063
2064 tree
2065 build_one_cst (tree type)
2066 {
2067   switch (TREE_CODE (type))
2068     {
2069     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2070     case POINTER_TYPE: case REFERENCE_TYPE:
2071     case OFFSET_TYPE:
2072       return build_int_cst (type, 1);
2073
2074     case REAL_TYPE:
2075       return build_real (type, dconst1);
2076
2077     case FIXED_POINT_TYPE:
2078       /* We can only generate 1 for accum types.  */
2079       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
2080       return build_fixed (type, FCONST1 (TYPE_MODE (type)));
2081
2082     case VECTOR_TYPE:
2083       {
2084         tree scalar = build_one_cst (TREE_TYPE (type));
2085
2086         return build_vector_from_val (type, scalar);
2087       }
2088
2089     case COMPLEX_TYPE:
2090       return build_complex (type,
2091                             build_one_cst (TREE_TYPE (type)),
2092                             build_zero_cst (TREE_TYPE (type)));
2093
2094     default:
2095       gcc_unreachable ();
2096     }
2097 }
2098
2099 /* Return an integer of type TYPE containing all 1's in as much precision as
2100    it contains, or a complex or vector whose subparts are such integers.  */
2101
2102 tree
2103 build_all_ones_cst (tree type)
2104 {
2105   if (TREE_CODE (type) == COMPLEX_TYPE)
2106     {
2107       tree scalar = build_all_ones_cst (TREE_TYPE (type));
2108       return build_complex (type, scalar, scalar);
2109     }
2110   else
2111     return build_minus_one_cst (type);
2112 }
2113
2114 /* Return a constant of arithmetic type TYPE which is the
2115    opposite of the multiplicative identity of the set TYPE.  */
2116
2117 tree
2118 build_minus_one_cst (tree type)
2119 {
2120   switch (TREE_CODE (type))
2121     {
2122     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2123     case POINTER_TYPE: case REFERENCE_TYPE:
2124     case OFFSET_TYPE:
2125       return build_int_cst (type, -1);
2126
2127     case REAL_TYPE:
2128       return build_real (type, dconstm1);
2129
2130     case FIXED_POINT_TYPE:
2131       /* We can only generate 1 for accum types.  */
2132       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
2133       return build_fixed (type, fixed_from_double_int (double_int_minus_one,
2134                                                        TYPE_MODE (type)));
2135
2136     case VECTOR_TYPE:
2137       {
2138         tree scalar = build_minus_one_cst (TREE_TYPE (type));
2139
2140         return build_vector_from_val (type, scalar);
2141       }
2142
2143     case COMPLEX_TYPE:
2144       return build_complex (type,
2145                             build_minus_one_cst (TREE_TYPE (type)),
2146                             build_zero_cst (TREE_TYPE (type)));
2147
2148     default:
2149       gcc_unreachable ();
2150     }
2151 }
2152
2153 /* Build 0 constant of type TYPE.  This is used by constructor folding
2154    and thus the constant should be represented in memory by
2155    zero(es).  */
2156
2157 tree
2158 build_zero_cst (tree type)
2159 {
2160   switch (TREE_CODE (type))
2161     {
2162     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2163     case POINTER_TYPE: case REFERENCE_TYPE:
2164     case OFFSET_TYPE: case NULLPTR_TYPE:
2165       return build_int_cst (type, 0);
2166
2167     case REAL_TYPE:
2168       return build_real (type, dconst0);
2169
2170     case FIXED_POINT_TYPE:
2171       return build_fixed (type, FCONST0 (TYPE_MODE (type)));
2172
2173     case VECTOR_TYPE:
2174       {
2175         tree scalar = build_zero_cst (TREE_TYPE (type));
2176
2177         return build_vector_from_val (type, scalar);
2178       }
2179
2180     case COMPLEX_TYPE:
2181       {
2182         tree zero = build_zero_cst (TREE_TYPE (type));
2183
2184         return build_complex (type, zero, zero);
2185       }
2186
2187     default:
2188       if (!AGGREGATE_TYPE_P (type))
2189         return fold_convert (type, integer_zero_node);
2190       return build_constructor (type, NULL);
2191     }
2192 }
2193
2194
2195 /* Build a BINFO with LEN language slots.  */
2196
2197 tree
2198 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
2199 {
2200   tree t;
2201   size_t length = (offsetof (struct tree_binfo, base_binfos)
2202                    + vec<tree, va_gc>::embedded_size (base_binfos));
2203
2204   record_node_allocation_statistics (TREE_BINFO, length);
2205
2206   t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
2207
2208   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
2209
2210   TREE_SET_CODE (t, TREE_BINFO);
2211
2212   BINFO_BASE_BINFOS (t)->embedded_init (base_binfos);
2213
2214   return t;
2215 }
2216
2217 /* Create a CASE_LABEL_EXPR tree node and return it.  */
2218
2219 tree
2220 build_case_label (tree low_value, tree high_value, tree label_decl)
2221 {
2222   tree t = make_node (CASE_LABEL_EXPR);
2223
2224   TREE_TYPE (t) = void_type_node;
2225   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl));
2226
2227   CASE_LOW (t) = low_value;
2228   CASE_HIGH (t) = high_value;
2229   CASE_LABEL (t) = label_decl;
2230   CASE_CHAIN (t) = NULL_TREE;
2231
2232   return t;
2233 }
2234
2235 /* Build a newly constructed INTEGER_CST node.  LEN and EXT_LEN are the
2236    values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
2237    The latter determines the length of the HOST_WIDE_INT vector.  */
2238
2239 tree
2240 make_int_cst_stat (int len, int ext_len MEM_STAT_DECL)
2241 {
2242   tree t;
2243   int length = ((ext_len - 1) * sizeof (HOST_WIDE_INT)
2244                 + sizeof (struct tree_int_cst));
2245
2246   gcc_assert (len);
2247   record_node_allocation_statistics (INTEGER_CST, length);
2248
2249   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2250
2251   TREE_SET_CODE (t, INTEGER_CST);
2252   TREE_INT_CST_NUNITS (t) = len;
2253   TREE_INT_CST_EXT_NUNITS (t) = ext_len;
2254   /* to_offset can only be applied to trees that are offset_int-sized
2255      or smaller.  EXT_LEN is correct if it fits, otherwise the constant
2256      must be exactly the precision of offset_int and so LEN is correct.  */
2257   if (ext_len <= OFFSET_INT_ELTS)
2258     TREE_INT_CST_OFFSET_NUNITS (t) = ext_len;
2259   else
2260     TREE_INT_CST_OFFSET_NUNITS (t) = len;
2261
2262   TREE_CONSTANT (t) = 1;
2263
2264   return t;
2265 }
2266
2267 /* Build a newly constructed TREE_VEC node of length LEN.  */
2268
2269 tree
2270 make_tree_vec_stat (int len MEM_STAT_DECL)
2271 {
2272   tree t;
2273   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2274
2275   record_node_allocation_statistics (TREE_VEC, length);
2276
2277   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
2278
2279   TREE_SET_CODE (t, TREE_VEC);
2280   TREE_VEC_LENGTH (t) = len;
2281
2282   return t;
2283 }
2284
2285 /* Grow a TREE_VEC node to new length LEN.  */
2286
2287 tree
2288 grow_tree_vec_stat (tree v, int len MEM_STAT_DECL)
2289 {
2290   gcc_assert (TREE_CODE (v) == TREE_VEC);
2291
2292   int oldlen = TREE_VEC_LENGTH (v);
2293   gcc_assert (len > oldlen);
2294
2295   int oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec);
2296   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
2297
2298   record_node_allocation_statistics (TREE_VEC, length - oldlength);
2299
2300   v = (tree) ggc_realloc (v, length PASS_MEM_STAT);
2301
2302   TREE_VEC_LENGTH (v) = len;
2303
2304   return v;
2305 }
2306 \f
2307 /* Return 1 if EXPR is the constant zero, whether it is integral, float or
2308    fixed, and scalar, complex or vector.  */
2309
2310 int
2311 zerop (const_tree expr)
2312 {
2313   return (integer_zerop (expr)
2314           || real_zerop (expr)
2315           || fixed_zerop (expr));
2316 }
2317
2318 /* Return 1 if EXPR is the integer constant zero or a complex constant
2319    of zero.  */
2320
2321 int
2322 integer_zerop (const_tree expr)
2323 {
2324   switch (TREE_CODE (expr))
2325     {
2326     case INTEGER_CST:
2327       return wi::eq_p (expr, 0);
2328     case COMPLEX_CST:
2329       return (integer_zerop (TREE_REALPART (expr))
2330               && integer_zerop (TREE_IMAGPART (expr)));
2331     case VECTOR_CST:
2332       {
2333         unsigned i;
2334         for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2335           if (!integer_zerop (VECTOR_CST_ELT (expr, i)))
2336             return false;
2337         return true;
2338       }
2339     default:
2340       return false;
2341     }
2342 }
2343
2344 /* Return 1 if EXPR is the integer constant one or the corresponding
2345    complex constant.  */
2346
2347 int
2348 integer_onep (const_tree expr)
2349 {
2350   switch (TREE_CODE (expr))
2351     {
2352     case INTEGER_CST:
2353       return wi::eq_p (wi::to_widest (expr), 1);
2354     case COMPLEX_CST:
2355       return (integer_onep (TREE_REALPART (expr))
2356               && integer_zerop (TREE_IMAGPART (expr)));
2357     case VECTOR_CST:
2358       {
2359         unsigned i;
2360         for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2361           if (!integer_onep (VECTOR_CST_ELT (expr, i)))
2362             return false;
2363         return true;
2364       }
2365     default:
2366       return false;
2367     }
2368 }
2369
2370 /* Return 1 if EXPR is the integer constant one.  For complex and vector,
2371    return 1 if every piece is the integer constant one.  */
2372
2373 int
2374 integer_each_onep (const_tree expr)
2375 {
2376   if (TREE_CODE (expr) == COMPLEX_CST)
2377     return (integer_onep (TREE_REALPART (expr))
2378             && integer_onep (TREE_IMAGPART (expr)));
2379   else
2380     return integer_onep (expr);
2381 }
2382
2383 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
2384    it contains, or a complex or vector whose subparts are such integers.  */
2385
2386 int
2387 integer_all_onesp (const_tree expr)
2388 {
2389   if (TREE_CODE (expr) == COMPLEX_CST
2390       && integer_all_onesp (TREE_REALPART (expr))
2391       && integer_all_onesp (TREE_IMAGPART (expr)))
2392     return 1;
2393
2394   else if (TREE_CODE (expr) == VECTOR_CST)
2395     {
2396       unsigned i;
2397       for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2398         if (!integer_all_onesp (VECTOR_CST_ELT (expr, i)))
2399           return 0;
2400       return 1;
2401     }
2402
2403   else if (TREE_CODE (expr) != INTEGER_CST)
2404     return 0;
2405
2406   return wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED) == expr;
2407 }
2408
2409 /* Return 1 if EXPR is the integer constant minus one.  */
2410
2411 int
2412 integer_minus_onep (const_tree expr)
2413 {
2414   if (TREE_CODE (expr) == COMPLEX_CST)
2415     return (integer_all_onesp (TREE_REALPART (expr))
2416             && integer_zerop (TREE_IMAGPART (expr)));
2417   else
2418     return integer_all_onesp (expr);
2419 }
2420
2421 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
2422    one bit on).  */
2423
2424 int
2425 integer_pow2p (const_tree expr)
2426 {
2427   if (TREE_CODE (expr) == COMPLEX_CST
2428       && integer_pow2p (TREE_REALPART (expr))
2429       && integer_zerop (TREE_IMAGPART (expr)))
2430     return 1;
2431
2432   if (TREE_CODE (expr) != INTEGER_CST)
2433     return 0;
2434
2435   return wi::popcount (expr) == 1;
2436 }
2437
2438 /* Return 1 if EXPR is an integer constant other than zero or a
2439    complex constant other than zero.  */
2440
2441 int
2442 integer_nonzerop (const_tree expr)
2443 {
2444   return ((TREE_CODE (expr) == INTEGER_CST
2445            && !wi::eq_p (expr, 0))
2446           || (TREE_CODE (expr) == COMPLEX_CST
2447               && (integer_nonzerop (TREE_REALPART (expr))
2448                   || integer_nonzerop (TREE_IMAGPART (expr)))));
2449 }
2450
2451 /* Return 1 if EXPR is the integer constant one.  For vector,
2452    return 1 if every piece is the integer constant minus one
2453    (representing the value TRUE).  */
2454
2455 int
2456 integer_truep (const_tree expr)
2457 {
2458   if (TREE_CODE (expr) == VECTOR_CST)
2459     return integer_all_onesp (expr);
2460   return integer_onep (expr);
2461 }
2462
2463 /* Return 1 if EXPR is the fixed-point constant zero.  */
2464
2465 int
2466 fixed_zerop (const_tree expr)
2467 {
2468   return (TREE_CODE (expr) == FIXED_CST
2469           && TREE_FIXED_CST (expr).data.is_zero ());
2470 }
2471
2472 /* Return the power of two represented by a tree node known to be a
2473    power of two.  */
2474
2475 int
2476 tree_log2 (const_tree expr)
2477 {
2478   if (TREE_CODE (expr) == COMPLEX_CST)
2479     return tree_log2 (TREE_REALPART (expr));
2480
2481   return wi::exact_log2 (expr);
2482 }
2483
2484 /* Similar, but return the largest integer Y such that 2 ** Y is less
2485    than or equal to EXPR.  */
2486
2487 int
2488 tree_floor_log2 (const_tree expr)
2489 {
2490   if (TREE_CODE (expr) == COMPLEX_CST)
2491     return tree_log2 (TREE_REALPART (expr));
2492
2493   return wi::floor_log2 (expr);
2494 }
2495
2496 /* Return number of known trailing zero bits in EXPR, or, if the value of
2497    EXPR is known to be zero, the precision of it's type.  */
2498
2499 unsigned int
2500 tree_ctz (const_tree expr)
2501 {
2502   if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
2503       && !POINTER_TYPE_P (TREE_TYPE (expr)))
2504     return 0;
2505
2506   unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr));
2507   switch (TREE_CODE (expr))
2508     {
2509     case INTEGER_CST:
2510       ret1 = wi::ctz (expr);
2511       return MIN (ret1, prec);
2512     case SSA_NAME:
2513       ret1 = wi::ctz (get_nonzero_bits (expr));
2514       return MIN (ret1, prec);
2515     case PLUS_EXPR:
2516     case MINUS_EXPR:
2517     case BIT_IOR_EXPR:
2518     case BIT_XOR_EXPR:
2519     case MIN_EXPR:
2520     case MAX_EXPR:
2521       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2522       if (ret1 == 0)
2523         return ret1;
2524       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2525       return MIN (ret1, ret2);
2526     case POINTER_PLUS_EXPR:
2527       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2528       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2529       /* Second operand is sizetype, which could be in theory
2530          wider than pointer's precision.  Make sure we never
2531          return more than prec.  */
2532       ret2 = MIN (ret2, prec);
2533       return MIN (ret1, ret2);
2534     case BIT_AND_EXPR:
2535       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2536       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2537       return MAX (ret1, ret2);
2538     case MULT_EXPR:
2539       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2540       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
2541       return MIN (ret1 + ret2, prec);
2542     case LSHIFT_EXPR:
2543       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2544       if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2545           && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2546         {
2547           ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2548           return MIN (ret1 + ret2, prec);
2549         }
2550       return ret1;
2551     case RSHIFT_EXPR:
2552       if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
2553           && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
2554         {
2555           ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2556           ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
2557           if (ret1 > ret2)
2558             return ret1 - ret2;
2559         }
2560       return 0;
2561     case TRUNC_DIV_EXPR:
2562     case CEIL_DIV_EXPR:
2563     case FLOOR_DIV_EXPR:
2564     case ROUND_DIV_EXPR:
2565     case EXACT_DIV_EXPR:
2566       if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
2567           && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1)
2568         {
2569           int l = tree_log2 (TREE_OPERAND (expr, 1));
2570           if (l >= 0)
2571             {
2572               ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2573               ret2 = l;
2574               if (ret1 > ret2)
2575                 return ret1 - ret2;
2576             }
2577         }
2578       return 0;
2579     CASE_CONVERT:
2580       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
2581       if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2582         ret1 = prec;
2583       return MIN (ret1, prec);
2584     case SAVE_EXPR:
2585       return tree_ctz (TREE_OPERAND (expr, 0));
2586     case COND_EXPR:
2587       ret1 = tree_ctz (TREE_OPERAND (expr, 1));
2588       if (ret1 == 0)
2589         return 0;
2590       ret2 = tree_ctz (TREE_OPERAND (expr, 2));
2591       return MIN (ret1, ret2);
2592     case COMPOUND_EXPR:
2593       return tree_ctz (TREE_OPERAND (expr, 1));
2594     case ADDR_EXPR:
2595       ret1 = get_pointer_alignment (CONST_CAST_TREE (expr));
2596       if (ret1 > BITS_PER_UNIT)
2597         {
2598           ret1 = ctz_hwi (ret1 / BITS_PER_UNIT);
2599           return MIN (ret1, prec);
2600         }
2601       return 0;
2602     default:
2603       return 0;
2604     }
2605 }
2606
2607 /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
2608    decimal float constants, so don't return 1 for them.  */
2609
2610 int
2611 real_zerop (const_tree expr)
2612 {
2613   switch (TREE_CODE (expr))
2614     {
2615     case REAL_CST:
2616       return real_equal (&TREE_REAL_CST (expr), &dconst0)
2617              && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2618     case COMPLEX_CST:
2619       return real_zerop (TREE_REALPART (expr))
2620              && real_zerop (TREE_IMAGPART (expr));
2621     case VECTOR_CST:
2622       {
2623         unsigned i;
2624         for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2625           if (!real_zerop (VECTOR_CST_ELT (expr, i)))
2626             return false;
2627         return true;
2628       }
2629     default:
2630       return false;
2631     }
2632 }
2633
2634 /* Return 1 if EXPR is the real constant one in real or complex form.
2635    Trailing zeroes matter for decimal float constants, so don't return
2636    1 for them.  */
2637
2638 int
2639 real_onep (const_tree expr)
2640 {
2641   switch (TREE_CODE (expr))
2642     {
2643     case REAL_CST:
2644       return real_equal (&TREE_REAL_CST (expr), &dconst1)
2645              && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2646     case COMPLEX_CST:
2647       return real_onep (TREE_REALPART (expr))
2648              && real_zerop (TREE_IMAGPART (expr));
2649     case VECTOR_CST:
2650       {
2651         unsigned i;
2652         for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2653           if (!real_onep (VECTOR_CST_ELT (expr, i)))
2654             return false;
2655         return true;
2656       }
2657     default:
2658       return false;
2659     }
2660 }
2661
2662 /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
2663    matter for decimal float constants, so don't return 1 for them.  */
2664
2665 int
2666 real_minus_onep (const_tree expr)
2667 {
2668   switch (TREE_CODE (expr))
2669     {
2670     case REAL_CST:
2671       return real_equal (&TREE_REAL_CST (expr), &dconstm1)
2672              && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
2673     case COMPLEX_CST:
2674       return real_minus_onep (TREE_REALPART (expr))
2675              && real_zerop (TREE_IMAGPART (expr));
2676     case VECTOR_CST:
2677       {
2678         unsigned i;
2679         for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
2680           if (!real_minus_onep (VECTOR_CST_ELT (expr, i)))
2681             return false;
2682         return true;
2683       }
2684     default:
2685       return false;
2686     }
2687 }
2688
2689 /* Nonzero if EXP is a constant or a cast of a constant.  */
2690
2691 int
2692 really_constant_p (const_tree exp)
2693 {
2694   /* This is not quite the same as STRIP_NOPS.  It does more.  */
2695   while (CONVERT_EXPR_P (exp)
2696          || TREE_CODE (exp) == NON_LVALUE_EXPR)
2697     exp = TREE_OPERAND (exp, 0);
2698   return TREE_CONSTANT (exp);
2699 }
2700 \f
2701 /* Return first list element whose TREE_VALUE is ELEM.
2702    Return 0 if ELEM is not in LIST.  */
2703
2704 tree
2705 value_member (tree elem, tree list)
2706 {
2707   while (list)
2708     {
2709       if (elem == TREE_VALUE (list))
2710         return list;
2711       list = TREE_CHAIN (list);
2712     }
2713   return NULL_TREE;
2714 }
2715
2716 /* Return first list element whose TREE_PURPOSE is ELEM.
2717    Return 0 if ELEM is not in LIST.  */
2718
2719 tree
2720 purpose_member (const_tree elem, tree list)
2721 {
2722   while (list)
2723     {
2724       if (elem == TREE_PURPOSE (list))
2725         return list;
2726       list = TREE_CHAIN (list);
2727     }
2728   return NULL_TREE;
2729 }
2730
2731 /* Return true if ELEM is in V.  */
2732
2733 bool
2734 vec_member (const_tree elem, vec<tree, va_gc> *v)
2735 {
2736   unsigned ix;
2737   tree t;
2738   FOR_EACH_VEC_SAFE_ELT (v, ix, t)
2739     if (elem == t)
2740       return true;
2741   return false;
2742 }
2743
2744 /* Returns element number IDX (zero-origin) of chain CHAIN, or
2745    NULL_TREE.  */
2746
2747 tree
2748 chain_index (int idx, tree chain)
2749 {
2750   for (; chain && idx > 0; --idx)
2751     chain = TREE_CHAIN (chain);
2752   return chain;
2753 }
2754
2755 /* Return nonzero if ELEM is part of the chain CHAIN.  */
2756
2757 int
2758 chain_member (const_tree elem, const_tree chain)
2759 {
2760   while (chain)
2761     {
2762       if (elem == chain)
2763         return 1;
2764       chain = DECL_CHAIN (chain);
2765     }
2766
2767   return 0;
2768 }
2769
2770 /* Return the length of a chain of nodes chained through TREE_CHAIN.
2771    We expect a null pointer to mark the end of the chain.
2772    This is the Lisp primitive `length'.  */
2773
2774 int
2775 list_length (const_tree t)
2776 {
2777   const_tree p = t;
2778 #ifdef ENABLE_TREE_CHECKING
2779   const_tree q = t;
2780 #endif
2781   int len = 0;
2782
2783   while (p)
2784     {
2785       p = TREE_CHAIN (p);
2786 #ifdef ENABLE_TREE_CHECKING
2787       if (len % 2)
2788         q = TREE_CHAIN (q);
2789       gcc_assert (p != q);
2790 #endif
2791       len++;
2792     }
2793
2794   return len;
2795 }
2796
2797 /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
2798    UNION_TYPE TYPE, or NULL_TREE if none.  */
2799
2800 tree
2801 first_field (const_tree type)
2802 {
2803   tree t = TYPE_FIELDS (type);
2804   while (t && TREE_CODE (t) != FIELD_DECL)
2805     t = TREE_CHAIN (t);
2806   return t;
2807 }
2808
2809 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
2810    by modifying the last node in chain 1 to point to chain 2.
2811    This is the Lisp primitive `nconc'.  */
2812
2813 tree
2814 chainon (tree op1, tree op2)
2815 {
2816   tree t1;
2817
2818   if (!op1)
2819     return op2;
2820   if (!op2)
2821     return op1;
2822
2823   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2824     continue;
2825   TREE_CHAIN (t1) = op2;
2826
2827 #ifdef ENABLE_TREE_CHECKING
2828   {
2829     tree t2;
2830     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2831       gcc_assert (t2 != t1);
2832   }
2833 #endif
2834
2835   return op1;
2836 }
2837
2838 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
2839
2840 tree
2841 tree_last (tree chain)
2842 {
2843   tree next;
2844   if (chain)
2845     while ((next = TREE_CHAIN (chain)))
2846       chain = next;
2847   return chain;
2848 }
2849
2850 /* Reverse the order of elements in the chain T,
2851    and return the new head of the chain (old last element).  */
2852
2853 tree
2854 nreverse (tree t)
2855 {
2856   tree prev = 0, decl, next;
2857   for (decl = t; decl; decl = next)
2858     {
2859       /* We shouldn't be using this function to reverse BLOCK chains; we
2860          have blocks_nreverse for that.  */
2861       gcc_checking_assert (TREE_CODE (decl) != BLOCK);
2862       next = TREE_CHAIN (decl);
2863       TREE_CHAIN (decl) = prev;
2864       prev = decl;
2865     }
2866   return prev;
2867 }
2868 \f
2869 /* Return a newly created TREE_LIST node whose
2870    purpose and value fields are PARM and VALUE.  */
2871
2872 tree
2873 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2874 {
2875   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2876   TREE_PURPOSE (t) = parm;
2877   TREE_VALUE (t) = value;
2878   return t;
2879 }
2880
2881 /* Build a chain of TREE_LIST nodes from a vector.  */
2882
2883 tree
2884 build_tree_list_vec_stat (const vec<tree, va_gc> *vec MEM_STAT_DECL)
2885 {
2886   tree ret = NULL_TREE;
2887   tree *pp = &ret;
2888   unsigned int i;
2889   tree t;
2890   FOR_EACH_VEC_SAFE_ELT (vec, i, t)
2891     {
2892       *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2893       pp = &TREE_CHAIN (*pp);
2894     }
2895   return ret;
2896 }
2897
2898 /* Return a newly created TREE_LIST node whose
2899    purpose and value fields are PURPOSE and VALUE
2900    and whose TREE_CHAIN is CHAIN.  */
2901
2902 tree
2903 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2904 {
2905   tree node;
2906
2907   node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
2908   memset (node, 0, sizeof (struct tree_common));
2909
2910   record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
2911
2912   TREE_SET_CODE (node, TREE_LIST);
2913   TREE_CHAIN (node) = chain;
2914   TREE_PURPOSE (node) = purpose;
2915   TREE_VALUE (node) = value;
2916   return node;
2917 }
2918
2919 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2920    trees.  */
2921
2922 vec<tree, va_gc> *
2923 ctor_to_vec (tree ctor)
2924 {
2925   vec<tree, va_gc> *vec;
2926   vec_alloc (vec, CONSTRUCTOR_NELTS (ctor));
2927   unsigned int ix;
2928   tree val;
2929
2930   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2931     vec->quick_push (val);
2932
2933   return vec;
2934 }
2935 \f
2936 /* Return the size nominally occupied by an object of type TYPE
2937    when it resides in memory.  The value is measured in units of bytes,
2938    and its data type is that normally used for type sizes
2939    (which is the first type created by make_signed_type or
2940    make_unsigned_type).  */
2941
2942 tree
2943 size_in_bytes_loc (location_t loc, const_tree type)
2944 {
2945   tree t;
2946
2947   if (type == error_mark_node)
2948     return integer_zero_node;
2949
2950   type = TYPE_MAIN_VARIANT (type);
2951   t = TYPE_SIZE_UNIT (type);
2952
2953   if (t == 0)
2954     {
2955       lang_hooks.types.incomplete_type_error (loc, NULL_TREE, type);
2956       return size_zero_node;
2957     }
2958
2959   return t;
2960 }
2961
2962 /* Return the size of TYPE (in bytes) as a wide integer
2963    or return -1 if the size can vary or is larger than an integer.  */
2964
2965 HOST_WIDE_INT
2966 int_size_in_bytes (const_tree type)
2967 {
2968   tree t;
2969
2970   if (type == error_mark_node)
2971     return 0;
2972
2973   type = TYPE_MAIN_VARIANT (type);
2974   t = TYPE_SIZE_UNIT (type);
2975
2976   if (t && tree_fits_uhwi_p (t))
2977     return TREE_INT_CST_LOW (t);
2978   else
2979     return -1;
2980 }
2981
2982 /* Return the maximum size of TYPE (in bytes) as a wide integer
2983    or return -1 if the size can vary or is larger than an integer.  */
2984
2985 HOST_WIDE_INT
2986 max_int_size_in_bytes (const_tree type)
2987 {
2988   HOST_WIDE_INT size = -1;
2989   tree size_tree;
2990
2991   /* If this is an array type, check for a possible MAX_SIZE attached.  */
2992
2993   if (TREE_CODE (type) == ARRAY_TYPE)
2994     {
2995       size_tree = TYPE_ARRAY_MAX_SIZE (type);
2996
2997       if (size_tree && tree_fits_uhwi_p (size_tree))
2998         size = tree_to_uhwi (size_tree);
2999     }
3000
3001   /* If we still haven't been able to get a size, see if the language
3002      can compute a maximum size.  */
3003
3004   if (size == -1)
3005     {
3006       size_tree = lang_hooks.types.max_size (type);
3007
3008       if (size_tree && tree_fits_uhwi_p (size_tree))
3009         size = tree_to_uhwi (size_tree);
3010     }
3011
3012   return size;
3013 }
3014 \f
3015 /* Return the bit position of FIELD, in bits from the start of the record.
3016    This is a tree of type bitsizetype.  */
3017
3018 tree
3019 bit_position (const_tree field)
3020 {
3021   return bit_from_pos (DECL_FIELD_OFFSET (field),
3022                        DECL_FIELD_BIT_OFFSET (field));
3023 }
3024 \f
3025 /* Return the byte position of FIELD, in bytes from the start of the record.
3026    This is a tree of type sizetype.  */
3027
3028 tree
3029 byte_position (const_tree field)
3030 {
3031   return byte_from_pos (DECL_FIELD_OFFSET (field),
3032                         DECL_FIELD_BIT_OFFSET (field));
3033 }
3034
3035 /* Likewise, but return as an integer.  It must be representable in
3036    that way (since it could be a signed value, we don't have the
3037    option of returning -1 like int_size_in_byte can.  */
3038
3039 HOST_WIDE_INT
3040 int_byte_position (const_tree field)
3041 {
3042   return tree_to_shwi (byte_position (field));
3043 }
3044 \f
3045 /* Return the strictest alignment, in bits, that T is known to have.  */
3046
3047 unsigned int
3048 expr_align (const_tree t)
3049 {
3050   unsigned int align0, align1;
3051
3052   switch (TREE_CODE (t))
3053     {
3054     CASE_CONVERT:  case NON_LVALUE_EXPR:
3055       /* If we have conversions, we know that the alignment of the
3056          object must meet each of the alignments of the types.  */
3057       align0 = expr_align (TREE_OPERAND (t, 0));
3058       align1 = TYPE_ALIGN (TREE_TYPE (t));
3059       return MAX (align0, align1);
3060
3061     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
3062     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
3063     case CLEANUP_POINT_EXPR:
3064       /* These don't change the alignment of an object.  */
3065       return expr_align (TREE_OPERAND (t, 0));
3066
3067     case COND_EXPR:
3068       /* The best we can do is say that the alignment is the least aligned
3069          of the two arms.  */
3070       align0 = expr_align (TREE_OPERAND (t, 1));
3071       align1 = expr_align (TREE_OPERAND (t, 2));
3072       return MIN (align0, align1);
3073
3074       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
3075          meaningfully, it's always 1.  */
3076     case LABEL_DECL:     case CONST_DECL:
3077     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
3078     case FUNCTION_DECL:
3079       gcc_assert (DECL_ALIGN (t) != 0);
3080       return DECL_ALIGN (t);
3081
3082     default:
3083       break;
3084     }
3085
3086   /* Otherwise take the alignment from that of the type.  */
3087   return TYPE_ALIGN (TREE_TYPE (t));
3088 }
3089 \f
3090 /* Return, as a tree node, the number of elements for TYPE (which is an
3091    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
3092
3093 tree
3094 array_type_nelts (const_tree type)
3095 {
3096   tree index_type, min, max;
3097
3098   /* If they did it with unspecified bounds, then we should have already
3099      given an error about it before we got here.  */
3100   if (! TYPE_DOMAIN (type))
3101     return error_mark_node;
3102
3103   index_type = TYPE_DOMAIN (type);
3104   min = TYPE_MIN_VALUE (index_type);
3105   max = TYPE_MAX_VALUE (index_type);
3106
3107   /* TYPE_MAX_VALUE may not be set if the array has unknown length.  */
3108   if (!max)
3109     return error_mark_node;
3110
3111   return (integer_zerop (min)
3112           ? max
3113           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
3114 }
3115 \f
3116 /* If arg is static -- a reference to an object in static storage -- then
3117    return the object.  This is not the same as the C meaning of `static'.
3118    If arg isn't static, return NULL.  */
3119
3120 tree
3121 staticp (tree arg)
3122 {
3123   switch (TREE_CODE (arg))
3124     {
3125     case FUNCTION_DECL:
3126       /* Nested functions are static, even though taking their address will
3127          involve a trampoline as we unnest the nested function and create
3128          the trampoline on the tree level.  */
3129       return arg;
3130
3131     case VAR_DECL:
3132       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3133               && ! DECL_THREAD_LOCAL_P (arg)
3134               && ! DECL_DLLIMPORT_P (arg)
3135               ? arg : NULL);
3136
3137     case CONST_DECL:
3138       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
3139               ? arg : NULL);
3140
3141     case CONSTRUCTOR:
3142       return TREE_STATIC (arg) ? arg : NULL;
3143
3144     case LABEL_DECL:
3145     case STRING_CST:
3146       return arg;
3147
3148     case COMPONENT_REF:
3149       /* If the thing being referenced is not a field, then it is
3150          something language specific.  */
3151       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
3152
3153       /* If we are referencing a bitfield, we can't evaluate an
3154          ADDR_EXPR at compile time and so it isn't a constant.  */
3155       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
3156         return NULL;
3157
3158       return staticp (TREE_OPERAND (arg, 0));
3159
3160     case BIT_FIELD_REF:
3161       return NULL;
3162
3163     case INDIRECT_REF:
3164       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
3165
3166     case ARRAY_REF:
3167     case ARRAY_RANGE_REF:
3168       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
3169           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
3170         return staticp (TREE_OPERAND (arg, 0));
3171       else
3172         return NULL;
3173
3174     case COMPOUND_LITERAL_EXPR:
3175       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
3176
3177     default:
3178       return NULL;
3179     }
3180 }
3181
3182 \f
3183
3184
3185 /* Return whether OP is a DECL whose address is function-invariant.  */
3186
3187 bool
3188 decl_address_invariant_p (const_tree op)
3189 {
3190   /* The conditions below are slightly less strict than the one in
3191      staticp.  */
3192
3193   switch (TREE_CODE (op))
3194     {
3195     case PARM_DECL:
3196     case RESULT_DECL:
3197     case LABEL_DECL:
3198     case FUNCTION_DECL:
3199       return true;
3200
3201     case VAR_DECL:
3202       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3203           || DECL_THREAD_LOCAL_P (op)
3204           || DECL_CONTEXT (op) == current_function_decl
3205           || decl_function_context (op) == current_function_decl)
3206         return true;
3207       break;
3208
3209     case CONST_DECL:
3210       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
3211           || decl_function_context (op) == current_function_decl)
3212         return true;
3213       break;
3214
3215     default:
3216       break;
3217     }
3218
3219   return false;
3220 }
3221
3222 /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
3223
3224 bool
3225 decl_address_ip_invariant_p (const_tree op)
3226 {
3227   /* The conditions below are slightly less strict than the one in
3228      staticp.  */
3229
3230   switch (TREE_CODE (op))
3231     {
3232     case LABEL_DECL:
3233     case FUNCTION_DECL:
3234     case STRING_CST:
3235       return true;
3236
3237     case VAR_DECL:
3238       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
3239            && !DECL_DLLIMPORT_P (op))
3240           || DECL_THREAD_LOCAL_P (op))
3241         return true;
3242       break;
3243
3244     case CONST_DECL:
3245       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
3246         return true;
3247       break;
3248
3249     default:
3250       break;
3251     }
3252
3253   return false;
3254 }
3255
3256
3257 /* Return true if T is function-invariant (internal function, does
3258    not handle arithmetic; that's handled in skip_simple_arithmetic and
3259    tree_invariant_p).  */
3260
3261 static bool
3262 tree_invariant_p_1 (tree t)
3263 {
3264   tree op;
3265
3266   if (TREE_CONSTANT (t)
3267       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
3268     return true;
3269
3270   switch (TREE_CODE (t))
3271     {
3272     case SAVE_EXPR:
3273       return true;
3274
3275     case ADDR_EXPR:
3276       op = TREE_OPERAND (t, 0);
3277       while (handled_component_p (op))
3278         {
3279           switch (TREE_CODE (op))
3280             {
3281             case ARRAY_REF:
3282             case ARRAY_RANGE_REF:
3283               if (!tree_invariant_p (TREE_OPERAND (op, 1))
3284                   || TREE_OPERAND (op, 2) != NULL_TREE
3285                   || TREE_OPERAND (op, 3) != NULL_TREE)
3286                 return false;
3287               break;
3288
3289             case COMPONENT_REF:
3290               if (TREE_OPERAND (op, 2) != NULL_TREE)
3291                 return false;
3292               break;
3293
3294             default:;
3295             }
3296           op = TREE_OPERAND (op, 0);
3297         }
3298
3299       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
3300
3301     default:
3302       break;
3303     }
3304
3305   return false;
3306 }
3307
3308 /* Return true if T is function-invariant.  */
3309
3310 bool
3311 tree_invariant_p (tree t)
3312 {
3313   tree inner = skip_simple_arithmetic (t);
3314   return tree_invariant_p_1 (inner);
3315 }
3316
3317 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
3318    Do this to any expression which may be used in more than one place,
3319    but must be evaluated only once.
3320
3321    Normally, expand_expr would reevaluate the expression each time.
3322    Calling save_expr produces something that is evaluated and recorded
3323    the first time expand_expr is called on it.  Subsequent calls to
3324    expand_expr just reuse the recorded value.
3325
3326    The call to expand_expr that generates code that actually computes
3327    the value is the first call *at compile time*.  Subsequent calls
3328    *at compile time* generate code to use the saved value.
3329    This produces correct result provided that *at run time* control
3330    always flows through the insns made by the first expand_expr
3331    before reaching the other places where the save_expr was evaluated.
3332    You, the caller of save_expr, must make sure this is so.
3333
3334    Constants, and certain read-only nodes, are returned with no
3335    SAVE_EXPR because that is safe.  Expressions containing placeholders
3336    are not touched; see tree.def for an explanation of what these
3337    are used for.  */
3338
3339 tree
3340 save_expr (tree expr)
3341 {
3342   tree t = fold (expr);
3343   tree inner;
3344
3345   /* If the tree evaluates to a constant, then we don't want to hide that
3346      fact (i.e. this allows further folding, and direct checks for constants).
3347      However, a read-only object that has side effects cannot be bypassed.
3348      Since it is no problem to reevaluate literals, we just return the
3349      literal node.  */
3350   inner = skip_simple_arithmetic (t);
3351   if (TREE_CODE (inner) == ERROR_MARK)
3352     return inner;
3353
3354   if (tree_invariant_p_1 (inner))
3355     return t;
3356
3357   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
3358      it means that the size or offset of some field of an object depends on
3359      the value within another field.
3360
3361      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
3362      and some variable since it would then need to be both evaluated once and
3363      evaluated more than once.  Front-ends must assure this case cannot
3364      happen by surrounding any such subexpressions in their own SAVE_EXPR
3365      and forcing evaluation at the proper time.  */
3366   if (contains_placeholder_p (inner))
3367     return t;
3368
3369   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
3370   SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
3371
3372   /* This expression might be placed ahead of a jump to ensure that the
3373      value was computed on both sides of the jump.  So make sure it isn't
3374      eliminated as dead.  */
3375   TREE_SIDE_EFFECTS (t) = 1;
3376   return t;
3377 }
3378
3379 /* Look inside EXPR into any simple arithmetic operations.  Return the
3380    outermost non-arithmetic or non-invariant node.  */
3381
3382 tree
3383 skip_simple_arithmetic (tree expr)
3384 {
3385   /* We don't care about whether this can be used as an lvalue in this
3386      context.  */
3387   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3388     expr = TREE_OPERAND (expr, 0);
3389
3390   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
3391      a constant, it will be more efficient to not make another SAVE_EXPR since
3392      it will allow better simplification and GCSE will be able to merge the
3393      computations if they actually occur.  */
3394   while (true)
3395     {
3396       if (UNARY_CLASS_P (expr))
3397         expr = TREE_OPERAND (expr, 0);
3398       else if (BINARY_CLASS_P (expr))
3399         {
3400           if (tree_invariant_p (TREE_OPERAND (expr, 1)))
3401             expr = TREE_OPERAND (expr, 0);
3402           else if (tree_invariant_p (TREE_OPERAND (expr, 0)))
3403             expr = TREE_OPERAND (expr, 1);
3404           else
3405             break;
3406         }
3407       else
3408         break;
3409     }
3410
3411   return expr;
3412 }
3413
3414 /* Look inside EXPR into simple arithmetic operations involving constants.
3415    Return the outermost non-arithmetic or non-constant node.  */
3416
3417 tree
3418 skip_simple_constant_arithmetic (tree expr)
3419 {
3420   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
3421     expr = TREE_OPERAND (expr, 0);
3422
3423   while (true)
3424     {
3425       if (UNARY_CLASS_P (expr))
3426         expr = TREE_OPERAND (expr, 0);
3427       else if (BINARY_CLASS_P (expr))
3428         {
3429           if (TREE_CONSTANT (TREE_OPERAND (expr, 1)))
3430             expr = TREE_OPERAND (expr, 0);
3431           else if (TREE_CONSTANT (TREE_OPERAND (expr, 0)))
3432             expr = TREE_OPERAND (expr, 1);
3433           else
3434             break;
3435         }
3436       else
3437         break;
3438     }
3439
3440   return expr;
3441 }
3442
3443 /* Return which tree structure is used by T.  */
3444
3445 enum tree_node_structure_enum
3446 tree_node_structure (const_tree t)
3447 {
3448   const enum tree_code code = TREE_CODE (t);
3449   return tree_node_structure_for_code (code);
3450 }
3451
3452 /* Set various status flags when building a CALL_EXPR object T.  */
3453
3454 static void
3455 process_call_operands (tree t)
3456 {
3457   bool side_effects = TREE_SIDE_EFFECTS (t);
3458   bool read_only = false;
3459   int i = call_expr_flags (t);
3460
3461   /* Calls have side-effects, except those to const or pure functions.  */
3462   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
3463     side_effects = true;
3464   /* Propagate TREE_READONLY of arguments for const functions.  */
3465   if (i & ECF_CONST)
3466     read_only = true;
3467
3468   if (!side_effects || read_only)
3469     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
3470       {
3471         tree op = TREE_OPERAND (t, i);
3472         if (op && TREE_SIDE_EFFECTS (op))
3473           side_effects = true;
3474         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
3475           read_only = false;
3476       }
3477
3478   TREE_SIDE_EFFECTS (t) = side_effects;
3479   TREE_READONLY (t) = read_only;
3480 }
3481 \f
3482 /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
3483    size or offset that depends on a field within a record.  */
3484
3485 bool
3486 contains_placeholder_p (const_tree exp)
3487 {
3488   enum tree_code code;
3489
3490   if (!exp)
3491     return 0;
3492
3493   code = TREE_CODE (exp);
3494   if (code == PLACEHOLDER_EXPR)
3495     return 1;
3496
3497   switch (TREE_CODE_CLASS (code))
3498     {
3499     case tcc_reference:
3500       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
3501          position computations since they will be converted into a
3502          WITH_RECORD_EXPR involving the reference, which will assume
3503          here will be valid.  */
3504       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3505
3506     case tcc_exceptional:
3507       if (code == TREE_LIST)
3508         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
3509                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
3510       break;
3511
3512     case tcc_unary:
3513     case tcc_binary:
3514     case tcc_comparison:
3515     case tcc_expression:
3516       switch (code)
3517         {
3518         case COMPOUND_EXPR:
3519           /* Ignoring the first operand isn't quite right, but works best.  */
3520           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
3521
3522         case COND_EXPR:
3523           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3524                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
3525                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
3526
3527         case SAVE_EXPR:
3528           /* The save_expr function never wraps anything containing
3529              a PLACEHOLDER_EXPR. */
3530           return 0;
3531
3532         default:
3533           break;
3534         }
3535
3536       switch (TREE_CODE_LENGTH (code))
3537         {
3538         case 1:
3539           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
3540         case 2:
3541           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
3542                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
3543         default:
3544           return 0;
3545         }
3546
3547     case tcc_vl_exp:
3548       switch (code)
3549         {
3550         case CALL_EXPR:
3551           {
3552             const_tree arg;
3553             const_call_expr_arg_iterator iter;
3554             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
3555               if (CONTAINS_PLACEHOLDER_P (arg))
3556                 return 1;
3557             return 0;
3558           }
3559         default:
3560           return 0;
3561         }
3562
3563     default:
3564       return 0;
3565     }
3566   return 0;
3567 }
3568
3569 /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
3570    directly.  This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
3571    field positions.  */
3572
3573 static bool
3574 type_contains_placeholder_1 (const_tree type)
3575 {
3576   /* If the size contains a placeholder or the parent type (component type in
3577      the case of arrays) type involves a placeholder, this type does.  */
3578   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
3579       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
3580       || (!POINTER_TYPE_P (type)
3581           && TREE_TYPE (type)
3582           && type_contains_placeholder_p (TREE_TYPE (type))))
3583     return true;
3584
3585   /* Now do type-specific checks.  Note that the last part of the check above
3586      greatly limits what we have to do below.  */
3587   switch (TREE_CODE (type))
3588     {
3589     case VOID_TYPE:
3590     case POINTER_BOUNDS_TYPE:
3591     case COMPLEX_TYPE:
3592     case ENUMERAL_TYPE:
3593     case BOOLEAN_TYPE:
3594     case POINTER_TYPE:
3595     case OFFSET_TYPE:
3596     case REFERENCE_TYPE:
3597     case METHOD_TYPE:
3598     case FUNCTION_TYPE:
3599     case VECTOR_TYPE:
3600     case NULLPTR_TYPE:
3601       return false;
3602
3603     case INTEGER_TYPE:
3604     case REAL_TYPE:
3605     case FIXED_POINT_TYPE:
3606       /* Here we just check the bounds.  */
3607       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
3608               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
3609
3610     case ARRAY_TYPE:
3611       /* We have already checked the component type above, so just check
3612          the domain type.  Flexible array members have a null domain.  */
3613       return TYPE_DOMAIN (type) ?
3614         type_contains_placeholder_p (TYPE_DOMAIN (type)) : false;
3615
3616     case RECORD_TYPE:
3617     case UNION_TYPE:
3618     case QUAL_UNION_TYPE:
3619       {
3620         tree field;
3621
3622         for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3623           if (TREE_CODE (field) == FIELD_DECL
3624               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
3625                   || (TREE_CODE (type) == QUAL_UNION_TYPE
3626                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
3627                   || type_contains_placeholder_p (TREE_TYPE (field))))
3628             return true;
3629
3630         return false;
3631       }
3632
3633     default:
3634       gcc_unreachable ();
3635     }
3636 }
3637
3638 /* Wrapper around above function used to cache its result.  */
3639
3640 bool
3641 type_contains_placeholder_p (tree type)
3642 {
3643   bool result;
3644
3645   /* If the contains_placeholder_bits field has been initialized,
3646      then we know the answer.  */
3647   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
3648     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
3649
3650   /* Indicate that we've seen this type node, and the answer is false.
3651      This is what we want to return if we run into recursion via fields.  */
3652   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
3653
3654   /* Compute the real value.  */
3655   result = type_contains_placeholder_1 (type);
3656
3657   /* Store the real value.  */
3658   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
3659
3660   return result;
3661 }
3662 \f
3663 /* Push tree EXP onto vector QUEUE if it is not already present.  */
3664
3665 static void
3666 push_without_duplicates (tree exp, vec<tree> *queue)
3667 {
3668   unsigned int i;
3669   tree iter;
3670
3671   FOR_EACH_VEC_ELT (*queue, i, iter)
3672     if (simple_cst_equal (iter, exp) == 1)
3673       break;
3674
3675   if (!iter)
3676     queue->safe_push (exp);
3677 }
3678
3679 /* Given a tree EXP, find all occurrences of references to fields
3680    in a PLACEHOLDER_EXPR and place them in vector REFS without
3681    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
3682    we assume here that EXP contains only arithmetic expressions
3683    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
3684    argument list.  */
3685
3686 void
3687 find_placeholder_in_expr (tree exp, vec<tree> *refs)
3688 {
3689   enum tree_code code = TREE_CODE (exp);
3690   tree inner;
3691   int i;
3692
3693   /* We handle TREE_LIST and COMPONENT_REF separately.  */
3694   if (code == TREE_LIST)
3695     {
3696       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
3697       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
3698     }
3699   else if (code == COMPONENT_REF)
3700     {
3701       for (inner = TREE_OPERAND (exp, 0);
3702            REFERENCE_CLASS_P (inner);
3703            inner = TREE_OPERAND (inner, 0))
3704         ;
3705
3706       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
3707         push_without_duplicates (exp, refs);
3708       else
3709         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
3710    }
3711   else
3712     switch (TREE_CODE_CLASS (code))
3713       {
3714       case tcc_constant:
3715         break;
3716
3717       case tcc_declaration:
3718         /* Variables allocated to static storage can stay.  */
3719         if (!TREE_STATIC (exp))
3720           push_without_duplicates (exp, refs);
3721         break;
3722
3723       case tcc_expression:
3724         /* This is the pattern built in ada/make_aligning_type.  */
3725         if (code == ADDR_EXPR
3726             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
3727           {
3728             push_without_duplicates (exp, refs);
3729             break;
3730           }
3731
3732         /* Fall through.  */
3733
3734       case tcc_exceptional:
3735       case tcc_unary:
3736       case tcc_binary:
3737       case tcc_comparison:
3738       case tcc_reference:
3739         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
3740           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3741         break;
3742
3743       case tcc_vl_exp:
3744         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3745           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
3746         break;
3747
3748       default:
3749         gcc_unreachable ();
3750       }
3751 }
3752
3753 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
3754    return a tree with all occurrences of references to F in a
3755    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
3756    CONST_DECLs.  Note that we assume here that EXP contains only
3757    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
3758    occurring only in their argument list.  */
3759
3760 tree
3761 substitute_in_expr (tree exp, tree f, tree r)
3762 {
3763   enum tree_code code = TREE_CODE (exp);
3764   tree op0, op1, op2, op3;
3765   tree new_tree;
3766
3767   /* We handle TREE_LIST and COMPONENT_REF separately.  */
3768   if (code == TREE_LIST)
3769     {
3770       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
3771       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
3772       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3773         return exp;
3774
3775       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3776     }
3777   else if (code == COMPONENT_REF)
3778     {
3779       tree inner;
3780
3781       /* If this expression is getting a value from a PLACEHOLDER_EXPR
3782          and it is the right field, replace it with R.  */
3783       for (inner = TREE_OPERAND (exp, 0);
3784            REFERENCE_CLASS_P (inner);
3785            inner = TREE_OPERAND (inner, 0))
3786         ;
3787
3788       /* The field.  */
3789       op1 = TREE_OPERAND (exp, 1);
3790
3791       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
3792         return r;
3793
3794       /* If this expression hasn't been completed let, leave it alone.  */
3795       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
3796         return exp;
3797
3798       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3799       if (op0 == TREE_OPERAND (exp, 0))
3800         return exp;
3801
3802       new_tree
3803         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3804    }
3805   else
3806     switch (TREE_CODE_CLASS (code))
3807       {
3808       case tcc_constant:
3809         return exp;
3810
3811       case tcc_declaration:
3812         if (exp == f)
3813           return r;
3814         else
3815           return exp;
3816
3817       case tcc_expression:
3818         if (exp == f)
3819           return r;
3820
3821         /* Fall through.  */
3822
3823       case tcc_exceptional:
3824       case tcc_unary:
3825       case tcc_binary:
3826       case tcc_comparison:
3827       case tcc_reference:
3828         switch (TREE_CODE_LENGTH (code))
3829           {
3830           case 0:
3831             return exp;
3832
3833           case 1:
3834             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3835             if (op0 == TREE_OPERAND (exp, 0))
3836               return exp;
3837
3838             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3839             break;
3840
3841           case 2:
3842             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3843             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3844
3845             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3846               return exp;
3847
3848             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3849             break;
3850
3851           case 3:
3852             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3853             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3854             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3855
3856             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3857                 && op2 == TREE_OPERAND (exp, 2))
3858               return exp;
3859
3860             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3861             break;
3862
3863           case 4:
3864             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3865             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3866             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3867             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3868
3869             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3870                 && op2 == TREE_OPERAND (exp, 2)
3871                 && op3 == TREE_OPERAND (exp, 3))
3872               return exp;
3873
3874             new_tree
3875               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3876             break;
3877
3878           default:
3879             gcc_unreachable ();
3880           }
3881         break;
3882
3883       case tcc_vl_exp:
3884         {
3885           int i;
3886
3887           new_tree = NULL_TREE;
3888
3889           /* If we are trying to replace F with a constant, inline back
3890              functions which do nothing else than computing a value from
3891              the arguments they are passed.  This makes it possible to
3892              fold partially or entirely the replacement expression.  */
3893           if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3894             {
3895               tree t = maybe_inline_call_in_expr (exp);
3896               if (t)
3897                 return SUBSTITUTE_IN_EXPR (t, f, r);
3898             }
3899
3900           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3901             {
3902               tree op = TREE_OPERAND (exp, i);
3903               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3904               if (new_op != op)
3905                 {
3906                   if (!new_tree)
3907                     new_tree = copy_node (exp);
3908                   TREE_OPERAND (new_tree, i) = new_op;
3909                 }
3910             }
3911
3912           if (new_tree)
3913             {
3914               new_tree = fold (new_tree);
3915               if (TREE_CODE (new_tree) == CALL_EXPR)
3916                 process_call_operands (new_tree);
3917             }
3918           else
3919             return exp;
3920         }
3921         break;
3922
3923       default:
3924         gcc_unreachable ();
3925       }
3926
3927   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3928
3929   if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
3930     TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
3931
3932   return new_tree;
3933 }
3934
3935 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3936    for it within OBJ, a tree that is an object or a chain of references.  */
3937
3938 tree
3939 substitute_placeholder_in_expr (tree exp, tree obj)
3940 {
3941   enum tree_code code = TREE_CODE (exp);
3942   tree op0, op1, op2, op3;
3943   tree new_tree;
3944
3945   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3946      in the chain of OBJ.  */
3947   if (code == PLACEHOLDER_EXPR)
3948     {
3949       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3950       tree elt;
3951
3952       for (elt = obj; elt != 0;
3953            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3954                    || TREE_CODE (elt) == COND_EXPR)
3955                   ? TREE_OPERAND (elt, 1)
3956                   : (REFERENCE_CLASS_P (elt)
3957                      || UNARY_CLASS_P (elt)
3958                      || BINARY_CLASS_P (elt)
3959                      || VL_EXP_CLASS_P (elt)
3960                      || EXPRESSION_CLASS_P (elt))
3961                   ? TREE_OPERAND (elt, 0) : 0))
3962         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3963           return elt;
3964
3965       for (elt = obj; elt != 0;
3966            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3967                    || TREE_CODE (elt) == COND_EXPR)
3968                   ? TREE_OPERAND (elt, 1)
3969                   : (REFERENCE_CLASS_P (elt)
3970                      || UNARY_CLASS_P (elt)
3971                      || BINARY_CLASS_P (elt)
3972                      || VL_EXP_CLASS_P (elt)
3973                      || EXPRESSION_CLASS_P (elt))
3974                   ? TREE_OPERAND (elt, 0) : 0))
3975         if (POINTER_TYPE_P (TREE_TYPE (elt))
3976             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3977                 == need_type))
3978           return fold_build1 (INDIRECT_REF, need_type, elt);
3979
3980       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3981          survives until RTL generation, there will be an error.  */
3982       return exp;
3983     }
3984
3985   /* TREE_LIST is special because we need to look at TREE_VALUE
3986      and TREE_CHAIN, not TREE_OPERANDS.  */
3987   else if (code == TREE_LIST)
3988     {
3989       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3990       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3991       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3992         return exp;
3993
3994       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3995     }
3996   else
3997     switch (TREE_CODE_CLASS (code))
3998       {
3999       case tcc_constant:
4000       case tcc_declaration:
4001         return exp;
4002
4003       case tcc_exceptional:
4004       case tcc_unary:
4005       case tcc_binary:
4006       case tcc_comparison:
4007       case tcc_expression:
4008       case tcc_reference:
4009       case tcc_statement:
4010         switch (TREE_CODE_LENGTH (code))
4011           {
4012           case 0:
4013             return exp;
4014
4015           case 1:
4016             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4017             if (op0 == TREE_OPERAND (exp, 0))
4018               return exp;
4019
4020             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
4021             break;
4022
4023           case 2:
4024             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4025             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4026
4027             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
4028               return exp;
4029
4030             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
4031             break;
4032
4033           case 3:
4034             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4035             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4036             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
4037
4038             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4039                 && op2 == TREE_OPERAND (exp, 2))
4040               return exp;
4041
4042             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
4043             break;
4044
4045           case 4:
4046             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
4047             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
4048             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
4049             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
4050
4051             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
4052                 && op2 == TREE_OPERAND (exp, 2)
4053                 && op3 == TREE_OPERAND (exp, 3))
4054               return exp;
4055
4056             new_tree
4057               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
4058             break;
4059
4060           default:
4061             gcc_unreachable ();
4062           }
4063         break;
4064
4065       case tcc_vl_exp:
4066         {
4067           int i;
4068
4069           new_tree = NULL_TREE;
4070
4071           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
4072             {
4073               tree op = TREE_OPERAND (exp, i);
4074               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
4075               if (new_op != op)
4076                 {
4077                   if (!new_tree)
4078                     new_tree = copy_node (exp);
4079                   TREE_OPERAND (new_tree, i) = new_op;
4080                 }
4081             }
4082
4083           if (new_tree)
4084             {
4085               new_tree = fold (new_tree);
4086               if (TREE_CODE (new_tree) == CALL_EXPR)
4087                 process_call_operands (new_tree);
4088             }
4089           else
4090             return exp;
4091         }
4092         break;
4093
4094       default:
4095         gcc_unreachable ();
4096       }
4097
4098   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
4099
4100   if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
4101     TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
4102
4103   return new_tree;
4104 }
4105 \f
4106
4107 /* Subroutine of stabilize_reference; this is called for subtrees of
4108    references.  Any expression with side-effects must be put in a SAVE_EXPR
4109    to ensure that it is only evaluated once.
4110
4111    We don't put SAVE_EXPR nodes around everything, because assigning very
4112    simple expressions to temporaries causes us to miss good opportunities
4113    for optimizations.  Among other things, the opportunity to fold in the
4114    addition of a constant into an addressing mode often gets lost, e.g.
4115    "y[i+1] += x;".  In general, we take the approach that we should not make
4116    an assignment unless we are forced into it - i.e., that any non-side effect
4117    operator should be allowed, and that cse should take care of coalescing
4118    multiple utterances of the same expression should that prove fruitful.  */
4119
4120 static tree
4121 stabilize_reference_1 (tree e)
4122 {
4123   tree result;
4124   enum tree_code code = TREE_CODE (e);
4125
4126   /* We cannot ignore const expressions because it might be a reference
4127      to a const array but whose index contains side-effects.  But we can
4128      ignore things that are actual constant or that already have been
4129      handled by this function.  */
4130
4131   if (tree_invariant_p (e))
4132     return e;
4133
4134   switch (TREE_CODE_CLASS (code))
4135     {
4136     case tcc_exceptional:
4137     case tcc_type:
4138     case tcc_declaration:
4139     case tcc_comparison:
4140     case tcc_statement:
4141     case tcc_expression:
4142     case tcc_reference:
4143     case tcc_vl_exp:
4144       /* If the expression has side-effects, then encase it in a SAVE_EXPR
4145          so that it will only be evaluated once.  */
4146       /* The reference (r) and comparison (<) classes could be handled as
4147          below, but it is generally faster to only evaluate them once.  */
4148       if (TREE_SIDE_EFFECTS (e))
4149         return save_expr (e);
4150       return e;
4151
4152     case tcc_constant:
4153       /* Constants need no processing.  In fact, we should never reach
4154          here.  */
4155       return e;
4156
4157     case tcc_binary:
4158       /* Division is slow and tends to be compiled with jumps,
4159          especially the division by powers of 2 that is often
4160          found inside of an array reference.  So do it just once.  */
4161       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
4162           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
4163           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
4164           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
4165         return save_expr (e);
4166       /* Recursively stabilize each operand.  */
4167       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
4168                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
4169       break;
4170
4171     case tcc_unary:
4172       /* Recursively stabilize each operand.  */
4173       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
4174       break;
4175
4176     default:
4177       gcc_unreachable ();
4178     }
4179
4180   TREE_TYPE (result) = TREE_TYPE (e);
4181   TREE_READONLY (result) = TREE_READONLY (e);
4182   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
4183   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
4184
4185   return result;
4186 }
4187
4188 /* Stabilize a reference so that we can use it any number of times
4189    without causing its operands to be evaluated more than once.
4190    Returns the stabilized reference.  This works by means of save_expr,
4191    so see the caveats in the comments about save_expr.
4192
4193    Also allows conversion expressions whose operands are references.
4194    Any other kind of expression is returned unchanged.  */
4195
4196 tree
4197 stabilize_reference (tree ref)
4198 {
4199   tree result;
4200   enum tree_code code = TREE_CODE (ref);
4201
4202   switch (code)
4203     {
4204     case VAR_DECL:
4205     case PARM_DECL:
4206     case RESULT_DECL:
4207       /* No action is needed in this case.  */
4208       return ref;
4209
4210     CASE_CONVERT:
4211     case FLOAT_EXPR:
4212     case FIX_TRUNC_EXPR:
4213       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
4214       break;
4215
4216     case INDIRECT_REF:
4217       result = build_nt (INDIRECT_REF,
4218                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
4219       break;
4220
4221     case COMPONENT_REF:
4222       result = build_nt (COMPONENT_REF,
4223                          stabilize_reference (TREE_OPERAND (ref, 0)),
4224                          TREE_OPERAND (ref, 1), NULL_TREE);
4225       break;
4226
4227     case BIT_FIELD_REF:
4228       result = build_nt (BIT_FIELD_REF,
4229                          stabilize_reference (TREE_OPERAND (ref, 0)),
4230                          TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2));
4231       REF_REVERSE_STORAGE_ORDER (result) = REF_REVERSE_STORAGE_ORDER (ref);
4232       break;
4233
4234     case ARRAY_REF:
4235       result = build_nt (ARRAY_REF,
4236                          stabilize_reference (TREE_OPERAND (ref, 0)),
4237                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4238                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4239       break;
4240
4241     case ARRAY_RANGE_REF:
4242       result = build_nt (ARRAY_RANGE_REF,
4243                          stabilize_reference (TREE_OPERAND (ref, 0)),
4244                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
4245                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
4246       break;
4247
4248     case COMPOUND_EXPR:
4249       /* We cannot wrap the first expression in a SAVE_EXPR, as then
4250          it wouldn't be ignored.  This matters when dealing with
4251          volatiles.  */
4252       return stabilize_reference_1 (ref);
4253
4254       /* If arg isn't a kind of lvalue we recognize, make no change.
4255          Caller should recognize the error for an invalid lvalue.  */
4256     default:
4257       return ref;
4258
4259     case ERROR_MARK:
4260       return error_mark_node;
4261     }
4262
4263   TREE_TYPE (result) = TREE_TYPE (ref);
4264   TREE_READONLY (result) = TREE_READONLY (ref);
4265   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
4266   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
4267
4268   return result;
4269 }
4270 \f
4271 /* Low-level constructors for expressions.  */
4272
4273 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
4274    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
4275
4276 void
4277 recompute_tree_invariant_for_addr_expr (tree t)
4278 {
4279   tree node;
4280   bool tc = true, se = false;
4281
4282   gcc_assert (TREE_CODE (t) == ADDR_EXPR);
4283
4284   /* We started out assuming this address is both invariant and constant, but
4285      does not have side effects.  Now go down any handled components and see if
4286      any of them involve offsets that are either non-constant or non-invariant.
4287      Also check for side-effects.
4288
4289      ??? Note that this code makes no attempt to deal with the case where
4290      taking the address of something causes a copy due to misalignment.  */
4291
4292 #define UPDATE_FLAGS(NODE)  \
4293 do { tree _node = (NODE); \
4294      if (_node && !TREE_CONSTANT (_node)) tc = false; \
4295      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
4296
4297   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
4298        node = TREE_OPERAND (node, 0))
4299     {
4300       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
4301          array reference (probably made temporarily by the G++ front end),
4302          so ignore all the operands.  */
4303       if ((TREE_CODE (node) == ARRAY_REF
4304            || TREE_CODE (node) == ARRAY_RANGE_REF)
4305           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
4306         {
4307           UPDATE_FLAGS (TREE_OPERAND (node, 1));
4308           if (TREE_OPERAND (node, 2))
4309             UPDATE_FLAGS (TREE_OPERAND (node, 2));
4310           if (TREE_OPERAND (node, 3))
4311             UPDATE_FLAGS (TREE_OPERAND (node, 3));
4312         }
4313       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
4314          FIELD_DECL, apparently.  The G++ front end can put something else
4315          there, at least temporarily.  */
4316       else if (TREE_CODE (node) == COMPONENT_REF
4317                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
4318         {
4319           if (TREE_OPERAND (node, 2))
4320             UPDATE_FLAGS (TREE_OPERAND (node, 2));
4321         }
4322     }
4323
4324   node = lang_hooks.expr_to_decl (node, &tc, &se);
4325
4326   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
4327      the address, since &(*a)->b is a form of addition.  If it's a constant, the
4328      address is constant too.  If it's a decl, its address is constant if the
4329      decl is static.  Everything else is not constant and, furthermore,
4330      taking the address of a volatile variable is not volatile.  */
4331   if (TREE_CODE (node) == INDIRECT_REF
4332       || TREE_CODE (node) == MEM_REF)
4333     UPDATE_FLAGS (TREE_OPERAND (node, 0));
4334   else if (CONSTANT_CLASS_P (node))
4335     ;
4336   else if (DECL_P (node))
4337     tc &= (staticp (node) != NULL_TREE);
4338   else
4339     {
4340       tc = false;
4341       se |= TREE_SIDE_EFFECTS (node);
4342     }
4343
4344
4345   TREE_CONSTANT (t) = tc;
4346   TREE_SIDE_EFFECTS (t) = se;
4347 #undef UPDATE_FLAGS
4348 }
4349
4350 /* Build an expression of code CODE, data type TYPE, and operands as
4351    specified.  Expressions and reference nodes can be created this way.
4352    Constants, decls, types and misc nodes cannot be.
4353
4354    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
4355    enough for all extant tree codes.  */
4356
4357 tree
4358 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
4359 {
4360   tree t;
4361
4362   gcc_assert (TREE_CODE_LENGTH (code) == 0);
4363
4364   t = make_node_stat (code PASS_MEM_STAT);
4365   TREE_TYPE (t) = tt;
4366
4367   return t;
4368 }
4369
4370 tree
4371 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
4372 {
4373   int length = sizeof (struct tree_exp);
4374   tree t;
4375
4376   record_node_allocation_statistics (code, length);
4377
4378   gcc_assert (TREE_CODE_LENGTH (code) == 1);
4379
4380   t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
4381
4382   memset (t, 0, sizeof (struct tree_common));
4383
4384   TREE_SET_CODE (t, code);
4385
4386   TREE_TYPE (t) = type;
4387   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
4388   TREE_OPERAND (t, 0) = node;
4389   if (node && !TYPE_P (node))
4390     {
4391       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
4392       TREE_READONLY (t) = TREE_READONLY (node);
4393     }
4394
4395   if (TREE_CODE_CLASS (code) == tcc_statement)
4396     TREE_SIDE_EFFECTS (t) = 1;
4397   else switch (code)
4398     {
4399     case VA_ARG_EXPR:
4400       /* All of these have side-effects, no matter what their
4401          operands are.  */
4402       TREE_SIDE_EFFECTS (t) = 1;
4403       TREE_READONLY (t) = 0;
4404       break;
4405
4406     case INDIRECT_REF:
4407       /* Whether a dereference is readonly has nothing to do with whether
4408          its operand is readonly.  */
4409       TREE_READONLY (t) = 0;
4410       break;
4411
4412     case ADDR_EXPR:
4413       if (node)
4414         recompute_tree_invariant_for_addr_expr (t);
4415       break;
4416
4417     default:
4418       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
4419           && node && !TYPE_P (node)
4420           && TREE_CONSTANT (node))
4421         TREE_CONSTANT (t) = 1;
4422       if (TREE_CODE_CLASS (code) == tcc_reference
4423           && node && TREE_THIS_VOLATILE (node))
4424         TREE_THIS_VOLATILE (t) = 1;
4425       break;
4426     }
4427
4428   return t;
4429 }
4430
4431 #define PROCESS_ARG(N)                          \
4432   do {                                          \
4433     TREE_OPERAND (t, N) = arg##N;               \
4434     if (arg##N &&!TYPE_P (arg##N))              \
4435       {                                         \
4436         if (TREE_SIDE_EFFECTS (arg##N))         \
4437           side_effects = 1;                     \
4438         if (!TREE_READONLY (arg##N)             \
4439             && !CONSTANT_CLASS_P (arg##N))      \
4440           (void) (read_only = 0);               \
4441         if (!TREE_CONSTANT (arg##N))            \
4442           (void) (constant = 0);                \
4443       }                                         \
4444   } while (0)
4445
4446 tree
4447 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
4448 {
4449   bool constant, read_only, side_effects;
4450   tree t;
4451
4452   gcc_assert (TREE_CODE_LENGTH (code) == 2);
4453
4454   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
4455       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
4456       /* When sizetype precision doesn't match that of pointers
4457          we need to be able to build explicit extensions or truncations
4458          of the offset argument.  */
4459       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
4460     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
4461                 && TREE_CODE (arg1) == INTEGER_CST);
4462
4463   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
4464     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
4465                 && ptrofftype_p (TREE_TYPE (arg1)));
4466
4467   t = make_node_stat (code PASS_MEM_STAT);
4468   TREE_TYPE (t) = tt;
4469
4470   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
4471      result based on those same flags for the arguments.  But if the
4472      arguments aren't really even `tree' expressions, we shouldn't be trying
4473      to do this.  */
4474
4475   /* Expressions without side effects may be constant if their
4476      arguments are as well.  */
4477   constant = (TREE_CODE_CLASS (code) == tcc_comparison
4478               || TREE_CODE_CLASS (code) == tcc_binary);
4479   read_only = 1;
4480   side_effects = TREE_SIDE_EFFECTS (t);
4481
4482   PROCESS_ARG (0);
4483   PROCESS_ARG (1);
4484
4485   TREE_SIDE_EFFECTS (t) = side_effects;
4486   if (code == MEM_REF)
4487     {
4488       if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
4489         {
4490           tree o = TREE_OPERAND (arg0, 0);
4491           TREE_READONLY (t) = TREE_READONLY (o);
4492           TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
4493         }
4494     }
4495   else
4496     {
4497       TREE_READONLY (t) = read_only;
4498       TREE_CONSTANT (t) = constant;
4499       TREE_THIS_VOLATILE (t)
4500         = (TREE_CODE_CLASS (code) == tcc_reference
4501            && arg0 && TREE_THIS_VOLATILE (arg0));
4502     }
4503
4504   return t;
4505 }
4506
4507
4508 tree
4509 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4510              tree arg2 MEM_STAT_DECL)
4511 {
4512   bool constant, read_only, side_effects;
4513   tree t;
4514
4515   gcc_assert (TREE_CODE_LENGTH (code) == 3);
4516   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4517
4518   t = make_node_stat (code PASS_MEM_STAT);
4519   TREE_TYPE (t) = tt;
4520
4521   read_only = 1;
4522
4523   /* As a special exception, if COND_EXPR has NULL branches, we
4524      assume that it is a gimple statement and always consider
4525      it to have side effects.  */
4526   if (code == COND_EXPR
4527       && tt == void_type_node
4528       && arg1 == NULL_TREE
4529       && arg2 == NULL_TREE)
4530     side_effects = true;
4531   else
4532     side_effects = TREE_SIDE_EFFECTS (t);
4533
4534   PROCESS_ARG (0);
4535   PROCESS_ARG (1);
4536   PROCESS_ARG (2);
4537
4538   if (code == COND_EXPR)
4539     TREE_READONLY (t) = read_only;
4540
4541   TREE_SIDE_EFFECTS (t) = side_effects;
4542   TREE_THIS_VOLATILE (t)
4543     = (TREE_CODE_CLASS (code) == tcc_reference
4544        && arg0 && TREE_THIS_VOLATILE (arg0));
4545
4546   return t;
4547 }
4548
4549 tree
4550 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4551              tree arg2, tree arg3 MEM_STAT_DECL)
4552 {
4553   bool constant, read_only, side_effects;
4554   tree t;
4555
4556   gcc_assert (TREE_CODE_LENGTH (code) == 4);
4557
4558   t = make_node_stat (code PASS_MEM_STAT);
4559   TREE_TYPE (t) = tt;
4560
4561   side_effects = TREE_SIDE_EFFECTS (t);
4562
4563   PROCESS_ARG (0);
4564   PROCESS_ARG (1);
4565   PROCESS_ARG (2);
4566   PROCESS_ARG (3);
4567
4568   TREE_SIDE_EFFECTS (t) = side_effects;
4569   TREE_THIS_VOLATILE (t)
4570     = (TREE_CODE_CLASS (code) == tcc_reference
4571        && arg0 && TREE_THIS_VOLATILE (arg0));
4572
4573   return t;
4574 }
4575
4576 tree
4577 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
4578              tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
4579 {
4580   bool constant, read_only, side_effects;
4581   tree t;
4582
4583   gcc_assert (TREE_CODE_LENGTH (code) == 5);
4584
4585   t = make_node_stat (code PASS_MEM_STAT);
4586   TREE_TYPE (t) = tt;
4587
4588   side_effects = TREE_SIDE_EFFECTS (t);
4589
4590   PROCESS_ARG (0);
4591   PROCESS_ARG (1);
4592   PROCESS_ARG (2);
4593   PROCESS_ARG (3);
4594   PROCESS_ARG (4);
4595
4596   TREE_SIDE_EFFECTS (t) = side_effects;
4597   if (code == TARGET_MEM_REF)
4598     {
4599       if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
4600         {
4601           tree o = TREE_OPERAND (arg0, 0);
4602           TREE_READONLY (t) = TREE_READONLY (o);
4603           TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
4604         }
4605     }
4606   else
4607     TREE_THIS_VOLATILE (t)
4608       = (TREE_CODE_CLASS (code) == tcc_reference
4609          && arg0 && TREE_THIS_VOLATILE (arg0));
4610
4611   return t;
4612 }
4613
4614 /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
4615    on the pointer PTR.  */
4616
4617 tree
4618 build_simple_mem_ref_loc (location_t loc, tree ptr)
4619 {
4620   HOST_WIDE_INT offset = 0;
4621   tree ptype = TREE_TYPE (ptr);
4622   tree tem;
4623   /* For convenience allow addresses that collapse to a simple base
4624      and offset.  */
4625   if (TREE_CODE (ptr) == ADDR_EXPR
4626       && (handled_component_p (TREE_OPERAND (ptr, 0))
4627           || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
4628     {
4629       ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
4630       gcc_assert (ptr);
4631       ptr = build_fold_addr_expr (ptr);
4632       gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
4633     }
4634   tem = build2 (MEM_REF, TREE_TYPE (ptype),
4635                 ptr, build_int_cst (ptype, offset));
4636   SET_EXPR_LOCATION (tem, loc);
4637   return tem;
4638 }
4639
4640 /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T.  */
4641
4642 offset_int
4643 mem_ref_offset (const_tree t)
4644 {
4645   return offset_int::from (TREE_OPERAND (t, 1), SIGNED);
4646 }
4647
4648 /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
4649    offsetted by OFFSET units.  */
4650
4651 tree
4652 build_invariant_address (tree type, tree base, HOST_WIDE_INT offset)
4653 {
4654   tree ref = fold_build2 (MEM_REF, TREE_TYPE (type),
4655                           build_fold_addr_expr (base),
4656                           build_int_cst (ptr_type_node, offset));
4657   tree addr = build1 (ADDR_EXPR, type, ref);
4658   recompute_tree_invariant_for_addr_expr (addr);
4659   return addr;
4660 }
4661
4662 /* Similar except don't specify the TREE_TYPE
4663    and leave the TREE_SIDE_EFFECTS as 0.
4664    It is permissible for arguments to be null,
4665    or even garbage if their values do not matter.  */
4666
4667 tree
4668 build_nt (enum tree_code code, ...)
4669 {
4670   tree t;
4671   int length;
4672   int i;
4673   va_list p;
4674
4675   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
4676
4677   va_start (p, code);
4678
4679   t = make_node (code);
4680   length = TREE_CODE_LENGTH (code);
4681
4682   for (i = 0; i < length; i++)
4683     TREE_OPERAND (t, i) = va_arg (p, tree);
4684
4685   va_end (p);
4686   return t;
4687 }
4688
4689 /* Similar to build_nt, but for creating a CALL_EXPR object with a
4690    tree vec.  */
4691
4692 tree
4693 build_nt_call_vec (tree fn, vec<tree, va_gc> *args)
4694 {
4695   tree ret, t;
4696   unsigned int ix;
4697
4698   ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
4699   CALL_EXPR_FN (ret) = fn;
4700   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
4701   FOR_EACH_VEC_SAFE_ELT (args, ix, t)
4702     CALL_EXPR_ARG (ret, ix) = t;
4703   return ret;
4704 }
4705 \f
4706 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
4707    We do NOT enter this node in any sort of symbol table.
4708
4709    LOC is the location of the decl.
4710
4711    layout_decl is used to set up the decl's storage layout.
4712    Other slots are initialized to 0 or null pointers.  */
4713
4714 tree
4715 build_decl_stat (location_t loc, enum tree_code code, tree name,
4716                  tree type MEM_STAT_DECL)
4717 {
4718   tree t;
4719
4720   t = make_node_stat (code PASS_MEM_STAT);
4721   DECL_SOURCE_LOCATION (t) = loc;
4722
4723 /*  if (type == error_mark_node)
4724     type = integer_type_node; */
4725 /* That is not done, deliberately, so that having error_mark_node
4726    as the type can suppress useless errors in the use of this variable.  */
4727
4728   DECL_NAME (t) = name;
4729   TREE_TYPE (t) = type;
4730
4731   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
4732     layout_decl (t, 0);
4733
4734   return t;
4735 }
4736
4737 /* Builds and returns function declaration with NAME and TYPE.  */
4738
4739 tree
4740 build_fn_decl (const char *name, tree type)
4741 {
4742   tree id = get_identifier (name);
4743   tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
4744
4745   DECL_EXTERNAL (decl) = 1;
4746   TREE_PUBLIC (decl) = 1;
4747   DECL_ARTIFICIAL (decl) = 1;
4748   TREE_NOTHROW (decl) = 1;
4749
4750   return decl;
4751 }
4752
4753 vec<tree, va_gc> *all_translation_units;
4754
4755 /* Builds a new translation-unit decl with name NAME, queues it in the
4756    global list of translation-unit decls and returns it.   */
4757
4758 tree
4759 build_translation_unit_decl (tree name)
4760 {
4761   tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
4762                         name, NULL_TREE);
4763   TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
4764   vec_safe_push (all_translation_units, tu);
4765   return tu;
4766 }
4767
4768 \f
4769 /* BLOCK nodes are used to represent the structure of binding contours
4770    and declarations, once those contours have been exited and their contents
4771    compiled.  This information is used for outputting debugging info.  */
4772
4773 tree
4774 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
4775 {
4776   tree block = make_node (BLOCK);
4777
4778   BLOCK_VARS (block) = vars;
4779   BLOCK_SUBBLOCKS (block) = subblocks;
4780   BLOCK_SUPERCONTEXT (block) = supercontext;
4781   BLOCK_CHAIN (block) = chain;
4782   return block;
4783 }
4784
4785 \f
4786 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
4787
4788    LOC is the location to use in tree T.  */
4789
4790 void
4791 protected_set_expr_location (tree t, location_t loc)
4792 {
4793   if (CAN_HAVE_LOCATION_P (t))
4794     SET_EXPR_LOCATION (t, loc);
4795 }
4796 \f
4797 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
4798    is ATTRIBUTE.  */
4799
4800 tree
4801 build_decl_attribute_variant (tree ddecl, tree attribute)
4802 {
4803   DECL_ATTRIBUTES (ddecl) = attribute;
4804   return ddecl;
4805 }
4806
4807 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4808    is ATTRIBUTE and its qualifiers are QUALS.
4809
4810    Record such modified types already made so we don't make duplicates.  */
4811
4812 tree
4813 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4814 {
4815   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4816     {
4817       inchash::hash hstate;
4818       tree ntype;
4819       int i;
4820       tree t;
4821       enum tree_code code = TREE_CODE (ttype);
4822
4823       /* Building a distinct copy of a tagged type is inappropriate; it
4824          causes breakage in code that expects there to be a one-to-one
4825          relationship between a struct and its fields.
4826          build_duplicate_type is another solution (as used in
4827          handle_transparent_union_attribute), but that doesn't play well
4828          with the stronger C++ type identity model.  */
4829       if (TREE_CODE (ttype) == RECORD_TYPE
4830           || TREE_CODE (ttype) == UNION_TYPE
4831           || TREE_CODE (ttype) == QUAL_UNION_TYPE
4832           || TREE_CODE (ttype) == ENUMERAL_TYPE)
4833         {
4834           warning (OPT_Wattributes,
4835                    "ignoring attributes applied to %qT after definition",
4836                    TYPE_MAIN_VARIANT (ttype));
4837           return build_qualified_type (ttype, quals);
4838         }
4839
4840       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4841       ntype = build_distinct_type_copy (ttype);
4842
4843       TYPE_ATTRIBUTES (ntype) = attribute;
4844
4845       hstate.add_int (code);
4846       if (TREE_TYPE (ntype))
4847         hstate.add_object (TYPE_HASH (TREE_TYPE (ntype)));
4848       attribute_hash_list (attribute, hstate);
4849
4850       switch (TREE_CODE (ntype))
4851         {
4852         case FUNCTION_TYPE:
4853           type_hash_list (TYPE_ARG_TYPES (ntype), hstate);
4854           break;
4855         case ARRAY_TYPE:
4856           if (TYPE_DOMAIN (ntype))
4857             hstate.add_object (TYPE_HASH (TYPE_DOMAIN (ntype)));
4858           break;
4859         case INTEGER_TYPE:
4860           t = TYPE_MAX_VALUE (ntype);
4861           for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
4862             hstate.add_object (TREE_INT_CST_ELT (t, i));
4863           break;
4864         case REAL_TYPE:
4865         case FIXED_POINT_TYPE:
4866           {
4867             unsigned int precision = TYPE_PRECISION (ntype);
4868             hstate.add_object (precision);
4869           }
4870           break;
4871         default:
4872           break;
4873         }
4874
4875       ntype = type_hash_canon (hstate.end(), ntype);
4876
4877       /* If the target-dependent attributes make NTYPE different from
4878          its canonical type, we will need to use structural equality
4879          checks for this type. */
4880       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4881           || !comp_type_attributes (ntype, ttype))
4882         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4883       else if (TYPE_CANONICAL (ntype) == ntype)
4884         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4885
4886       ttype = build_qualified_type (ntype, quals);
4887     }
4888   else if (TYPE_QUALS (ttype) != quals)
4889     ttype = build_qualified_type (ttype, quals);
4890
4891   return ttype;
4892 }
4893
4894 /* Check if "omp declare simd" attribute arguments, CLAUSES1 and CLAUSES2, are
4895    the same.  */
4896
4897 static bool
4898 omp_declare_simd_clauses_equal (tree clauses1, tree clauses2)
4899 {
4900   tree cl1, cl2;
4901   for (cl1 = clauses1, cl2 = clauses2;
4902        cl1 && cl2;
4903        cl1 = OMP_CLAUSE_CHAIN (cl1), cl2 = OMP_CLAUSE_CHAIN (cl2))
4904     {
4905       if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_CODE (cl2))
4906         return false;
4907       if (OMP_CLAUSE_CODE (cl1) != OMP_CLAUSE_SIMDLEN)
4908         {
4909           if (simple_cst_equal (OMP_CLAUSE_DECL (cl1),
4910                                 OMP_CLAUSE_DECL (cl2)) != 1)
4911             return false;
4912         }
4913       switch (OMP_CLAUSE_CODE (cl1))
4914         {
4915         case OMP_CLAUSE_ALIGNED:
4916           if (simple_cst_equal (OMP_CLAUSE_ALIGNED_ALIGNMENT (cl1),
4917                                 OMP_CLAUSE_ALIGNED_ALIGNMENT (cl2)) != 1)
4918             return false;
4919           break;
4920         case OMP_CLAUSE_LINEAR:
4921           if (simple_cst_equal (OMP_CLAUSE_LINEAR_STEP (cl1),
4922                                 OMP_CLAUSE_LINEAR_STEP (cl2)) != 1)
4923             return false;
4924           break;
4925         case OMP_CLAUSE_SIMDLEN:
4926           if (simple_cst_equal (OMP_CLAUSE_SIMDLEN_EXPR (cl1),
4927                                 OMP_CLAUSE_SIMDLEN_EXPR (cl2)) != 1)
4928             return false;
4929         default:
4930           break;
4931         }
4932     }
4933   return true;
4934 }
4935
4936 /* Compare two constructor-element-type constants.  Return 1 if the lists
4937    are known to be equal; otherwise return 0.  */
4938
4939 static bool
4940 simple_cst_list_equal (const_tree l1, const_tree l2)
4941 {
4942   while (l1 != NULL_TREE && l2 != NULL_TREE)
4943     {
4944       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
4945         return false;
4946
4947       l1 = TREE_CHAIN (l1);
4948       l2 = TREE_CHAIN (l2);
4949     }
4950
4951   return l1 == l2;
4952 }
4953
4954 /* Compare two identifier nodes representing attributes.  Either one may
4955    be in wrapped __ATTR__ form.  Return true if they are the same, false
4956    otherwise.  */
4957
4958 static bool
4959 cmp_attrib_identifiers (const_tree attr1, const_tree attr2)
4960 {
4961   /* Make sure we're dealing with IDENTIFIER_NODEs.  */
4962   gcc_checking_assert (TREE_CODE (attr1) == IDENTIFIER_NODE
4963                        && TREE_CODE (attr2) == IDENTIFIER_NODE);
4964
4965   /* Identifiers can be compared directly for equality.  */
4966   if (attr1 == attr2)
4967     return true;
4968
4969   /* If they are not equal, they may still be one in the form
4970      'text' while the other one is in the form '__text__'.  TODO:
4971      If we were storing attributes in normalized 'text' form, then
4972      this could all go away and we could take full advantage of
4973      the fact that we're comparing identifiers. :-)  */
4974   const size_t attr1_len = IDENTIFIER_LENGTH (attr1);
4975   const size_t attr2_len = IDENTIFIER_LENGTH (attr2);
4976
4977   if (attr2_len == attr1_len + 4)
4978     {
4979       const char *p = IDENTIFIER_POINTER (attr2);
4980       const char *q = IDENTIFIER_POINTER (attr1);
4981       if (p[0] == '_' && p[1] == '_'
4982           && p[attr2_len - 2] == '_' && p[attr2_len - 1] == '_'
4983           && strncmp (q, p + 2, attr1_len) == 0)
4984         return true;;
4985     }
4986   else if (attr2_len + 4 == attr1_len)
4987     {
4988       const char *p = IDENTIFIER_POINTER (attr2);
4989       const char *q = IDENTIFIER_POINTER (attr1);
4990       if (q[0] == '_' && q[1] == '_'
4991           && q[attr1_len - 2] == '_' && q[attr1_len - 1] == '_'
4992           && strncmp (q + 2, p, attr2_len) == 0)
4993         return true;
4994     }
4995
4996   return false;
4997 }
4998
4999 /* Compare two attributes for their value identity.  Return true if the
5000    attribute values are known to be equal; otherwise return false.  */
5001
5002 bool
5003 attribute_value_equal (const_tree attr1, const_tree attr2)
5004 {
5005   if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
5006     return true;
5007
5008   if (TREE_VALUE (attr1) != NULL_TREE
5009       && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
5010       && TREE_VALUE (attr2) != NULL_TREE
5011       && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
5012     {
5013       /* Handle attribute format.  */
5014       if (is_attribute_p ("format", get_attribute_name (attr1)))
5015         {
5016           attr1 = TREE_VALUE (attr1);
5017           attr2 = TREE_VALUE (attr2);
5018           /* Compare the archetypes (printf/scanf/strftime/...).  */
5019           if (!cmp_attrib_identifiers (TREE_VALUE (attr1),
5020                                        TREE_VALUE (attr2)))
5021             return false;
5022           /* Archetypes are the same.  Compare the rest.  */
5023           return (simple_cst_list_equal (TREE_CHAIN (attr1),
5024                                          TREE_CHAIN (attr2)) == 1);
5025         }
5026       return (simple_cst_list_equal (TREE_VALUE (attr1),
5027                                      TREE_VALUE (attr2)) == 1);
5028     }
5029
5030   if ((flag_openmp || flag_openmp_simd)
5031       && TREE_VALUE (attr1) && TREE_VALUE (attr2)
5032       && TREE_CODE (TREE_VALUE (attr1)) == OMP_CLAUSE
5033       && TREE_CODE (TREE_VALUE (attr2)) == OMP_CLAUSE)
5034     return omp_declare_simd_clauses_equal (TREE_VALUE (attr1),
5035                                            TREE_VALUE (attr2));
5036
5037   return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
5038 }
5039
5040 /* Return 0 if the attributes for two types are incompatible, 1 if they
5041    are compatible, and 2 if they are nearly compatible (which causes a
5042    warning to be generated).  */
5043 int
5044 comp_type_attributes (const_tree type1, const_tree type2)
5045 {
5046   const_tree a1 = TYPE_ATTRIBUTES (type1);
5047   const_tree a2 = TYPE_ATTRIBUTES (type2);
5048   const_tree a;
5049
5050   if (a1 == a2)
5051     return 1;
5052   for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
5053     {
5054       const struct attribute_spec *as;
5055       const_tree attr;
5056
5057       as = lookup_attribute_spec (get_attribute_name (a));
5058       if (!as || as->affects_type_identity == false)
5059         continue;
5060
5061       attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
5062       if (!attr || !attribute_value_equal (a, attr))
5063         break;
5064     }
5065   if (!a)
5066     {
5067       for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
5068         {
5069           const struct attribute_spec *as;
5070
5071           as = lookup_attribute_spec (get_attribute_name (a));
5072           if (!as || as->affects_type_identity == false)
5073             continue;
5074
5075           if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
5076             break;
5077           /* We don't need to compare trees again, as we did this
5078              already in first loop.  */
5079         }
5080       /* All types - affecting identity - are equal, so
5081          there is no need to call target hook for comparison.  */
5082       if (!a)
5083         return 1;
5084     }
5085   if (lookup_attribute ("transaction_safe", CONST_CAST_TREE (a)))
5086     return 0;
5087   /* As some type combinations - like default calling-convention - might
5088      be compatible, we have to call the target hook to get the final result.  */
5089   return targetm.comp_type_attributes (type1, type2);
5090 }
5091
5092 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
5093    is ATTRIBUTE.
5094
5095    Record such modified types already made so we don't make duplicates.  */
5096
5097 tree
5098 build_type_attribute_variant (tree ttype, tree attribute)
5099 {
5100   return build_type_attribute_qual_variant (ttype, attribute,
5101                                             TYPE_QUALS (ttype));
5102 }
5103
5104
5105 /* Reset the expression *EXPR_P, a size or position.
5106
5107    ??? We could reset all non-constant sizes or positions.  But it's cheap
5108    enough to not do so and refrain from adding workarounds to dwarf2out.c.
5109
5110    We need to reset self-referential sizes or positions because they cannot
5111    be gimplified and thus can contain a CALL_EXPR after the gimplification
5112    is finished, which will run afoul of LTO streaming.  And they need to be
5113    reset to something essentially dummy but not constant, so as to preserve
5114    the properties of the object they are attached to.  */
5115
5116 static inline void
5117 free_lang_data_in_one_sizepos (tree *expr_p)
5118 {
5119   tree expr = *expr_p;
5120   if (CONTAINS_PLACEHOLDER_P (expr))
5121     *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
5122 }
5123
5124
5125 /* Reset all the fields in a binfo node BINFO.  We only keep
5126    BINFO_VTABLE, which is used by gimple_fold_obj_type_ref.  */
5127
5128 static void
5129 free_lang_data_in_binfo (tree binfo)
5130 {
5131   unsigned i;
5132   tree t;
5133
5134   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
5135
5136   BINFO_VIRTUALS (binfo) = NULL_TREE;
5137   BINFO_BASE_ACCESSES (binfo) = NULL;
5138   BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
5139   BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
5140
5141   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t)
5142     free_lang_data_in_binfo (t);
5143 }
5144
5145
5146 /* Reset all language specific information still present in TYPE.  */
5147
5148 static void
5149 free_lang_data_in_type (tree type)
5150 {
5151   gcc_assert (TYPE_P (type));
5152
5153   /* Give the FE a chance to remove its own data first.  */
5154   lang_hooks.free_lang_data (type);
5155
5156   TREE_LANG_FLAG_0 (type) = 0;
5157   TREE_LANG_FLAG_1 (type) = 0;
5158   TREE_LANG_FLAG_2 (type) = 0;
5159   TREE_LANG_FLAG_3 (type) = 0;
5160   TREE_LANG_FLAG_4 (type) = 0;
5161   TREE_LANG_FLAG_5 (type) = 0;
5162   TREE_LANG_FLAG_6 (type) = 0;
5163
5164   if (TREE_CODE (type) == FUNCTION_TYPE)
5165     {
5166       /* Remove the const and volatile qualifiers from arguments.  The
5167          C++ front end removes them, but the C front end does not,
5168          leading to false ODR violation errors when merging two
5169          instances of the same function signature compiled by
5170          different front ends.  */
5171       tree p;
5172
5173       for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
5174         {
5175           tree arg_type = TREE_VALUE (p);
5176
5177           if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
5178             {
5179               int quals = TYPE_QUALS (arg_type)
5180                           & ~TYPE_QUAL_CONST
5181                           & ~TYPE_QUAL_VOLATILE;
5182               TREE_VALUE (p) = build_qualified_type (arg_type, quals);
5183               free_lang_data_in_type (TREE_VALUE (p));
5184             }
5185           /* C++ FE uses TREE_PURPOSE to store initial values.  */
5186           TREE_PURPOSE (p) = NULL;
5187         }
5188       /* Java uses TYPE_MINVAL for TYPE_ARGUMENT_SIGNATURE.  */
5189       TYPE_MINVAL (type) = NULL;
5190     }
5191   if (TREE_CODE (type) == METHOD_TYPE)
5192     {
5193       tree p;
5194
5195       for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
5196         {
5197           /* C++ FE uses TREE_PURPOSE to store initial values.  */
5198           TREE_PURPOSE (p) = NULL;
5199         }
5200       /* Java uses TYPE_MINVAL for TYPE_ARGUMENT_SIGNATURE.  */
5201       TYPE_MINVAL (type) = NULL;
5202     }
5203
5204   /* Remove members that are not actually FIELD_DECLs from the field
5205      list of an aggregate.  These occur in C++.  */
5206   if (RECORD_OR_UNION_TYPE_P (type))
5207     {
5208       tree prev, member;
5209
5210       /* Note that TYPE_FIELDS can be shared across distinct
5211          TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
5212          to be removed, we cannot set its TREE_CHAIN to NULL.
5213          Otherwise, we would not be able to find all the other fields
5214          in the other instances of this TREE_TYPE.
5215
5216          This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
5217       prev = NULL_TREE;
5218       member = TYPE_FIELDS (type);
5219       while (member)
5220         {
5221           if (TREE_CODE (member) == FIELD_DECL
5222               || (TREE_CODE (member) == TYPE_DECL
5223                   && !DECL_IGNORED_P (member)
5224                   && debug_info_level > DINFO_LEVEL_TERSE
5225                   && !is_redundant_typedef (member)))
5226             {
5227               if (prev)
5228                 TREE_CHAIN (prev) = member;
5229               else
5230                 TYPE_FIELDS (type) = member;
5231               prev = member;
5232             }
5233
5234           member = TREE_CHAIN (member);
5235         }
5236
5237       if (prev)
5238         TREE_CHAIN (prev) = NULL_TREE;
5239       else
5240         TYPE_FIELDS (type) = NULL_TREE;
5241
5242       /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
5243          and danagle the pointer from time to time.  */
5244       if (TYPE_VFIELD (type) && TREE_CODE (TYPE_VFIELD (type)) != FIELD_DECL)
5245         TYPE_VFIELD (type) = NULL_TREE;
5246
5247       /* Remove TYPE_METHODS list.  While it would be nice to keep it
5248          to enable ODR warnings about different method lists, doing so
5249          seems to impractically increase size of LTO data streamed.
5250          Keep the information if TYPE_METHODS was non-NULL. This is used
5251          by function.c and pretty printers.  */
5252       if (TYPE_METHODS (type))
5253         TYPE_METHODS (type) = error_mark_node;
5254       if (TYPE_BINFO (type))
5255         {
5256           free_lang_data_in_binfo (TYPE_BINFO (type));
5257           /* We need to preserve link to bases and virtual table for all
5258              polymorphic types to make devirtualization machinery working.
5259              Debug output cares only about bases, but output also
5260              virtual table pointers so merging of -fdevirtualize and
5261              -fno-devirtualize units is easier.  */
5262           if ((!BINFO_VTABLE (TYPE_BINFO (type))
5263                || !flag_devirtualize)
5264               && ((!BINFO_N_BASE_BINFOS (TYPE_BINFO (type))
5265                    && !BINFO_VTABLE (TYPE_BINFO (type)))
5266                   || debug_info_level != DINFO_LEVEL_NONE))
5267             TYPE_BINFO (type) = NULL;
5268         }
5269     }
5270   else
5271     {
5272       /* For non-aggregate types, clear out the language slot (which
5273          overloads TYPE_BINFO).  */
5274       TYPE_LANG_SLOT_1 (type) = NULL_TREE;
5275
5276       if (INTEGRAL_TYPE_P (type)
5277           || SCALAR_FLOAT_TYPE_P (type)
5278           || FIXED_POINT_TYPE_P (type))
5279         {
5280           free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
5281           free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
5282         }
5283     }
5284
5285   free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
5286   free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
5287
5288   if (TYPE_CONTEXT (type)
5289       && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
5290     {
5291       tree ctx = TYPE_CONTEXT (type);
5292       do
5293         {
5294           ctx = BLOCK_SUPERCONTEXT (ctx);
5295         }
5296       while (ctx && TREE_CODE (ctx) == BLOCK);
5297       TYPE_CONTEXT (type) = ctx;
5298     }
5299 }
5300
5301
5302 /* Return true if DECL may need an assembler name to be set.  */
5303
5304 static inline bool
5305 need_assembler_name_p (tree decl)
5306 {
5307   /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition
5308      Rule merging.  This makes type_odr_p to return true on those types during
5309      LTO and by comparing the mangled name, we can say what types are intended
5310      to be equivalent across compilation unit.
5311
5312      We do not store names of type_in_anonymous_namespace_p.
5313
5314      Record, union and enumeration type have linkage that allows use
5315      to check type_in_anonymous_namespace_p. We do not mangle compound types
5316      that always can be compared structurally.
5317
5318      Similarly for builtin types, we compare properties of their main variant.
5319      A special case are integer types where mangling do make differences
5320      between char/signed char/unsigned char etc.  Storing name for these makes
5321      e.g.  -fno-signed-char/-fsigned-char mismatches to be handled well.
5322      See cp/mangle.c:write_builtin_type for details.  */
5323
5324   if (flag_lto_odr_type_mering
5325       && TREE_CODE (decl) == TYPE_DECL
5326       && DECL_NAME (decl)
5327       && decl == TYPE_NAME (TREE_TYPE (decl))
5328       && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TREE_TYPE (decl)
5329       && !TYPE_ARTIFICIAL (TREE_TYPE (decl))
5330       && (type_with_linkage_p (TREE_TYPE (decl))
5331           || TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE)
5332       && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
5333     return !DECL_ASSEMBLER_NAME_SET_P (decl);
5334   /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
5335   if (!VAR_OR_FUNCTION_DECL_P (decl))
5336     return false;
5337
5338   /* If DECL already has its assembler name set, it does not need a
5339      new one.  */
5340   if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
5341       || DECL_ASSEMBLER_NAME_SET_P (decl))
5342     return false;
5343
5344   /* Abstract decls do not need an assembler name.  */
5345   if (DECL_ABSTRACT_P (decl))
5346     return false;
5347
5348   /* For VAR_DECLs, only static, public and external symbols need an
5349      assembler name.  */
5350   if (VAR_P (decl)
5351       && !TREE_STATIC (decl)
5352       && !TREE_PUBLIC (decl)
5353       && !DECL_EXTERNAL (decl))
5354     return false;
5355
5356   if (TREE_CODE (decl) == FUNCTION_DECL)
5357     {
5358       /* Do not set assembler name on builtins.  Allow RTL expansion to
5359          decide whether to expand inline or via a regular call.  */
5360       if (DECL_BUILT_IN (decl)
5361           && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
5362         return false;
5363
5364       /* Functions represented in the callgraph need an assembler name.  */
5365       if (cgraph_node::get (decl) != NULL)
5366         return true;
5367
5368       /* Unused and not public functions don't need an assembler name.  */
5369       if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
5370         return false;
5371     }
5372
5373   return true;
5374 }
5375
5376
5377 /* Reset all language specific information still present in symbol
5378    DECL.  */
5379
5380 static void
5381 free_lang_data_in_decl (tree decl)
5382 {
5383   gcc_assert (DECL_P (decl));
5384
5385   /* Give the FE a chance to remove its own data first.  */
5386   lang_hooks.free_lang_data (decl);
5387
5388   TREE_LANG_FLAG_0 (decl) = 0;
5389   TREE_LANG_FLAG_1 (decl) = 0;
5390   TREE_LANG_FLAG_2 (decl) = 0;
5391   TREE_LANG_FLAG_3 (decl) = 0;
5392   TREE_LANG_FLAG_4 (decl) = 0;
5393   TREE_LANG_FLAG_5 (decl) = 0;
5394   TREE_LANG_FLAG_6 (decl) = 0;
5395
5396   free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
5397   free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
5398   if (TREE_CODE (decl) == FIELD_DECL)
5399     {
5400       free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
5401       if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
5402         DECL_QUALIFIER (decl) = NULL_TREE;
5403     }
5404
5405  if (TREE_CODE (decl) == FUNCTION_DECL)
5406     {
5407       struct cgraph_node *node;
5408       if (!(node = cgraph_node::get (decl))
5409           || (!node->definition && !node->clones))
5410         {
5411           if (node)
5412             node->release_body ();
5413           else
5414             {
5415               release_function_body (decl);
5416               DECL_ARGUMENTS (decl) = NULL;
5417               DECL_RESULT (decl) = NULL;
5418               DECL_INITIAL (decl) = error_mark_node;
5419             }
5420         }
5421       if (gimple_has_body_p (decl) || (node && node->thunk.thunk_p))
5422         {
5423           tree t;
5424
5425           /* If DECL has a gimple body, then the context for its
5426              arguments must be DECL.  Otherwise, it doesn't really
5427              matter, as we will not be emitting any code for DECL.  In
5428              general, there may be other instances of DECL created by
5429              the front end and since PARM_DECLs are generally shared,
5430              their DECL_CONTEXT changes as the replicas of DECL are
5431              created.  The only time where DECL_CONTEXT is important
5432              is for the FUNCTION_DECLs that have a gimple body (since
5433              the PARM_DECL will be used in the function's body).  */
5434           for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
5435             DECL_CONTEXT (t) = decl;
5436           if (!DECL_FUNCTION_SPECIFIC_TARGET (decl))
5437             DECL_FUNCTION_SPECIFIC_TARGET (decl)
5438               = target_option_default_node;
5439           if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl))
5440             DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl)
5441               = optimization_default_node;
5442         }
5443
5444       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
5445          At this point, it is not needed anymore.  */
5446       DECL_SAVED_TREE (decl) = NULL_TREE;
5447
5448       /* Clear the abstract origin if it refers to a method.  Otherwise
5449          dwarf2out.c will ICE as we clear TYPE_METHODS and thus the
5450          origin will not be output correctly.  */
5451       if (DECL_ABSTRACT_ORIGIN (decl)
5452           && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
5453           && RECORD_OR_UNION_TYPE_P
5454                (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
5455         DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
5456
5457       /* Sometimes the C++ frontend doesn't manage to transform a temporary
5458          DECL_VINDEX referring to itself into a vtable slot number as it
5459          should.  Happens with functions that are copied and then forgotten
5460          about.  Just clear it, it won't matter anymore.  */
5461       if (DECL_VINDEX (decl) && !tree_fits_shwi_p (DECL_VINDEX (decl)))
5462         DECL_VINDEX (decl) = NULL_TREE;
5463     }
5464   else if (VAR_P (decl))
5465     {
5466       if ((DECL_EXTERNAL (decl)
5467            && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
5468           || (decl_function_context (decl) && !TREE_STATIC (decl)))
5469         DECL_INITIAL (decl) = NULL_TREE;
5470     }
5471   else if (TREE_CODE (decl) == TYPE_DECL)
5472     {
5473       DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5474       DECL_VISIBILITY_SPECIFIED (decl) = 0;
5475       DECL_INITIAL (decl) = NULL_TREE;
5476     }
5477   else if (TREE_CODE (decl) == FIELD_DECL)
5478     DECL_INITIAL (decl) = NULL_TREE;
5479   else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL
5480            && DECL_INITIAL (decl)
5481            && TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
5482     {
5483       /* Strip builtins from the translation-unit BLOCK.  We still have targets
5484          without builtin_decl_explicit support and also builtins are shared
5485          nodes and thus we can't use TREE_CHAIN in multiple lists.  */
5486       tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
5487       while (*nextp)
5488         {
5489           tree var = *nextp;
5490           if (TREE_CODE (var) == FUNCTION_DECL
5491               && DECL_BUILT_IN (var))
5492             *nextp = TREE_CHAIN (var);
5493           else
5494             nextp = &TREE_CHAIN (var);
5495         }
5496     }
5497 }
5498
5499
5500 /* Data used when collecting DECLs and TYPEs for language data removal.  */
5501
5502 struct free_lang_data_d
5503 {
5504   free_lang_data_d () : decls (100), types (100) {}
5505
5506   /* Worklist to avoid excessive recursion.  */
5507   auto_vec<tree> worklist;
5508
5509   /* Set of traversed objects.  Used to avoid duplicate visits.  */
5510   hash_set<tree> pset;
5511
5512   /* Array of symbols to process with free_lang_data_in_decl.  */
5513   auto_vec<tree> decls;
5514
5515   /* Array of types to process with free_lang_data_in_type.  */
5516   auto_vec<tree> types;
5517 };
5518
5519
5520 /* Save all language fields needed to generate proper debug information
5521    for DECL.  This saves most fields cleared out by free_lang_data_in_decl.  */
5522
5523 static void
5524 save_debug_info_for_decl (tree t)
5525 {
5526   /*struct saved_debug_info_d *sdi;*/
5527
5528   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
5529
5530   /* FIXME.  Partial implementation for saving debug info removed.  */
5531 }
5532
5533
5534 /* Save all language fields needed to generate proper debug information
5535    for TYPE.  This saves most fields cleared out by free_lang_data_in_type.  */
5536
5537 static void
5538 save_debug_info_for_type (tree t)
5539 {
5540   /*struct saved_debug_info_d *sdi;*/
5541
5542   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
5543
5544   /* FIXME.  Partial implementation for saving debug info removed.  */
5545 }
5546
5547
5548 /* Add type or decl T to one of the list of tree nodes that need their
5549    language data removed.  The lists are held inside FLD.  */
5550
5551 static void
5552 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
5553 {
5554   if (DECL_P (t))
5555     {
5556       fld->decls.safe_push (t);
5557       if (debug_info_level > DINFO_LEVEL_TERSE)
5558         save_debug_info_for_decl (t);
5559     }
5560   else if (TYPE_P (t))
5561     {
5562       fld->types.safe_push (t);
5563       if (debug_info_level > DINFO_LEVEL_TERSE)
5564         save_debug_info_for_type (t);
5565     }
5566   else
5567     gcc_unreachable ();
5568 }
5569
5570 /* Push tree node T into FLD->WORKLIST.  */
5571
5572 static inline void
5573 fld_worklist_push (tree t, struct free_lang_data_d *fld)
5574 {
5575   if (t && !is_lang_specific (t) && !fld->pset.contains (t))
5576     fld->worklist.safe_push ((t));
5577 }
5578
5579
5580 /* Operand callback helper for free_lang_data_in_node.  *TP is the
5581    subtree operand being considered.  */
5582
5583 static tree
5584 find_decls_types_r (tree *tp, int *ws, void *data)
5585 {
5586   tree t = *tp;
5587   struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
5588
5589   if (TREE_CODE (t) == TREE_LIST)
5590     return NULL_TREE;
5591
5592   /* Language specific nodes will be removed, so there is no need
5593      to gather anything under them.  */
5594   if (is_lang_specific (t))
5595     {
5596       *ws = 0;
5597       return NULL_TREE;
5598     }
5599
5600   if (DECL_P (t))
5601     {
5602       /* Note that walk_tree does not traverse every possible field in
5603          decls, so we have to do our own traversals here.  */
5604       add_tree_to_fld_list (t, fld);
5605
5606       fld_worklist_push (DECL_NAME (t), fld);
5607       fld_worklist_push (DECL_CONTEXT (t), fld);
5608       fld_worklist_push (DECL_SIZE (t), fld);
5609       fld_worklist_push (DECL_SIZE_UNIT (t), fld);
5610
5611       /* We are going to remove everything under DECL_INITIAL for
5612          TYPE_DECLs.  No point walking them.  */
5613       if (TREE_CODE (t) != TYPE_DECL)
5614         fld_worklist_push (DECL_INITIAL (t), fld);
5615
5616       fld_worklist_push (DECL_ATTRIBUTES (t), fld);
5617       fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
5618
5619       if (TREE_CODE (t) == FUNCTION_DECL)
5620         {
5621           fld_worklist_push (DECL_ARGUMENTS (t), fld);
5622           fld_worklist_push (DECL_RESULT (t), fld);
5623         }
5624       else if (TREE_CODE (t) == TYPE_DECL)
5625         {
5626           fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld);
5627         }
5628       else if (TREE_CODE (t) == FIELD_DECL)
5629         {
5630           fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
5631           fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
5632           fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
5633           fld_worklist_push (DECL_FCONTEXT (t), fld);
5634         }
5635
5636       if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL)
5637           && DECL_HAS_VALUE_EXPR_P (t))
5638         fld_worklist_push (DECL_VALUE_EXPR (t), fld);
5639
5640       if (TREE_CODE (t) != FIELD_DECL
5641           && TREE_CODE (t) != TYPE_DECL)
5642         fld_worklist_push (TREE_CHAIN (t), fld);
5643       *ws = 0;
5644     }
5645   else if (TYPE_P (t))
5646     {
5647       /* Note that walk_tree does not traverse every possible field in
5648          types, so we have to do our own traversals here.  */
5649       add_tree_to_fld_list (t, fld);
5650
5651       if (!RECORD_OR_UNION_TYPE_P (t))
5652         fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
5653       fld_worklist_push (TYPE_SIZE (t), fld);
5654       fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
5655       fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
5656       fld_worklist_push (TYPE_POINTER_TO (t), fld);
5657       fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
5658       fld_worklist_push (TYPE_NAME (t), fld);
5659       /* Do not walk TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  We do not stream
5660          them and thus do not and want not to reach unused pointer types
5661          this way.  */
5662       if (!POINTER_TYPE_P (t))
5663         fld_worklist_push (TYPE_MINVAL (t), fld);
5664       if (!RECORD_OR_UNION_TYPE_P (t))
5665         fld_worklist_push (TYPE_MAXVAL (t), fld);
5666       fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
5667       /* Do not walk TYPE_NEXT_VARIANT.  We do not stream it and thus
5668          do not and want not to reach unused variants this way.  */
5669       if (TYPE_CONTEXT (t))
5670         {
5671           tree ctx = TYPE_CONTEXT (t);
5672           /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
5673              So push that instead.  */
5674           while (ctx && TREE_CODE (ctx) == BLOCK)
5675             ctx = BLOCK_SUPERCONTEXT (ctx);
5676           fld_worklist_push (ctx, fld);
5677         }
5678       /* Do not walk TYPE_CANONICAL.  We do not stream it and thus do not
5679          and want not to reach unused types this way.  */
5680
5681       if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
5682         {
5683           unsigned i;
5684           tree tem;
5685           FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
5686             fld_worklist_push (TREE_TYPE (tem), fld);
5687           tem = BINFO_VIRTUALS (TYPE_BINFO (t));
5688           if (tem
5689               /* The Java FE overloads BINFO_VIRTUALS for its own purpose.  */
5690               && TREE_CODE (tem) == TREE_LIST)
5691             do
5692               {
5693                 fld_worklist_push (TREE_VALUE (tem), fld);
5694                 tem = TREE_CHAIN (tem);
5695               }
5696             while (tem);
5697         }
5698       if (RECORD_OR_UNION_TYPE_P (t))
5699         {
5700           tree tem;
5701           /* Push all TYPE_FIELDS - there can be interleaving interesting
5702              and non-interesting things.  */
5703           tem = TYPE_FIELDS (t);
5704           while (tem)
5705             {
5706               if (TREE_CODE (tem) == FIELD_DECL
5707                   || (TREE_CODE (tem) == TYPE_DECL
5708                       && !DECL_IGNORED_P (tem)
5709                       && debug_info_level > DINFO_LEVEL_TERSE
5710                       && !is_redundant_typedef (tem)))
5711                 fld_worklist_push (tem, fld);
5712               tem = TREE_CHAIN (tem);
5713             }
5714         }
5715
5716       fld_worklist_push (TYPE_STUB_DECL (t), fld);
5717       *ws = 0;
5718     }
5719   else if (TREE_CODE (t) == BLOCK)
5720     {
5721       tree tem;
5722       for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
5723         fld_worklist_push (tem, fld);
5724       for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
5725         fld_worklist_push (tem, fld);
5726       fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
5727     }
5728
5729   if (TREE_CODE (t) != IDENTIFIER_NODE
5730       && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED))
5731     fld_worklist_push (TREE_TYPE (t), fld);
5732
5733   return NULL_TREE;
5734 }
5735
5736
5737 /* Find decls and types in T.  */
5738
5739 static void
5740 find_decls_types (tree t, struct free_lang_data_d *fld)
5741 {
5742   while (1)
5743     {
5744       if (!fld->pset.contains (t))
5745         walk_tree (&t, find_decls_types_r, fld, &fld->pset);
5746       if (fld->worklist.is_empty ())
5747         break;
5748       t = fld->worklist.pop ();
5749     }
5750 }
5751
5752 /* Translate all the types in LIST with the corresponding runtime
5753    types.  */
5754
5755 static tree
5756 get_eh_types_for_runtime (tree list)
5757 {
5758   tree head, prev;
5759
5760   if (list == NULL_TREE)
5761     return NULL_TREE;
5762
5763   head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5764   prev = head;
5765   list = TREE_CHAIN (list);
5766   while (list)
5767     {
5768       tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
5769       TREE_CHAIN (prev) = n;
5770       prev = TREE_CHAIN (prev);
5771       list = TREE_CHAIN (list);
5772     }
5773
5774   return head;
5775 }
5776
5777
5778 /* Find decls and types referenced in EH region R and store them in
5779    FLD->DECLS and FLD->TYPES.  */
5780
5781 static void
5782 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
5783 {
5784   switch (r->type)
5785     {
5786     case ERT_CLEANUP:
5787       break;
5788
5789     case ERT_TRY:
5790       {
5791         eh_catch c;
5792
5793         /* The types referenced in each catch must first be changed to the
5794            EH types used at runtime.  This removes references to FE types
5795            in the region.  */
5796         for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
5797           {
5798             c->type_list = get_eh_types_for_runtime (c->type_list);
5799             walk_tree (&c->type_list, find_decls_types_r, fld, &fld->pset);
5800           }
5801       }
5802       break;
5803
5804     case ERT_ALLOWED_EXCEPTIONS:
5805       r->u.allowed.type_list
5806         = get_eh_types_for_runtime (r->u.allowed.type_list);
5807       walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, &fld->pset);
5808       break;
5809
5810     case ERT_MUST_NOT_THROW:
5811       walk_tree (&r->u.must_not_throw.failure_decl,
5812                  find_decls_types_r, fld, &fld->pset);
5813       break;
5814     }
5815 }
5816
5817
5818 /* Find decls and types referenced in cgraph node N and store them in
5819    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
5820    look for *every* kind of DECL and TYPE node reachable from N,
5821    including those embedded inside types and decls (i.e,, TYPE_DECLs,
5822    NAMESPACE_DECLs, etc).  */
5823
5824 static void
5825 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
5826 {
5827   basic_block bb;
5828   struct function *fn;
5829   unsigned ix;
5830   tree t;
5831
5832   find_decls_types (n->decl, fld);
5833
5834   if (!gimple_has_body_p (n->decl))
5835     return;
5836
5837   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
5838
5839   fn = DECL_STRUCT_FUNCTION (n->decl);
5840
5841   /* Traverse locals. */
5842   FOR_EACH_LOCAL_DECL (fn, ix, t)
5843     find_decls_types (t, fld);
5844
5845   /* Traverse EH regions in FN.  */
5846   {
5847     eh_region r;
5848     FOR_ALL_EH_REGION_FN (r, fn)
5849       find_decls_types_in_eh_region (r, fld);
5850   }
5851
5852   /* Traverse every statement in FN.  */
5853   FOR_EACH_BB_FN (bb, fn)
5854     {
5855       gphi_iterator psi;
5856       gimple_stmt_iterator si;
5857       unsigned i;
5858
5859       for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
5860         {
5861           gphi *phi = psi.phi ();
5862
5863           for (i = 0; i < gimple_phi_num_args (phi); i++)
5864             {
5865               tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
5866               find_decls_types (*arg_p, fld);
5867             }
5868         }
5869
5870       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
5871         {
5872           gimple *stmt = gsi_stmt (si);
5873
5874           if (is_gimple_call (stmt))
5875             find_decls_types (gimple_call_fntype (stmt), fld);
5876
5877           for (i = 0; i < gimple_num_ops (stmt); i++)
5878             {
5879               tree arg = gimple_op (stmt, i);
5880               find_decls_types (arg, fld);
5881             }
5882         }
5883     }
5884 }
5885
5886
5887 /* Find decls and types referenced in varpool node N and store them in
5888    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
5889    look for *every* kind of DECL and TYPE node reachable from N,
5890    including those embedded inside types and decls (i.e,, TYPE_DECLs,
5891    NAMESPACE_DECLs, etc).  */
5892
5893 static void
5894 find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld)
5895 {
5896   find_decls_types (v->decl, fld);
5897 }
5898
5899 /* If T needs an assembler name, have one created for it.  */
5900
5901 void
5902 assign_assembler_name_if_needed (tree t)
5903 {
5904   if (need_assembler_name_p (t))
5905     {
5906       /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
5907          diagnostics that use input_location to show locus
5908          information.  The problem here is that, at this point,
5909          input_location is generally anchored to the end of the file
5910          (since the parser is long gone), so we don't have a good
5911          position to pin it to.
5912
5913          To alleviate this problem, this uses the location of T's
5914          declaration.  Examples of this are
5915          testsuite/g++.dg/template/cond2.C and
5916          testsuite/g++.dg/template/pr35240.C.  */
5917       location_t saved_location = input_location;
5918       input_location = DECL_SOURCE_LOCATION (t);
5919
5920       decl_assembler_name (t);
5921
5922       input_location = saved_location;
5923     }
5924 }
5925
5926
5927 /* Free language specific information for every operand and expression
5928    in every node of the call graph.  This process operates in three stages:
5929
5930    1- Every callgraph node and varpool node is traversed looking for
5931       decls and types embedded in them.  This is a more exhaustive
5932       search than that done by find_referenced_vars, because it will
5933       also collect individual fields, decls embedded in types, etc.
5934
5935    2- All the decls found are sent to free_lang_data_in_decl.
5936
5937    3- All the types found are sent to free_lang_data_in_type.
5938
5939    The ordering between decls and types is important because
5940    free_lang_data_in_decl sets assembler names, which includes
5941    mangling.  So types cannot be freed up until assembler names have
5942    been set up.  */
5943
5944 static void
5945 free_lang_data_in_cgraph (void)
5946 {
5947   struct cgraph_node *n;
5948   varpool_node *v;
5949   struct free_lang_data_d fld;
5950   tree t;
5951   unsigned i;
5952   alias_pair *p;
5953
5954   /* Find decls and types in the body of every function in the callgraph.  */
5955   FOR_EACH_FUNCTION (n)
5956     find_decls_types_in_node (n, &fld);
5957
5958   FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
5959     find_decls_types (p->decl, &fld);
5960
5961   /* Find decls and types in every varpool symbol.  */
5962   FOR_EACH_VARIABLE (v)
5963     find_decls_types_in_var (v, &fld);
5964
5965   /* Set the assembler name on every decl found.  We need to do this
5966      now because free_lang_data_in_decl will invalidate data needed
5967      for mangling.  This breaks mangling on interdependent decls.  */
5968   FOR_EACH_VEC_ELT (fld.decls, i, t)
5969     assign_assembler_name_if_needed (t);
5970
5971   /* Traverse every decl found freeing its language data.  */
5972   FOR_EACH_VEC_ELT (fld.decls, i, t)
5973     free_lang_data_in_decl (t);
5974
5975   /* Traverse every type found freeing its language data.  */
5976   FOR_EACH_VEC_ELT (fld.types, i, t)
5977     free_lang_data_in_type (t);
5978   if (flag_checking)
5979     {
5980       FOR_EACH_VEC_ELT (fld.types, i, t)
5981         verify_type (t);
5982     }
5983 }
5984
5985
5986 /* Free resources that are used by FE but are not needed once they are done. */
5987
5988 static unsigned
5989 free_lang_data (void)
5990 {
5991   unsigned i;
5992
5993   /* If we are the LTO frontend we have freed lang-specific data already.  */
5994   if (in_lto_p
5995       || (!flag_generate_lto && !flag_generate_offload))
5996     return 0;
5997
5998   /* Allocate and assign alias sets to the standard integer types
5999      while the slots are still in the way the frontends generated them.  */
6000   for (i = 0; i < itk_none; ++i)
6001     if (integer_types[i])
6002       TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
6003
6004   /* Traverse the IL resetting language specific information for
6005      operands, expressions, etc.  */
6006   free_lang_data_in_cgraph ();
6007
6008   /* Create gimple variants for common types.  */
6009   fileptr_type_node = ptr_type_node;
6010   const_tm_ptr_type_node = const_ptr_type_node;
6011
6012   /* Reset some langhooks.  Do not reset types_compatible_p, it may
6013      still be used indirectly via the get_alias_set langhook.  */
6014   lang_hooks.dwarf_name = lhd_dwarf_name;
6015   lang_hooks.decl_printable_name = gimple_decl_printable_name;
6016   lang_hooks.gimplify_expr = lhd_gimplify_expr;
6017
6018   /* We do not want the default decl_assembler_name implementation,
6019      rather if we have fixed everything we want a wrapper around it
6020      asserting that all non-local symbols already got their assembler
6021      name and only produce assembler names for local symbols.  Or rather
6022      make sure we never call decl_assembler_name on local symbols and
6023      devise a separate, middle-end private scheme for it.  */
6024
6025   /* Reset diagnostic machinery.  */
6026   tree_diagnostics_defaults (global_dc);
6027
6028   return 0;
6029 }
6030
6031
6032 namespace {
6033
6034 const pass_data pass_data_ipa_free_lang_data =
6035 {
6036   SIMPLE_IPA_PASS, /* type */
6037   "*free_lang_data", /* name */
6038   OPTGROUP_NONE, /* optinfo_flags */
6039   TV_IPA_FREE_LANG_DATA, /* tv_id */
6040   0, /* properties_required */
6041   0, /* properties_provided */
6042   0, /* properties_destroyed */
6043   0, /* todo_flags_start */
6044   0, /* todo_flags_finish */
6045 };
6046
6047 class pass_ipa_free_lang_data : public simple_ipa_opt_pass
6048 {
6049 public:
6050   pass_ipa_free_lang_data (gcc::context *ctxt)
6051     : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
6052   {}
6053
6054   /* opt_pass methods: */
6055   virtual unsigned int execute (function *) { return free_lang_data (); }
6056
6057 }; // class pass_ipa_free_lang_data
6058
6059 } // anon namespace
6060
6061 simple_ipa_opt_pass *
6062 make_pass_ipa_free_lang_data (gcc::context *ctxt)
6063 {
6064   return new pass_ipa_free_lang_data (ctxt);
6065 }
6066
6067 /* The backbone of is_attribute_p().  ATTR_LEN is the string length of
6068    ATTR_NAME.  Also used internally by remove_attribute().  */
6069 bool
6070 private_is_attribute_p (const char *attr_name, size_t attr_len, const_tree ident)
6071 {
6072   size_t ident_len = IDENTIFIER_LENGTH (ident);
6073
6074   if (ident_len == attr_len)
6075     {
6076       if (strcmp (attr_name, IDENTIFIER_POINTER (ident)) == 0)
6077         return true;
6078     }
6079   else if (ident_len == attr_len + 4)
6080     {
6081       /* There is the possibility that ATTR is 'text' and IDENT is
6082          '__text__'.  */
6083       const char *p = IDENTIFIER_POINTER (ident);
6084       if (p[0] == '_' && p[1] == '_'
6085           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
6086           && strncmp (attr_name, p + 2, attr_len) == 0)
6087         return true;
6088     }
6089
6090   return false;
6091 }
6092
6093 /* The backbone of lookup_attribute().  ATTR_LEN is the string length
6094    of ATTR_NAME, and LIST is not NULL_TREE.  */
6095 tree
6096 private_lookup_attribute (const char *attr_name, size_t attr_len, tree list)
6097 {
6098   while (list)
6099     {
6100       size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
6101
6102       if (ident_len == attr_len)
6103         {
6104           if (!strcmp (attr_name,
6105                        IDENTIFIER_POINTER (get_attribute_name (list))))
6106             break;
6107         }
6108       /* TODO: If we made sure that attributes were stored in the
6109          canonical form without '__...__' (ie, as in 'text' as opposed
6110          to '__text__') then we could avoid the following case.  */
6111       else if (ident_len == attr_len + 4)
6112         {
6113           const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
6114           if (p[0] == '_' && p[1] == '_'
6115               && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
6116               && strncmp (attr_name, p + 2, attr_len) == 0)
6117             break;
6118         }
6119       list = TREE_CHAIN (list);
6120     }
6121
6122   return list;
6123 }
6124
6125 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
6126    return a pointer to the attribute's list first element if the attribute
6127    starts with ATTR_NAME. ATTR_NAME must be in the form 'text' (not
6128    '__text__').  */
6129
6130 tree
6131 private_lookup_attribute_by_prefix (const char *attr_name, size_t attr_len,
6132                                     tree list)
6133 {
6134   while (list)
6135     {
6136       size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
6137
6138       if (attr_len > ident_len)
6139         {
6140           list = TREE_CHAIN (list);
6141           continue;
6142         }
6143
6144       const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
6145
6146       if (strncmp (attr_name, p, attr_len) == 0)
6147         break;
6148
6149       /* TODO: If we made sure that attributes were stored in the
6150          canonical form without '__...__' (ie, as in 'text' as opposed
6151          to '__text__') then we could avoid the following case.  */
6152       if (p[0] == '_' && p[1] == '_' &&
6153           strncmp (attr_name, p + 2, attr_len) == 0)
6154         break;
6155
6156       list = TREE_CHAIN (list);
6157     }
6158
6159   return list;
6160 }
6161
6162
6163 /* A variant of lookup_attribute() that can be used with an identifier
6164    as the first argument, and where the identifier can be either
6165    'text' or '__text__'.
6166
6167    Given an attribute ATTR_IDENTIFIER, and a list of attributes LIST,
6168    return a pointer to the attribute's list element if the attribute
6169    is part of the list, or NULL_TREE if not found.  If the attribute
6170    appears more than once, this only returns the first occurrence; the
6171    TREE_CHAIN of the return value should be passed back in if further
6172    occurrences are wanted.  ATTR_IDENTIFIER must be an identifier but
6173    can be in the form 'text' or '__text__'.  */
6174 static tree
6175 lookup_ident_attribute (tree attr_identifier, tree list)
6176 {
6177   gcc_checking_assert (TREE_CODE (attr_identifier) == IDENTIFIER_NODE);
6178
6179   while (list)
6180     {
6181       gcc_checking_assert (TREE_CODE (get_attribute_name (list))
6182                            == IDENTIFIER_NODE);
6183
6184       if (cmp_attrib_identifiers (attr_identifier,
6185                                   get_attribute_name (list)))
6186         /* Found it.  */
6187         break;
6188       list = TREE_CHAIN (list);
6189     }
6190
6191   return list;
6192 }
6193
6194 /* Remove any instances of attribute ATTR_NAME in LIST and return the
6195    modified list.  */
6196
6197 tree
6198 remove_attribute (const char *attr_name, tree list)
6199 {
6200   tree *p;
6201   size_t attr_len = strlen (attr_name);
6202
6203   gcc_checking_assert (attr_name[0] != '_');
6204
6205   for (p = &list; *p; )
6206     {
6207       tree l = *p;
6208       /* TODO: If we were storing attributes in normalized form, here
6209          we could use a simple strcmp().  */
6210       if (private_is_attribute_p (attr_name, attr_len, get_attribute_name (l)))
6211         *p = TREE_CHAIN (l);
6212       else
6213         p = &TREE_CHAIN (l);
6214     }
6215
6216   return list;
6217 }
6218
6219 /* Return an attribute list that is the union of a1 and a2.  */
6220
6221 tree
6222 merge_attributes (tree a1, tree a2)
6223 {
6224   tree attributes;
6225
6226   /* Either one unset?  Take the set one.  */
6227
6228   if ((attributes = a1) == 0)
6229     attributes = a2;
6230
6231   /* One that completely contains the other?  Take it.  */
6232
6233   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
6234     {
6235       if (attribute_list_contained (a2, a1))
6236         attributes = a2;
6237       else
6238         {
6239           /* Pick the longest list, and hang on the other list.  */
6240
6241           if (list_length (a1) < list_length (a2))
6242             attributes = a2, a2 = a1;
6243
6244           for (; a2 != 0; a2 = TREE_CHAIN (a2))
6245             {
6246               tree a;
6247               for (a = lookup_ident_attribute (get_attribute_name (a2),
6248                                                attributes);
6249                    a != NULL_TREE && !attribute_value_equal (a, a2);
6250                    a = lookup_ident_attribute (get_attribute_name (a2),
6251                                                TREE_CHAIN (a)))
6252                 ;
6253               if (a == NULL_TREE)
6254                 {
6255                   a1 = copy_node (a2);
6256                   TREE_CHAIN (a1) = attributes;
6257                   attributes = a1;
6258                 }
6259             }
6260         }
6261     }
6262   return attributes;
6263 }
6264
6265 /* Given types T1 and T2, merge their attributes and return
6266   the result.  */
6267
6268 tree
6269 merge_type_attributes (tree t1, tree t2)
6270 {
6271   return merge_attributes (TYPE_ATTRIBUTES (t1),
6272                            TYPE_ATTRIBUTES (t2));
6273 }
6274
6275 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
6276    the result.  */
6277
6278 tree
6279 merge_decl_attributes (tree olddecl, tree newdecl)
6280 {
6281   return merge_attributes (DECL_ATTRIBUTES (olddecl),
6282                            DECL_ATTRIBUTES (newdecl));
6283 }
6284
6285 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
6286
6287 /* Specialization of merge_decl_attributes for various Windows targets.
6288
6289    This handles the following situation:
6290
6291      __declspec (dllimport) int foo;
6292      int foo;
6293
6294    The second instance of `foo' nullifies the dllimport.  */
6295
6296 tree
6297 merge_dllimport_decl_attributes (tree old, tree new_tree)
6298 {
6299   tree a;
6300   int delete_dllimport_p = 1;
6301
6302   /* What we need to do here is remove from `old' dllimport if it doesn't
6303      appear in `new'.  dllimport behaves like extern: if a declaration is
6304      marked dllimport and a definition appears later, then the object
6305      is not dllimport'd.  We also remove a `new' dllimport if the old list
6306      contains dllexport:  dllexport always overrides dllimport, regardless
6307      of the order of declaration.  */
6308   if (!VAR_OR_FUNCTION_DECL_P (new_tree))
6309     delete_dllimport_p = 0;
6310   else if (DECL_DLLIMPORT_P (new_tree)
6311            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
6312     {
6313       DECL_DLLIMPORT_P (new_tree) = 0;
6314       warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
6315               "dllimport ignored", new_tree);
6316     }
6317   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
6318     {
6319       /* Warn about overriding a symbol that has already been used, e.g.:
6320            extern int __attribute__ ((dllimport)) foo;
6321            int* bar () {return &foo;}
6322            int foo;
6323       */
6324       if (TREE_USED (old))
6325         {
6326           warning (0, "%q+D redeclared without dllimport attribute "
6327                    "after being referenced with dll linkage", new_tree);
6328           /* If we have used a variable's address with dllimport linkage,
6329               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
6330               decl may already have had TREE_CONSTANT computed.
6331               We still remove the attribute so that assembler code refers
6332               to '&foo rather than '_imp__foo'.  */
6333           if (VAR_P (old) && TREE_ADDRESSABLE (old))
6334             DECL_DLLIMPORT_P (new_tree) = 1;
6335         }
6336
6337       /* Let an inline definition silently override the external reference,
6338          but otherwise warn about attribute inconsistency.  */
6339       else if (VAR_P (new_tree) || !DECL_DECLARED_INLINE_P (new_tree))
6340         warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
6341                   "previous dllimport ignored", new_tree);
6342     }
6343   else
6344     delete_dllimport_p = 0;
6345
6346   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
6347
6348   if (delete_dllimport_p)
6349     a = remove_attribute ("dllimport", a);
6350
6351   return a;
6352 }
6353
6354 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
6355    struct attribute_spec.handler.  */
6356
6357 tree
6358 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
6359                       bool *no_add_attrs)
6360 {
6361   tree node = *pnode;
6362   bool is_dllimport;
6363
6364   /* These attributes may apply to structure and union types being created,
6365      but otherwise should pass to the declaration involved.  */
6366   if (!DECL_P (node))
6367     {
6368       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
6369                    | (int) ATTR_FLAG_ARRAY_NEXT))
6370         {
6371           *no_add_attrs = true;
6372           return tree_cons (name, args, NULL_TREE);
6373         }
6374       if (TREE_CODE (node) == RECORD_TYPE
6375           || TREE_CODE (node) == UNION_TYPE)
6376         {
6377           node = TYPE_NAME (node);
6378           if (!node)
6379             return NULL_TREE;
6380         }
6381       else
6382         {
6383           warning (OPT_Wattributes, "%qE attribute ignored",
6384                    name);
6385           *no_add_attrs = true;
6386           return NULL_TREE;
6387         }
6388     }
6389
6390   if (!VAR_OR_FUNCTION_DECL_P (node) && TREE_CODE (node) != TYPE_DECL)
6391     {
6392       *no_add_attrs = true;
6393       warning (OPT_Wattributes, "%qE attribute ignored",
6394                name);
6395       return NULL_TREE;
6396     }
6397
6398   if (TREE_CODE (node) == TYPE_DECL
6399       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
6400       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
6401     {
6402       *no_add_attrs = true;
6403       warning (OPT_Wattributes, "%qE attribute ignored",
6404                name);
6405       return NULL_TREE;
6406     }
6407
6408   is_dllimport = is_attribute_p ("dllimport", name);
6409
6410   /* Report error on dllimport ambiguities seen now before they cause
6411      any damage.  */
6412   if (is_dllimport)
6413     {
6414       /* Honor any target-specific overrides. */
6415       if (!targetm.valid_dllimport_attribute_p (node))
6416         *no_add_attrs = true;
6417
6418      else if (TREE_CODE (node) == FUNCTION_DECL
6419                 && DECL_DECLARED_INLINE_P (node))
6420         {
6421           warning (OPT_Wattributes, "inline function %q+D declared as "
6422                   " dllimport: attribute ignored", node);
6423           *no_add_attrs = true;
6424         }
6425       /* Like MS, treat definition of dllimported variables and
6426          non-inlined functions on declaration as syntax errors. */
6427      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
6428         {
6429           error ("function %q+D definition is marked dllimport", node);
6430           *no_add_attrs = true;
6431         }
6432
6433      else if (VAR_P (node))
6434         {
6435           if (DECL_INITIAL (node))
6436             {
6437               error ("variable %q+D definition is marked dllimport",
6438                      node);
6439               *no_add_attrs = true;
6440             }
6441
6442           /* `extern' needn't be specified with dllimport.
6443              Specify `extern' now and hope for the best.  Sigh.  */
6444           DECL_EXTERNAL (node) = 1;
6445           /* Also, implicitly give dllimport'd variables declared within
6446              a function global scope, unless declared static.  */
6447           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
6448             TREE_PUBLIC (node) = 1;
6449         }
6450
6451       if (*no_add_attrs == false)
6452         DECL_DLLIMPORT_P (node) = 1;
6453     }
6454   else if (TREE_CODE (node) == FUNCTION_DECL
6455            && DECL_DECLARED_INLINE_P (node)
6456            && flag_keep_inline_dllexport)
6457     /* An exported function, even if inline, must be emitted.  */
6458     DECL_EXTERNAL (node) = 0;
6459
6460   /*  Report error if symbol is not accessible at global scope.  */
6461   if (!TREE_PUBLIC (node) && VAR_OR_FUNCTION_DECL_P (node))
6462     {
6463       error ("external linkage required for symbol %q+D because of "
6464              "%qE attribute", node, name);
6465       *no_add_attrs = true;
6466     }
6467
6468   /* A dllexport'd entity must have default visibility so that other
6469      program units (shared libraries or the main executable) can see
6470      it.  A dllimport'd entity must have default visibility so that
6471      the linker knows that undefined references within this program
6472      unit can be resolved by the dynamic linker.  */
6473   if (!*no_add_attrs)
6474     {
6475       if (DECL_VISIBILITY_SPECIFIED (node)
6476           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
6477         error ("%qE implies default visibility, but %qD has already "
6478                "been declared with a different visibility",
6479                name, node);
6480       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
6481       DECL_VISIBILITY_SPECIFIED (node) = 1;
6482     }
6483
6484   return NULL_TREE;
6485 }
6486
6487 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
6488 \f
6489 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
6490    of the various TYPE_QUAL values.  */
6491
6492 static void
6493 set_type_quals (tree type, int type_quals)
6494 {
6495   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
6496   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
6497   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
6498   TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
6499   TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
6500 }
6501
6502 /* Returns true iff CAND and BASE have equivalent language-specific
6503    qualifiers.  */
6504
6505 bool
6506 check_lang_type (const_tree cand, const_tree base)
6507 {
6508   if (lang_hooks.types.type_hash_eq == NULL)
6509     return true;
6510   /* type_hash_eq currently only applies to these types.  */
6511   if (TREE_CODE (cand) != FUNCTION_TYPE
6512       && TREE_CODE (cand) != METHOD_TYPE)
6513     return true;
6514   return lang_hooks.types.type_hash_eq (cand, base);
6515 }
6516
6517 /* Returns true iff unqualified CAND and BASE are equivalent.  */
6518
6519 bool
6520 check_base_type (const_tree cand, const_tree base)
6521 {
6522   return (TYPE_NAME (cand) == TYPE_NAME (base)
6523           /* Apparently this is needed for Objective-C.  */
6524           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6525           /* Check alignment.  */
6526           && TYPE_ALIGN (cand) == TYPE_ALIGN (base)
6527           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6528                                    TYPE_ATTRIBUTES (base)));
6529 }
6530
6531 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
6532
6533 bool
6534 check_qualified_type (const_tree cand, const_tree base, int type_quals)
6535 {
6536   return (TYPE_QUALS (cand) == type_quals
6537           && check_base_type (cand, base)
6538           && check_lang_type (cand, base));
6539 }
6540
6541 /* Returns true iff CAND is equivalent to BASE with ALIGN.  */
6542
6543 static bool
6544 check_aligned_type (const_tree cand, const_tree base, unsigned int align)
6545 {
6546   return (TYPE_QUALS (cand) == TYPE_QUALS (base)
6547           && TYPE_NAME (cand) == TYPE_NAME (base)
6548           /* Apparently this is needed for Objective-C.  */
6549           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
6550           /* Check alignment.  */
6551           && TYPE_ALIGN (cand) == align
6552           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
6553                                    TYPE_ATTRIBUTES (base))
6554           && check_lang_type (cand, base));
6555 }
6556
6557 /* This function checks to see if TYPE matches the size one of the built-in
6558    atomic types, and returns that core atomic type.  */
6559
6560 static tree
6561 find_atomic_core_type (tree type)
6562 {
6563   tree base_atomic_type;
6564
6565   /* Only handle complete types.  */
6566   if (TYPE_SIZE (type) == NULL_TREE)
6567     return NULL_TREE;
6568
6569   HOST_WIDE_INT type_size = tree_to_uhwi (TYPE_SIZE (type));
6570   switch (type_size)
6571     {
6572     case 8:
6573       base_atomic_type = atomicQI_type_node;
6574       break;
6575
6576     case 16:
6577       base_atomic_type = atomicHI_type_node;
6578       break;
6579
6580     case 32:
6581       base_atomic_type = atomicSI_type_node;
6582       break;
6583
6584     case 64:
6585       base_atomic_type = atomicDI_type_node;
6586       break;
6587
6588     case 128:
6589       base_atomic_type = atomicTI_type_node;
6590       break;
6591
6592     default:
6593       base_atomic_type = NULL_TREE;
6594     }
6595
6596   return base_atomic_type;
6597 }
6598
6599 /* Return a version of the TYPE, qualified as indicated by the
6600    TYPE_QUALS, if one exists.  If no qualified version exists yet,
6601    return NULL_TREE.  */
6602
6603 tree
6604 get_qualified_type (tree type, int type_quals)
6605 {
6606   tree t;
6607
6608   if (TYPE_QUALS (type) == type_quals)
6609     return type;
6610
6611   /* Search the chain of variants to see if there is already one there just
6612      like the one we need to have.  If so, use that existing one.  We must
6613      preserve the TYPE_NAME, since there is code that depends on this.  */
6614   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6615     if (check_qualified_type (t, type, type_quals))
6616       return t;
6617
6618   return NULL_TREE;
6619 }
6620
6621 /* Like get_qualified_type, but creates the type if it does not
6622    exist.  This function never returns NULL_TREE.  */
6623
6624 tree
6625 build_qualified_type (tree type, int type_quals MEM_STAT_DECL)
6626 {
6627   tree t;
6628
6629   /* See if we already have the appropriate qualified variant.  */
6630   t = get_qualified_type (type, type_quals);
6631
6632   /* If not, build it.  */
6633   if (!t)
6634     {
6635       t = build_variant_type_copy (type PASS_MEM_STAT);
6636       set_type_quals (t, type_quals);
6637
6638       if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC))
6639         {
6640           /* See if this object can map to a basic atomic type.  */
6641           tree atomic_type = find_atomic_core_type (type);
6642           if (atomic_type)
6643             {
6644               /* Ensure the alignment of this type is compatible with
6645                  the required alignment of the atomic type.  */
6646               if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t))
6647                 SET_TYPE_ALIGN (t, TYPE_ALIGN (atomic_type));
6648             }
6649         }
6650
6651       if (TYPE_STRUCTURAL_EQUALITY_P (type))
6652         /* Propagate structural equality. */
6653         SET_TYPE_STRUCTURAL_EQUALITY (t);
6654       else if (TYPE_CANONICAL (type) != type)
6655         /* Build the underlying canonical type, since it is different
6656            from TYPE. */
6657         {
6658           tree c = build_qualified_type (TYPE_CANONICAL (type), type_quals);
6659           TYPE_CANONICAL (t) = TYPE_CANONICAL (c);
6660         }
6661       else
6662         /* T is its own canonical type. */
6663         TYPE_CANONICAL (t) = t;
6664
6665     }
6666
6667   return t;
6668 }
6669
6670 /* Create a variant of type T with alignment ALIGN.  */
6671
6672 tree
6673 build_aligned_type (tree type, unsigned int align)
6674 {
6675   tree t;
6676
6677   if (TYPE_PACKED (type)
6678       || TYPE_ALIGN (type) == align)
6679     return type;
6680
6681   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6682     if (check_aligned_type (t, type, align))
6683       return t;
6684
6685   t = build_variant_type_copy (type);
6686   SET_TYPE_ALIGN (t, align);
6687   TYPE_USER_ALIGN (t) = 1;
6688
6689   return t;
6690 }
6691
6692 /* Create a new distinct copy of TYPE.  The new type is made its own
6693    MAIN_VARIANT. If TYPE requires structural equality checks, the
6694    resulting type requires structural equality checks; otherwise, its
6695    TYPE_CANONICAL points to itself. */
6696
6697 tree
6698 build_distinct_type_copy (tree type MEM_STAT_DECL)
6699 {
6700   tree t = copy_node_stat (type PASS_MEM_STAT);
6701
6702   TYPE_POINTER_TO (t) = 0;
6703   TYPE_REFERENCE_TO (t) = 0;
6704
6705   /* Set the canonical type either to a new equivalence class, or
6706      propagate the need for structural equality checks. */
6707   if (TYPE_STRUCTURAL_EQUALITY_P (type))
6708     SET_TYPE_STRUCTURAL_EQUALITY (t);
6709   else
6710     TYPE_CANONICAL (t) = t;
6711
6712   /* Make it its own variant.  */
6713   TYPE_MAIN_VARIANT (t) = t;
6714   TYPE_NEXT_VARIANT (t) = 0;
6715
6716   /* We do not record methods in type copies nor variants
6717      so we do not need to keep them up to date when new method
6718      is inserted.  */
6719   if (RECORD_OR_UNION_TYPE_P (t))
6720     TYPE_METHODS (t) = NULL_TREE;
6721
6722   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
6723      whose TREE_TYPE is not t.  This can also happen in the Ada
6724      frontend when using subtypes.  */
6725
6726   return t;
6727 }
6728
6729 /* Create a new variant of TYPE, equivalent but distinct.  This is so
6730    the caller can modify it. TYPE_CANONICAL for the return type will
6731    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
6732    are considered equal by the language itself (or that both types
6733    require structural equality checks). */
6734
6735 tree
6736 build_variant_type_copy (tree type MEM_STAT_DECL)
6737 {
6738   tree t, m = TYPE_MAIN_VARIANT (type);
6739
6740   t = build_distinct_type_copy (type PASS_MEM_STAT);
6741
6742   /* Since we're building a variant, assume that it is a non-semantic
6743      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
6744   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
6745   /* Type variants have no alias set defined.  */
6746   TYPE_ALIAS_SET (t) = -1;
6747
6748   /* Add the new type to the chain of variants of TYPE.  */
6749   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
6750   TYPE_NEXT_VARIANT (m) = t;
6751   TYPE_MAIN_VARIANT (t) = m;
6752
6753   return t;
6754 }
6755 \f
6756 /* Return true if the from tree in both tree maps are equal.  */
6757
6758 int
6759 tree_map_base_eq (const void *va, const void *vb)
6760 {
6761   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
6762     *const b = (const struct tree_map_base *) vb;
6763   return (a->from == b->from);
6764 }
6765
6766 /* Hash a from tree in a tree_base_map.  */
6767
6768 unsigned int
6769 tree_map_base_hash (const void *item)
6770 {
6771   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
6772 }
6773
6774 /* Return true if this tree map structure is marked for garbage collection
6775    purposes.  We simply return true if the from tree is marked, so that this
6776    structure goes away when the from tree goes away.  */
6777
6778 int
6779 tree_map_base_marked_p (const void *p)
6780 {
6781   return ggc_marked_p (((const struct tree_map_base *) p)->from);
6782 }
6783
6784 /* Hash a from tree in a tree_map.  */
6785
6786 unsigned int
6787 tree_map_hash (const void *item)
6788 {
6789   return (((const struct tree_map *) item)->hash);
6790 }
6791
6792 /* Hash a from tree in a tree_decl_map.  */
6793
6794 unsigned int
6795 tree_decl_map_hash (const void *item)
6796 {
6797   return DECL_UID (((const struct tree_decl_map *) item)->base.from);
6798 }
6799
6800 /* Return the initialization priority for DECL.  */
6801
6802 priority_type
6803 decl_init_priority_lookup (tree decl)
6804 {
6805   symtab_node *snode = symtab_node::get (decl);
6806
6807   if (!snode)
6808     return DEFAULT_INIT_PRIORITY;
6809   return
6810     snode->get_init_priority ();
6811 }
6812
6813 /* Return the finalization priority for DECL.  */
6814
6815 priority_type
6816 decl_fini_priority_lookup (tree decl)
6817 {
6818   cgraph_node *node = cgraph_node::get (decl);
6819
6820   if (!node)
6821     return DEFAULT_INIT_PRIORITY;
6822   return
6823     node->get_fini_priority ();
6824 }
6825
6826 /* Set the initialization priority for DECL to PRIORITY.  */
6827
6828 void
6829 decl_init_priority_insert (tree decl, priority_type priority)
6830 {
6831   struct symtab_node *snode;
6832
6833   if (priority == DEFAULT_INIT_PRIORITY)
6834     {
6835       snode = symtab_node::get (decl);
6836       if (!snode)
6837         return;
6838     }
6839   else if (VAR_P (decl))
6840     snode = varpool_node::get_create (decl);
6841   else
6842     snode = cgraph_node::get_create (decl);
6843   snode->set_init_priority (priority);
6844 }
6845
6846 /* Set the finalization priority for DECL to PRIORITY.  */
6847
6848 void
6849 decl_fini_priority_insert (tree decl, priority_type priority)
6850 {
6851   struct cgraph_node *node;
6852
6853   if (priority == DEFAULT_INIT_PRIORITY)
6854     {
6855       node = cgraph_node::get (decl);
6856       if (!node)
6857         return;
6858     }
6859   else
6860     node = cgraph_node::get_create (decl);
6861   node->set_fini_priority (priority);
6862 }
6863
6864 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
6865
6866 static void
6867 print_debug_expr_statistics (void)
6868 {
6869   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
6870            (long) debug_expr_for_decl->size (),
6871            (long) debug_expr_for_decl->elements (),
6872            debug_expr_for_decl->collisions ());
6873 }
6874
6875 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
6876
6877 static void
6878 print_value_expr_statistics (void)
6879 {
6880   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
6881            (long) value_expr_for_decl->size (),
6882            (long) value_expr_for_decl->elements (),
6883            value_expr_for_decl->collisions ());
6884 }
6885
6886 /* Lookup a debug expression for FROM, and return it if we find one.  */
6887
6888 tree
6889 decl_debug_expr_lookup (tree from)
6890 {
6891   struct tree_decl_map *h, in;
6892   in.base.from = from;
6893
6894   h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6895   if (h)
6896     return h->to;
6897   return NULL_TREE;
6898 }
6899
6900 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
6901
6902 void
6903 decl_debug_expr_insert (tree from, tree to)
6904 {
6905   struct tree_decl_map *h;
6906
6907   h = ggc_alloc<tree_decl_map> ();
6908   h->base.from = from;
6909   h->to = to;
6910   *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6911 }
6912
6913 /* Lookup a value expression for FROM, and return it if we find one.  */
6914
6915 tree
6916 decl_value_expr_lookup (tree from)
6917 {
6918   struct tree_decl_map *h, in;
6919   in.base.from = from;
6920
6921   h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
6922   if (h)
6923     return h->to;
6924   return NULL_TREE;
6925 }
6926
6927 /* Insert a mapping FROM->TO in the value expression hashtable.  */
6928
6929 void
6930 decl_value_expr_insert (tree from, tree to)
6931 {
6932   struct tree_decl_map *h;
6933
6934   h = ggc_alloc<tree_decl_map> ();
6935   h->base.from = from;
6936   h->to = to;
6937   *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
6938 }
6939
6940 /* Lookup a vector of debug arguments for FROM, and return it if we
6941    find one.  */
6942
6943 vec<tree, va_gc> **
6944 decl_debug_args_lookup (tree from)
6945 {
6946   struct tree_vec_map *h, in;
6947
6948   if (!DECL_HAS_DEBUG_ARGS_P (from))
6949     return NULL;
6950   gcc_checking_assert (debug_args_for_decl != NULL);
6951   in.base.from = from;
6952   h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from));
6953   if (h)
6954     return &h->to;
6955   return NULL;
6956 }
6957
6958 /* Insert a mapping FROM->empty vector of debug arguments in the value
6959    expression hashtable.  */
6960
6961 vec<tree, va_gc> **
6962 decl_debug_args_insert (tree from)
6963 {
6964   struct tree_vec_map *h;
6965   tree_vec_map **loc;
6966
6967   if (DECL_HAS_DEBUG_ARGS_P (from))
6968     return decl_debug_args_lookup (from);
6969   if (debug_args_for_decl == NULL)
6970     debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64);
6971   h = ggc_alloc<tree_vec_map> ();
6972   h->base.from = from;
6973   h->to = NULL;
6974   loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT);
6975   *loc = h;
6976   DECL_HAS_DEBUG_ARGS_P (from) = 1;
6977   return &h->to;
6978 }
6979
6980 /* Hashing of types so that we don't make duplicates.
6981    The entry point is `type_hash_canon'.  */
6982
6983 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
6984    with types in the TREE_VALUE slots), by adding the hash codes
6985    of the individual types.  */
6986
6987 static void
6988 type_hash_list (const_tree list, inchash::hash &hstate)
6989 {
6990   const_tree tail;
6991
6992   for (tail = list; tail; tail = TREE_CHAIN (tail))
6993     if (TREE_VALUE (tail) != error_mark_node)
6994       hstate.add_object (TYPE_HASH (TREE_VALUE (tail)));
6995 }
6996
6997 /* These are the Hashtable callback functions.  */
6998
6999 /* Returns true iff the types are equivalent.  */
7000
7001 bool
7002 type_cache_hasher::equal (type_hash *a, type_hash *b)
7003 {
7004   /* First test the things that are the same for all types.  */
7005   if (a->hash != b->hash
7006       || TREE_CODE (a->type) != TREE_CODE (b->type)
7007       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
7008       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
7009                                  TYPE_ATTRIBUTES (b->type))
7010       || (TREE_CODE (a->type) != COMPLEX_TYPE
7011           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
7012     return 0;
7013
7014   /* Be careful about comparing arrays before and after the element type
7015      has been completed; don't compare TYPE_ALIGN unless both types are
7016      complete.  */
7017   if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
7018       && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
7019           || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
7020     return 0;
7021
7022   switch (TREE_CODE (a->type))
7023     {
7024     case VOID_TYPE:
7025     case COMPLEX_TYPE:
7026     case POINTER_TYPE:
7027     case REFERENCE_TYPE:
7028     case NULLPTR_TYPE:
7029       return 1;
7030
7031     case VECTOR_TYPE:
7032       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
7033
7034     case ENUMERAL_TYPE:
7035       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
7036           && !(TYPE_VALUES (a->type)
7037                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
7038                && TYPE_VALUES (b->type)
7039                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
7040                && type_list_equal (TYPE_VALUES (a->type),
7041                                    TYPE_VALUES (b->type))))
7042         return 0;
7043
7044       /* fall through */
7045
7046     case INTEGER_TYPE:
7047     case REAL_TYPE:
7048     case BOOLEAN_TYPE:
7049       if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
7050         return false;
7051       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
7052                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
7053                                       TYPE_MAX_VALUE (b->type)))
7054               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
7055                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
7056                                          TYPE_MIN_VALUE (b->type))));
7057
7058     case FIXED_POINT_TYPE:
7059       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
7060
7061     case OFFSET_TYPE:
7062       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
7063
7064     case METHOD_TYPE:
7065       if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
7066           && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
7067               || (TYPE_ARG_TYPES (a->type)
7068                   && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
7069                   && TYPE_ARG_TYPES (b->type)
7070                   && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
7071                   && type_list_equal (TYPE_ARG_TYPES (a->type),
7072                                       TYPE_ARG_TYPES (b->type)))))
7073         break;
7074       return 0;
7075     case ARRAY_TYPE:
7076       return (TYPE_TYPELESS_STORAGE (a->type)
7077               == TYPE_TYPELESS_STORAGE (b->type)
7078               && TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type));
7079
7080     case RECORD_TYPE:
7081     case UNION_TYPE:
7082     case QUAL_UNION_TYPE:
7083       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
7084               || (TYPE_FIELDS (a->type)
7085                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
7086                   && TYPE_FIELDS (b->type)
7087                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
7088                   && type_list_equal (TYPE_FIELDS (a->type),
7089                                       TYPE_FIELDS (b->type))));
7090
7091     case FUNCTION_TYPE:
7092       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
7093           || (TYPE_ARG_TYPES (a->type)
7094               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
7095               && TYPE_ARG_TYPES (b->type)
7096               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
7097               && type_list_equal (TYPE_ARG_TYPES (a->type),
7098                                   TYPE_ARG_TYPES (b->type))))
7099         break;
7100       return 0;
7101
7102     default:
7103       return 0;
7104     }
7105
7106   if (lang_hooks.types.type_hash_eq != NULL)
7107     return lang_hooks.types.type_hash_eq (a->type, b->type);
7108
7109   return 1;
7110 }
7111
7112 /* Given TYPE, and HASHCODE its hash code, return the canonical
7113    object for an identical type if one already exists.
7114    Otherwise, return TYPE, and record it as the canonical object.
7115
7116    To use this function, first create a type of the sort you want.
7117    Then compute its hash code from the fields of the type that
7118    make it different from other similar types.
7119    Then call this function and use the value.  */
7120
7121 tree
7122 type_hash_canon (unsigned int hashcode, tree type)
7123 {
7124   type_hash in;
7125   type_hash **loc;
7126
7127   /* The hash table only contains main variants, so ensure that's what we're
7128      being passed.  */
7129   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
7130
7131   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
7132      must call that routine before comparing TYPE_ALIGNs.  */
7133   layout_type (type);
7134
7135   in.hash = hashcode;
7136   in.type = type;
7137
7138   loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT);
7139   if (*loc)
7140     {
7141       tree t1 = ((type_hash *) *loc)->type;
7142       gcc_assert (TYPE_MAIN_VARIANT (t1) == t1);
7143       free_node (type);
7144       return t1;
7145     }
7146   else
7147     {
7148       struct type_hash *h;
7149
7150       h = ggc_alloc<type_hash> ();
7151       h->hash = hashcode;
7152       h->type = type;
7153       *loc = h;
7154
7155       return type;
7156     }
7157 }
7158
7159 static void
7160 print_type_hash_statistics (void)
7161 {
7162   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
7163            (long) type_hash_table->size (),
7164            (long) type_hash_table->elements (),
7165            type_hash_table->collisions ());
7166 }
7167
7168 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
7169    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
7170    by adding the hash codes of the individual attributes.  */
7171
7172 static void
7173 attribute_hash_list (const_tree list, inchash::hash &hstate)
7174 {
7175   const_tree tail;
7176
7177   for (tail = list; tail; tail = TREE_CHAIN (tail))
7178     /* ??? Do we want to add in TREE_VALUE too? */
7179     hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (tail)));
7180 }
7181
7182 /* Given two lists of attributes, return true if list l2 is
7183    equivalent to l1.  */
7184
7185 int
7186 attribute_list_equal (const_tree l1, const_tree l2)
7187 {
7188   if (l1 == l2)
7189     return 1;
7190
7191   return attribute_list_contained (l1, l2)
7192          && attribute_list_contained (l2, l1);
7193 }
7194
7195 /* Given two lists of attributes, return true if list L2 is
7196    completely contained within L1.  */
7197 /* ??? This would be faster if attribute names were stored in a canonicalized
7198    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
7199    must be used to show these elements are equivalent (which they are).  */
7200 /* ??? It's not clear that attributes with arguments will always be handled
7201    correctly.  */
7202
7203 int
7204 attribute_list_contained (const_tree l1, const_tree l2)
7205 {
7206   const_tree t1, t2;
7207
7208   /* First check the obvious, maybe the lists are identical.  */
7209   if (l1 == l2)
7210     return 1;
7211
7212   /* Maybe the lists are similar.  */
7213   for (t1 = l1, t2 = l2;
7214        t1 != 0 && t2 != 0
7215         && get_attribute_name (t1) == get_attribute_name (t2)
7216         && TREE_VALUE (t1) == TREE_VALUE (t2);
7217        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
7218     ;
7219
7220   /* Maybe the lists are equal.  */
7221   if (t1 == 0 && t2 == 0)
7222     return 1;
7223
7224   for (; t2 != 0; t2 = TREE_CHAIN (t2))
7225     {
7226       const_tree attr;
7227       /* This CONST_CAST is okay because lookup_attribute does not
7228          modify its argument and the return value is assigned to a
7229          const_tree.  */
7230       for (attr = lookup_ident_attribute (get_attribute_name (t2),
7231                                           CONST_CAST_TREE (l1));
7232            attr != NULL_TREE && !attribute_value_equal (t2, attr);
7233            attr = lookup_ident_attribute (get_attribute_name (t2),
7234                                           TREE_CHAIN (attr)))
7235         ;
7236
7237       if (attr == NULL_TREE)
7238         return 0;
7239     }
7240
7241   return 1;
7242 }
7243
7244 /* Given two lists of types
7245    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
7246    return 1 if the lists contain the same types in the same order.
7247    Also, the TREE_PURPOSEs must match.  */
7248
7249 int
7250 type_list_equal (const_tree l1, const_tree l2)
7251 {
7252   const_tree t1, t2;
7253
7254   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
7255     if (TREE_VALUE (t1) != TREE_VALUE (t2)
7256         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
7257             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
7258                   && (TREE_TYPE (TREE_PURPOSE (t1))
7259                       == TREE_TYPE (TREE_PURPOSE (t2))))))
7260       return 0;
7261
7262   return t1 == t2;
7263 }
7264
7265 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
7266    given by TYPE.  If the argument list accepts variable arguments,
7267    then this function counts only the ordinary arguments.  */
7268
7269 int
7270 type_num_arguments (const_tree type)
7271 {
7272   int i = 0;
7273   tree t;
7274
7275   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
7276     /* If the function does not take a variable number of arguments,
7277        the last element in the list will have type `void'.  */
7278     if (VOID_TYPE_P (TREE_VALUE (t)))
7279       break;
7280     else
7281       ++i;
7282
7283   return i;
7284 }
7285
7286 /* Nonzero if integer constants T1 and T2
7287    represent the same constant value.  */
7288
7289 int
7290 tree_int_cst_equal (const_tree t1, const_tree t2)
7291 {
7292   if (t1 == t2)
7293     return 1;
7294
7295   if (t1 == 0 || t2 == 0)
7296     return 0;
7297
7298   if (TREE_CODE (t1) == INTEGER_CST
7299       && TREE_CODE (t2) == INTEGER_CST
7300       && wi::to_widest (t1) == wi::to_widest (t2))
7301     return 1;
7302
7303   return 0;
7304 }
7305
7306 /* Return true if T is an INTEGER_CST whose numerical value (extended
7307    according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.  */
7308
7309 bool
7310 tree_fits_shwi_p (const_tree t)
7311 {
7312   return (t != NULL_TREE
7313           && TREE_CODE (t) == INTEGER_CST
7314           && wi::fits_shwi_p (wi::to_widest (t)));
7315 }
7316
7317 /* Return true if T is an INTEGER_CST whose numerical value (extended
7318    according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.  */
7319
7320 bool
7321 tree_fits_uhwi_p (const_tree t)
7322 {
7323   return (t != NULL_TREE
7324           && TREE_CODE (t) == INTEGER_CST
7325           && wi::fits_uhwi_p (wi::to_widest (t)));
7326 }
7327
7328 /* T is an INTEGER_CST whose numerical value (extended according to
7329    TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.  Return that
7330    HOST_WIDE_INT.  */
7331
7332 HOST_WIDE_INT
7333 tree_to_shwi (const_tree t)
7334 {
7335   gcc_assert (tree_fits_shwi_p (t));
7336   return TREE_INT_CST_LOW (t);
7337 }
7338
7339 /* T is an INTEGER_CST whose numerical value (extended according to
7340    TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.  Return that
7341    HOST_WIDE_INT.  */
7342
7343 unsigned HOST_WIDE_INT
7344 tree_to_uhwi (const_tree t)
7345 {
7346   gcc_assert (tree_fits_uhwi_p (t));
7347   return TREE_INT_CST_LOW (t);
7348 }
7349
7350 /* Return the most significant (sign) bit of T.  */
7351
7352 int
7353 tree_int_cst_sign_bit (const_tree t)
7354 {
7355   unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
7356
7357   return wi::extract_uhwi (t, bitno, 1);
7358 }
7359
7360 /* Return an indication of the sign of the integer constant T.
7361    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
7362    Note that -1 will never be returned if T's type is unsigned.  */
7363
7364 int
7365 tree_int_cst_sgn (const_tree t)
7366 {
7367   if (wi::eq_p (t, 0))
7368     return 0;
7369   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
7370     return 1;
7371   else if (wi::neg_p (t))
7372     return -1;
7373   else
7374     return 1;
7375 }
7376
7377 /* Return the minimum number of bits needed to represent VALUE in a
7378    signed or unsigned type, UNSIGNEDP says which.  */
7379
7380 unsigned int
7381 tree_int_cst_min_precision (tree value, signop sgn)
7382 {
7383   /* If the value is negative, compute its negative minus 1.  The latter
7384      adjustment is because the absolute value of the largest negative value
7385      is one larger than the largest positive value.  This is equivalent to
7386      a bit-wise negation, so use that operation instead.  */
7387
7388   if (tree_int_cst_sgn (value) < 0)
7389     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
7390
7391   /* Return the number of bits needed, taking into account the fact
7392      that we need one more bit for a signed than unsigned type.
7393      If value is 0 or -1, the minimum precision is 1 no matter
7394      whether unsignedp is true or false.  */
7395
7396   if (integer_zerop (value))
7397     return 1;
7398   else
7399     return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
7400 }
7401
7402 /* Return truthvalue of whether T1 is the same tree structure as T2.
7403    Return 1 if they are the same.
7404    Return 0 if they are understandably different.
7405    Return -1 if either contains tree structure not understood by
7406    this function.  */
7407
7408 int
7409 simple_cst_equal (const_tree t1, const_tree t2)
7410 {
7411   enum tree_code code1, code2;
7412   int cmp;
7413   int i;
7414
7415   if (t1 == t2)
7416     return 1;
7417   if (t1 == 0 || t2 == 0)
7418     return 0;
7419
7420   code1 = TREE_CODE (t1);
7421   code2 = TREE_CODE (t2);
7422
7423   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
7424     {
7425       if (CONVERT_EXPR_CODE_P (code2)
7426           || code2 == NON_LVALUE_EXPR)
7427         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7428       else
7429         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
7430     }
7431
7432   else if (CONVERT_EXPR_CODE_P (code2)
7433            || code2 == NON_LVALUE_EXPR)
7434     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
7435
7436   if (code1 != code2)
7437     return 0;
7438
7439   switch (code1)
7440     {
7441     case INTEGER_CST:
7442       return wi::to_widest (t1) == wi::to_widest (t2);
7443
7444     case REAL_CST:
7445       return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
7446
7447     case FIXED_CST:
7448       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
7449
7450     case STRING_CST:
7451       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
7452               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
7453                          TREE_STRING_LENGTH (t1)));
7454
7455     case CONSTRUCTOR:
7456       {
7457         unsigned HOST_WIDE_INT idx;
7458         vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
7459         vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
7460
7461         if (vec_safe_length (v1) != vec_safe_length (v2))
7462           return false;
7463
7464         for (idx = 0; idx < vec_safe_length (v1); ++idx)
7465           /* ??? Should we handle also fields here? */
7466           if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
7467             return false;
7468         return true;
7469       }
7470
7471     case SAVE_EXPR:
7472       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7473
7474     case CALL_EXPR:
7475       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
7476       if (cmp <= 0)
7477         return cmp;
7478       if (call_expr_nargs (t1) != call_expr_nargs (t2))
7479         return 0;
7480       {
7481         const_tree arg1, arg2;
7482         const_call_expr_arg_iterator iter1, iter2;
7483         for (arg1 = first_const_call_expr_arg (t1, &iter1),
7484                arg2 = first_const_call_expr_arg (t2, &iter2);
7485              arg1 && arg2;
7486              arg1 = next_const_call_expr_arg (&iter1),
7487                arg2 = next_const_call_expr_arg (&iter2))
7488           {
7489             cmp = simple_cst_equal (arg1, arg2);
7490             if (cmp <= 0)
7491               return cmp;
7492           }
7493         return arg1 == arg2;
7494       }
7495
7496     case TARGET_EXPR:
7497       /* Special case: if either target is an unallocated VAR_DECL,
7498          it means that it's going to be unified with whatever the
7499          TARGET_EXPR is really supposed to initialize, so treat it
7500          as being equivalent to anything.  */
7501       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
7502            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
7503            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
7504           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
7505               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
7506               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
7507         cmp = 1;
7508       else
7509         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7510
7511       if (cmp <= 0)
7512         return cmp;
7513
7514       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
7515
7516     case WITH_CLEANUP_EXPR:
7517       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7518       if (cmp <= 0)
7519         return cmp;
7520
7521       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
7522
7523     case COMPONENT_REF:
7524       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
7525         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
7526
7527       return 0;
7528
7529     case VAR_DECL:
7530     case PARM_DECL:
7531     case CONST_DECL:
7532     case FUNCTION_DECL:
7533       return 0;
7534
7535     default:
7536       break;
7537     }
7538
7539   /* This general rule works for most tree codes.  All exceptions should be
7540      handled above.  If this is a language-specific tree code, we can't
7541      trust what might be in the operand, so say we don't know
7542      the situation.  */
7543   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
7544     return -1;
7545
7546   switch (TREE_CODE_CLASS (code1))
7547     {
7548     case tcc_unary:
7549     case tcc_binary:
7550     case tcc_comparison:
7551     case tcc_expression:
7552     case tcc_reference:
7553     case tcc_statement:
7554       cmp = 1;
7555       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
7556         {
7557           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
7558           if (cmp <= 0)
7559             return cmp;
7560         }
7561
7562       return cmp;
7563
7564     default:
7565       return -1;
7566     }
7567 }
7568
7569 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
7570    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
7571    than U, respectively.  */
7572
7573 int
7574 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
7575 {
7576   if (tree_int_cst_sgn (t) < 0)
7577     return -1;
7578   else if (!tree_fits_uhwi_p (t))
7579     return 1;
7580   else if (TREE_INT_CST_LOW (t) == u)
7581     return 0;
7582   else if (TREE_INT_CST_LOW (t) < u)
7583     return -1;
7584   else
7585     return 1;
7586 }
7587
7588 /* Return true if SIZE represents a constant size that is in bounds of
7589    what the middle-end and the backend accepts (covering not more than
7590    half of the address-space).  */
7591
7592 bool
7593 valid_constant_size_p (const_tree size)
7594 {
7595   if (! tree_fits_uhwi_p (size)
7596       || TREE_OVERFLOW (size)
7597       || tree_int_cst_sign_bit (size) != 0)
7598     return false;
7599   return true;
7600 }
7601
7602 /* Return the precision of the type, or for a complex or vector type the
7603    precision of the type of its elements.  */
7604
7605 unsigned int
7606 element_precision (const_tree type)
7607 {
7608   if (!TYPE_P (type))
7609     type = TREE_TYPE (type);
7610   enum tree_code code = TREE_CODE (type);
7611   if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
7612     type = TREE_TYPE (type);
7613
7614   return TYPE_PRECISION (type);
7615 }
7616
7617 /* Return true if CODE represents an associative tree code.  Otherwise
7618    return false.  */
7619 bool
7620 associative_tree_code (enum tree_code code)
7621 {
7622   switch (code)
7623     {
7624     case BIT_IOR_EXPR:
7625     case BIT_AND_EXPR:
7626     case BIT_XOR_EXPR:
7627     case PLUS_EXPR:
7628     case MULT_EXPR:
7629     case MIN_EXPR:
7630     case MAX_EXPR:
7631       return true;
7632
7633     default:
7634       break;
7635     }
7636   return false;
7637 }
7638
7639 /* Return true if CODE represents a commutative tree code.  Otherwise
7640    return false.  */
7641 bool
7642 commutative_tree_code (enum tree_code code)
7643 {
7644   switch (code)
7645     {
7646     case PLUS_EXPR:
7647     case MULT_EXPR:
7648     case MULT_HIGHPART_EXPR:
7649     case MIN_EXPR:
7650     case MAX_EXPR:
7651     case BIT_IOR_EXPR:
7652     case BIT_XOR_EXPR:
7653     case BIT_AND_EXPR:
7654     case NE_EXPR:
7655     case EQ_EXPR:
7656     case UNORDERED_EXPR:
7657     case ORDERED_EXPR:
7658     case UNEQ_EXPR:
7659     case LTGT_EXPR:
7660     case TRUTH_AND_EXPR:
7661     case TRUTH_XOR_EXPR:
7662     case TRUTH_OR_EXPR:
7663     case WIDEN_MULT_EXPR:
7664     case VEC_WIDEN_MULT_HI_EXPR:
7665     case VEC_WIDEN_MULT_LO_EXPR:
7666     case VEC_WIDEN_MULT_EVEN_EXPR:
7667     case VEC_WIDEN_MULT_ODD_EXPR:
7668       return true;
7669
7670     default:
7671       break;
7672     }
7673   return false;
7674 }
7675
7676 /* Return true if CODE represents a ternary tree code for which the
7677    first two operands are commutative.  Otherwise return false.  */
7678 bool
7679 commutative_ternary_tree_code (enum tree_code code)
7680 {
7681   switch (code)
7682     {
7683     case WIDEN_MULT_PLUS_EXPR:
7684     case WIDEN_MULT_MINUS_EXPR:
7685     case DOT_PROD_EXPR:
7686     case FMA_EXPR:
7687       return true;
7688
7689     default:
7690       break;
7691     }
7692   return false;
7693 }
7694
7695 /* Returns true if CODE can overflow.  */
7696
7697 bool
7698 operation_can_overflow (enum tree_code code)
7699 {
7700   switch (code)
7701     {
7702     case PLUS_EXPR:
7703     case MINUS_EXPR:
7704     case MULT_EXPR:
7705     case LSHIFT_EXPR:
7706       /* Can overflow in various ways.  */
7707       return true;
7708     case TRUNC_DIV_EXPR:
7709     case EXACT_DIV_EXPR:
7710     case FLOOR_DIV_EXPR:
7711     case CEIL_DIV_EXPR:
7712       /* For INT_MIN / -1.  */
7713       return true;
7714     case NEGATE_EXPR:
7715     case ABS_EXPR:
7716       /* For -INT_MIN.  */
7717       return true;
7718     default:
7719       /* These operators cannot overflow.  */
7720       return false;
7721     }
7722 }
7723
7724 /* Returns true if CODE operating on operands of type TYPE doesn't overflow, or
7725    ftrapv doesn't generate trapping insns for CODE.  */
7726
7727 bool
7728 operation_no_trapping_overflow (tree type, enum tree_code code)
7729 {
7730   gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type));
7731
7732   /* We don't generate instructions that trap on overflow for complex or vector
7733      types.  */
7734   if (!INTEGRAL_TYPE_P (type))
7735     return true;
7736
7737   if (!TYPE_OVERFLOW_TRAPS (type))
7738     return true;
7739
7740   switch (code)
7741     {
7742     case PLUS_EXPR:
7743     case MINUS_EXPR:
7744     case MULT_EXPR:
7745     case NEGATE_EXPR:
7746     case ABS_EXPR:
7747       /* These operators can overflow, and -ftrapv generates trapping code for
7748          these.  */
7749       return false;
7750     case TRUNC_DIV_EXPR:
7751     case EXACT_DIV_EXPR:
7752     case FLOOR_DIV_EXPR:
7753     case CEIL_DIV_EXPR:
7754     case LSHIFT_EXPR:
7755       /* These operators can overflow, but -ftrapv does not generate trapping
7756          code for these.  */
7757       return true;
7758     default:
7759       /* These operators cannot overflow.  */
7760       return true;
7761     }
7762 }
7763
7764 namespace inchash
7765 {
7766
7767 /* Generate a hash value for an expression.  This can be used iteratively
7768    by passing a previous result as the HSTATE argument.
7769
7770    This function is intended to produce the same hash for expressions which
7771    would compare equal using operand_equal_p.  */
7772 void
7773 add_expr (const_tree t, inchash::hash &hstate, unsigned int flags)
7774 {
7775   int i;
7776   enum tree_code code;
7777   enum tree_code_class tclass;
7778
7779   if (t == NULL_TREE || t == error_mark_node)
7780     {
7781       hstate.merge_hash (0);
7782       return;
7783     }
7784
7785   if (!(flags & OEP_ADDRESS_OF))
7786     STRIP_NOPS (t);
7787
7788   code = TREE_CODE (t);
7789
7790   switch (code)
7791     {
7792     /* Alas, constants aren't shared, so we can't rely on pointer
7793        identity.  */
7794     case VOID_CST:
7795       hstate.merge_hash (0);
7796       return;
7797     case INTEGER_CST:
7798       gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7799       for (i = 0; i < TREE_INT_CST_EXT_NUNITS (t); i++)
7800         hstate.add_wide_int (TREE_INT_CST_ELT (t, i));
7801       return;
7802     case REAL_CST:
7803       {
7804         unsigned int val2;
7805         if (!HONOR_SIGNED_ZEROS (t) && real_zerop (t))
7806           val2 = rvc_zero;
7807         else
7808           val2 = real_hash (TREE_REAL_CST_PTR (t));
7809         hstate.merge_hash (val2);
7810         return;
7811       }
7812     case FIXED_CST:
7813       {
7814         unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
7815         hstate.merge_hash (val2);
7816         return;
7817       }
7818     case STRING_CST:
7819       hstate.add ((const void *) TREE_STRING_POINTER (t),
7820                   TREE_STRING_LENGTH (t));
7821       return;
7822     case COMPLEX_CST:
7823       inchash::add_expr (TREE_REALPART (t), hstate, flags);
7824       inchash::add_expr (TREE_IMAGPART (t), hstate, flags);
7825       return;
7826     case VECTOR_CST:
7827       {
7828         unsigned i;
7829         for (i = 0; i < VECTOR_CST_NELTS (t); ++i)
7830           inchash::add_expr (VECTOR_CST_ELT (t, i), hstate, flags);
7831         return;
7832       }
7833     case SSA_NAME:
7834       /* We can just compare by pointer.  */
7835       hstate.add_wide_int (SSA_NAME_VERSION (t));
7836       return;
7837     case PLACEHOLDER_EXPR:
7838       /* The node itself doesn't matter.  */
7839       return;
7840     case BLOCK:
7841     case OMP_CLAUSE:
7842       /* Ignore.  */
7843       return;
7844     case TREE_LIST:
7845       /* A list of expressions, for a CALL_EXPR or as the elements of a
7846          VECTOR_CST.  */
7847       for (; t; t = TREE_CHAIN (t))
7848         inchash::add_expr (TREE_VALUE (t), hstate, flags);
7849       return;
7850     case CONSTRUCTOR:
7851       {
7852         unsigned HOST_WIDE_INT idx;
7853         tree field, value;
7854         flags &= ~OEP_ADDRESS_OF;
7855         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
7856           {
7857             inchash::add_expr (field, hstate, flags);
7858             inchash::add_expr (value, hstate, flags);
7859           }
7860         return;
7861       }
7862     case STATEMENT_LIST:
7863       {
7864         tree_stmt_iterator i;
7865         for (i = tsi_start (CONST_CAST_TREE (t));
7866              !tsi_end_p (i); tsi_next (&i))
7867           inchash::add_expr (tsi_stmt (i), hstate, flags);
7868         return;
7869       }
7870     case TREE_VEC:
7871       for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
7872         inchash::add_expr (TREE_VEC_ELT (t, i), hstate, flags);
7873       return;
7874     case FUNCTION_DECL:
7875       /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
7876          Otherwise nodes that compare equal according to operand_equal_p might
7877          get different hash codes.  However, don't do this for machine specific
7878          or front end builtins, since the function code is overloaded in those
7879          cases.  */
7880       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
7881           && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t)))
7882         {
7883           t = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
7884           code = TREE_CODE (t);
7885         }
7886       /* FALL THROUGH */
7887     default:
7888       tclass = TREE_CODE_CLASS (code);
7889
7890       if (tclass == tcc_declaration)
7891         {
7892           /* DECL's have a unique ID */
7893           hstate.add_wide_int (DECL_UID (t));
7894         }
7895       else if (tclass == tcc_comparison && !commutative_tree_code (code))
7896         {
7897           /* For comparisons that can be swapped, use the lower
7898              tree code.  */
7899           enum tree_code ccode = swap_tree_comparison (code);
7900           if (code < ccode)
7901             ccode = code;
7902           hstate.add_object (ccode);
7903           inchash::add_expr (TREE_OPERAND (t, ccode != code), hstate, flags);
7904           inchash::add_expr (TREE_OPERAND (t, ccode == code), hstate, flags);
7905         }
7906       else if (CONVERT_EXPR_CODE_P (code))
7907         {
7908           /* NOP_EXPR and CONVERT_EXPR are considered equal by
7909              operand_equal_p.  */
7910           enum tree_code ccode = NOP_EXPR;
7911           hstate.add_object (ccode);
7912
7913           /* Don't hash the type, that can lead to having nodes which
7914              compare equal according to operand_equal_p, but which
7915              have different hash codes.  Make sure to include signedness
7916              in the hash computation.  */
7917           hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
7918           inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
7919         }
7920       /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl.  */
7921       else if (code == MEM_REF
7922                && (flags & OEP_ADDRESS_OF) != 0
7923                && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
7924                && DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
7925                && integer_zerop (TREE_OPERAND (t, 1)))
7926         inchash::add_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0),
7927                            hstate, flags);
7928       /* Don't ICE on FE specific trees, or their arguments etc.
7929          during operand_equal_p hash verification.  */
7930       else if (!IS_EXPR_CODE_CLASS (tclass))
7931         gcc_assert (flags & OEP_HASH_CHECK);
7932       else
7933         {
7934           unsigned int sflags = flags;
7935
7936           hstate.add_object (code);
7937
7938           switch (code)
7939             {
7940             case ADDR_EXPR:
7941               gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
7942               flags |= OEP_ADDRESS_OF;
7943               sflags = flags;
7944               break;
7945
7946             case INDIRECT_REF:
7947             case MEM_REF:
7948             case TARGET_MEM_REF:
7949               flags &= ~OEP_ADDRESS_OF;
7950               sflags = flags;
7951               break;
7952
7953             case ARRAY_REF:
7954             case ARRAY_RANGE_REF:
7955             case COMPONENT_REF:
7956             case BIT_FIELD_REF:
7957               sflags &= ~OEP_ADDRESS_OF;
7958               break;
7959
7960             case COND_EXPR:
7961               flags &= ~OEP_ADDRESS_OF;
7962               break;
7963
7964             case FMA_EXPR:
7965             case WIDEN_MULT_PLUS_EXPR:
7966             case WIDEN_MULT_MINUS_EXPR:
7967               {
7968                 /* The multiplication operands are commutative.  */
7969                 inchash::hash one, two;
7970                 inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
7971                 inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
7972                 hstate.add_commutative (one, two);
7973                 inchash::add_expr (TREE_OPERAND (t, 2), two, flags);
7974                 return;
7975               }
7976
7977             case CALL_EXPR:
7978               if (CALL_EXPR_FN (t) == NULL_TREE)
7979                 hstate.add_int (CALL_EXPR_IFN (t));
7980               break;
7981
7982             case TARGET_EXPR:
7983               /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT.
7984                  Usually different TARGET_EXPRs just should use
7985                  different temporaries in their slots.  */
7986               inchash::add_expr (TARGET_EXPR_SLOT (t), hstate, flags);
7987               return;
7988
7989             default:
7990               break;
7991             }
7992
7993           /* Don't hash the type, that can lead to having nodes which
7994              compare equal according to operand_equal_p, but which
7995              have different hash codes.  */
7996           if (code == NON_LVALUE_EXPR)
7997             {
7998               /* Make sure to include signness in the hash computation.  */
7999               hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t)));
8000               inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags);
8001             }
8002
8003           else if (commutative_tree_code (code))
8004             {
8005               /* It's a commutative expression.  We want to hash it the same
8006                  however it appears.  We do this by first hashing both operands
8007                  and then rehashing based on the order of their independent
8008                  hashes.  */
8009               inchash::hash one, two;
8010               inchash::add_expr (TREE_OPERAND (t, 0), one, flags);
8011               inchash::add_expr (TREE_OPERAND (t, 1), two, flags);
8012               hstate.add_commutative (one, two);
8013             }
8014           else
8015             for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
8016               inchash::add_expr (TREE_OPERAND (t, i), hstate,
8017                                  i == 0 ? flags : sflags);
8018         }
8019       return;
8020     }
8021 }
8022
8023 }
8024
8025 /* Constructors for pointer, array and function types.
8026    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
8027    constructed by language-dependent code, not here.)  */
8028
8029 /* Construct, lay out and return the type of pointers to TO_TYPE with
8030    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
8031    reference all of memory. If such a type has already been
8032    constructed, reuse it.  */
8033
8034 tree
8035 build_pointer_type_for_mode (tree to_type, machine_mode mode,
8036                              bool can_alias_all)
8037 {
8038   tree t;
8039   bool could_alias = can_alias_all;
8040
8041   if (to_type == error_mark_node)
8042     return error_mark_node;
8043
8044   /* If the pointed-to type has the may_alias attribute set, force
8045      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
8046   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
8047     can_alias_all = true;
8048
8049   /* In some cases, languages will have things that aren't a POINTER_TYPE
8050      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
8051      In that case, return that type without regard to the rest of our
8052      operands.
8053
8054      ??? This is a kludge, but consistent with the way this function has
8055      always operated and there doesn't seem to be a good way to avoid this
8056      at the moment.  */
8057   if (TYPE_POINTER_TO (to_type) != 0
8058       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
8059     return TYPE_POINTER_TO (to_type);
8060
8061   /* First, if we already have a type for pointers to TO_TYPE and it's
8062      the proper mode, use it.  */
8063   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
8064     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
8065       return t;
8066
8067   t = make_node (POINTER_TYPE);
8068
8069   TREE_TYPE (t) = to_type;
8070   SET_TYPE_MODE (t, mode);
8071   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
8072   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
8073   TYPE_POINTER_TO (to_type) = t;
8074
8075   /* During LTO we do not set TYPE_CANONICAL of pointers and references.  */
8076   if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
8077     SET_TYPE_STRUCTURAL_EQUALITY (t);
8078   else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
8079     TYPE_CANONICAL (t)
8080       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
8081                                      mode, false);
8082
8083   /* Lay out the type.  This function has many callers that are concerned
8084      with expression-construction, and this simplifies them all.  */
8085   layout_type (t);
8086
8087   return t;
8088 }
8089
8090 /* By default build pointers in ptr_mode.  */
8091
8092 tree
8093 build_pointer_type (tree to_type)
8094 {
8095   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
8096                                               : TYPE_ADDR_SPACE (to_type);
8097   machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
8098   return build_pointer_type_for_mode (to_type, pointer_mode, false);
8099 }
8100
8101 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
8102
8103 tree
8104 build_reference_type_for_mode (tree to_type, machine_mode mode,
8105                                bool can_alias_all)
8106 {
8107   tree t;
8108   bool could_alias = can_alias_all;
8109
8110   if (to_type == error_mark_node)
8111     return error_mark_node;
8112
8113   /* If the pointed-to type has the may_alias attribute set, force
8114      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
8115   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
8116     can_alias_all = true;
8117
8118   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
8119      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
8120      In that case, return that type without regard to the rest of our
8121      operands.
8122
8123      ??? This is a kludge, but consistent with the way this function has
8124      always operated and there doesn't seem to be a good way to avoid this
8125      at the moment.  */
8126   if (TYPE_REFERENCE_TO (to_type) != 0
8127       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
8128     return TYPE_REFERENCE_TO (to_type);
8129
8130   /* First, if we already have a type for pointers to TO_TYPE and it's
8131      the proper mode, use it.  */
8132   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
8133     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
8134       return t;
8135
8136   t = make_node (REFERENCE_TYPE);
8137
8138   TREE_TYPE (t) = to_type;
8139   SET_TYPE_MODE (t, mode);
8140   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
8141   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
8142   TYPE_REFERENCE_TO (to_type) = t;
8143
8144   /* During LTO we do not set TYPE_CANONICAL of pointers and references.  */
8145   if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
8146     SET_TYPE_STRUCTURAL_EQUALITY (t);
8147   else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
8148     TYPE_CANONICAL (t)
8149       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
8150                                        mode, false);
8151
8152   layout_type (t);
8153
8154   return t;
8155 }
8156
8157
8158 /* Build the node for the type of references-to-TO_TYPE by default
8159    in ptr_mode.  */
8160
8161 tree
8162 build_reference_type (tree to_type)
8163 {
8164   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
8165                                               : TYPE_ADDR_SPACE (to_type);
8166   machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
8167   return build_reference_type_for_mode (to_type, pointer_mode, false);
8168 }
8169
8170 #define MAX_INT_CACHED_PREC \
8171   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8172 static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
8173
8174 /* Builds a signed or unsigned integer type of precision PRECISION.
8175    Used for C bitfields whose precision does not match that of
8176    built-in target types.  */
8177 tree
8178 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
8179                                 int unsignedp)
8180 {
8181   tree itype, ret;
8182
8183   if (unsignedp)
8184     unsignedp = MAX_INT_CACHED_PREC + 1;
8185
8186   if (precision <= MAX_INT_CACHED_PREC)
8187     {
8188       itype = nonstandard_integer_type_cache[precision + unsignedp];
8189       if (itype)
8190         return itype;
8191     }
8192
8193   itype = make_node (INTEGER_TYPE);
8194   TYPE_PRECISION (itype) = precision;
8195
8196   if (unsignedp)
8197     fixup_unsigned_type (itype);
8198   else
8199     fixup_signed_type (itype);
8200
8201   ret = itype;
8202   if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype)))
8203     ret = type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype)), itype);
8204   if (precision <= MAX_INT_CACHED_PREC)
8205     nonstandard_integer_type_cache[precision + unsignedp] = ret;
8206
8207   return ret;
8208 }
8209
8210 #define MAX_BOOL_CACHED_PREC \
8211   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
8212 static GTY(()) tree nonstandard_boolean_type_cache[MAX_BOOL_CACHED_PREC + 1];
8213
8214 /* Builds a boolean type of precision PRECISION.
8215    Used for boolean vectors to choose proper vector element size.  */
8216 tree
8217 build_nonstandard_boolean_type (unsigned HOST_WIDE_INT precision)
8218 {
8219   tree type;
8220
8221   if (precision <= MAX_BOOL_CACHED_PREC)
8222     {
8223       type = nonstandard_boolean_type_cache[precision];
8224       if (type)
8225         return type;
8226     }
8227
8228   type = make_node (BOOLEAN_TYPE);
8229   TYPE_PRECISION (type) = precision;
8230   fixup_signed_type (type);
8231
8232   if (precision <= MAX_INT_CACHED_PREC)
8233     nonstandard_boolean_type_cache[precision] = type;
8234
8235   return type;
8236 }
8237
8238 /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE
8239    or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL.  If SHARED
8240    is true, reuse such a type that has already been constructed.  */
8241
8242 static tree
8243 build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
8244 {
8245   tree itype = make_node (INTEGER_TYPE);
8246   inchash::hash hstate;
8247
8248   TREE_TYPE (itype) = type;
8249
8250   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
8251   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
8252
8253   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
8254   SET_TYPE_MODE (itype, TYPE_MODE (type));
8255   TYPE_SIZE (itype) = TYPE_SIZE (type);
8256   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
8257   SET_TYPE_ALIGN (itype, TYPE_ALIGN (type));
8258   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
8259
8260   if (!shared)
8261     return itype;
8262
8263   if ((TYPE_MIN_VALUE (itype)
8264        && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
8265       || (TYPE_MAX_VALUE (itype)
8266           && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
8267     {
8268       /* Since we cannot reliably merge this type, we need to compare it using
8269          structural equality checks.  */
8270       SET_TYPE_STRUCTURAL_EQUALITY (itype);
8271       return itype;
8272     }
8273
8274   inchash::add_expr (TYPE_MIN_VALUE (itype), hstate);
8275   inchash::add_expr (TYPE_MAX_VALUE (itype), hstate);
8276   hstate.merge_hash (TYPE_HASH (type));
8277   itype = type_hash_canon (hstate.end (), itype);
8278
8279   return itype;
8280 }
8281
8282 /* Wrapper around build_range_type_1 with SHARED set to true.  */
8283
8284 tree
8285 build_range_type (tree type, tree lowval, tree highval)
8286 {
8287   return build_range_type_1 (type, lowval, highval, true);
8288 }
8289
8290 /* Wrapper around build_range_type_1 with SHARED set to false.  */
8291
8292 tree
8293 build_nonshared_range_type (tree type, tree lowval, tree highval)
8294 {
8295   return build_range_type_1 (type, lowval, highval, false);
8296 }
8297
8298 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
8299    MAXVAL should be the maximum value in the domain
8300    (one less than the length of the array).
8301
8302    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
8303    We don't enforce this limit, that is up to caller (e.g. language front end).
8304    The limit exists because the result is a signed type and we don't handle
8305    sizes that use more than one HOST_WIDE_INT.  */
8306
8307 tree
8308 build_index_type (tree maxval)
8309 {
8310   return build_range_type (sizetype, size_zero_node, maxval);
8311 }
8312
8313 /* Return true if the debug information for TYPE, a subtype, should be emitted
8314    as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
8315    high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
8316    debug info and doesn't reflect the source code.  */
8317
8318 bool
8319 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
8320 {
8321   tree base_type = TREE_TYPE (type), low, high;
8322
8323   /* Subrange types have a base type which is an integral type.  */
8324   if (!INTEGRAL_TYPE_P (base_type))
8325     return false;
8326
8327   /* Get the real bounds of the subtype.  */
8328   if (lang_hooks.types.get_subrange_bounds)
8329     lang_hooks.types.get_subrange_bounds (type, &low, &high);
8330   else
8331     {
8332       low = TYPE_MIN_VALUE (type);
8333       high = TYPE_MAX_VALUE (type);
8334     }
8335
8336   /* If the type and its base type have the same representation and the same
8337      name, then the type is not a subrange but a copy of the base type.  */
8338   if ((TREE_CODE (base_type) == INTEGER_TYPE
8339        || TREE_CODE (base_type) == BOOLEAN_TYPE)
8340       && int_size_in_bytes (type) == int_size_in_bytes (base_type)
8341       && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
8342       && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))
8343       && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type))
8344     return false;
8345
8346   if (lowval)
8347     *lowval = low;
8348   if (highval)
8349     *highval = high;
8350   return true;
8351 }
8352
8353 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
8354    and number of elements specified by the range of values of INDEX_TYPE.
8355    If TYPELESS_STORAGE is true, TYPE_TYPELESS_STORAGE flag is set on the type.
8356    If SHARED is true, reuse such a type that has already been constructed.  */
8357
8358 static tree
8359 build_array_type_1 (tree elt_type, tree index_type, bool typeless_storage,
8360                     bool shared)
8361 {
8362   tree t;
8363
8364   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
8365     {
8366       error ("arrays of functions are not meaningful");
8367       elt_type = integer_type_node;
8368     }
8369
8370   t = make_node (ARRAY_TYPE);
8371   TREE_TYPE (t) = elt_type;
8372   TYPE_DOMAIN (t) = index_type;
8373   TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
8374   TYPE_TYPELESS_STORAGE (t) = typeless_storage;
8375   layout_type (t);
8376
8377   /* If the element type is incomplete at this point we get marked for
8378      structural equality.  Do not record these types in the canonical
8379      type hashtable.  */
8380   if (TYPE_STRUCTURAL_EQUALITY_P (t))
8381     return t;
8382
8383   if (shared)
8384     {
8385       inchash::hash hstate;
8386       hstate.add_object (TYPE_HASH (elt_type));
8387       if (index_type)
8388         hstate.add_object (TYPE_HASH (index_type));
8389       hstate.add_flag (typeless_storage);
8390       t = type_hash_canon (hstate.end (), t);
8391     }
8392
8393   if (TYPE_CANONICAL (t) == t)
8394     {
8395       if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
8396           || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))
8397           || in_lto_p)
8398         SET_TYPE_STRUCTURAL_EQUALITY (t);
8399       else if (TYPE_CANONICAL (elt_type) != elt_type
8400                || (index_type && TYPE_CANONICAL (index_type) != index_type))
8401         TYPE_CANONICAL (t)
8402           = build_array_type_1 (TYPE_CANONICAL (elt_type),
8403                                 index_type
8404                                 ? TYPE_CANONICAL (index_type) : NULL_TREE,
8405                                 typeless_storage, shared);
8406     }
8407
8408   return t;
8409 }
8410
8411 /* Wrapper around build_array_type_1 with SHARED set to true.  */
8412
8413 tree
8414 build_array_type (tree elt_type, tree index_type, bool typeless_storage)
8415 {
8416   return build_array_type_1 (elt_type, index_type, typeless_storage, true);
8417 }
8418
8419 /* Wrapper around build_array_type_1 with SHARED set to false.  */
8420
8421 tree
8422 build_nonshared_array_type (tree elt_type, tree index_type)
8423 {
8424   return build_array_type_1 (elt_type, index_type, false, false);
8425 }
8426
8427 /* Return a representation of ELT_TYPE[NELTS], using indices of type
8428    sizetype.  */
8429
8430 tree
8431 build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts)
8432 {
8433   return build_array_type (elt_type, build_index_type (size_int (nelts - 1)));
8434 }
8435
8436 /* Recursively examines the array elements of TYPE, until a non-array
8437    element type is found.  */
8438
8439 tree
8440 strip_array_types (tree type)
8441 {
8442   while (TREE_CODE (type) == ARRAY_TYPE)
8443     type = TREE_TYPE (type);
8444
8445   return type;
8446 }
8447
8448 /* Computes the canonical argument types from the argument type list
8449    ARGTYPES.
8450
8451    Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
8452    on entry to this function, or if any of the ARGTYPES are
8453    structural.
8454
8455    Upon return, *ANY_NONCANONICAL_P will be true iff either it was
8456    true on entry to this function, or if any of the ARGTYPES are
8457    non-canonical.
8458
8459    Returns a canonical argument list, which may be ARGTYPES when the
8460    canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
8461    true) or would not differ from ARGTYPES.  */
8462
8463 static tree
8464 maybe_canonicalize_argtypes (tree argtypes,
8465                              bool *any_structural_p,
8466                              bool *any_noncanonical_p)
8467 {
8468   tree arg;
8469   bool any_noncanonical_argtypes_p = false;
8470
8471   for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
8472     {
8473       if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
8474         /* Fail gracefully by stating that the type is structural.  */
8475         *any_structural_p = true;
8476       else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
8477         *any_structural_p = true;
8478       else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
8479                || TREE_PURPOSE (arg))
8480         /* If the argument has a default argument, we consider it
8481            non-canonical even though the type itself is canonical.
8482            That way, different variants of function and method types
8483            with default arguments will all point to the variant with
8484            no defaults as their canonical type.  */
8485         any_noncanonical_argtypes_p = true;
8486     }
8487
8488   if (*any_structural_p)
8489     return argtypes;
8490
8491   if (any_noncanonical_argtypes_p)
8492     {
8493       /* Build the canonical list of argument types.  */
8494       tree canon_argtypes = NULL_TREE;
8495       bool is_void = false;
8496
8497       for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
8498         {
8499           if (arg == void_list_node)
8500             is_void = true;
8501           else
8502             canon_argtypes = tree_cons (NULL_TREE,
8503                                         TYPE_CANONICAL (TREE_VALUE (arg)),
8504                                         canon_argtypes);
8505         }
8506
8507       canon_argtypes = nreverse (canon_argtypes);
8508       if (is_void)
8509         canon_argtypes = chainon (canon_argtypes, void_list_node);
8510
8511       /* There is a non-canonical type.  */
8512       *any_noncanonical_p = true;
8513       return canon_argtypes;
8514     }
8515
8516   /* The canonical argument types are the same as ARGTYPES.  */
8517   return argtypes;
8518 }
8519
8520 /* Construct, lay out and return
8521    the type of functions returning type VALUE_TYPE
8522    given arguments of types ARG_TYPES.
8523    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
8524    are data type nodes for the arguments of the function.
8525    If such a type has already been constructed, reuse it.  */
8526
8527 tree
8528 build_function_type (tree value_type, tree arg_types)
8529 {
8530   tree t;
8531   inchash::hash hstate;
8532   bool any_structural_p, any_noncanonical_p;
8533   tree canon_argtypes;
8534
8535   if (TREE_CODE (value_type) == FUNCTION_TYPE)
8536     {
8537       error ("function return type cannot be function");
8538       value_type = integer_type_node;
8539     }
8540
8541   /* Make a node of the sort we want.  */
8542   t = make_node (FUNCTION_TYPE);
8543   TREE_TYPE (t) = value_type;
8544   TYPE_ARG_TYPES (t) = arg_types;
8545
8546   /* If we already have such a type, use the old one.  */
8547   hstate.add_object (TYPE_HASH (value_type));
8548   type_hash_list (arg_types, hstate);
8549   t = type_hash_canon (hstate.end (), t);
8550
8551   /* Set up the canonical type. */
8552   any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
8553   any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
8554   canon_argtypes = maybe_canonicalize_argtypes (arg_types,
8555                                                 &any_structural_p,
8556                                                 &any_noncanonical_p);
8557   if (any_structural_p)
8558     SET_TYPE_STRUCTURAL_EQUALITY (t);
8559   else if (any_noncanonical_p)
8560     TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
8561                                               canon_argtypes);
8562
8563   if (!COMPLETE_TYPE_P (t))
8564     layout_type (t);
8565   return t;
8566 }
8567
8568 /* Build a function type.  The RETURN_TYPE is the type returned by the
8569    function.  If VAARGS is set, no void_type_node is appended to the
8570    list.  ARGP must be always be terminated be a NULL_TREE.  */
8571
8572 static tree
8573 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
8574 {
8575   tree t, args, last;
8576
8577   t = va_arg (argp, tree);
8578   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
8579     args = tree_cons (NULL_TREE, t, args);
8580
8581   if (vaargs)
8582     {
8583       last = args;
8584       if (args != NULL_TREE)
8585         args = nreverse (args);
8586       gcc_assert (last != void_list_node);
8587     }
8588   else if (args == NULL_TREE)
8589     args = void_list_node;
8590   else
8591     {
8592       last = args;
8593       args = nreverse (args);
8594       TREE_CHAIN (last) = void_list_node;
8595     }
8596   args = build_function_type (return_type, args);
8597
8598   return args;
8599 }
8600
8601 /* Build a function type.  The RETURN_TYPE is the type returned by the
8602    function.  If additional arguments are provided, they are
8603    additional argument types.  The list of argument types must always
8604    be terminated by NULL_TREE.  */
8605
8606 tree
8607 build_function_type_list (tree return_type, ...)
8608 {
8609   tree args;
8610   va_list p;
8611
8612   va_start (p, return_type);
8613   args = build_function_type_list_1 (false, return_type, p);
8614   va_end (p);
8615   return args;
8616 }
8617
8618 /* Build a variable argument function type.  The RETURN_TYPE is the
8619    type returned by the function.  If additional arguments are provided,
8620    they are additional argument types.  The list of argument types must
8621    always be terminated by NULL_TREE.  */
8622
8623 tree
8624 build_varargs_function_type_list (tree return_type, ...)
8625 {
8626   tree args;
8627   va_list p;
8628
8629   va_start (p, return_type);
8630   args = build_function_type_list_1 (true, return_type, p);
8631   va_end (p);
8632
8633   return args;
8634 }
8635
8636 /* Build a function type.  RETURN_TYPE is the type returned by the
8637    function; VAARGS indicates whether the function takes varargs.  The
8638    function takes N named arguments, the types of which are provided in
8639    ARG_TYPES.  */
8640
8641 static tree
8642 build_function_type_array_1 (bool vaargs, tree return_type, int n,
8643                              tree *arg_types)
8644 {
8645   int i;
8646   tree t = vaargs ? NULL_TREE : void_list_node;
8647
8648   for (i = n - 1; i >= 0; i--)
8649     t = tree_cons (NULL_TREE, arg_types[i], t);
8650
8651   return build_function_type (return_type, t);
8652 }
8653
8654 /* Build a function type.  RETURN_TYPE is the type returned by the
8655    function.  The function takes N named arguments, the types of which
8656    are provided in ARG_TYPES.  */
8657
8658 tree
8659 build_function_type_array (tree return_type, int n, tree *arg_types)
8660 {
8661   return build_function_type_array_1 (false, return_type, n, arg_types);
8662 }
8663
8664 /* Build a variable argument function type.  RETURN_TYPE is the type
8665    returned by the function.  The function takes N named arguments, the
8666    types of which are provided in ARG_TYPES.  */
8667
8668 tree
8669 build_varargs_function_type_array (tree return_type, int n, tree *arg_types)
8670 {
8671   return build_function_type_array_1 (true, return_type, n, arg_types);
8672 }
8673
8674 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
8675    and ARGTYPES (a TREE_LIST) are the return type and arguments types
8676    for the method.  An implicit additional parameter (of type
8677    pointer-to-BASETYPE) is added to the ARGTYPES.  */
8678
8679 tree
8680 build_method_type_directly (tree basetype,
8681                             tree rettype,
8682                             tree argtypes)
8683 {
8684   tree t;
8685   tree ptype;
8686   inchash::hash hstate;
8687   bool any_structural_p, any_noncanonical_p;
8688   tree canon_argtypes;
8689
8690   /* Make a node of the sort we want.  */
8691   t = make_node (METHOD_TYPE);
8692
8693   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8694   TREE_TYPE (t) = rettype;
8695   ptype = build_pointer_type (basetype);
8696
8697   /* The actual arglist for this function includes a "hidden" argument
8698      which is "this".  Put it into the list of argument types.  */
8699   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
8700   TYPE_ARG_TYPES (t) = argtypes;
8701
8702   /* If we already have such a type, use the old one.  */
8703   hstate.add_object (TYPE_HASH (basetype));
8704   hstate.add_object (TYPE_HASH (rettype));
8705   type_hash_list (argtypes, hstate);
8706   t = type_hash_canon (hstate.end (), t);
8707
8708   /* Set up the canonical type. */
8709   any_structural_p
8710     = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8711        || TYPE_STRUCTURAL_EQUALITY_P (rettype));
8712   any_noncanonical_p
8713     = (TYPE_CANONICAL (basetype) != basetype
8714        || TYPE_CANONICAL (rettype) != rettype);
8715   canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
8716                                                 &any_structural_p,
8717                                                 &any_noncanonical_p);
8718   if (any_structural_p)
8719     SET_TYPE_STRUCTURAL_EQUALITY (t);
8720   else if (any_noncanonical_p)
8721     TYPE_CANONICAL (t)
8722       = build_method_type_directly (TYPE_CANONICAL (basetype),
8723                                     TYPE_CANONICAL (rettype),
8724                                     canon_argtypes);
8725   if (!COMPLETE_TYPE_P (t))
8726     layout_type (t);
8727
8728   return t;
8729 }
8730
8731 /* Construct, lay out and return the type of methods belonging to class
8732    BASETYPE and whose arguments and values are described by TYPE.
8733    If that type exists already, reuse it.
8734    TYPE must be a FUNCTION_TYPE node.  */
8735
8736 tree
8737 build_method_type (tree basetype, tree type)
8738 {
8739   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
8740
8741   return build_method_type_directly (basetype,
8742                                      TREE_TYPE (type),
8743                                      TYPE_ARG_TYPES (type));
8744 }
8745
8746 /* Construct, lay out and return the type of offsets to a value
8747    of type TYPE, within an object of type BASETYPE.
8748    If a suitable offset type exists already, reuse it.  */
8749
8750 tree
8751 build_offset_type (tree basetype, tree type)
8752 {
8753   tree t;
8754   inchash::hash hstate;
8755
8756   /* Make a node of the sort we want.  */
8757   t = make_node (OFFSET_TYPE);
8758
8759   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
8760   TREE_TYPE (t) = type;
8761
8762   /* If we already have such a type, use the old one.  */
8763   hstate.add_object (TYPE_HASH (basetype));
8764   hstate.add_object (TYPE_HASH (type));
8765   t = type_hash_canon (hstate.end (), t);
8766
8767   if (!COMPLETE_TYPE_P (t))
8768     layout_type (t);
8769
8770   if (TYPE_CANONICAL (t) == t)
8771     {
8772       if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
8773           || TYPE_STRUCTURAL_EQUALITY_P (type))
8774         SET_TYPE_STRUCTURAL_EQUALITY (t);
8775       else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
8776                || TYPE_CANONICAL (type) != type)
8777         TYPE_CANONICAL (t)
8778           = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
8779                                TYPE_CANONICAL (type));
8780     }
8781
8782   return t;
8783 }
8784
8785 /* Create a complex type whose components are COMPONENT_TYPE.
8786
8787    If NAMED is true, the type is given a TYPE_NAME.  We do not always
8788    do so because this creates a DECL node and thus make the DECL_UIDs
8789    dependent on the type canonicalization hashtable, which is GC-ed,
8790    so the DECL_UIDs would not be stable wrt garbage collection.  */
8791
8792 tree
8793 build_complex_type (tree component_type, bool named)
8794 {
8795   tree t;
8796   inchash::hash hstate;
8797
8798   gcc_assert (INTEGRAL_TYPE_P (component_type)
8799               || SCALAR_FLOAT_TYPE_P (component_type)
8800               || FIXED_POINT_TYPE_P (component_type));
8801
8802   /* Make a node of the sort we want.  */
8803   t = make_node (COMPLEX_TYPE);
8804
8805   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
8806
8807   /* If we already have such a type, use the old one.  */
8808   hstate.add_object (TYPE_HASH (component_type));
8809   t = type_hash_canon (hstate.end (), t);
8810
8811   if (!COMPLETE_TYPE_P (t))
8812     layout_type (t);
8813
8814   if (TYPE_CANONICAL (t) == t)
8815     {
8816       if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
8817         SET_TYPE_STRUCTURAL_EQUALITY (t);
8818       else if (TYPE_CANONICAL (component_type) != component_type)
8819         TYPE_CANONICAL (t)
8820           = build_complex_type (TYPE_CANONICAL (component_type), named);
8821     }
8822
8823   /* We need to create a name, since complex is a fundamental type.  */
8824   if (!TYPE_NAME (t) && named)
8825     {
8826       const char *name;
8827       if (component_type == char_type_node)
8828         name = "complex char";
8829       else if (component_type == signed_char_type_node)
8830         name = "complex signed char";
8831       else if (component_type == unsigned_char_type_node)
8832         name = "complex unsigned char";
8833       else if (component_type == short_integer_type_node)
8834         name = "complex short int";
8835       else if (component_type == short_unsigned_type_node)
8836         name = "complex short unsigned int";
8837       else if (component_type == integer_type_node)
8838         name = "complex int";
8839       else if (component_type == unsigned_type_node)
8840         name = "complex unsigned int";
8841       else if (component_type == long_integer_type_node)
8842         name = "complex long int";
8843       else if (component_type == long_unsigned_type_node)
8844         name = "complex long unsigned int";
8845       else if (component_type == long_long_integer_type_node)
8846         name = "complex long long int";
8847       else if (component_type == long_long_unsigned_type_node)
8848         name = "complex long long unsigned int";
8849       else
8850         name = 0;
8851
8852       if (name != 0)
8853         TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
8854                                     get_identifier (name), t);
8855     }
8856
8857   return build_qualified_type (t, TYPE_QUALS (component_type));
8858 }
8859
8860 /* If TYPE is a real or complex floating-point type and the target
8861    does not directly support arithmetic on TYPE then return the wider
8862    type to be used for arithmetic on TYPE.  Otherwise, return
8863    NULL_TREE.  */
8864
8865 tree
8866 excess_precision_type (tree type)
8867 {
8868   /* The target can give two different responses to the question of
8869      which excess precision mode it would like depending on whether we
8870      are in -fexcess-precision=standard or -fexcess-precision=fast.  */
8871
8872   enum excess_precision_type requested_type
8873     = (flag_excess_precision == EXCESS_PRECISION_FAST
8874        ? EXCESS_PRECISION_TYPE_FAST
8875        : EXCESS_PRECISION_TYPE_STANDARD);
8876
8877   enum flt_eval_method target_flt_eval_method
8878     = targetm.c.excess_precision (requested_type);
8879
8880   /* The target should not ask for unpredictable float evaluation (though
8881      it might advertise that implicitly the evaluation is unpredictable,
8882      but we don't care about that here, it will have been reported
8883      elsewhere).  If it does ask for unpredictable evaluation, we have
8884      nothing to do here.  */
8885   gcc_assert (target_flt_eval_method != FLT_EVAL_METHOD_UNPREDICTABLE);
8886
8887   /* Nothing to do.  The target has asked for all types we know about
8888      to be computed with their native precision and range.  */
8889   if (target_flt_eval_method == FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16)
8890     return NULL_TREE;
8891
8892   /* The target will promote this type in a target-dependent way, so excess
8893      precision ought to leave it alone.  */
8894   if (targetm.promoted_type (type) != NULL_TREE)
8895     return NULL_TREE;
8896
8897   machine_mode float16_type_mode = (float16_type_node
8898                                     ? TYPE_MODE (float16_type_node)
8899                                     : VOIDmode);
8900   machine_mode float_type_mode = TYPE_MODE (float_type_node);
8901   machine_mode double_type_mode = TYPE_MODE (double_type_node);
8902
8903   switch (TREE_CODE (type))
8904     {
8905     case REAL_TYPE:
8906       {
8907         machine_mode type_mode = TYPE_MODE (type);
8908         switch (target_flt_eval_method)
8909           {
8910           case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8911             if (type_mode == float16_type_mode)
8912               return float_type_node;
8913             break;
8914           case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8915             if (type_mode == float16_type_mode
8916                 || type_mode == float_type_mode)
8917               return double_type_node;
8918             break;
8919           case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8920             if (type_mode == float16_type_mode
8921                 || type_mode == float_type_mode
8922                 || type_mode == double_type_mode)
8923               return long_double_type_node;
8924             break;
8925           default:
8926             gcc_unreachable ();
8927           }
8928         break;
8929       }
8930     case COMPLEX_TYPE:
8931       {
8932         if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
8933           return NULL_TREE;
8934         machine_mode type_mode = TYPE_MODE (TREE_TYPE (type));
8935         switch (target_flt_eval_method)
8936           {
8937           case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
8938             if (type_mode == float16_type_mode)
8939               return complex_float_type_node;
8940             break;
8941           case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
8942             if (type_mode == float16_type_mode
8943                 || type_mode == float_type_mode)
8944               return complex_double_type_node;
8945             break;
8946           case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
8947             if (type_mode == float16_type_mode
8948                 || type_mode == float_type_mode
8949                 || type_mode == double_type_mode)
8950               return complex_long_double_type_node;
8951             break;
8952           default:
8953             gcc_unreachable ();
8954           }
8955         break;
8956       }
8957     default:
8958       break;
8959     }
8960
8961   return NULL_TREE;
8962 }
8963 \f
8964 /* Return OP, stripped of any conversions to wider types as much as is safe.
8965    Converting the value back to OP's type makes a value equivalent to OP.
8966
8967    If FOR_TYPE is nonzero, we return a value which, if converted to
8968    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
8969
8970    OP must have integer, real or enumeral type.  Pointers are not allowed!
8971
8972    There are some cases where the obvious value we could return
8973    would regenerate to OP if converted to OP's type,
8974    but would not extend like OP to wider types.
8975    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
8976    For example, if OP is (unsigned short)(signed char)-1,
8977    we avoid returning (signed char)-1 if FOR_TYPE is int,
8978    even though extending that to an unsigned short would regenerate OP,
8979    since the result of extending (signed char)-1 to (int)
8980    is different from (int) OP.  */
8981
8982 tree
8983 get_unwidened (tree op, tree for_type)
8984 {
8985   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
8986   tree type = TREE_TYPE (op);
8987   unsigned final_prec
8988     = TYPE_PRECISION (for_type != 0 ? for_type : type);
8989   int uns
8990     = (for_type != 0 && for_type != type
8991        && final_prec > TYPE_PRECISION (type)
8992        && TYPE_UNSIGNED (type));
8993   tree win = op;
8994
8995   while (CONVERT_EXPR_P (op))
8996     {
8997       int bitschange;
8998
8999       /* TYPE_PRECISION on vector types has different meaning
9000          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
9001          so avoid them here.  */
9002       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
9003         break;
9004
9005       bitschange = TYPE_PRECISION (TREE_TYPE (op))
9006                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
9007
9008       /* Truncations are many-one so cannot be removed.
9009          Unless we are later going to truncate down even farther.  */
9010       if (bitschange < 0
9011           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
9012         break;
9013
9014       /* See what's inside this conversion.  If we decide to strip it,
9015          we will set WIN.  */
9016       op = TREE_OPERAND (op, 0);
9017
9018       /* If we have not stripped any zero-extensions (uns is 0),
9019          we can strip any kind of extension.
9020          If we have previously stripped a zero-extension,
9021          only zero-extensions can safely be stripped.
9022          Any extension can be stripped if the bits it would produce
9023          are all going to be discarded later by truncating to FOR_TYPE.  */
9024
9025       if (bitschange > 0)
9026         {
9027           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
9028             win = op;
9029           /* TYPE_UNSIGNED says whether this is a zero-extension.
9030              Let's avoid computing it if it does not affect WIN
9031              and if UNS will not be needed again.  */
9032           if ((uns
9033                || CONVERT_EXPR_P (op))
9034               && TYPE_UNSIGNED (TREE_TYPE (op)))
9035             {
9036               uns = 1;
9037               win = op;
9038             }
9039         }
9040     }
9041
9042   /* If we finally reach a constant see if it fits in sth smaller and
9043      in that case convert it.  */
9044   if (TREE_CODE (win) == INTEGER_CST)
9045     {
9046       tree wtype = TREE_TYPE (win);
9047       unsigned prec = wi::min_precision (win, TYPE_SIGN (wtype));
9048       if (for_type)
9049         prec = MAX (prec, final_prec);
9050       if (prec < TYPE_PRECISION (wtype))
9051         {
9052           tree t = lang_hooks.types.type_for_size (prec, TYPE_UNSIGNED (wtype));
9053           if (t && TYPE_PRECISION (t) < TYPE_PRECISION (wtype))
9054             win = fold_convert (t, win);
9055         }
9056     }
9057
9058   return win;
9059 }
9060 \f
9061 /* Return OP or a simpler expression for a narrower value
9062    which can be sign-extended or zero-extended to give back OP.
9063    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
9064    or 0 if the value should be sign-extended.  */
9065
9066 tree
9067 get_narrower (tree op, int *unsignedp_ptr)
9068 {
9069   int uns = 0;
9070   int first = 1;
9071   tree win = op;
9072   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
9073
9074   while (TREE_CODE (op) == NOP_EXPR)
9075     {
9076       int bitschange
9077         = (TYPE_PRECISION (TREE_TYPE (op))
9078            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
9079
9080       /* Truncations are many-one so cannot be removed.  */
9081       if (bitschange < 0)
9082         break;
9083
9084       /* See what's inside this conversion.  If we decide to strip it,
9085          we will set WIN.  */
9086
9087       if (bitschange > 0)
9088         {
9089           op = TREE_OPERAND (op, 0);
9090           /* An extension: the outermost one can be stripped,
9091              but remember whether it is zero or sign extension.  */
9092           if (first)
9093             uns = TYPE_UNSIGNED (TREE_TYPE (op));
9094           /* Otherwise, if a sign extension has been stripped,
9095              only sign extensions can now be stripped;
9096              if a zero extension has been stripped, only zero-extensions.  */
9097           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
9098             break;
9099           first = 0;
9100         }
9101       else /* bitschange == 0 */
9102         {
9103           /* A change in nominal type can always be stripped, but we must
9104              preserve the unsignedness.  */
9105           if (first)
9106             uns = TYPE_UNSIGNED (TREE_TYPE (op));
9107           first = 0;
9108           op = TREE_OPERAND (op, 0);
9109           /* Keep trying to narrow, but don't assign op to win if it
9110              would turn an integral type into something else.  */
9111           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
9112             continue;
9113         }
9114
9115       win = op;
9116     }
9117
9118   if (TREE_CODE (op) == COMPONENT_REF
9119       /* Since type_for_size always gives an integer type.  */
9120       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
9121       && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
9122       /* Ensure field is laid out already.  */
9123       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
9124       && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
9125     {
9126       unsigned HOST_WIDE_INT innerprec
9127         = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1)));
9128       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
9129                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
9130       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
9131
9132       /* We can get this structure field in a narrower type that fits it,
9133          but the resulting extension to its nominal type (a fullword type)
9134          must satisfy the same conditions as for other extensions.
9135
9136          Do this only for fields that are aligned (not bit-fields),
9137          because when bit-field insns will be used there is no
9138          advantage in doing this.  */
9139
9140       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
9141           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
9142           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
9143           && type != 0)
9144         {
9145           if (first)
9146             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
9147           win = fold_convert (type, op);
9148         }
9149     }
9150
9151   *unsignedp_ptr = uns;
9152   return win;
9153 }
9154 \f
9155 /* Return true if integer constant C has a value that is permissible
9156    for TYPE, an integral type.  */
9157
9158 bool
9159 int_fits_type_p (const_tree c, const_tree type)
9160 {
9161   tree type_low_bound, type_high_bound;
9162   bool ok_for_low_bound, ok_for_high_bound;
9163   signop sgn_c = TYPE_SIGN (TREE_TYPE (c));
9164
9165   /* Non-standard boolean types can have arbitrary precision but various
9166      transformations assume that they can only take values 0 and +/-1.  */
9167   if (TREE_CODE (type) == BOOLEAN_TYPE)
9168     return wi::fits_to_boolean_p (c, type);
9169
9170 retry:
9171   type_low_bound = TYPE_MIN_VALUE (type);
9172   type_high_bound = TYPE_MAX_VALUE (type);
9173
9174   /* If at least one bound of the type is a constant integer, we can check
9175      ourselves and maybe make a decision. If no such decision is possible, but
9176      this type is a subtype, try checking against that.  Otherwise, use
9177      fits_to_tree_p, which checks against the precision.
9178
9179      Compute the status for each possibly constant bound, and return if we see
9180      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
9181      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
9182      for "constant known to fit".  */
9183
9184   /* Check if c >= type_low_bound.  */
9185   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
9186     {
9187       if (tree_int_cst_lt (c, type_low_bound))
9188         return false;
9189       ok_for_low_bound = true;
9190     }
9191   else
9192     ok_for_low_bound = false;
9193
9194   /* Check if c <= type_high_bound.  */
9195   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
9196     {
9197       if (tree_int_cst_lt (type_high_bound, c))
9198         return false;
9199       ok_for_high_bound = true;
9200     }
9201   else
9202     ok_for_high_bound = false;
9203
9204   /* If the constant fits both bounds, the result is known.  */
9205   if (ok_for_low_bound && ok_for_high_bound)
9206     return true;
9207
9208   /* Perform some generic filtering which may allow making a decision
9209      even if the bounds are not constant.  First, negative integers
9210      never fit in unsigned types, */
9211   if (TYPE_UNSIGNED (type) && sgn_c == SIGNED && wi::neg_p (c))
9212     return false;
9213
9214   /* Second, narrower types always fit in wider ones.  */
9215   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
9216     return true;
9217
9218   /* Third, unsigned integers with top bit set never fit signed types.  */
9219   if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED)
9220     {
9221       int prec = GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (c))) - 1;
9222       if (prec < TYPE_PRECISION (TREE_TYPE (c)))
9223         {
9224           /* When a tree_cst is converted to a wide-int, the precision
9225              is taken from the type.  However, if the precision of the
9226              mode underneath the type is smaller than that, it is
9227              possible that the value will not fit.  The test below
9228              fails if any bit is set between the sign bit of the
9229              underlying mode and the top bit of the type.  */
9230           if (wi::ne_p (wi::zext (c, prec - 1), c))
9231             return false;
9232         }
9233       else if (wi::neg_p (c))
9234         return false;
9235     }
9236
9237   /* If we haven't been able to decide at this point, there nothing more we
9238      can check ourselves here.  Look at the base type if we have one and it
9239      has the same precision.  */
9240   if (TREE_CODE (type) == INTEGER_TYPE
9241       && TREE_TYPE (type) != 0
9242       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
9243     {
9244       type = TREE_TYPE (type);
9245       goto retry;
9246     }
9247
9248   /* Or to fits_to_tree_p, if nothing else.  */
9249   return wi::fits_to_tree_p (c, type);
9250 }
9251
9252 /* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
9253    bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
9254    represented (assuming two's-complement arithmetic) within the bit
9255    precision of the type are returned instead.  */
9256
9257 void
9258 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
9259 {
9260   if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
9261       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
9262     wi::to_mpz (TYPE_MIN_VALUE (type), min, TYPE_SIGN (type));
9263   else
9264     {
9265       if (TYPE_UNSIGNED (type))
9266         mpz_set_ui (min, 0);
9267       else
9268         {
9269           wide_int mn = wi::min_value (TYPE_PRECISION (type), SIGNED);
9270           wi::to_mpz (mn, min, SIGNED);
9271         }
9272     }
9273
9274   if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
9275       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
9276     wi::to_mpz (TYPE_MAX_VALUE (type), max, TYPE_SIGN (type));
9277   else
9278     {
9279       wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
9280       wi::to_mpz (mn, max, TYPE_SIGN (type));
9281     }
9282 }
9283
9284 /* Return true if VAR is an automatic variable defined in function FN.  */
9285
9286 bool
9287 auto_var_in_fn_p (const_tree var, const_tree fn)
9288 {
9289   return (DECL_P (var) && DECL_CONTEXT (var) == fn
9290           && ((((VAR_P (var) && ! DECL_EXTERNAL (var))
9291                 || TREE_CODE (var) == PARM_DECL)
9292                && ! TREE_STATIC (var))
9293               || TREE_CODE (var) == LABEL_DECL
9294               || TREE_CODE (var) == RESULT_DECL));
9295 }
9296
9297 /* Subprogram of following function.  Called by walk_tree.
9298
9299    Return *TP if it is an automatic variable or parameter of the
9300    function passed in as DATA.  */
9301
9302 static tree
9303 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
9304 {
9305   tree fn = (tree) data;
9306
9307   if (TYPE_P (*tp))
9308     *walk_subtrees = 0;
9309
9310   else if (DECL_P (*tp)
9311            && auto_var_in_fn_p (*tp, fn))
9312     return *tp;
9313
9314   return NULL_TREE;
9315 }
9316
9317 /* Returns true if T is, contains, or refers to a type with variable
9318    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
9319    arguments, but not the return type.  If FN is nonzero, only return
9320    true if a modifier of the type or position of FN is a variable or
9321    parameter inside FN.
9322
9323    This concept is more general than that of C99 'variably modified types':
9324    in C99, a struct type is never variably modified because a VLA may not
9325    appear as a structure member.  However, in GNU C code like:
9326
9327      struct S { int i[f()]; };
9328
9329    is valid, and other languages may define similar constructs.  */
9330
9331 bool
9332 variably_modified_type_p (tree type, tree fn)
9333 {
9334   tree t;
9335
9336 /* Test if T is either variable (if FN is zero) or an expression containing
9337    a variable in FN.  If TYPE isn't gimplified, return true also if
9338    gimplify_one_sizepos would gimplify the expression into a local
9339    variable.  */
9340 #define RETURN_TRUE_IF_VAR(T)                                           \
9341   do { tree _t = (T);                                                   \
9342     if (_t != NULL_TREE                                                 \
9343         && _t != error_mark_node                                        \
9344         && TREE_CODE (_t) != INTEGER_CST                                \
9345         && TREE_CODE (_t) != PLACEHOLDER_EXPR                           \
9346         && (!fn                                                         \
9347             || (!TYPE_SIZES_GIMPLIFIED (type)                           \
9348                 && !is_gimple_sizepos (_t))                             \
9349             || walk_tree (&_t, find_var_from_fn, fn, NULL)))            \
9350       return true;  } while (0)
9351
9352   if (type == error_mark_node)
9353     return false;
9354
9355   /* If TYPE itself has variable size, it is variably modified.  */
9356   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
9357   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
9358
9359   switch (TREE_CODE (type))
9360     {
9361     case POINTER_TYPE:
9362     case REFERENCE_TYPE:
9363     case VECTOR_TYPE:
9364       if (variably_modified_type_p (TREE_TYPE (type), fn))
9365         return true;
9366       break;
9367
9368     case FUNCTION_TYPE:
9369     case METHOD_TYPE:
9370       /* If TYPE is a function type, it is variably modified if the
9371          return type is variably modified.  */
9372       if (variably_modified_type_p (TREE_TYPE (type), fn))
9373           return true;
9374       break;
9375
9376     case INTEGER_TYPE:
9377     case REAL_TYPE:
9378     case FIXED_POINT_TYPE:
9379     case ENUMERAL_TYPE:
9380     case BOOLEAN_TYPE:
9381       /* Scalar types are variably modified if their end points
9382          aren't constant.  */
9383       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
9384       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
9385       break;
9386
9387     case RECORD_TYPE:
9388     case UNION_TYPE:
9389     case QUAL_UNION_TYPE:
9390       /* We can't see if any of the fields are variably-modified by the
9391          definition we normally use, since that would produce infinite
9392          recursion via pointers.  */
9393       /* This is variably modified if some field's type is.  */
9394       for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
9395         if (TREE_CODE (t) == FIELD_DECL)
9396           {
9397             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
9398             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
9399             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
9400
9401             if (TREE_CODE (type) == QUAL_UNION_TYPE)
9402               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
9403           }
9404       break;
9405
9406     case ARRAY_TYPE:
9407       /* Do not call ourselves to avoid infinite recursion.  This is
9408          variably modified if the element type is.  */
9409       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
9410       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
9411       break;
9412
9413     default:
9414       break;
9415     }
9416
9417   /* The current language may have other cases to check, but in general,
9418      all other types are not variably modified.  */
9419   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
9420
9421 #undef RETURN_TRUE_IF_VAR
9422 }
9423
9424 /* Given a DECL or TYPE, return the scope in which it was declared, or
9425    NULL_TREE if there is no containing scope.  */
9426
9427 tree
9428 get_containing_scope (const_tree t)
9429 {
9430   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
9431 }
9432
9433 /* Return the innermost context enclosing DECL that is
9434    a FUNCTION_DECL, or zero if none.  */
9435
9436 tree
9437 decl_function_context (const_tree decl)
9438 {
9439   tree context;
9440
9441   if (TREE_CODE (decl) == ERROR_MARK)
9442     return 0;
9443
9444   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
9445      where we look up the function at runtime.  Such functions always take
9446      a first argument of type 'pointer to real context'.
9447
9448      C++ should really be fixed to use DECL_CONTEXT for the real context,
9449      and use something else for the "virtual context".  */
9450   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
9451     context
9452       = TYPE_MAIN_VARIANT
9453         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
9454   else
9455     context = DECL_CONTEXT (decl);
9456
9457   while (context && TREE_CODE (context) != FUNCTION_DECL)
9458     {
9459       if (TREE_CODE (context) == BLOCK)
9460         context = BLOCK_SUPERCONTEXT (context);
9461       else
9462         context = get_containing_scope (context);
9463     }
9464
9465   return context;
9466 }
9467
9468 /* Return the innermost context enclosing DECL that is
9469    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
9470    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
9471
9472 tree
9473 decl_type_context (const_tree decl)
9474 {
9475   tree context = DECL_CONTEXT (decl);
9476
9477   while (context)
9478     switch (TREE_CODE (context))
9479       {
9480       case NAMESPACE_DECL:
9481       case TRANSLATION_UNIT_DECL:
9482         return NULL_TREE;
9483
9484       case RECORD_TYPE:
9485       case UNION_TYPE:
9486       case QUAL_UNION_TYPE:
9487         return context;
9488
9489       case TYPE_DECL:
9490       case FUNCTION_DECL:
9491         context = DECL_CONTEXT (context);
9492         break;
9493
9494       case BLOCK:
9495         context = BLOCK_SUPERCONTEXT (context);
9496         break;
9497
9498       default:
9499         gcc_unreachable ();
9500       }
9501
9502   return NULL_TREE;
9503 }
9504
9505 /* CALL is a CALL_EXPR.  Return the declaration for the function
9506    called, or NULL_TREE if the called function cannot be
9507    determined.  */
9508
9509 tree
9510 get_callee_fndecl (const_tree call)
9511 {
9512   tree addr;
9513
9514   if (call == error_mark_node)
9515     return error_mark_node;
9516
9517   /* It's invalid to call this function with anything but a
9518      CALL_EXPR.  */
9519   gcc_assert (TREE_CODE (call) == CALL_EXPR);
9520
9521   /* The first operand to the CALL is the address of the function
9522      called.  */
9523   addr = CALL_EXPR_FN (call);
9524
9525   /* If there is no function, return early.  */
9526   if (addr == NULL_TREE)
9527     return NULL_TREE;
9528
9529   STRIP_NOPS (addr);
9530
9531   /* If this is a readonly function pointer, extract its initial value.  */
9532   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
9533       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
9534       && DECL_INITIAL (addr))
9535     addr = DECL_INITIAL (addr);
9536
9537   /* If the address is just `&f' for some function `f', then we know
9538      that `f' is being called.  */
9539   if (TREE_CODE (addr) == ADDR_EXPR
9540       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
9541     return TREE_OPERAND (addr, 0);
9542
9543   /* We couldn't figure out what was being called.  */
9544   return NULL_TREE;
9545 }
9546
9547 /* If CALL_EXPR CALL calls a normal built-in function or an internal function,
9548    return the associated function code, otherwise return CFN_LAST.  */
9549
9550 combined_fn
9551 get_call_combined_fn (const_tree call)
9552 {
9553   /* It's invalid to call this function with anything but a CALL_EXPR.  */
9554   gcc_assert (TREE_CODE (call) == CALL_EXPR);
9555
9556   if (!CALL_EXPR_FN (call))
9557     return as_combined_fn (CALL_EXPR_IFN (call));
9558
9559   tree fndecl = get_callee_fndecl (call);
9560   if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
9561     return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
9562
9563   return CFN_LAST;
9564 }
9565
9566 #define TREE_MEM_USAGE_SPACES 40
9567
9568 /* Print debugging information about tree nodes generated during the compile,
9569    and any language-specific information.  */
9570
9571 void
9572 dump_tree_statistics (void)
9573 {
9574   if (GATHER_STATISTICS)
9575     {
9576       int i;
9577       int total_nodes, total_bytes;
9578       fprintf (stderr, "\nKind                   Nodes      Bytes\n");
9579       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9580       total_nodes = total_bytes = 0;
9581       for (i = 0; i < (int) all_kinds; i++)
9582         {
9583           fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
9584                    tree_node_counts[i], tree_node_sizes[i]);
9585           total_nodes += tree_node_counts[i];
9586           total_bytes += tree_node_sizes[i];
9587         }
9588       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9589       fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
9590       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9591       fprintf (stderr, "Code                   Nodes\n");
9592       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9593       for (i = 0; i < (int) MAX_TREE_CODES; i++)
9594         fprintf (stderr, "%-32s %7d\n", get_tree_code_name ((enum tree_code) i),
9595                  tree_code_counts[i]);
9596       mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
9597       fprintf (stderr, "\n");
9598       ssanames_print_statistics ();
9599       fprintf (stderr, "\n");
9600       phinodes_print_statistics ();
9601       fprintf (stderr, "\n");
9602     }
9603   else
9604     fprintf (stderr, "(No per-node statistics)\n");
9605
9606   print_type_hash_statistics ();
9607   print_debug_expr_statistics ();
9608   print_value_expr_statistics ();
9609   lang_hooks.print_statistics ();
9610 }
9611 \f
9612 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
9613
9614 /* Generate a crc32 of the low BYTES bytes of VALUE.  */
9615
9616 unsigned
9617 crc32_unsigned_n (unsigned chksum, unsigned value, unsigned bytes)
9618 {
9619   /* This relies on the raw feedback's top 4 bits being zero.  */
9620 #define FEEDBACK(X) ((X) * 0x04c11db7)
9621 #define SYNDROME(X) (FEEDBACK ((X) & 1) ^ FEEDBACK ((X) & 2) \
9622                      ^ FEEDBACK ((X) & 4) ^ FEEDBACK ((X) & 8))
9623   static const unsigned syndromes[16] =
9624     {
9625       SYNDROME(0x0), SYNDROME(0x1), SYNDROME(0x2), SYNDROME(0x3),
9626       SYNDROME(0x4), SYNDROME(0x5), SYNDROME(0x6), SYNDROME(0x7),
9627       SYNDROME(0x8), SYNDROME(0x9), SYNDROME(0xa), SYNDROME(0xb),
9628       SYNDROME(0xc), SYNDROME(0xd), SYNDROME(0xe), SYNDROME(0xf),
9629     };
9630 #undef FEEDBACK
9631 #undef SYNDROME
9632
9633   value <<= (32 - bytes * 8);
9634   for (unsigned ix = bytes * 2; ix--; value <<= 4)
9635     {
9636       unsigned feedback = syndromes[((value ^ chksum) >> 28) & 0xf];
9637
9638       chksum = (chksum << 4) ^ feedback;
9639     }
9640
9641   return chksum;
9642 }
9643
9644 /* Generate a crc32 of a string.  */
9645
9646 unsigned
9647 crc32_string (unsigned chksum, const char *string)
9648 {
9649   do
9650     chksum = crc32_byte (chksum, *string);
9651   while (*string++);
9652   return chksum;
9653 }
9654
9655 /* P is a string that will be used in a symbol.  Mask out any characters
9656    that are not valid in that context.  */
9657
9658 void
9659 clean_symbol_name (char *p)
9660 {
9661   for (; *p; p++)
9662     if (! (ISALNUM (*p)
9663 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
9664             || *p == '$'
9665 #endif
9666 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
9667             || *p == '.'
9668 #endif
9669            ))
9670       *p = '_';
9671 }
9672
9673 /* For anonymous aggregate types, we need some sort of name to
9674    hold on to.  In practice, this should not appear, but it should
9675    not be harmful if it does.  */
9676 bool
9677 anon_aggrname_p(const_tree id_node)
9678 {
9679 #ifndef NO_DOT_IN_LABEL
9680  return (IDENTIFIER_POINTER (id_node)[0] == '.'
9681          && IDENTIFIER_POINTER (id_node)[1] == '_');
9682 #else /* NO_DOT_IN_LABEL */
9683 #ifndef NO_DOLLAR_IN_LABEL
9684   return (IDENTIFIER_POINTER (id_node)[0] == '$' \
9685           && IDENTIFIER_POINTER (id_node)[1] == '_');
9686 #else /* NO_DOLLAR_IN_LABEL */
9687 #define ANON_AGGRNAME_PREFIX "__anon_"
9688   return (!strncmp (IDENTIFIER_POINTER (id_node), ANON_AGGRNAME_PREFIX,
9689                     sizeof (ANON_AGGRNAME_PREFIX) - 1));
9690 #endif  /* NO_DOLLAR_IN_LABEL */
9691 #endif  /* NO_DOT_IN_LABEL */
9692 }
9693
9694 /* Return a format for an anonymous aggregate name.  */
9695 const char *
9696 anon_aggrname_format()
9697 {
9698 #ifndef NO_DOT_IN_LABEL
9699  return "._%d";
9700 #else /* NO_DOT_IN_LABEL */
9701 #ifndef NO_DOLLAR_IN_LABEL
9702   return "$_%d";
9703 #else /* NO_DOLLAR_IN_LABEL */
9704   return "__anon_%d";
9705 #endif  /* NO_DOLLAR_IN_LABEL */
9706 #endif  /* NO_DOT_IN_LABEL */
9707 }
9708
9709 /* Generate a name for a special-purpose function.
9710    The generated name may need to be unique across the whole link.
9711    Changes to this function may also require corresponding changes to
9712    xstrdup_mask_random.
9713    TYPE is some string to identify the purpose of this function to the
9714    linker or collect2; it must start with an uppercase letter,
9715    one of:
9716    I - for constructors
9717    D - for destructors
9718    N - for C++ anonymous namespaces
9719    F - for DWARF unwind frame information.  */
9720
9721 tree
9722 get_file_function_name (const char *type)
9723 {
9724   char *buf;
9725   const char *p;
9726   char *q;
9727
9728   /* If we already have a name we know to be unique, just use that.  */
9729   if (first_global_object_name)
9730     p = q = ASTRDUP (first_global_object_name);
9731   /* If the target is handling the constructors/destructors, they
9732      will be local to this file and the name is only necessary for
9733      debugging purposes.
9734      We also assign sub_I and sub_D sufixes to constructors called from
9735      the global static constructors.  These are always local.  */
9736   else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
9737            || (strncmp (type, "sub_", 4) == 0
9738                && (type[4] == 'I' || type[4] == 'D')))
9739     {
9740       const char *file = main_input_filename;
9741       if (! file)
9742         file = LOCATION_FILE (input_location);
9743       /* Just use the file's basename, because the full pathname
9744          might be quite long.  */
9745       p = q = ASTRDUP (lbasename (file));
9746     }
9747   else
9748     {
9749       /* Otherwise, the name must be unique across the entire link.
9750          We don't have anything that we know to be unique to this translation
9751          unit, so use what we do have and throw in some randomness.  */
9752       unsigned len;
9753       const char *name = weak_global_object_name;
9754       const char *file = main_input_filename;
9755
9756       if (! name)
9757         name = "";
9758       if (! file)
9759         file = LOCATION_FILE (input_location);
9760
9761       len = strlen (file);
9762       q = (char *) alloca (9 + 19 + len + 1);
9763       memcpy (q, file, len + 1);
9764
9765       snprintf (q + len, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
9766                 crc32_string (0, name), get_random_seed (false));
9767
9768       p = q;
9769     }
9770
9771   clean_symbol_name (q);
9772   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
9773                          + strlen (type));
9774
9775   /* Set up the name of the file-level functions we may need.
9776      Use a global object (which is already required to be unique over
9777      the program) rather than the file name (which imposes extra
9778      constraints).  */
9779   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
9780
9781   return get_identifier (buf);
9782 }
9783 \f
9784 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
9785
9786 /* Complain that the tree code of NODE does not match the expected 0
9787    terminated list of trailing codes. The trailing code list can be
9788    empty, for a more vague error message.  FILE, LINE, and FUNCTION
9789    are of the caller.  */
9790
9791 void
9792 tree_check_failed (const_tree node, const char *file,
9793                    int line, const char *function, ...)
9794 {
9795   va_list args;
9796   const char *buffer;
9797   unsigned length = 0;
9798   enum tree_code code;
9799
9800   va_start (args, function);
9801   while ((code = (enum tree_code) va_arg (args, int)))
9802     length += 4 + strlen (get_tree_code_name (code));
9803   va_end (args);
9804   if (length)
9805     {
9806       char *tmp;
9807       va_start (args, function);
9808       length += strlen ("expected ");
9809       buffer = tmp = (char *) alloca (length);
9810       length = 0;
9811       while ((code = (enum tree_code) va_arg (args, int)))
9812         {
9813           const char *prefix = length ? " or " : "expected ";
9814
9815           strcpy (tmp + length, prefix);
9816           length += strlen (prefix);
9817           strcpy (tmp + length, get_tree_code_name (code));
9818           length += strlen (get_tree_code_name (code));
9819         }
9820       va_end (args);
9821     }
9822   else
9823     buffer = "unexpected node";
9824
9825   internal_error ("tree check: %s, have %s in %s, at %s:%d",
9826                   buffer, get_tree_code_name (TREE_CODE (node)),
9827                   function, trim_filename (file), line);
9828 }
9829
9830 /* Complain that the tree code of NODE does match the expected 0
9831    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
9832    the caller.  */
9833
9834 void
9835 tree_not_check_failed (const_tree node, const char *file,
9836                        int line, const char *function, ...)
9837 {
9838   va_list args;
9839   char *buffer;
9840   unsigned length = 0;
9841   enum tree_code code;
9842
9843   va_start (args, function);
9844   while ((code = (enum tree_code) va_arg (args, int)))
9845     length += 4 + strlen (get_tree_code_name (code));
9846   va_end (args);
9847   va_start (args, function);
9848   buffer = (char *) alloca (length);
9849   length = 0;
9850   while ((code = (enum tree_code) va_arg (args, int)))
9851     {
9852       if (length)
9853         {
9854           strcpy (buffer + length, " or ");
9855           length += 4;
9856         }
9857       strcpy (buffer + length, get_tree_code_name (code));
9858       length += strlen (get_tree_code_name (code));
9859     }
9860   va_end (args);
9861
9862   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
9863                   buffer, get_tree_code_name (TREE_CODE (node)),
9864                   function, trim_filename (file), line);
9865 }
9866
9867 /* Similar to tree_check_failed, except that we check for a class of tree
9868    code, given in CL.  */
9869
9870 void
9871 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
9872                          const char *file, int line, const char *function)
9873 {
9874   internal_error
9875     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
9876      TREE_CODE_CLASS_STRING (cl),
9877      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9878      get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9879 }
9880
9881 /* Similar to tree_check_failed, except that instead of specifying a
9882    dozen codes, use the knowledge that they're all sequential.  */
9883
9884 void
9885 tree_range_check_failed (const_tree node, const char *file, int line,
9886                          const char *function, enum tree_code c1,
9887                          enum tree_code c2)
9888 {
9889   char *buffer;
9890   unsigned length = 0;
9891   unsigned int c;
9892
9893   for (c = c1; c <= c2; ++c)
9894     length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
9895
9896   length += strlen ("expected ");
9897   buffer = (char *) alloca (length);
9898   length = 0;
9899
9900   for (c = c1; c <= c2; ++c)
9901     {
9902       const char *prefix = length ? " or " : "expected ";
9903
9904       strcpy (buffer + length, prefix);
9905       length += strlen (prefix);
9906       strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
9907       length += strlen (get_tree_code_name ((enum tree_code) c));
9908     }
9909
9910   internal_error ("tree check: %s, have %s in %s, at %s:%d",
9911                   buffer, get_tree_code_name (TREE_CODE (node)),
9912                   function, trim_filename (file), line);
9913 }
9914
9915
9916 /* Similar to tree_check_failed, except that we check that a tree does
9917    not have the specified code, given in CL.  */
9918
9919 void
9920 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
9921                              const char *file, int line, const char *function)
9922 {
9923   internal_error
9924     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
9925      TREE_CODE_CLASS_STRING (cl),
9926      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
9927      get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
9928 }
9929
9930
9931 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
9932
9933 void
9934 omp_clause_check_failed (const_tree node, const char *file, int line,
9935                          const char *function, enum omp_clause_code code)
9936 {
9937   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
9938                   omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
9939                   function, trim_filename (file), line);
9940 }
9941
9942
9943 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
9944
9945 void
9946 omp_clause_range_check_failed (const_tree node, const char *file, int line,
9947                                const char *function, enum omp_clause_code c1,
9948                                enum omp_clause_code c2)
9949 {
9950   char *buffer;
9951   unsigned length = 0;
9952   unsigned int c;
9953
9954   for (c = c1; c <= c2; ++c)
9955     length += 4 + strlen (omp_clause_code_name[c]);
9956
9957   length += strlen ("expected ");
9958   buffer = (char *) alloca (length);
9959   length = 0;
9960
9961   for (c = c1; c <= c2; ++c)
9962     {
9963       const char *prefix = length ? " or " : "expected ";
9964
9965       strcpy (buffer + length, prefix);
9966       length += strlen (prefix);
9967       strcpy (buffer + length, omp_clause_code_name[c]);
9968       length += strlen (omp_clause_code_name[c]);
9969     }
9970
9971   internal_error ("tree check: %s, have %s in %s, at %s:%d",
9972                   buffer, omp_clause_code_name[TREE_CODE (node)],
9973                   function, trim_filename (file), line);
9974 }
9975
9976
9977 #undef DEFTREESTRUCT
9978 #define DEFTREESTRUCT(VAL, NAME) NAME,
9979
9980 static const char *ts_enum_names[] = {
9981 #include "treestruct.def"
9982 };
9983 #undef DEFTREESTRUCT
9984
9985 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
9986
9987 /* Similar to tree_class_check_failed, except that we check for
9988    whether CODE contains the tree structure identified by EN.  */
9989
9990 void
9991 tree_contains_struct_check_failed (const_tree node,
9992                                    const enum tree_node_structure_enum en,
9993                                    const char *file, int line,
9994                                    const char *function)
9995 {
9996   internal_error
9997     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
9998      TS_ENUM_NAME (en),
9999      get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
10000 }
10001
10002
10003 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
10004    (dynamically sized) vector.  */
10005
10006 void
10007 tree_int_cst_elt_check_failed (int idx, int len, const char *file, int line,
10008                                const char *function)
10009 {
10010   internal_error
10011     ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d",
10012      idx + 1, len, function, trim_filename (file), line);
10013 }
10014
10015 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
10016    (dynamically sized) vector.  */
10017
10018 void
10019 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
10020                            const char *function)
10021 {
10022   internal_error
10023     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
10024      idx + 1, len, function, trim_filename (file), line);
10025 }
10026
10027 /* Similar to above, except that the check is for the bounds of the operand
10028    vector of an expression node EXP.  */
10029
10030 void
10031 tree_operand_check_failed (int idx, const_tree exp, const char *file,
10032                            int line, const char *function)
10033 {
10034   enum tree_code code = TREE_CODE (exp);
10035   internal_error
10036     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
10037      idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
10038      function, trim_filename (file), line);
10039 }
10040
10041 /* Similar to above, except that the check is for the number of
10042    operands of an OMP_CLAUSE node.  */
10043
10044 void
10045 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
10046                                  int line, const char *function)
10047 {
10048   internal_error
10049     ("tree check: accessed operand %d of omp_clause %s with %d operands "
10050      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
10051      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
10052      trim_filename (file), line);
10053 }
10054 #endif /* ENABLE_TREE_CHECKING */
10055 \f
10056 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
10057    and mapped to the machine mode MODE.  Initialize its fields and build
10058    the information necessary for debugging output.  */
10059
10060 static tree
10061 make_vector_type (tree innertype, int nunits, machine_mode mode)
10062 {
10063   tree t;
10064   inchash::hash hstate;
10065   tree mv_innertype = TYPE_MAIN_VARIANT (innertype);
10066
10067   t = make_node (VECTOR_TYPE);
10068   TREE_TYPE (t) = mv_innertype;
10069   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
10070   SET_TYPE_MODE (t, mode);
10071
10072   if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p)
10073     SET_TYPE_STRUCTURAL_EQUALITY (t);
10074   else if ((TYPE_CANONICAL (mv_innertype) != innertype
10075             || mode != VOIDmode)
10076            && !VECTOR_BOOLEAN_TYPE_P (t))
10077     TYPE_CANONICAL (t)
10078       = make_vector_type (TYPE_CANONICAL (mv_innertype), nunits, VOIDmode);
10079
10080   layout_type (t);
10081
10082   hstate.add_wide_int (VECTOR_TYPE);
10083   hstate.add_wide_int (nunits);
10084   hstate.add_wide_int (mode);
10085   hstate.add_object (TYPE_HASH (TREE_TYPE (t)));
10086   t = type_hash_canon (hstate.end (), t);
10087
10088   /* We have built a main variant, based on the main variant of the
10089      inner type. Use it to build the variant we return.  */
10090   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
10091       && TREE_TYPE (t) != innertype)
10092     return build_type_attribute_qual_variant (t,
10093                                               TYPE_ATTRIBUTES (innertype),
10094                                               TYPE_QUALS (innertype));
10095
10096   return t;
10097 }
10098
10099 static tree
10100 make_or_reuse_type (unsigned size, int unsignedp)
10101 {
10102   int i;
10103
10104   if (size == INT_TYPE_SIZE)
10105     return unsignedp ? unsigned_type_node : integer_type_node;
10106   if (size == CHAR_TYPE_SIZE)
10107     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
10108   if (size == SHORT_TYPE_SIZE)
10109     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
10110   if (size == LONG_TYPE_SIZE)
10111     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
10112   if (size == LONG_LONG_TYPE_SIZE)
10113     return (unsignedp ? long_long_unsigned_type_node
10114             : long_long_integer_type_node);
10115
10116   for (i = 0; i < NUM_INT_N_ENTS; i ++)
10117     if (size == int_n_data[i].bitsize
10118         && int_n_enabled_p[i])
10119       return (unsignedp ? int_n_trees[i].unsigned_type
10120               : int_n_trees[i].signed_type);
10121
10122   if (unsignedp)
10123     return make_unsigned_type (size);
10124   else
10125     return make_signed_type (size);
10126 }
10127
10128 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
10129
10130 static tree
10131 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
10132 {
10133   if (satp)
10134     {
10135       if (size == SHORT_FRACT_TYPE_SIZE)
10136         return unsignedp ? sat_unsigned_short_fract_type_node
10137                          : sat_short_fract_type_node;
10138       if (size == FRACT_TYPE_SIZE)
10139         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
10140       if (size == LONG_FRACT_TYPE_SIZE)
10141         return unsignedp ? sat_unsigned_long_fract_type_node
10142                          : sat_long_fract_type_node;
10143       if (size == LONG_LONG_FRACT_TYPE_SIZE)
10144         return unsignedp ? sat_unsigned_long_long_fract_type_node
10145                          : sat_long_long_fract_type_node;
10146     }
10147   else
10148     {
10149       if (size == SHORT_FRACT_TYPE_SIZE)
10150         return unsignedp ? unsigned_short_fract_type_node
10151                          : short_fract_type_node;
10152       if (size == FRACT_TYPE_SIZE)
10153         return unsignedp ? unsigned_fract_type_node : fract_type_node;
10154       if (size == LONG_FRACT_TYPE_SIZE)
10155         return unsignedp ? unsigned_long_fract_type_node
10156                          : long_fract_type_node;
10157       if (size == LONG_LONG_FRACT_TYPE_SIZE)
10158         return unsignedp ? unsigned_long_long_fract_type_node
10159                          : long_long_fract_type_node;
10160     }
10161
10162   return make_fract_type (size, unsignedp, satp);
10163 }
10164
10165 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
10166
10167 static tree
10168 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
10169 {
10170   if (satp)
10171     {
10172       if (size == SHORT_ACCUM_TYPE_SIZE)
10173         return unsignedp ? sat_unsigned_short_accum_type_node
10174                          : sat_short_accum_type_node;
10175       if (size == ACCUM_TYPE_SIZE)
10176         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
10177       if (size == LONG_ACCUM_TYPE_SIZE)
10178         return unsignedp ? sat_unsigned_long_accum_type_node
10179                          : sat_long_accum_type_node;
10180       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
10181         return unsignedp ? sat_unsigned_long_long_accum_type_node
10182                          : sat_long_long_accum_type_node;
10183     }
10184   else
10185     {
10186       if (size == SHORT_ACCUM_TYPE_SIZE)
10187         return unsignedp ? unsigned_short_accum_type_node
10188                          : short_accum_type_node;
10189       if (size == ACCUM_TYPE_SIZE)
10190         return unsignedp ? unsigned_accum_type_node : accum_type_node;
10191       if (size == LONG_ACCUM_TYPE_SIZE)
10192         return unsignedp ? unsigned_long_accum_type_node
10193                          : long_accum_type_node;
10194       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
10195         return unsignedp ? unsigned_long_long_accum_type_node
10196                          : long_long_accum_type_node;
10197     }
10198
10199   return make_accum_type (size, unsignedp, satp);
10200 }
10201
10202
10203 /* Create an atomic variant node for TYPE.  This routine is called
10204    during initialization of data types to create the 5 basic atomic
10205    types. The generic build_variant_type function requires these to
10206    already be set up in order to function properly, so cannot be
10207    called from there.  If ALIGN is non-zero, then ensure alignment is
10208    overridden to this value.  */
10209
10210 static tree
10211 build_atomic_base (tree type, unsigned int align)
10212 {
10213   tree t;
10214
10215   /* Make sure its not already registered.  */
10216   if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC)))
10217     return t;
10218
10219   t = build_variant_type_copy (type);
10220   set_type_quals (t, TYPE_QUAL_ATOMIC);
10221
10222   if (align)
10223     SET_TYPE_ALIGN (t, align);
10224
10225   return t;
10226 }
10227
10228 /* Information about the _FloatN and _FloatNx types.  This must be in
10229    the same order as the corresponding TI_* enum values.  */
10230 const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES] =
10231   {
10232     { 16, false },
10233     { 32, false },
10234     { 64, false },
10235     { 128, false },
10236     { 32, true },
10237     { 64, true },
10238     { 128, true },
10239   };
10240
10241
10242 /* Create nodes for all integer types (and error_mark_node) using the sizes
10243    of C datatypes.  SIGNED_CHAR specifies whether char is signed.  */
10244
10245 void
10246 build_common_tree_nodes (bool signed_char)
10247 {
10248   int i;
10249
10250   error_mark_node = make_node (ERROR_MARK);
10251   TREE_TYPE (error_mark_node) = error_mark_node;
10252
10253   initialize_sizetypes ();
10254
10255   /* Define both `signed char' and `unsigned char'.  */
10256   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
10257   TYPE_STRING_FLAG (signed_char_type_node) = 1;
10258   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
10259   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
10260
10261   /* Define `char', which is like either `signed char' or `unsigned char'
10262      but not the same as either.  */
10263   char_type_node
10264     = (signed_char
10265        ? make_signed_type (CHAR_TYPE_SIZE)
10266        : make_unsigned_type (CHAR_TYPE_SIZE));
10267   TYPE_STRING_FLAG (char_type_node) = 1;
10268
10269   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
10270   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
10271   integer_type_node = make_signed_type (INT_TYPE_SIZE);
10272   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
10273   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
10274   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
10275   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
10276   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
10277
10278   for (i = 0; i < NUM_INT_N_ENTS; i ++)
10279     {
10280       int_n_trees[i].signed_type = make_signed_type (int_n_data[i].bitsize);
10281       int_n_trees[i].unsigned_type = make_unsigned_type (int_n_data[i].bitsize);
10282       TYPE_SIZE (int_n_trees[i].signed_type) = bitsize_int (int_n_data[i].bitsize);
10283       TYPE_SIZE (int_n_trees[i].unsigned_type) = bitsize_int (int_n_data[i].bitsize);
10284
10285       if (int_n_data[i].bitsize > LONG_LONG_TYPE_SIZE
10286           && int_n_enabled_p[i])
10287         {
10288           integer_types[itk_intN_0 + i * 2] = int_n_trees[i].signed_type;
10289           integer_types[itk_unsigned_intN_0 + i * 2] = int_n_trees[i].unsigned_type;
10290         }
10291     }
10292
10293   /* Define a boolean type.  This type only represents boolean values but
10294      may be larger than char depending on the value of BOOL_TYPE_SIZE.  */
10295   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
10296   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
10297   TYPE_PRECISION (boolean_type_node) = 1;
10298   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
10299
10300   /* Define what type to use for size_t.  */
10301   if (strcmp (SIZE_TYPE, "unsigned int") == 0)
10302     size_type_node = unsigned_type_node;
10303   else if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
10304     size_type_node = long_unsigned_type_node;
10305   else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0)
10306     size_type_node = long_long_unsigned_type_node;
10307   else if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
10308     size_type_node = short_unsigned_type_node;
10309   else
10310     {
10311       int i;
10312
10313       size_type_node = NULL_TREE;
10314       for (i = 0; i < NUM_INT_N_ENTS; i++)
10315         if (int_n_enabled_p[i])
10316           {
10317             char name[50];
10318             sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
10319
10320             if (strcmp (name, SIZE_TYPE) == 0)
10321               {
10322                 size_type_node = int_n_trees[i].unsigned_type;
10323               }
10324           }
10325       if (size_type_node == NULL_TREE)
10326         gcc_unreachable ();
10327     }
10328
10329   /* Define what type to use for ptrdiff_t.  */
10330   if (strcmp (PTRDIFF_TYPE, "int") == 0)
10331     ptrdiff_type_node = integer_type_node;
10332   else if (strcmp (PTRDIFF_TYPE, "long int") == 0)
10333     ptrdiff_type_node = long_integer_type_node;
10334   else if (strcmp (PTRDIFF_TYPE, "long long int") == 0)
10335     ptrdiff_type_node = long_long_integer_type_node;
10336   else if (strcmp (PTRDIFF_TYPE, "short int") == 0)
10337     ptrdiff_type_node = short_integer_type_node;
10338   else
10339     {
10340       ptrdiff_type_node = NULL_TREE;
10341       for (int i = 0; i < NUM_INT_N_ENTS; i++)
10342         if (int_n_enabled_p[i])
10343           {
10344             char name[50];
10345             sprintf (name, "__int%d", int_n_data[i].bitsize);
10346             if (strcmp (name, PTRDIFF_TYPE) == 0)
10347               ptrdiff_type_node = int_n_trees[i].signed_type;
10348           }
10349       if (ptrdiff_type_node == NULL_TREE)
10350         gcc_unreachable ();
10351     }
10352
10353   /* Fill in the rest of the sized types.  Reuse existing type nodes
10354      when possible.  */
10355   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
10356   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
10357   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
10358   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
10359   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
10360
10361   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
10362   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
10363   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
10364   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
10365   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
10366
10367   /* Don't call build_qualified type for atomics.  That routine does
10368      special processing for atomics, and until they are initialized
10369      it's better not to make that call.
10370
10371      Check to see if there is a target override for atomic types.  */
10372
10373   atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node,
10374                                         targetm.atomic_align_for_mode (QImode));
10375   atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node,
10376                                         targetm.atomic_align_for_mode (HImode));
10377   atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node,
10378                                         targetm.atomic_align_for_mode (SImode));
10379   atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node,
10380                                         targetm.atomic_align_for_mode (DImode));
10381   atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node,
10382                                         targetm.atomic_align_for_mode (TImode));
10383
10384   access_public_node = get_identifier ("public");
10385   access_protected_node = get_identifier ("protected");
10386   access_private_node = get_identifier ("private");
10387
10388   /* Define these next since types below may used them.  */
10389   integer_zero_node = build_int_cst (integer_type_node, 0);
10390   integer_one_node = build_int_cst (integer_type_node, 1);
10391   integer_three_node = build_int_cst (integer_type_node, 3);
10392   integer_minus_one_node = build_int_cst (integer_type_node, -1);
10393
10394   size_zero_node = size_int (0);
10395   size_one_node = size_int (1);
10396   bitsize_zero_node = bitsize_int (0);
10397   bitsize_one_node = bitsize_int (1);
10398   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
10399
10400   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
10401   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
10402
10403   void_type_node = make_node (VOID_TYPE);
10404   layout_type (void_type_node);
10405
10406   pointer_bounds_type_node = targetm.chkp_bound_type ();
10407
10408   /* We are not going to have real types in C with less than byte alignment,
10409      so we might as well not have any types that claim to have it.  */
10410   SET_TYPE_ALIGN (void_type_node, BITS_PER_UNIT);
10411   TYPE_USER_ALIGN (void_type_node) = 0;
10412
10413   void_node = make_node (VOID_CST);
10414   TREE_TYPE (void_node) = void_type_node;
10415
10416   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
10417   layout_type (TREE_TYPE (null_pointer_node));
10418
10419   ptr_type_node = build_pointer_type (void_type_node);
10420   const_ptr_type_node
10421     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
10422   fileptr_type_node = ptr_type_node;
10423   const_tm_ptr_type_node = const_ptr_type_node;
10424
10425   pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1);
10426
10427   float_type_node = make_node (REAL_TYPE);
10428   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
10429   layout_type (float_type_node);
10430
10431   double_type_node = make_node (REAL_TYPE);
10432   TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
10433   layout_type (double_type_node);
10434
10435   long_double_type_node = make_node (REAL_TYPE);
10436   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
10437   layout_type (long_double_type_node);
10438
10439   for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
10440     {
10441       int n = floatn_nx_types[i].n;
10442       bool extended = floatn_nx_types[i].extended;
10443       machine_mode mode = targetm.floatn_mode (n, extended);
10444       if (mode == VOIDmode)
10445         continue;
10446       int precision = GET_MODE_PRECISION (mode);
10447       /* Work around the rs6000 KFmode having precision 113 not
10448          128.  */
10449       const struct real_format *fmt = REAL_MODE_FORMAT (mode);
10450       gcc_assert (fmt->b == 2 && fmt->emin + fmt->emax == 3);
10451       int min_precision = fmt->p + ceil_log2 (fmt->emax - fmt->emin);
10452       if (!extended)
10453         gcc_assert (min_precision == n);
10454       if (precision < min_precision)
10455         precision = min_precision;
10456       FLOATN_NX_TYPE_NODE (i) = make_node (REAL_TYPE);
10457       TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i)) = precision;
10458       layout_type (FLOATN_NX_TYPE_NODE (i));
10459       SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode);
10460     }
10461
10462   float_ptr_type_node = build_pointer_type (float_type_node);
10463   double_ptr_type_node = build_pointer_type (double_type_node);
10464   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
10465   integer_ptr_type_node = build_pointer_type (integer_type_node);
10466
10467   /* Fixed size integer types.  */
10468   uint16_type_node = make_or_reuse_type (16, 1);
10469   uint32_type_node = make_or_reuse_type (32, 1);
10470   uint64_type_node = make_or_reuse_type (64, 1);
10471
10472   /* Decimal float types. */
10473   dfloat32_type_node = make_node (REAL_TYPE);
10474   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
10475   SET_TYPE_MODE (dfloat32_type_node, SDmode);
10476   layout_type (dfloat32_type_node);
10477   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
10478
10479   dfloat64_type_node = make_node (REAL_TYPE);
10480   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
10481   SET_TYPE_MODE (dfloat64_type_node, DDmode);
10482   layout_type (dfloat64_type_node);
10483   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
10484
10485   dfloat128_type_node = make_node (REAL_TYPE);
10486   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
10487   SET_TYPE_MODE (dfloat128_type_node, TDmode);
10488   layout_type (dfloat128_type_node);
10489   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
10490
10491   complex_integer_type_node = build_complex_type (integer_type_node, true);
10492   complex_float_type_node = build_complex_type (float_type_node, true);
10493   complex_double_type_node = build_complex_type (double_type_node, true);
10494   complex_long_double_type_node = build_complex_type (long_double_type_node,
10495                                                       true);
10496
10497   for (i = 0; i < NUM_FLOATN_NX_TYPES; i++)
10498     {
10499       if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE)
10500         COMPLEX_FLOATN_NX_TYPE_NODE (i)
10501           = build_complex_type (FLOATN_NX_TYPE_NODE (i));
10502     }
10503
10504 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
10505 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
10506   sat_ ## KIND ## _type_node = \
10507     make_sat_signed_ ## KIND ## _type (SIZE); \
10508   sat_unsigned_ ## KIND ## _type_node = \
10509     make_sat_unsigned_ ## KIND ## _type (SIZE); \
10510   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10511   unsigned_ ## KIND ## _type_node = \
10512     make_unsigned_ ## KIND ## _type (SIZE);
10513
10514 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
10515   sat_ ## WIDTH ## KIND ## _type_node = \
10516     make_sat_signed_ ## KIND ## _type (SIZE); \
10517   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
10518     make_sat_unsigned_ ## KIND ## _type (SIZE); \
10519   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
10520   unsigned_ ## WIDTH ## KIND ## _type_node = \
10521     make_unsigned_ ## KIND ## _type (SIZE);
10522
10523 /* Make fixed-point type nodes based on four different widths.  */
10524 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
10525   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
10526   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
10527   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
10528   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
10529
10530 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
10531 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
10532   NAME ## _type_node = \
10533     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
10534   u ## NAME ## _type_node = \
10535     make_or_reuse_unsigned_ ## KIND ## _type \
10536       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
10537   sat_ ## NAME ## _type_node = \
10538     make_or_reuse_sat_signed_ ## KIND ## _type \
10539       (GET_MODE_BITSIZE (MODE ## mode)); \
10540   sat_u ## NAME ## _type_node = \
10541     make_or_reuse_sat_unsigned_ ## KIND ## _type \
10542       (GET_MODE_BITSIZE (U ## MODE ## mode));
10543
10544   /* Fixed-point type and mode nodes.  */
10545   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
10546   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
10547   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
10548   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
10549   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
10550   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
10551   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
10552   MAKE_FIXED_MODE_NODE (accum, ha, HA)
10553   MAKE_FIXED_MODE_NODE (accum, sa, SA)
10554   MAKE_FIXED_MODE_NODE (accum, da, DA)
10555   MAKE_FIXED_MODE_NODE (accum, ta, TA)
10556
10557   {
10558     tree t = targetm.build_builtin_va_list ();
10559
10560     /* Many back-ends define record types without setting TYPE_NAME.
10561        If we copied the record type here, we'd keep the original
10562        record type without a name.  This breaks name mangling.  So,
10563        don't copy record types and let c_common_nodes_and_builtins()
10564        declare the type to be __builtin_va_list.  */
10565     if (TREE_CODE (t) != RECORD_TYPE)
10566       t = build_variant_type_copy (t);
10567
10568     va_list_type_node = t;
10569   }
10570 }
10571
10572 /* Modify DECL for given flags.
10573    TM_PURE attribute is set only on types, so the function will modify
10574    DECL's type when ECF_TM_PURE is used.  */
10575
10576 void
10577 set_call_expr_flags (tree decl, int flags)
10578 {
10579   if (flags & ECF_NOTHROW)
10580     TREE_NOTHROW (decl) = 1;
10581   if (flags & ECF_CONST)
10582     TREE_READONLY (decl) = 1;
10583   if (flags & ECF_PURE)
10584     DECL_PURE_P (decl) = 1;
10585   if (flags & ECF_LOOPING_CONST_OR_PURE)
10586     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
10587   if (flags & ECF_NOVOPS)
10588     DECL_IS_NOVOPS (decl) = 1;
10589   if (flags & ECF_NORETURN)
10590     TREE_THIS_VOLATILE (decl) = 1;
10591   if (flags & ECF_MALLOC)
10592     DECL_IS_MALLOC (decl) = 1;
10593   if (flags & ECF_RETURNS_TWICE)
10594     DECL_IS_RETURNS_TWICE (decl) = 1;
10595   if (flags & ECF_LEAF)
10596     DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"),
10597                                         NULL, DECL_ATTRIBUTES (decl));
10598   if (flags & ECF_RET1)
10599     DECL_ATTRIBUTES (decl)
10600       = tree_cons (get_identifier ("fn spec"),
10601                    build_tree_list (NULL_TREE, build_string (1, "1")),
10602                    DECL_ATTRIBUTES (decl));
10603   if ((flags & ECF_TM_PURE) && flag_tm)
10604     apply_tm_attr (decl, get_identifier ("transaction_pure"));
10605   /* Looping const or pure is implied by noreturn.
10606      There is currently no way to declare looping const or looping pure alone.  */
10607   gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE)
10608               || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE))));
10609 }
10610
10611
10612 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
10613
10614 static void
10615 local_define_builtin (const char *name, tree type, enum built_in_function code,
10616                       const char *library_name, int ecf_flags)
10617 {
10618   tree decl;
10619
10620   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
10621                                library_name, NULL_TREE);
10622   set_call_expr_flags (decl, ecf_flags);
10623
10624   set_builtin_decl (code, decl, true);
10625 }
10626
10627 /* Call this function after instantiating all builtins that the language
10628    front end cares about.  This will build the rest of the builtins
10629    and internal functions that are relied upon by the tree optimizers and
10630    the middle-end.  */
10631
10632 void
10633 build_common_builtin_nodes (void)
10634 {
10635   tree tmp, ftype;
10636   int ecf_flags;
10637
10638   if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE)
10639       || !builtin_decl_explicit_p (BUILT_IN_ABORT))
10640     {
10641       ftype = build_function_type (void_type_node, void_list_node);
10642       if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE))
10643         local_define_builtin ("__builtin_unreachable", ftype,
10644                               BUILT_IN_UNREACHABLE,
10645                               "__builtin_unreachable",
10646                               ECF_NOTHROW | ECF_LEAF | ECF_NORETURN
10647                               | ECF_CONST);
10648       if (!builtin_decl_explicit_p (BUILT_IN_ABORT))
10649         local_define_builtin ("__builtin_abort", ftype, BUILT_IN_ABORT,
10650                               "abort",
10651                               ECF_LEAF | ECF_NORETURN | ECF_CONST);
10652     }
10653
10654   if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)
10655       || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10656     {
10657       ftype = build_function_type_list (ptr_type_node,
10658                                         ptr_type_node, const_ptr_type_node,
10659                                         size_type_node, NULL_TREE);
10660
10661       if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
10662         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
10663                               "memcpy", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10664       if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
10665         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
10666                               "memmove", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10667     }
10668
10669   if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP))
10670     {
10671       ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10672                                         const_ptr_type_node, size_type_node,
10673                                         NULL_TREE);
10674       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
10675                             "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10676     }
10677
10678   if (!builtin_decl_explicit_p (BUILT_IN_MEMSET))
10679     {
10680       ftype = build_function_type_list (ptr_type_node,
10681                                         ptr_type_node, integer_type_node,
10682                                         size_type_node, NULL_TREE);
10683       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
10684                             "memset", ECF_NOTHROW | ECF_LEAF | ECF_RET1);
10685     }
10686
10687   /* If we're checking the stack, `alloca' can throw.  */
10688   const int alloca_flags
10689     = ECF_MALLOC | ECF_LEAF | (flag_stack_check ? 0 : ECF_NOTHROW);
10690
10691   if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA))
10692     {
10693       ftype = build_function_type_list (ptr_type_node,
10694                                         size_type_node, NULL_TREE);
10695       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
10696                             "alloca", alloca_flags);
10697     }
10698
10699   ftype = build_function_type_list (ptr_type_node, size_type_node,
10700                                     size_type_node, NULL_TREE);
10701   local_define_builtin ("__builtin_alloca_with_align", ftype,
10702                         BUILT_IN_ALLOCA_WITH_ALIGN,
10703                         "__builtin_alloca_with_align",
10704                         alloca_flags);
10705
10706   ftype = build_function_type_list (void_type_node,
10707                                     ptr_type_node, ptr_type_node,
10708                                     ptr_type_node, NULL_TREE);
10709   local_define_builtin ("__builtin_init_trampoline", ftype,
10710                         BUILT_IN_INIT_TRAMPOLINE,
10711                         "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF);
10712   local_define_builtin ("__builtin_init_heap_trampoline", ftype,
10713                         BUILT_IN_INIT_HEAP_TRAMPOLINE,
10714                         "__builtin_init_heap_trampoline",
10715                         ECF_NOTHROW | ECF_LEAF);
10716   local_define_builtin ("__builtin_init_descriptor", ftype,
10717                         BUILT_IN_INIT_DESCRIPTOR,
10718                         "__builtin_init_descriptor", ECF_NOTHROW | ECF_LEAF);
10719
10720   ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
10721   local_define_builtin ("__builtin_adjust_trampoline", ftype,
10722                         BUILT_IN_ADJUST_TRAMPOLINE,
10723                         "__builtin_adjust_trampoline",
10724                         ECF_CONST | ECF_NOTHROW);
10725   local_define_builtin ("__builtin_adjust_descriptor", ftype,
10726                         BUILT_IN_ADJUST_DESCRIPTOR,
10727                         "__builtin_adjust_descriptor",
10728                         ECF_CONST | ECF_NOTHROW);
10729
10730   ftype = build_function_type_list (void_type_node,
10731                                     ptr_type_node, ptr_type_node, NULL_TREE);
10732   local_define_builtin ("__builtin_nonlocal_goto", ftype,
10733                         BUILT_IN_NONLOCAL_GOTO,
10734                         "__builtin_nonlocal_goto",
10735                         ECF_NORETURN | ECF_NOTHROW);
10736
10737   ftype = build_function_type_list (void_type_node,
10738                                     ptr_type_node, ptr_type_node, NULL_TREE);
10739   local_define_builtin ("__builtin_setjmp_setup", ftype,
10740                         BUILT_IN_SETJMP_SETUP,
10741                         "__builtin_setjmp_setup", ECF_NOTHROW);
10742
10743   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10744   local_define_builtin ("__builtin_setjmp_receiver", ftype,
10745                         BUILT_IN_SETJMP_RECEIVER,
10746                         "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF);
10747
10748   ftype = build_function_type_list (ptr_type_node, NULL_TREE);
10749   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
10750                         "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
10751
10752   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10753   local_define_builtin ("__builtin_stack_restore", ftype,
10754                         BUILT_IN_STACK_RESTORE,
10755                         "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF);
10756
10757   ftype = build_function_type_list (integer_type_node, const_ptr_type_node,
10758                                     const_ptr_type_node, size_type_node,
10759                                     NULL_TREE);
10760   local_define_builtin ("__builtin_memcmp_eq", ftype, BUILT_IN_MEMCMP_EQ,
10761                         "__builtin_memcmp_eq",
10762                         ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10763
10764   /* If there's a possibility that we might use the ARM EABI, build the
10765     alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
10766   if (targetm.arm_eabi_unwinder)
10767     {
10768       ftype = build_function_type_list (void_type_node, NULL_TREE);
10769       local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
10770                             BUILT_IN_CXA_END_CLEANUP,
10771                             "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
10772     }
10773
10774   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
10775   local_define_builtin ("__builtin_unwind_resume", ftype,
10776                         BUILT_IN_UNWIND_RESUME,
10777                         ((targetm_common.except_unwind_info (&global_options)
10778                           == UI_SJLJ)
10779                          ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
10780                         ECF_NORETURN);
10781
10782   if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE)
10783     {
10784       ftype = build_function_type_list (ptr_type_node, integer_type_node,
10785                                         NULL_TREE);
10786       local_define_builtin ("__builtin_return_address", ftype,
10787                             BUILT_IN_RETURN_ADDRESS,
10788                             "__builtin_return_address",
10789                             ECF_NOTHROW);
10790     }
10791
10792   if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)
10793       || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10794     {
10795       ftype = build_function_type_list (void_type_node, ptr_type_node,
10796                                         ptr_type_node, NULL_TREE);
10797       if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER))
10798         local_define_builtin ("__cyg_profile_func_enter", ftype,
10799                               BUILT_IN_PROFILE_FUNC_ENTER,
10800                               "__cyg_profile_func_enter", 0);
10801       if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT))
10802         local_define_builtin ("__cyg_profile_func_exit", ftype,
10803                               BUILT_IN_PROFILE_FUNC_EXIT,
10804                               "__cyg_profile_func_exit", 0);
10805     }
10806
10807   /* The exception object and filter values from the runtime.  The argument
10808      must be zero before exception lowering, i.e. from the front end.  After
10809      exception lowering, it will be the region number for the exception
10810      landing pad.  These functions are PURE instead of CONST to prevent
10811      them from being hoisted past the exception edge that will initialize
10812      its value in the landing pad.  */
10813   ftype = build_function_type_list (ptr_type_node,
10814                                     integer_type_node, NULL_TREE);
10815   ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF;
10816   /* Only use TM_PURE if we have TM language support.  */
10817   if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1))
10818     ecf_flags |= ECF_TM_PURE;
10819   local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
10820                         "__builtin_eh_pointer", ecf_flags);
10821
10822   tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
10823   ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE);
10824   local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
10825                         "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
10826
10827   ftype = build_function_type_list (void_type_node,
10828                                     integer_type_node, integer_type_node,
10829                                     NULL_TREE);
10830   local_define_builtin ("__builtin_eh_copy_values", ftype,
10831                         BUILT_IN_EH_COPY_VALUES,
10832                         "__builtin_eh_copy_values", ECF_NOTHROW);
10833
10834   /* Complex multiplication and division.  These are handled as builtins
10835      rather than optabs because emit_library_call_value doesn't support
10836      complex.  Further, we can do slightly better with folding these
10837      beasties if the real and complex parts of the arguments are separate.  */
10838   {
10839     int mode;
10840
10841     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
10842       {
10843         char mode_name_buf[4], *q;
10844         const char *p;
10845         enum built_in_function mcode, dcode;
10846         tree type, inner_type;
10847         const char *prefix = "__";
10848
10849         if (targetm.libfunc_gnu_prefix)
10850           prefix = "__gnu_";
10851
10852         type = lang_hooks.types.type_for_mode ((machine_mode) mode, 0);
10853         if (type == NULL)
10854           continue;
10855         inner_type = TREE_TYPE (type);
10856
10857         ftype = build_function_type_list (type, inner_type, inner_type,
10858                                           inner_type, inner_type, NULL_TREE);
10859
10860         mcode = ((enum built_in_function)
10861                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10862         dcode = ((enum built_in_function)
10863                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
10864
10865         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
10866           *q = TOLOWER (*p);
10867         *q = '\0';
10868
10869         built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3",
10870                                         NULL);
10871         local_define_builtin (built_in_names[mcode], ftype, mcode,
10872                               built_in_names[mcode],
10873                               ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10874
10875         built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3",
10876                                         NULL);
10877         local_define_builtin (built_in_names[dcode], ftype, dcode,
10878                               built_in_names[dcode],
10879                               ECF_CONST | ECF_NOTHROW | ECF_LEAF);
10880       }
10881   }
10882
10883   init_internal_fns ();
10884 }
10885
10886 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
10887    better way.
10888
10889    If we requested a pointer to a vector, build up the pointers that
10890    we stripped off while looking for the inner type.  Similarly for
10891    return values from functions.
10892
10893    The argument TYPE is the top of the chain, and BOTTOM is the
10894    new type which we will point to.  */
10895
10896 tree
10897 reconstruct_complex_type (tree type, tree bottom)
10898 {
10899   tree inner, outer;
10900
10901   if (TREE_CODE (type) == POINTER_TYPE)
10902     {
10903       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10904       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
10905                                            TYPE_REF_CAN_ALIAS_ALL (type));
10906     }
10907   else if (TREE_CODE (type) == REFERENCE_TYPE)
10908     {
10909       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10910       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
10911                                              TYPE_REF_CAN_ALIAS_ALL (type));
10912     }
10913   else if (TREE_CODE (type) == ARRAY_TYPE)
10914     {
10915       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10916       outer = build_array_type (inner, TYPE_DOMAIN (type));
10917     }
10918   else if (TREE_CODE (type) == FUNCTION_TYPE)
10919     {
10920       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10921       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
10922     }
10923   else if (TREE_CODE (type) == METHOD_TYPE)
10924     {
10925       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10926       /* The build_method_type_directly() routine prepends 'this' to argument list,
10927          so we must compensate by getting rid of it.  */
10928       outer
10929         = build_method_type_directly
10930             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
10931              inner,
10932              TREE_CHAIN (TYPE_ARG_TYPES (type)));
10933     }
10934   else if (TREE_CODE (type) == OFFSET_TYPE)
10935     {
10936       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
10937       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
10938     }
10939   else
10940     return bottom;
10941
10942   return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
10943                                             TYPE_QUALS (type));
10944 }
10945
10946 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
10947    the inner type.  */
10948 tree
10949 build_vector_type_for_mode (tree innertype, machine_mode mode)
10950 {
10951   int nunits;
10952
10953   switch (GET_MODE_CLASS (mode))
10954     {
10955     case MODE_VECTOR_INT:
10956     case MODE_VECTOR_FLOAT:
10957     case MODE_VECTOR_FRACT:
10958     case MODE_VECTOR_UFRACT:
10959     case MODE_VECTOR_ACCUM:
10960     case MODE_VECTOR_UACCUM:
10961       nunits = GET_MODE_NUNITS (mode);
10962       break;
10963
10964     case MODE_INT:
10965       /* Check that there are no leftover bits.  */
10966       gcc_assert (GET_MODE_BITSIZE (mode)
10967                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
10968
10969       nunits = GET_MODE_BITSIZE (mode)
10970                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
10971       break;
10972
10973     default:
10974       gcc_unreachable ();
10975     }
10976
10977   return make_vector_type (innertype, nunits, mode);
10978 }
10979
10980 /* Similarly, but takes the inner type and number of units, which must be
10981    a power of two.  */
10982
10983 tree
10984 build_vector_type (tree innertype, int nunits)
10985 {
10986   return make_vector_type (innertype, nunits, VOIDmode);
10987 }
10988
10989 /* Build truth vector with specified length and number of units.  */
10990
10991 tree
10992 build_truth_vector_type (unsigned nunits, unsigned vector_size)
10993 {
10994   machine_mode mask_mode = targetm.vectorize.get_mask_mode (nunits,
10995                                                             vector_size);
10996
10997   gcc_assert (mask_mode != VOIDmode);
10998
10999   unsigned HOST_WIDE_INT vsize;
11000   if (mask_mode == BLKmode)
11001     vsize = vector_size * BITS_PER_UNIT;
11002   else
11003     vsize = GET_MODE_BITSIZE (mask_mode);
11004
11005   unsigned HOST_WIDE_INT esize = vsize / nunits;
11006   gcc_assert (esize * nunits == vsize);
11007
11008   tree bool_type = build_nonstandard_boolean_type (esize);
11009
11010   return make_vector_type (bool_type, nunits, mask_mode);
11011 }
11012
11013 /* Returns a vector type corresponding to a comparison of VECTYPE.  */
11014
11015 tree
11016 build_same_sized_truth_vector_type (tree vectype)
11017 {
11018   if (VECTOR_BOOLEAN_TYPE_P (vectype))
11019     return vectype;
11020
11021   unsigned HOST_WIDE_INT size = GET_MODE_SIZE (TYPE_MODE (vectype));
11022
11023   if (!size)
11024     size = tree_to_uhwi (TYPE_SIZE_UNIT (vectype));
11025
11026   return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype), size);
11027 }
11028
11029 /* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set.  */
11030
11031 tree
11032 build_opaque_vector_type (tree innertype, int nunits)
11033 {
11034   tree t = make_vector_type (innertype, nunits, VOIDmode);
11035   tree cand;
11036   /* We always build the non-opaque variant before the opaque one,
11037      so if it already exists, it is TYPE_NEXT_VARIANT of this one.  */
11038   cand = TYPE_NEXT_VARIANT (t);
11039   if (cand
11040       && TYPE_VECTOR_OPAQUE (cand)
11041       && check_qualified_type (cand, t, TYPE_QUALS (t)))
11042     return cand;
11043   /* Othewise build a variant type and make sure to queue it after
11044      the non-opaque type.  */
11045   cand = build_distinct_type_copy (t);
11046   TYPE_VECTOR_OPAQUE (cand) = true;
11047   TYPE_CANONICAL (cand) = TYPE_CANONICAL (t);
11048   TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t);
11049   TYPE_NEXT_VARIANT (t) = cand;
11050   TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t);
11051   return cand;
11052 }
11053
11054
11055 /* Given an initializer INIT, return TRUE if INIT is zero or some
11056    aggregate of zeros.  Otherwise return FALSE.  */
11057 bool
11058 initializer_zerop (const_tree init)
11059 {
11060   tree elt;
11061
11062   STRIP_NOPS (init);
11063
11064   switch (TREE_CODE (init))
11065     {
11066     case INTEGER_CST:
11067       return integer_zerop (init);
11068
11069     case REAL_CST:
11070       /* ??? Note that this is not correct for C4X float formats.  There,
11071          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
11072          negative exponent.  */
11073       return real_zerop (init)
11074         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
11075
11076     case FIXED_CST:
11077       return fixed_zerop (init);
11078
11079     case COMPLEX_CST:
11080       return integer_zerop (init)
11081         || (real_zerop (init)
11082             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
11083             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
11084
11085     case VECTOR_CST:
11086       {
11087         unsigned i;
11088         for (i = 0; i < VECTOR_CST_NELTS (init); ++i)
11089           if (!initializer_zerop (VECTOR_CST_ELT (init, i)))
11090             return false;
11091         return true;
11092       }
11093
11094     case CONSTRUCTOR:
11095       {
11096         unsigned HOST_WIDE_INT idx;
11097
11098         if (TREE_CLOBBER_P (init))
11099           return false;
11100         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
11101           if (!initializer_zerop (elt))
11102             return false;
11103         return true;
11104       }
11105
11106     case STRING_CST:
11107       {
11108         int i;
11109
11110         /* We need to loop through all elements to handle cases like
11111            "\0" and "\0foobar".  */
11112         for (i = 0; i < TREE_STRING_LENGTH (init); ++i)
11113           if (TREE_STRING_POINTER (init)[i] != '\0')
11114             return false;
11115
11116         return true;
11117       }
11118
11119     default:
11120       return false;
11121     }
11122 }
11123
11124 /* Check if vector VEC consists of all the equal elements and
11125    that the number of elements corresponds to the type of VEC.
11126    The function returns first element of the vector
11127    or NULL_TREE if the vector is not uniform.  */
11128 tree
11129 uniform_vector_p (const_tree vec)
11130 {
11131   tree first, t;
11132   unsigned i;
11133
11134   if (vec == NULL_TREE)
11135     return NULL_TREE;
11136
11137   gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
11138
11139   if (TREE_CODE (vec) == VECTOR_CST)
11140     {
11141       first = VECTOR_CST_ELT (vec, 0);
11142       for (i = 1; i < VECTOR_CST_NELTS (vec); ++i)
11143         if (!operand_equal_p (first, VECTOR_CST_ELT (vec, i), 0))
11144           return NULL_TREE;
11145
11146       return first;
11147     }
11148
11149   else if (TREE_CODE (vec) == CONSTRUCTOR)
11150     {
11151       first = error_mark_node;
11152
11153       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t)
11154         {
11155           if (i == 0)
11156             {
11157               first = t;
11158               continue;
11159             }
11160           if (!operand_equal_p (first, t, 0))
11161             return NULL_TREE;
11162         }
11163       if (i != TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)))
11164         return NULL_TREE;
11165
11166       return first;
11167     }
11168
11169   return NULL_TREE;
11170 }
11171
11172 /* Build an empty statement at location LOC.  */
11173
11174 tree
11175 build_empty_stmt (location_t loc)
11176 {
11177   tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
11178   SET_EXPR_LOCATION (t, loc);
11179   return t;
11180 }
11181
11182
11183 /* Build an OpenMP clause with code CODE.  LOC is the location of the
11184    clause.  */
11185
11186 tree
11187 build_omp_clause (location_t loc, enum omp_clause_code code)
11188 {
11189   tree t;
11190   int size, length;
11191
11192   length = omp_clause_num_ops[code];
11193   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
11194
11195   record_node_allocation_statistics (OMP_CLAUSE, size);
11196
11197   t = (tree) ggc_internal_alloc (size);
11198   memset (t, 0, size);
11199   TREE_SET_CODE (t, OMP_CLAUSE);
11200   OMP_CLAUSE_SET_CODE (t, code);
11201   OMP_CLAUSE_LOCATION (t) = loc;
11202
11203   return t;
11204 }
11205
11206 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
11207    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
11208    Except for the CODE and operand count field, other storage for the
11209    object is initialized to zeros.  */
11210
11211 tree
11212 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
11213 {
11214   tree t;
11215   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
11216
11217   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
11218   gcc_assert (len >= 1);
11219
11220   record_node_allocation_statistics (code, length);
11221
11222   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
11223
11224   TREE_SET_CODE (t, code);
11225
11226   /* Can't use TREE_OPERAND to store the length because if checking is
11227      enabled, it will try to check the length before we store it.  :-P  */
11228   t->exp.operands[0] = build_int_cst (sizetype, len);
11229
11230   return t;
11231 }
11232
11233 /* Helper function for build_call_* functions; build a CALL_EXPR with
11234    indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of
11235    the argument slots.  */
11236
11237 static tree
11238 build_call_1 (tree return_type, tree fn, int nargs)
11239 {
11240   tree t;
11241
11242   t = build_vl_exp (CALL_EXPR, nargs + 3);
11243   TREE_TYPE (t) = return_type;
11244   CALL_EXPR_FN (t) = fn;
11245   CALL_EXPR_STATIC_CHAIN (t) = NULL;
11246
11247   return t;
11248 }
11249
11250 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11251    FN and a null static chain slot.  NARGS is the number of call arguments
11252    which are specified as "..." arguments.  */
11253
11254 tree
11255 build_call_nary (tree return_type, tree fn, int nargs, ...)
11256 {
11257   tree ret;
11258   va_list args;
11259   va_start (args, nargs);
11260   ret = build_call_valist (return_type, fn, nargs, args);
11261   va_end (args);
11262   return ret;
11263 }
11264
11265 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11266    FN and a null static chain slot.  NARGS is the number of call arguments
11267    which are specified as a va_list ARGS.  */
11268
11269 tree
11270 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
11271 {
11272   tree t;
11273   int i;
11274
11275   t = build_call_1 (return_type, fn, nargs);
11276   for (i = 0; i < nargs; i++)
11277     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
11278   process_call_operands (t);
11279   return t;
11280 }
11281
11282 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
11283    FN and a null static chain slot.  NARGS is the number of call arguments
11284    which are specified as a tree array ARGS.  */
11285
11286 tree
11287 build_call_array_loc (location_t loc, tree return_type, tree fn,
11288                       int nargs, const tree *args)
11289 {
11290   tree t;
11291   int i;
11292
11293   t = build_call_1 (return_type, fn, nargs);
11294   for (i = 0; i < nargs; i++)
11295     CALL_EXPR_ARG (t, i) = args[i];
11296   process_call_operands (t);
11297   SET_EXPR_LOCATION (t, loc);
11298   return t;
11299 }
11300
11301 /* Like build_call_array, but takes a vec.  */
11302
11303 tree
11304 build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args)
11305 {
11306   tree ret, t;
11307   unsigned int ix;
11308
11309   ret = build_call_1 (return_type, fn, vec_safe_length (args));
11310   FOR_EACH_VEC_SAFE_ELT (args, ix, t)
11311     CALL_EXPR_ARG (ret, ix) = t;
11312   process_call_operands (ret);
11313   return ret;
11314 }
11315
11316 /* Conveniently construct a function call expression.  FNDECL names the
11317    function to be called and N arguments are passed in the array
11318    ARGARRAY.  */
11319
11320 tree
11321 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
11322 {
11323   tree fntype = TREE_TYPE (fndecl);
11324   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11325
11326   return fold_build_call_array_loc (loc, TREE_TYPE (fntype), fn, n, argarray);
11327 }
11328
11329 /* Conveniently construct a function call expression.  FNDECL names the
11330    function to be called and the arguments are passed in the vector
11331    VEC.  */
11332
11333 tree
11334 build_call_expr_loc_vec (location_t loc, tree fndecl, vec<tree, va_gc> *vec)
11335 {
11336   return build_call_expr_loc_array (loc, fndecl, vec_safe_length (vec),
11337                                     vec_safe_address (vec));
11338 }
11339
11340
11341 /* Conveniently construct a function call expression.  FNDECL names the
11342    function to be called, N is the number of arguments, and the "..."
11343    parameters are the argument expressions.  */
11344
11345 tree
11346 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
11347 {
11348   va_list ap;
11349   tree *argarray = XALLOCAVEC (tree, n);
11350   int i;
11351
11352   va_start (ap, n);
11353   for (i = 0; i < n; i++)
11354     argarray[i] = va_arg (ap, tree);
11355   va_end (ap);
11356   return build_call_expr_loc_array (loc, fndecl, n, argarray);
11357 }
11358
11359 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
11360    varargs macros aren't supported by all bootstrap compilers.  */
11361
11362 tree
11363 build_call_expr (tree fndecl, int n, ...)
11364 {
11365   va_list ap;
11366   tree *argarray = XALLOCAVEC (tree, n);
11367   int i;
11368
11369   va_start (ap, n);
11370   for (i = 0; i < n; i++)
11371     argarray[i] = va_arg (ap, tree);
11372   va_end (ap);
11373   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
11374 }
11375
11376 /* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return
11377    type TYPE.  This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL.
11378    It will get gimplified later into an ordinary internal function.  */
11379
11380 tree
11381 build_call_expr_internal_loc_array (location_t loc, internal_fn ifn,
11382                                     tree type, int n, const tree *args)
11383 {
11384   tree t = build_call_1 (type, NULL_TREE, n);
11385   for (int i = 0; i < n; ++i)
11386     CALL_EXPR_ARG (t, i) = args[i];
11387   SET_EXPR_LOCATION (t, loc);
11388   CALL_EXPR_IFN (t) = ifn;
11389   return t;
11390 }
11391
11392 /* Build internal call expression.  This is just like CALL_EXPR, except
11393    its CALL_EXPR_FN is NULL.  It will get gimplified later into ordinary
11394    internal function.  */
11395
11396 tree
11397 build_call_expr_internal_loc (location_t loc, enum internal_fn ifn,
11398                               tree type, int n, ...)
11399 {
11400   va_list ap;
11401   tree *argarray = XALLOCAVEC (tree, n);
11402   int i;
11403
11404   va_start (ap, n);
11405   for (i = 0; i < n; i++)
11406     argarray[i] = va_arg (ap, tree);
11407   va_end (ap);
11408   return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
11409 }
11410
11411 /* Return a function call to FN, if the target is guaranteed to support it,
11412    or null otherwise.
11413
11414    N is the number of arguments, passed in the "...", and TYPE is the
11415    type of the return value.  */
11416
11417 tree
11418 maybe_build_call_expr_loc (location_t loc, combined_fn fn, tree type,
11419                            int n, ...)
11420 {
11421   va_list ap;
11422   tree *argarray = XALLOCAVEC (tree, n);
11423   int i;
11424
11425   va_start (ap, n);
11426   for (i = 0; i < n; i++)
11427     argarray[i] = va_arg (ap, tree);
11428   va_end (ap);
11429   if (internal_fn_p (fn))
11430     {
11431       internal_fn ifn = as_internal_fn (fn);
11432       if (direct_internal_fn_p (ifn))
11433         {
11434           tree_pair types = direct_internal_fn_types (ifn, type, argarray);
11435           if (!direct_internal_fn_supported_p (ifn, types,
11436                                                OPTIMIZE_FOR_BOTH))
11437             return NULL_TREE;
11438         }
11439       return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray);
11440     }
11441   else
11442     {
11443       tree fndecl = builtin_decl_implicit (as_builtin_fn (fn));
11444       if (!fndecl)
11445         return NULL_TREE;
11446       return build_call_expr_loc_array (loc, fndecl, n, argarray);
11447     }
11448 }
11449
11450 /* Create a new constant string literal and return a char* pointer to it.
11451    The STRING_CST value is the LEN characters at STR.  */
11452 tree
11453 build_string_literal (int len, const char *str)
11454 {
11455   tree t, elem, index, type;
11456
11457   t = build_string (len, str);
11458   elem = build_type_variant (char_type_node, 1, 0);
11459   index = build_index_type (size_int (len - 1));
11460   type = build_array_type (elem, index);
11461   TREE_TYPE (t) = type;
11462   TREE_CONSTANT (t) = 1;
11463   TREE_READONLY (t) = 1;
11464   TREE_STATIC (t) = 1;
11465
11466   type = build_pointer_type (elem);
11467   t = build1 (ADDR_EXPR, type,
11468               build4 (ARRAY_REF, elem,
11469                       t, integer_zero_node, NULL_TREE, NULL_TREE));
11470   return t;
11471 }
11472
11473
11474
11475 /* Return true if T (assumed to be a DECL) must be assigned a memory
11476    location.  */
11477
11478 bool
11479 needs_to_live_in_memory (const_tree t)
11480 {
11481   return (TREE_ADDRESSABLE (t)
11482           || is_global_var (t)
11483           || (TREE_CODE (t) == RESULT_DECL
11484               && !DECL_BY_REFERENCE (t)
11485               && aggregate_value_p (t, current_function_decl)));
11486 }
11487
11488 /* Return value of a constant X and sign-extend it.  */
11489
11490 HOST_WIDE_INT
11491 int_cst_value (const_tree x)
11492 {
11493   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
11494   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
11495
11496   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
11497   gcc_assert (cst_and_fits_in_hwi (x));
11498
11499   if (bits < HOST_BITS_PER_WIDE_INT)
11500     {
11501       bool negative = ((val >> (bits - 1)) & 1) != 0;
11502       if (negative)
11503         val |= HOST_WIDE_INT_M1U << (bits - 1) << 1;
11504       else
11505         val &= ~(HOST_WIDE_INT_M1U << (bits - 1) << 1);
11506     }
11507
11508   return val;
11509 }
11510
11511 /* If TYPE is an integral or pointer type, return an integer type with
11512    the same precision which is unsigned iff UNSIGNEDP is true, or itself
11513    if TYPE is already an integer type of signedness UNSIGNEDP.  */
11514
11515 tree
11516 signed_or_unsigned_type_for (int unsignedp, tree type)
11517 {
11518   if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp)
11519     return type;
11520
11521   if (TREE_CODE (type) == VECTOR_TYPE)
11522     {
11523       tree inner = TREE_TYPE (type);
11524       tree inner2 = signed_or_unsigned_type_for (unsignedp, inner);
11525       if (!inner2)
11526         return NULL_TREE;
11527       if (inner == inner2)
11528         return type;
11529       return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type));
11530     }
11531
11532   if (!INTEGRAL_TYPE_P (type)
11533       && !POINTER_TYPE_P (type)
11534       && TREE_CODE (type) != OFFSET_TYPE)
11535     return NULL_TREE;
11536
11537   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
11538 }
11539
11540 /* If TYPE is an integral or pointer type, return an integer type with
11541    the same precision which is unsigned, or itself if TYPE is already an
11542    unsigned integer type.  */
11543
11544 tree
11545 unsigned_type_for (tree type)
11546 {
11547   return signed_or_unsigned_type_for (1, type);
11548 }
11549
11550 /* If TYPE is an integral or pointer type, return an integer type with
11551    the same precision which is signed, or itself if TYPE is already a
11552    signed integer type.  */
11553
11554 tree
11555 signed_type_for (tree type)
11556 {
11557   return signed_or_unsigned_type_for (0, type);
11558 }
11559
11560 /* If TYPE is a vector type, return a signed integer vector type with the
11561    same width and number of subparts. Otherwise return boolean_type_node.  */
11562
11563 tree
11564 truth_type_for (tree type)
11565 {
11566   if (TREE_CODE (type) == VECTOR_TYPE)
11567     {
11568       if (VECTOR_BOOLEAN_TYPE_P (type))
11569         return type;
11570       return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type),
11571                                       GET_MODE_SIZE (TYPE_MODE (type)));
11572     }
11573   else
11574     return boolean_type_node;
11575 }
11576
11577 /* Returns the largest value obtainable by casting something in INNER type to
11578    OUTER type.  */
11579
11580 tree
11581 upper_bound_in_type (tree outer, tree inner)
11582 {
11583   unsigned int det = 0;
11584   unsigned oprec = TYPE_PRECISION (outer);
11585   unsigned iprec = TYPE_PRECISION (inner);
11586   unsigned prec;
11587
11588   /* Compute a unique number for every combination.  */
11589   det |= (oprec > iprec) ? 4 : 0;
11590   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
11591   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
11592
11593   /* Determine the exponent to use.  */
11594   switch (det)
11595     {
11596     case 0:
11597     case 1:
11598       /* oprec <= iprec, outer: signed, inner: don't care.  */
11599       prec = oprec - 1;
11600       break;
11601     case 2:
11602     case 3:
11603       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
11604       prec = oprec;
11605       break;
11606     case 4:
11607       /* oprec > iprec, outer: signed, inner: signed.  */
11608       prec = iprec - 1;
11609       break;
11610     case 5:
11611       /* oprec > iprec, outer: signed, inner: unsigned.  */
11612       prec = iprec;
11613       break;
11614     case 6:
11615       /* oprec > iprec, outer: unsigned, inner: signed.  */
11616       prec = oprec;
11617       break;
11618     case 7:
11619       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
11620       prec = iprec;
11621       break;
11622     default:
11623       gcc_unreachable ();
11624     }
11625
11626   return wide_int_to_tree (outer,
11627                            wi::mask (prec, false, TYPE_PRECISION (outer)));
11628 }
11629
11630 /* Returns the smallest value obtainable by casting something in INNER type to
11631    OUTER type.  */
11632
11633 tree
11634 lower_bound_in_type (tree outer, tree inner)
11635 {
11636   unsigned oprec = TYPE_PRECISION (outer);
11637   unsigned iprec = TYPE_PRECISION (inner);
11638
11639   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
11640      and obtain 0.  */
11641   if (TYPE_UNSIGNED (outer)
11642       /* If we are widening something of an unsigned type, OUTER type
11643          contains all values of INNER type.  In particular, both INNER
11644          and OUTER types have zero in common.  */
11645       || (oprec > iprec && TYPE_UNSIGNED (inner)))
11646     return build_int_cst (outer, 0);
11647   else
11648     {
11649       /* If we are widening a signed type to another signed type, we
11650          want to obtain -2^^(iprec-1).  If we are keeping the
11651          precision or narrowing to a signed type, we want to obtain
11652          -2^(oprec-1).  */
11653       unsigned prec = oprec > iprec ? iprec : oprec;
11654       return wide_int_to_tree (outer,
11655                                wi::mask (prec - 1, true,
11656                                          TYPE_PRECISION (outer)));
11657     }
11658 }
11659
11660 /* Return nonzero if two operands that are suitable for PHI nodes are
11661    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
11662    SSA_NAME or invariant.  Note that this is strictly an optimization.
11663    That is, callers of this function can directly call operand_equal_p
11664    and get the same result, only slower.  */
11665
11666 int
11667 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
11668 {
11669   if (arg0 == arg1)
11670     return 1;
11671   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
11672     return 0;
11673   return operand_equal_p (arg0, arg1, 0);
11674 }
11675
11676 /* Returns number of zeros at the end of binary representation of X.  */
11677
11678 tree
11679 num_ending_zeros (const_tree x)
11680 {
11681   return build_int_cst (TREE_TYPE (x), wi::ctz (x));
11682 }
11683
11684
11685 #define WALK_SUBTREE(NODE)                              \
11686   do                                                    \
11687     {                                                   \
11688       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
11689       if (result)                                       \
11690         return result;                                  \
11691     }                                                   \
11692   while (0)
11693
11694 /* This is a subroutine of walk_tree that walks field of TYPE that are to
11695    be walked whenever a type is seen in the tree.  Rest of operands and return
11696    value are as for walk_tree.  */
11697
11698 static tree
11699 walk_type_fields (tree type, walk_tree_fn func, void *data,
11700                   hash_set<tree> *pset, walk_tree_lh lh)
11701 {
11702   tree result = NULL_TREE;
11703
11704   switch (TREE_CODE (type))
11705     {
11706     case POINTER_TYPE:
11707     case REFERENCE_TYPE:
11708     case VECTOR_TYPE:
11709       /* We have to worry about mutually recursive pointers.  These can't
11710          be written in C.  They can in Ada.  It's pathological, but
11711          there's an ACATS test (c38102a) that checks it.  Deal with this
11712          by checking if we're pointing to another pointer, that one
11713          points to another pointer, that one does too, and we have no htab.
11714          If so, get a hash table.  We check three levels deep to avoid
11715          the cost of the hash table if we don't need one.  */
11716       if (POINTER_TYPE_P (TREE_TYPE (type))
11717           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
11718           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
11719           && !pset)
11720         {
11721           result = walk_tree_without_duplicates (&TREE_TYPE (type),
11722                                                  func, data);
11723           if (result)
11724             return result;
11725
11726           break;
11727         }
11728
11729       /* fall through */
11730
11731     case COMPLEX_TYPE:
11732       WALK_SUBTREE (TREE_TYPE (type));
11733       break;
11734
11735     case METHOD_TYPE:
11736       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
11737
11738       /* Fall through.  */
11739
11740     case FUNCTION_TYPE:
11741       WALK_SUBTREE (TREE_TYPE (type));
11742       {
11743         tree arg;
11744
11745         /* We never want to walk into default arguments.  */
11746         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
11747           WALK_SUBTREE (TREE_VALUE (arg));
11748       }
11749       break;
11750
11751     case ARRAY_TYPE:
11752       /* Don't follow this nodes's type if a pointer for fear that
11753          we'll have infinite recursion.  If we have a PSET, then we
11754          need not fear.  */
11755       if (pset
11756           || (!POINTER_TYPE_P (TREE_TYPE (type))
11757               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
11758         WALK_SUBTREE (TREE_TYPE (type));
11759       WALK_SUBTREE (TYPE_DOMAIN (type));
11760       break;
11761
11762     case OFFSET_TYPE:
11763       WALK_SUBTREE (TREE_TYPE (type));
11764       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
11765       break;
11766
11767     default:
11768       break;
11769     }
11770
11771   return NULL_TREE;
11772 }
11773
11774 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
11775    called with the DATA and the address of each sub-tree.  If FUNC returns a
11776    non-NULL value, the traversal is stopped, and the value returned by FUNC
11777    is returned.  If PSET is non-NULL it is used to record the nodes visited,
11778    and to avoid visiting a node more than once.  */
11779
11780 tree
11781 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
11782              hash_set<tree> *pset, walk_tree_lh lh)
11783 {
11784   enum tree_code code;
11785   int walk_subtrees;
11786   tree result;
11787
11788 #define WALK_SUBTREE_TAIL(NODE)                         \
11789   do                                                    \
11790     {                                                   \
11791        tp = & (NODE);                                   \
11792        goto tail_recurse;                               \
11793     }                                                   \
11794   while (0)
11795
11796  tail_recurse:
11797   /* Skip empty subtrees.  */
11798   if (!*tp)
11799     return NULL_TREE;
11800
11801   /* Don't walk the same tree twice, if the user has requested
11802      that we avoid doing so.  */
11803   if (pset && pset->add (*tp))
11804     return NULL_TREE;
11805
11806   /* Call the function.  */
11807   walk_subtrees = 1;
11808   result = (*func) (tp, &walk_subtrees, data);
11809
11810   /* If we found something, return it.  */
11811   if (result)
11812     return result;
11813
11814   code = TREE_CODE (*tp);
11815
11816   /* Even if we didn't, FUNC may have decided that there was nothing
11817      interesting below this point in the tree.  */
11818   if (!walk_subtrees)
11819     {
11820       /* But we still need to check our siblings.  */
11821       if (code == TREE_LIST)
11822         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11823       else if (code == OMP_CLAUSE)
11824         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11825       else
11826         return NULL_TREE;
11827     }
11828
11829   if (lh)
11830     {
11831       result = (*lh) (tp, &walk_subtrees, func, data, pset);
11832       if (result || !walk_subtrees)
11833         return result;
11834     }
11835
11836   switch (code)
11837     {
11838     case ERROR_MARK:
11839     case IDENTIFIER_NODE:
11840     case INTEGER_CST:
11841     case REAL_CST:
11842     case FIXED_CST:
11843     case VECTOR_CST:
11844     case STRING_CST:
11845     case BLOCK:
11846     case PLACEHOLDER_EXPR:
11847     case SSA_NAME:
11848     case FIELD_DECL:
11849     case RESULT_DECL:
11850       /* None of these have subtrees other than those already walked
11851          above.  */
11852       break;
11853
11854     case TREE_LIST:
11855       WALK_SUBTREE (TREE_VALUE (*tp));
11856       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
11857       break;
11858
11859     case TREE_VEC:
11860       {
11861         int len = TREE_VEC_LENGTH (*tp);
11862
11863         if (len == 0)
11864           break;
11865
11866         /* Walk all elements but the first.  */
11867         while (--len)
11868           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
11869
11870         /* Now walk the first one as a tail call.  */
11871         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
11872       }
11873
11874     case COMPLEX_CST:
11875       WALK_SUBTREE (TREE_REALPART (*tp));
11876       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
11877
11878     case CONSTRUCTOR:
11879       {
11880         unsigned HOST_WIDE_INT idx;
11881         constructor_elt *ce;
11882
11883         for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
11884              idx++)
11885           WALK_SUBTREE (ce->value);
11886       }
11887       break;
11888
11889     case SAVE_EXPR:
11890       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
11891
11892     case BIND_EXPR:
11893       {
11894         tree decl;
11895         for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
11896           {
11897             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
11898                into declarations that are just mentioned, rather than
11899                declared; they don't really belong to this part of the tree.
11900                And, we can see cycles: the initializer for a declaration
11901                can refer to the declaration itself.  */
11902             WALK_SUBTREE (DECL_INITIAL (decl));
11903             WALK_SUBTREE (DECL_SIZE (decl));
11904             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
11905           }
11906         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
11907       }
11908
11909     case STATEMENT_LIST:
11910       {
11911         tree_stmt_iterator i;
11912         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
11913           WALK_SUBTREE (*tsi_stmt_ptr (i));
11914       }
11915       break;
11916
11917     case OMP_CLAUSE:
11918       switch (OMP_CLAUSE_CODE (*tp))
11919         {
11920         case OMP_CLAUSE_GANG:
11921         case OMP_CLAUSE__GRIDDIM_:
11922           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
11923           /* FALLTHRU */
11924
11925         case OMP_CLAUSE_ASYNC:
11926         case OMP_CLAUSE_WAIT:
11927         case OMP_CLAUSE_WORKER:
11928         case OMP_CLAUSE_VECTOR:
11929         case OMP_CLAUSE_NUM_GANGS:
11930         case OMP_CLAUSE_NUM_WORKERS:
11931         case OMP_CLAUSE_VECTOR_LENGTH:
11932         case OMP_CLAUSE_PRIVATE:
11933         case OMP_CLAUSE_SHARED:
11934         case OMP_CLAUSE_FIRSTPRIVATE:
11935         case OMP_CLAUSE_COPYIN:
11936         case OMP_CLAUSE_COPYPRIVATE:
11937         case OMP_CLAUSE_FINAL:
11938         case OMP_CLAUSE_IF:
11939         case OMP_CLAUSE_NUM_THREADS:
11940         case OMP_CLAUSE_SCHEDULE:
11941         case OMP_CLAUSE_UNIFORM:
11942         case OMP_CLAUSE_DEPEND:
11943         case OMP_CLAUSE_NUM_TEAMS:
11944         case OMP_CLAUSE_THREAD_LIMIT:
11945         case OMP_CLAUSE_DEVICE:
11946         case OMP_CLAUSE_DIST_SCHEDULE:
11947         case OMP_CLAUSE_SAFELEN:
11948         case OMP_CLAUSE_SIMDLEN:
11949         case OMP_CLAUSE_ORDERED:
11950         case OMP_CLAUSE_PRIORITY:
11951         case OMP_CLAUSE_GRAINSIZE:
11952         case OMP_CLAUSE_NUM_TASKS:
11953         case OMP_CLAUSE_HINT:
11954         case OMP_CLAUSE_TO_DECLARE:
11955         case OMP_CLAUSE_LINK:
11956         case OMP_CLAUSE_USE_DEVICE_PTR:
11957         case OMP_CLAUSE_IS_DEVICE_PTR:
11958         case OMP_CLAUSE__LOOPTEMP_:
11959         case OMP_CLAUSE__SIMDUID_:
11960         case OMP_CLAUSE__CILK_FOR_COUNT_:
11961           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
11962           /* FALLTHRU */
11963
11964         case OMP_CLAUSE_INDEPENDENT:
11965         case OMP_CLAUSE_NOWAIT:
11966         case OMP_CLAUSE_DEFAULT:
11967         case OMP_CLAUSE_UNTIED:
11968         case OMP_CLAUSE_MERGEABLE:
11969         case OMP_CLAUSE_PROC_BIND:
11970         case OMP_CLAUSE_INBRANCH:
11971         case OMP_CLAUSE_NOTINBRANCH:
11972         case OMP_CLAUSE_FOR:
11973         case OMP_CLAUSE_PARALLEL:
11974         case OMP_CLAUSE_SECTIONS:
11975         case OMP_CLAUSE_TASKGROUP:
11976         case OMP_CLAUSE_NOGROUP:
11977         case OMP_CLAUSE_THREADS:
11978         case OMP_CLAUSE_SIMD:
11979         case OMP_CLAUSE_DEFAULTMAP:
11980         case OMP_CLAUSE_AUTO:
11981         case OMP_CLAUSE_SEQ:
11982         case OMP_CLAUSE_TILE:
11983         case OMP_CLAUSE__SIMT_:
11984           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11985
11986         case OMP_CLAUSE_LASTPRIVATE:
11987           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
11988           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
11989           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11990
11991         case OMP_CLAUSE_COLLAPSE:
11992           {
11993             int i;
11994             for (i = 0; i < 3; i++)
11995               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
11996             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
11997           }
11998
11999         case OMP_CLAUSE_LINEAR:
12000           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
12001           WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp));
12002           WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp));
12003           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12004
12005         case OMP_CLAUSE_ALIGNED:
12006         case OMP_CLAUSE_FROM:
12007         case OMP_CLAUSE_TO:
12008         case OMP_CLAUSE_MAP:
12009         case OMP_CLAUSE__CACHE_:
12010           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
12011           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
12012           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12013
12014         case OMP_CLAUSE_REDUCTION:
12015           {
12016             int i;
12017             for (i = 0; i < 5; i++)
12018               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
12019             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
12020           }
12021
12022         default:
12023           gcc_unreachable ();
12024         }
12025       break;
12026
12027     case TARGET_EXPR:
12028       {
12029         int i, len;
12030
12031         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
12032            But, we only want to walk once.  */
12033         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
12034         for (i = 0; i < len; ++i)
12035           WALK_SUBTREE (TREE_OPERAND (*tp, i));
12036         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
12037       }
12038
12039     case DECL_EXPR:
12040       /* If this is a TYPE_DECL, walk into the fields of the type that it's
12041          defining.  We only want to walk into these fields of a type in this
12042          case and not in the general case of a mere reference to the type.
12043
12044          The criterion is as follows: if the field can be an expression, it
12045          must be walked only here.  This should be in keeping with the fields
12046          that are directly gimplified in gimplify_type_sizes in order for the
12047          mark/copy-if-shared/unmark machinery of the gimplifier to work with
12048          variable-sized types.
12049
12050          Note that DECLs get walked as part of processing the BIND_EXPR.  */
12051       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
12052         {
12053           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
12054           if (TREE_CODE (*type_p) == ERROR_MARK)
12055             return NULL_TREE;
12056
12057           /* Call the function for the type.  See if it returns anything or
12058              doesn't want us to continue.  If we are to continue, walk both
12059              the normal fields and those for the declaration case.  */
12060           result = (*func) (type_p, &walk_subtrees, data);
12061           if (result || !walk_subtrees)
12062             return result;
12063
12064           /* But do not walk a pointed-to type since it may itself need to
12065              be walked in the declaration case if it isn't anonymous.  */
12066           if (!POINTER_TYPE_P (*type_p))
12067             {
12068               result = walk_type_fields (*type_p, func, data, pset, lh);
12069               if (result)
12070                 return result;
12071             }
12072
12073           /* If this is a record type, also walk the fields.  */
12074           if (RECORD_OR_UNION_TYPE_P (*type_p))
12075             {
12076               tree field;
12077
12078               for (field = TYPE_FIELDS (*type_p); field;
12079                    field = DECL_CHAIN (field))
12080                 {
12081                   /* We'd like to look at the type of the field, but we can
12082                      easily get infinite recursion.  So assume it's pointed
12083                      to elsewhere in the tree.  Also, ignore things that
12084                      aren't fields.  */
12085                   if (TREE_CODE (field) != FIELD_DECL)
12086                     continue;
12087
12088                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
12089                   WALK_SUBTREE (DECL_SIZE (field));
12090                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
12091                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
12092                     WALK_SUBTREE (DECL_QUALIFIER (field));
12093                 }
12094             }
12095
12096           /* Same for scalar types.  */
12097           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
12098                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
12099                    || TREE_CODE (*type_p) == INTEGER_TYPE
12100                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
12101                    || TREE_CODE (*type_p) == REAL_TYPE)
12102             {
12103               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
12104               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
12105             }
12106
12107           WALK_SUBTREE (TYPE_SIZE (*type_p));
12108           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
12109         }
12110       /* FALLTHRU */
12111
12112     default:
12113       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
12114         {
12115           int i, len;
12116
12117           /* Walk over all the sub-trees of this operand.  */
12118           len = TREE_OPERAND_LENGTH (*tp);
12119
12120           /* Go through the subtrees.  We need to do this in forward order so
12121              that the scope of a FOR_EXPR is handled properly.  */
12122           if (len)
12123             {
12124               for (i = 0; i < len - 1; ++i)
12125                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
12126               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
12127             }
12128         }
12129       /* If this is a type, walk the needed fields in the type.  */
12130       else if (TYPE_P (*tp))
12131         return walk_type_fields (*tp, func, data, pset, lh);
12132       break;
12133     }
12134
12135   /* We didn't find what we were looking for.  */
12136   return NULL_TREE;
12137
12138 #undef WALK_SUBTREE_TAIL
12139 }
12140 #undef WALK_SUBTREE
12141
12142 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
12143
12144 tree
12145 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
12146                                 walk_tree_lh lh)
12147 {
12148   tree result;
12149
12150   hash_set<tree> pset;
12151   result = walk_tree_1 (tp, func, data, &pset, lh);
12152   return result;
12153 }
12154
12155
12156 tree
12157 tree_block (tree t)
12158 {
12159   const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
12160
12161   if (IS_EXPR_CODE_CLASS (c))
12162     return LOCATION_BLOCK (t->exp.locus);
12163   gcc_unreachable ();
12164   return NULL;
12165 }
12166
12167 void
12168 tree_set_block (tree t, tree b)
12169 {
12170   const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
12171
12172   if (IS_EXPR_CODE_CLASS (c))
12173     {
12174       t->exp.locus = set_block (t->exp.locus, b);
12175     }
12176   else
12177     gcc_unreachable ();
12178 }
12179
12180 /* Create a nameless artificial label and put it in the current
12181    function context.  The label has a location of LOC.  Returns the
12182    newly created label.  */
12183
12184 tree
12185 create_artificial_label (location_t loc)
12186 {
12187   tree lab = build_decl (loc,
12188                          LABEL_DECL, NULL_TREE, void_type_node);
12189
12190   DECL_ARTIFICIAL (lab) = 1;
12191   DECL_IGNORED_P (lab) = 1;
12192   DECL_CONTEXT (lab) = current_function_decl;
12193   return lab;
12194 }
12195
12196 /*  Given a tree, try to return a useful variable name that we can use
12197     to prefix a temporary that is being assigned the value of the tree.
12198     I.E. given  <temp> = &A, return A.  */
12199
12200 const char *
12201 get_name (tree t)
12202 {
12203   tree stripped_decl;
12204
12205   stripped_decl = t;
12206   STRIP_NOPS (stripped_decl);
12207   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
12208     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
12209   else if (TREE_CODE (stripped_decl) == SSA_NAME)
12210     {
12211       tree name = SSA_NAME_IDENTIFIER (stripped_decl);
12212       if (!name)
12213         return NULL;
12214       return IDENTIFIER_POINTER (name);
12215     }
12216   else
12217     {
12218       switch (TREE_CODE (stripped_decl))
12219         {
12220         case ADDR_EXPR:
12221           return get_name (TREE_OPERAND (stripped_decl, 0));
12222         default:
12223           return NULL;
12224         }
12225     }
12226 }
12227
12228 /* Return true if TYPE has a variable argument list.  */
12229
12230 bool
12231 stdarg_p (const_tree fntype)
12232 {
12233   function_args_iterator args_iter;
12234   tree n = NULL_TREE, t;
12235
12236   if (!fntype)
12237     return false;
12238
12239   FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
12240     {
12241       n = t;
12242     }
12243
12244   return n != NULL_TREE && n != void_type_node;
12245 }
12246
12247 /* Return true if TYPE has a prototype.  */
12248
12249 bool
12250 prototype_p (const_tree fntype)
12251 {
12252   tree t;
12253
12254   gcc_assert (fntype != NULL_TREE);
12255
12256   t = TYPE_ARG_TYPES (fntype);
12257   return (t != NULL_TREE);
12258 }
12259
12260 /* If BLOCK is inlined from an __attribute__((__artificial__))
12261    routine, return pointer to location from where it has been
12262    called.  */
12263 location_t *
12264 block_nonartificial_location (tree block)
12265 {
12266   location_t *ret = NULL;
12267
12268   while (block && TREE_CODE (block) == BLOCK
12269          && BLOCK_ABSTRACT_ORIGIN (block))
12270     {
12271       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
12272
12273       while (TREE_CODE (ao) == BLOCK
12274              && BLOCK_ABSTRACT_ORIGIN (ao)
12275              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
12276         ao = BLOCK_ABSTRACT_ORIGIN (ao);
12277
12278       if (TREE_CODE (ao) == FUNCTION_DECL)
12279         {
12280           /* If AO is an artificial inline, point RET to the
12281              call site locus at which it has been inlined and continue
12282              the loop, in case AO's caller is also an artificial
12283              inline.  */
12284           if (DECL_DECLARED_INLINE_P (ao)
12285               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
12286             ret = &BLOCK_SOURCE_LOCATION (block);
12287           else
12288             break;
12289         }
12290       else if (TREE_CODE (ao) != BLOCK)
12291         break;
12292
12293       block = BLOCK_SUPERCONTEXT (block);
12294     }
12295   return ret;
12296 }
12297
12298
12299 /* If EXP is inlined from an __attribute__((__artificial__))
12300    function, return the location of the original call expression.  */
12301
12302 location_t
12303 tree_nonartificial_location (tree exp)
12304 {
12305   location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
12306
12307   if (loc)
12308     return *loc;
12309   else
12310     return EXPR_LOCATION (exp);
12311 }
12312
12313
12314 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
12315    nodes.  */
12316
12317 /* Return the hash code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
12318
12319 hashval_t
12320 cl_option_hasher::hash (tree x)
12321 {
12322   const_tree const t = x;
12323   const char *p;
12324   size_t i;
12325   size_t len = 0;
12326   hashval_t hash = 0;
12327
12328   if (TREE_CODE (t) == OPTIMIZATION_NODE)
12329     {
12330       p = (const char *)TREE_OPTIMIZATION (t);
12331       len = sizeof (struct cl_optimization);
12332     }
12333
12334   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
12335     return cl_target_option_hash (TREE_TARGET_OPTION (t));
12336
12337   else
12338     gcc_unreachable ();
12339
12340   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
12341      something else.  */
12342   for (i = 0; i < len; i++)
12343     if (p[i])
12344       hash = (hash << 4) ^ ((i << 2) | p[i]);
12345
12346   return hash;
12347 }
12348
12349 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
12350    TARGET_OPTION tree node) is the same as that given by *Y, which is the
12351    same.  */
12352
12353 bool
12354 cl_option_hasher::equal (tree x, tree y)
12355 {
12356   const_tree const xt = x;
12357   const_tree const yt = y;
12358   const char *xp;
12359   const char *yp;
12360   size_t len;
12361
12362   if (TREE_CODE (xt) != TREE_CODE (yt))
12363     return 0;
12364
12365   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
12366     {
12367       xp = (const char *)TREE_OPTIMIZATION (xt);
12368       yp = (const char *)TREE_OPTIMIZATION (yt);
12369       len = sizeof (struct cl_optimization);
12370     }
12371
12372   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
12373     {
12374       return cl_target_option_eq (TREE_TARGET_OPTION (xt),
12375                                   TREE_TARGET_OPTION (yt));
12376     }
12377
12378   else
12379     gcc_unreachable ();
12380
12381   return (memcmp (xp, yp, len) == 0);
12382 }
12383
12384 /* Build an OPTIMIZATION_NODE based on the options in OPTS.  */
12385
12386 tree
12387 build_optimization_node (struct gcc_options *opts)
12388 {
12389   tree t;
12390
12391   /* Use the cache of optimization nodes.  */
12392
12393   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
12394                         opts);
12395
12396   tree *slot = cl_option_hash_table->find_slot (cl_optimization_node, INSERT);
12397   t = *slot;
12398   if (!t)
12399     {
12400       /* Insert this one into the hash table.  */
12401       t = cl_optimization_node;
12402       *slot = t;
12403
12404       /* Make a new node for next time round.  */
12405       cl_optimization_node = make_node (OPTIMIZATION_NODE);
12406     }
12407
12408   return t;
12409 }
12410
12411 /* Build a TARGET_OPTION_NODE based on the options in OPTS.  */
12412
12413 tree
12414 build_target_option_node (struct gcc_options *opts)
12415 {
12416   tree t;
12417
12418   /* Use the cache of optimization nodes.  */
12419
12420   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
12421                          opts);
12422
12423   tree *slot = cl_option_hash_table->find_slot (cl_target_option_node, INSERT);
12424   t = *slot;
12425   if (!t)
12426     {
12427       /* Insert this one into the hash table.  */
12428       t = cl_target_option_node;
12429       *slot = t;
12430
12431       /* Make a new node for next time round.  */
12432       cl_target_option_node = make_node (TARGET_OPTION_NODE);
12433     }
12434
12435   return t;
12436 }
12437
12438 /* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
12439    so that they aren't saved during PCH writing.  */
12440
12441 void
12442 prepare_target_option_nodes_for_pch (void)
12443 {
12444   hash_table<cl_option_hasher>::iterator iter = cl_option_hash_table->begin ();
12445   for (; iter != cl_option_hash_table->end (); ++iter)
12446     if (TREE_CODE (*iter) == TARGET_OPTION_NODE)
12447       TREE_TARGET_GLOBALS (*iter) = NULL;
12448 }
12449
12450 /* Determine the "ultimate origin" of a block.  The block may be an inlined
12451    instance of an inlined instance of a block which is local to an inline
12452    function, so we have to trace all of the way back through the origin chain
12453    to find out what sort of node actually served as the original seed for the
12454    given block.  */
12455
12456 tree
12457 block_ultimate_origin (const_tree block)
12458 {
12459   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
12460
12461   /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if
12462      we're trying to output the abstract instance of this function.  */
12463   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
12464     return NULL_TREE;
12465
12466   if (immediate_origin == NULL_TREE)
12467     return NULL_TREE;
12468   else
12469     {
12470       tree ret_val;
12471       tree lookahead = immediate_origin;
12472
12473       do
12474         {
12475           ret_val = lookahead;
12476           lookahead = (TREE_CODE (ret_val) == BLOCK
12477                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
12478         }
12479       while (lookahead != NULL && lookahead != ret_val);
12480
12481       /* The block's abstract origin chain may not be the *ultimate* origin of
12482          the block. It could lead to a DECL that has an abstract origin set.
12483          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
12484          will give us if it has one).  Note that DECL's abstract origins are
12485          supposed to be the most distant ancestor (or so decl_ultimate_origin
12486          claims), so we don't need to loop following the DECL origins.  */
12487       if (DECL_P (ret_val))
12488         return DECL_ORIGIN (ret_val);
12489
12490       return ret_val;
12491     }
12492 }
12493
12494 /* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
12495    no instruction.  */
12496
12497 bool
12498 tree_nop_conversion_p (const_tree outer_type, const_tree inner_type)
12499 {
12500   /* Do not strip casts into or out of differing address spaces.  */
12501   if (POINTER_TYPE_P (outer_type)
12502       && TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) != ADDR_SPACE_GENERIC)
12503     {
12504       if (!POINTER_TYPE_P (inner_type)
12505           || (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
12506               != TYPE_ADDR_SPACE (TREE_TYPE (inner_type))))
12507         return false;
12508     }
12509   else if (POINTER_TYPE_P (inner_type)
12510            && TYPE_ADDR_SPACE (TREE_TYPE (inner_type)) != ADDR_SPACE_GENERIC)
12511     {
12512       /* We already know that outer_type is not a pointer with
12513          a non-generic address space.  */
12514       return false;
12515     }
12516
12517   /* Use precision rather then machine mode when we can, which gives
12518      the correct answer even for submode (bit-field) types.  */
12519   if ((INTEGRAL_TYPE_P (outer_type)
12520        || POINTER_TYPE_P (outer_type)
12521        || TREE_CODE (outer_type) == OFFSET_TYPE)
12522       && (INTEGRAL_TYPE_P (inner_type)
12523           || POINTER_TYPE_P (inner_type)
12524           || TREE_CODE (inner_type) == OFFSET_TYPE))
12525     return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
12526
12527   /* Otherwise fall back on comparing machine modes (e.g. for
12528      aggregate types, floats).  */
12529   return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
12530 }
12531
12532 /* Return true iff conversion in EXP generates no instruction.  Mark
12533    it inline so that we fully inline into the stripping functions even
12534    though we have two uses of this function.  */
12535
12536 static inline bool
12537 tree_nop_conversion (const_tree exp)
12538 {
12539   tree outer_type, inner_type;
12540
12541   if (!CONVERT_EXPR_P (exp)
12542       && TREE_CODE (exp) != NON_LVALUE_EXPR)
12543     return false;
12544   if (TREE_OPERAND (exp, 0) == error_mark_node)
12545     return false;
12546
12547   outer_type = TREE_TYPE (exp);
12548   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12549
12550   if (!inner_type)
12551     return false;
12552
12553   return tree_nop_conversion_p (outer_type, inner_type);
12554 }
12555
12556 /* Return true iff conversion in EXP generates no instruction.  Don't
12557    consider conversions changing the signedness.  */
12558
12559 static bool
12560 tree_sign_nop_conversion (const_tree exp)
12561 {
12562   tree outer_type, inner_type;
12563
12564   if (!tree_nop_conversion (exp))
12565     return false;
12566
12567   outer_type = TREE_TYPE (exp);
12568   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
12569
12570   return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
12571           && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
12572 }
12573
12574 /* Strip conversions from EXP according to tree_nop_conversion and
12575    return the resulting expression.  */
12576
12577 tree
12578 tree_strip_nop_conversions (tree exp)
12579 {
12580   while (tree_nop_conversion (exp))
12581     exp = TREE_OPERAND (exp, 0);
12582   return exp;
12583 }
12584
12585 /* Strip conversions from EXP according to tree_sign_nop_conversion
12586    and return the resulting expression.  */
12587
12588 tree
12589 tree_strip_sign_nop_conversions (tree exp)
12590 {
12591   while (tree_sign_nop_conversion (exp))
12592     exp = TREE_OPERAND (exp, 0);
12593   return exp;
12594 }
12595
12596 /* Avoid any floating point extensions from EXP.  */
12597 tree
12598 strip_float_extensions (tree exp)
12599 {
12600   tree sub, expt, subt;
12601
12602   /*  For floating point constant look up the narrowest type that can hold
12603       it properly and handle it like (type)(narrowest_type)constant.
12604       This way we can optimize for instance a=a*2.0 where "a" is float
12605       but 2.0 is double constant.  */
12606   if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp)))
12607     {
12608       REAL_VALUE_TYPE orig;
12609       tree type = NULL;
12610
12611       orig = TREE_REAL_CST (exp);
12612       if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
12613           && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
12614         type = float_type_node;
12615       else if (TYPE_PRECISION (TREE_TYPE (exp))
12616                > TYPE_PRECISION (double_type_node)
12617                && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
12618         type = double_type_node;
12619       if (type)
12620         return build_real_truncate (type, orig);
12621     }
12622
12623   if (!CONVERT_EXPR_P (exp))
12624     return exp;
12625
12626   sub = TREE_OPERAND (exp, 0);
12627   subt = TREE_TYPE (sub);
12628   expt = TREE_TYPE (exp);
12629
12630   if (!FLOAT_TYPE_P (subt))
12631     return exp;
12632
12633   if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt))
12634     return exp;
12635
12636   if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
12637     return exp;
12638
12639   return strip_float_extensions (sub);
12640 }
12641
12642 /* Strip out all handled components that produce invariant
12643    offsets.  */
12644
12645 const_tree
12646 strip_invariant_refs (const_tree op)
12647 {
12648   while (handled_component_p (op))
12649     {
12650       switch (TREE_CODE (op))
12651         {
12652         case ARRAY_REF:
12653         case ARRAY_RANGE_REF:
12654           if (!is_gimple_constant (TREE_OPERAND (op, 1))
12655               || TREE_OPERAND (op, 2) != NULL_TREE
12656               || TREE_OPERAND (op, 3) != NULL_TREE)
12657             return NULL;
12658           break;
12659
12660         case COMPONENT_REF:
12661           if (TREE_OPERAND (op, 2) != NULL_TREE)
12662             return NULL;
12663           break;
12664
12665         default:;
12666         }
12667       op = TREE_OPERAND (op, 0);
12668     }
12669
12670   return op;
12671 }
12672
12673 static GTY(()) tree gcc_eh_personality_decl;
12674
12675 /* Return the GCC personality function decl.  */
12676
12677 tree
12678 lhd_gcc_personality (void)
12679 {
12680   if (!gcc_eh_personality_decl)
12681     gcc_eh_personality_decl = build_personality_function ("gcc");
12682   return gcc_eh_personality_decl;
12683 }
12684
12685 /* TARGET is a call target of GIMPLE call statement
12686    (obtained by gimple_call_fn).  Return true if it is
12687    OBJ_TYPE_REF representing an virtual call of C++ method.
12688    (As opposed to OBJ_TYPE_REF representing objc calls
12689    through a cast where middle-end devirtualization machinery
12690    can't apply.) */
12691
12692 bool
12693 virtual_method_call_p (const_tree target)
12694 {
12695   if (TREE_CODE (target) != OBJ_TYPE_REF)
12696     return false;
12697   tree t = TREE_TYPE (target);
12698   gcc_checking_assert (TREE_CODE (t) == POINTER_TYPE);
12699   t = TREE_TYPE (t);
12700   if (TREE_CODE (t) == FUNCTION_TYPE)
12701     return false;
12702   gcc_checking_assert (TREE_CODE (t) == METHOD_TYPE);
12703   /* If we do not have BINFO associated, it means that type was built
12704      without devirtualization enabled.  Do not consider this a virtual
12705      call.  */
12706   if (!TYPE_BINFO (obj_type_ref_class (target)))
12707     return false;
12708   return true;
12709 }
12710
12711 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to.  */
12712
12713 tree
12714 obj_type_ref_class (const_tree ref)
12715 {
12716   gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
12717   ref = TREE_TYPE (ref);
12718   gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12719   ref = TREE_TYPE (ref);
12720   /* We look for type THIS points to.  ObjC also builds
12721      OBJ_TYPE_REF with non-method calls, Their first parameter
12722      ID however also corresponds to class type. */
12723   gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
12724                        || TREE_CODE (ref) == FUNCTION_TYPE);
12725   ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
12726   gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
12727   return TREE_TYPE (ref);
12728 }
12729
12730 /* Lookup sub-BINFO of BINFO of TYPE at offset POS.  */
12731
12732 static tree
12733 lookup_binfo_at_offset (tree binfo, tree type, HOST_WIDE_INT pos)
12734 {
12735   unsigned int i;
12736   tree base_binfo, b;
12737
12738   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12739     if (pos == tree_to_shwi (BINFO_OFFSET (base_binfo))
12740         && types_same_for_odr (TREE_TYPE (base_binfo), type))
12741       return base_binfo;
12742     else if ((b = lookup_binfo_at_offset (base_binfo, type, pos)) != NULL)
12743       return b;
12744   return NULL;
12745 }
12746
12747 /* Try to find a base info of BINFO that would have its field decl at offset
12748    OFFSET within the BINFO type and which is of EXPECTED_TYPE.  If it can be
12749    found, return, otherwise return NULL_TREE.  */
12750
12751 tree
12752 get_binfo_at_offset (tree binfo, HOST_WIDE_INT offset, tree expected_type)
12753 {
12754   tree type = BINFO_TYPE (binfo);
12755
12756   while (true)
12757     {
12758       HOST_WIDE_INT pos, size;
12759       tree fld;
12760       int i;
12761
12762       if (types_same_for_odr (type, expected_type))
12763           return binfo;
12764       if (offset < 0)
12765         return NULL_TREE;
12766
12767       for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
12768         {
12769           if (TREE_CODE (fld) != FIELD_DECL || !DECL_ARTIFICIAL (fld))
12770             continue;
12771
12772           pos = int_bit_position (fld);
12773           size = tree_to_uhwi (DECL_SIZE (fld));
12774           if (pos <= offset && (pos + size) > offset)
12775             break;
12776         }
12777       if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
12778         return NULL_TREE;
12779
12780       /* Offset 0 indicates the primary base, whose vtable contents are
12781          represented in the binfo for the derived class.  */
12782       else if (offset != 0)
12783         {
12784           tree found_binfo = NULL, base_binfo;
12785           /* Offsets in BINFO are in bytes relative to the whole structure
12786              while POS is in bits relative to the containing field.  */
12787           int binfo_offset = (tree_to_shwi (BINFO_OFFSET (binfo)) + pos
12788                              / BITS_PER_UNIT);
12789
12790           for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12791             if (tree_to_shwi (BINFO_OFFSET (base_binfo)) == binfo_offset
12792                 && types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld)))
12793               {
12794                 found_binfo = base_binfo;
12795                 break;
12796               }
12797           if (found_binfo)
12798             binfo = found_binfo;
12799           else
12800             binfo = lookup_binfo_at_offset (binfo, TREE_TYPE (fld),
12801                                             binfo_offset);
12802          }
12803
12804       type = TREE_TYPE (fld);
12805       offset -= pos;
12806     }
12807 }
12808
12809 /* Returns true if X is a typedef decl.  */
12810
12811 bool
12812 is_typedef_decl (const_tree x)
12813 {
12814   return (x && TREE_CODE (x) == TYPE_DECL
12815           && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
12816 }
12817
12818 /* Returns true iff TYPE is a type variant created for a typedef. */
12819
12820 bool
12821 typedef_variant_p (const_tree type)
12822 {
12823   return is_typedef_decl (TYPE_NAME (type));
12824 }
12825
12826 /* Warn about a use of an identifier which was marked deprecated.  */
12827 void
12828 warn_deprecated_use (tree node, tree attr)
12829 {
12830   const char *msg;
12831
12832   if (node == 0 || !warn_deprecated_decl)
12833     return;
12834
12835   if (!attr)
12836     {
12837       if (DECL_P (node))
12838         attr = DECL_ATTRIBUTES (node);
12839       else if (TYPE_P (node))
12840         {
12841           tree decl = TYPE_STUB_DECL (node);
12842           if (decl)
12843             attr = lookup_attribute ("deprecated",
12844                                      TYPE_ATTRIBUTES (TREE_TYPE (decl)));
12845         }
12846     }
12847
12848   if (attr)
12849     attr = lookup_attribute ("deprecated", attr);
12850
12851   if (attr)
12852     msg = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)));
12853   else
12854     msg = NULL;
12855
12856   bool w;
12857   if (DECL_P (node))
12858     {
12859       if (msg)
12860         w = warning (OPT_Wdeprecated_declarations,
12861                      "%qD is deprecated: %s", node, msg);
12862       else
12863         w = warning (OPT_Wdeprecated_declarations,
12864                      "%qD is deprecated", node);
12865       if (w)
12866         inform (DECL_SOURCE_LOCATION (node), "declared here");
12867     }
12868   else if (TYPE_P (node))
12869     {
12870       tree what = NULL_TREE;
12871       tree decl = TYPE_STUB_DECL (node);
12872
12873       if (TYPE_NAME (node))
12874         {
12875           if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
12876             what = TYPE_NAME (node);
12877           else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
12878                    && DECL_NAME (TYPE_NAME (node)))
12879             what = DECL_NAME (TYPE_NAME (node));
12880         }
12881
12882       if (decl)
12883         {
12884           if (what)
12885             {
12886               if (msg)
12887                 w = warning (OPT_Wdeprecated_declarations,
12888                              "%qE is deprecated: %s", what, msg);
12889               else
12890                 w = warning (OPT_Wdeprecated_declarations,
12891                              "%qE is deprecated", what);
12892             }
12893           else
12894             {
12895               if (msg)
12896                 w = warning (OPT_Wdeprecated_declarations,
12897                              "type is deprecated: %s", msg);
12898               else
12899                 w = warning (OPT_Wdeprecated_declarations,
12900                              "type is deprecated");
12901             }
12902           if (w)
12903             inform (DECL_SOURCE_LOCATION (decl), "declared here");
12904         }
12905       else
12906         {
12907           if (what)
12908             {
12909               if (msg)
12910                 warning (OPT_Wdeprecated_declarations, "%qE is deprecated: %s",
12911                          what, msg);
12912               else
12913                 warning (OPT_Wdeprecated_declarations, "%qE is deprecated", what);
12914             }
12915           else
12916             {
12917               if (msg)
12918                 warning (OPT_Wdeprecated_declarations, "type is deprecated: %s",
12919                          msg);
12920               else
12921                 warning (OPT_Wdeprecated_declarations, "type is deprecated");
12922             }
12923         }
12924     }
12925 }
12926
12927 /* Return true if REF has a COMPONENT_REF with a bit-field field declaration
12928    somewhere in it.  */
12929
12930 bool
12931 contains_bitfld_component_ref_p (const_tree ref)
12932 {
12933   while (handled_component_p (ref))
12934     {
12935       if (TREE_CODE (ref) == COMPONENT_REF
12936           && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
12937         return true;
12938       ref = TREE_OPERAND (ref, 0);
12939     }
12940
12941   return false;
12942 }
12943
12944 /* Try to determine whether a TRY_CATCH expression can fall through.
12945    This is a subroutine of block_may_fallthru.  */
12946
12947 static bool
12948 try_catch_may_fallthru (const_tree stmt)
12949 {
12950   tree_stmt_iterator i;
12951
12952   /* If the TRY block can fall through, the whole TRY_CATCH can
12953      fall through.  */
12954   if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
12955     return true;
12956
12957   i = tsi_start (TREE_OPERAND (stmt, 1));
12958   switch (TREE_CODE (tsi_stmt (i)))
12959     {
12960     case CATCH_EXPR:
12961       /* We expect to see a sequence of CATCH_EXPR trees, each with a
12962          catch expression and a body.  The whole TRY_CATCH may fall
12963          through iff any of the catch bodies falls through.  */
12964       for (; !tsi_end_p (i); tsi_next (&i))
12965         {
12966           if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
12967             return true;
12968         }
12969       return false;
12970
12971     case EH_FILTER_EXPR:
12972       /* The exception filter expression only matters if there is an
12973          exception.  If the exception does not match EH_FILTER_TYPES,
12974          we will execute EH_FILTER_FAILURE, and we will fall through
12975          if that falls through.  If the exception does match
12976          EH_FILTER_TYPES, the stack unwinder will continue up the
12977          stack, so we will not fall through.  We don't know whether we
12978          will throw an exception which matches EH_FILTER_TYPES or not,
12979          so we just ignore EH_FILTER_TYPES and assume that we might
12980          throw an exception which doesn't match.  */
12981       return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
12982
12983     default:
12984       /* This case represents statements to be executed when an
12985          exception occurs.  Those statements are implicitly followed
12986          by a RESX statement to resume execution after the exception.
12987          So in this case the TRY_CATCH never falls through.  */
12988       return false;
12989     }
12990 }
12991
12992 /* Try to determine if we can fall out of the bottom of BLOCK.  This guess
12993    need not be 100% accurate; simply be conservative and return true if we
12994    don't know.  This is used only to avoid stupidly generating extra code.
12995    If we're wrong, we'll just delete the extra code later.  */
12996
12997 bool
12998 block_may_fallthru (const_tree block)
12999 {
13000   /* This CONST_CAST is okay because expr_last returns its argument
13001      unmodified and we assign it to a const_tree.  */
13002   const_tree stmt = expr_last (CONST_CAST_TREE (block));
13003
13004   switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
13005     {
13006     case GOTO_EXPR:
13007     case RETURN_EXPR:
13008       /* Easy cases.  If the last statement of the block implies
13009          control transfer, then we can't fall through.  */
13010       return false;
13011
13012     case SWITCH_EXPR:
13013       /* If SWITCH_LABELS is set, this is lowered, and represents a
13014          branch to a selected label and hence can not fall through.
13015          Otherwise SWITCH_BODY is set, and the switch can fall
13016          through.  */
13017       return SWITCH_LABELS (stmt) == NULL_TREE;
13018
13019     case COND_EXPR:
13020       if (block_may_fallthru (COND_EXPR_THEN (stmt)))
13021         return true;
13022       return block_may_fallthru (COND_EXPR_ELSE (stmt));
13023
13024     case BIND_EXPR:
13025       return block_may_fallthru (BIND_EXPR_BODY (stmt));
13026
13027     case TRY_CATCH_EXPR:
13028       return try_catch_may_fallthru (stmt);
13029
13030     case TRY_FINALLY_EXPR:
13031       /* The finally clause is always executed after the try clause,
13032          so if it does not fall through, then the try-finally will not
13033          fall through.  Otherwise, if the try clause does not fall
13034          through, then when the finally clause falls through it will
13035          resume execution wherever the try clause was going.  So the
13036          whole try-finally will only fall through if both the try
13037          clause and the finally clause fall through.  */
13038       return (block_may_fallthru (TREE_OPERAND (stmt, 0))
13039               && block_may_fallthru (TREE_OPERAND (stmt, 1)));
13040
13041     case MODIFY_EXPR:
13042       if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
13043         stmt = TREE_OPERAND (stmt, 1);
13044       else
13045         return true;
13046       /* FALLTHRU */
13047
13048     case CALL_EXPR:
13049       /* Functions that do not return do not fall through.  */
13050       return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
13051
13052     case CLEANUP_POINT_EXPR:
13053       return block_may_fallthru (TREE_OPERAND (stmt, 0));
13054
13055     case TARGET_EXPR:
13056       return block_may_fallthru (TREE_OPERAND (stmt, 1));
13057
13058     case ERROR_MARK:
13059       return true;
13060
13061     default:
13062       return lang_hooks.block_may_fallthru (stmt);
13063     }
13064 }
13065
13066 /* True if we are using EH to handle cleanups.  */
13067 static bool using_eh_for_cleanups_flag = false;
13068
13069 /* This routine is called from front ends to indicate eh should be used for
13070    cleanups.  */
13071 void
13072 using_eh_for_cleanups (void)
13073 {
13074   using_eh_for_cleanups_flag = true;
13075 }
13076
13077 /* Query whether EH is used for cleanups.  */
13078 bool
13079 using_eh_for_cleanups_p (void)
13080 {
13081   return using_eh_for_cleanups_flag;
13082 }
13083
13084 /* Wrapper for tree_code_name to ensure that tree code is valid */
13085 const char *
13086 get_tree_code_name (enum tree_code code)
13087 {
13088   const char *invalid = "<invalid tree code>";
13089
13090   if (code >= MAX_TREE_CODES)
13091     return invalid;
13092
13093   return tree_code_name[code];
13094 }
13095
13096 /* Drops the TREE_OVERFLOW flag from T.  */
13097
13098 tree
13099 drop_tree_overflow (tree t)
13100 {
13101   gcc_checking_assert (TREE_OVERFLOW (t));
13102
13103   /* For tree codes with a sharing machinery re-build the result.  */
13104   if (TREE_CODE (t) == INTEGER_CST)
13105     return wide_int_to_tree (TREE_TYPE (t), t);
13106
13107   /* Otherwise, as all tcc_constants are possibly shared, copy the node
13108      and drop the flag.  */
13109   t = copy_node (t);
13110   TREE_OVERFLOW (t) = 0;
13111   return t;
13112 }
13113
13114 /* Given a memory reference expression T, return its base address.
13115    The base address of a memory reference expression is the main
13116    object being referenced.  For instance, the base address for
13117    'array[i].fld[j]' is 'array'.  You can think of this as stripping
13118    away the offset part from a memory address.
13119
13120    This function calls handled_component_p to strip away all the inner
13121    parts of the memory reference until it reaches the base object.  */
13122
13123 tree
13124 get_base_address (tree t)
13125 {
13126   while (handled_component_p (t))
13127     t = TREE_OPERAND (t, 0);
13128
13129   if ((TREE_CODE (t) == MEM_REF
13130        || TREE_CODE (t) == TARGET_MEM_REF)
13131       && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
13132     t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
13133
13134   /* ???  Either the alias oracle or all callers need to properly deal
13135      with WITH_SIZE_EXPRs before we can look through those.  */
13136   if (TREE_CODE (t) == WITH_SIZE_EXPR)
13137     return NULL_TREE;
13138
13139   return t;
13140 }
13141
13142 /* Return a tree of sizetype representing the size, in bytes, of the element
13143    of EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
13144
13145 tree
13146 array_ref_element_size (tree exp)
13147 {
13148   tree aligned_size = TREE_OPERAND (exp, 3);
13149   tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)));
13150   location_t loc = EXPR_LOCATION (exp);
13151
13152   /* If a size was specified in the ARRAY_REF, it's the size measured
13153      in alignment units of the element type.  So multiply by that value.  */
13154   if (aligned_size)
13155     {
13156       /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13157          sizetype from another type of the same width and signedness.  */
13158       if (TREE_TYPE (aligned_size) != sizetype)
13159         aligned_size = fold_convert_loc (loc, sizetype, aligned_size);
13160       return size_binop_loc (loc, MULT_EXPR, aligned_size,
13161                              size_int (TYPE_ALIGN_UNIT (elmt_type)));
13162     }
13163
13164   /* Otherwise, take the size from that of the element type.  Substitute
13165      any PLACEHOLDER_EXPR that we have.  */
13166   else
13167     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type), exp);
13168 }
13169
13170 /* Return a tree representing the lower bound of the array mentioned in
13171    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
13172
13173 tree
13174 array_ref_low_bound (tree exp)
13175 {
13176   tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
13177
13178   /* If a lower bound is specified in EXP, use it.  */
13179   if (TREE_OPERAND (exp, 2))
13180     return TREE_OPERAND (exp, 2);
13181
13182   /* Otherwise, if there is a domain type and it has a lower bound, use it,
13183      substituting for a PLACEHOLDER_EXPR as needed.  */
13184   if (domain_type && TYPE_MIN_VALUE (domain_type))
13185     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type), exp);
13186
13187   /* Otherwise, return a zero of the appropriate type.  */
13188   return build_int_cst (TREE_TYPE (TREE_OPERAND (exp, 1)), 0);
13189 }
13190
13191 /* Return a tree representing the upper bound of the array mentioned in
13192    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
13193
13194 tree
13195 array_ref_up_bound (tree exp)
13196 {
13197   tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
13198
13199   /* If there is a domain type and it has an upper bound, use it, substituting
13200      for a PLACEHOLDER_EXPR as needed.  */
13201   if (domain_type && TYPE_MAX_VALUE (domain_type))
13202     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type), exp);
13203
13204   /* Otherwise fail.  */
13205   return NULL_TREE;
13206 }
13207
13208 /* Returns true if REF is an array reference to an array at the end of
13209    a structure.  If this is the case, the array may be allocated larger
13210    than its upper bound implies.  When ALLOW_COMPREF is true considers
13211    REF when it's a COMPONENT_REF in addition ARRAY_REF and
13212    ARRAY_RANGE_REF.  */
13213
13214 bool
13215 array_at_struct_end_p (tree ref, bool allow_compref)
13216 {
13217   if (TREE_CODE (ref) != ARRAY_REF
13218       && TREE_CODE (ref) != ARRAY_RANGE_REF
13219       && (!allow_compref || TREE_CODE (ref) != COMPONENT_REF))
13220     return false;
13221
13222   while (handled_component_p (ref))
13223     {
13224       /* If the reference chain contains a component reference to a
13225          non-union type and there follows another field the reference
13226          is not at the end of a structure.  */
13227       if (TREE_CODE (ref) == COMPONENT_REF
13228           && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0))) == RECORD_TYPE)
13229         {
13230           tree nextf = DECL_CHAIN (TREE_OPERAND (ref, 1));
13231           while (nextf && TREE_CODE (nextf) != FIELD_DECL)
13232             nextf = DECL_CHAIN (nextf);
13233           if (nextf)
13234             return false;
13235         }
13236
13237       ref = TREE_OPERAND (ref, 0);
13238     }
13239
13240   tree size = NULL;
13241
13242   if (TREE_CODE (ref) == MEM_REF
13243       && TREE_CODE (TREE_OPERAND (ref, 0)) == ADDR_EXPR)
13244     {
13245       size = TYPE_SIZE (TREE_TYPE (ref));
13246       ref = TREE_OPERAND (TREE_OPERAND (ref, 0), 0);
13247     }
13248
13249   /* If the reference is based on a declared entity, the size of the array
13250      is constrained by its given domain.  (Do not trust commons PR/69368).  */
13251   if (DECL_P (ref)
13252       /* Be sure the size of MEM_REF target match.  For example:
13253
13254            char buf[10];
13255            struct foo *str = (struct foo *)&buf;
13256
13257            str->trailin_array[2] = 1;
13258
13259          is valid because BUF allocate enough space.  */
13260
13261       && (!size || (DECL_SIZE (ref) != NULL
13262                     && operand_equal_p (DECL_SIZE (ref), size, 0)))
13263       && !(flag_unconstrained_commons
13264            && VAR_P (ref) && DECL_COMMON (ref)))
13265     return false;
13266
13267   return true;
13268 }
13269
13270 /* Return a tree representing the offset, in bytes, of the field referenced
13271    by EXP.  This does not include any offset in DECL_FIELD_BIT_OFFSET.  */
13272
13273 tree
13274 component_ref_field_offset (tree exp)
13275 {
13276   tree aligned_offset = TREE_OPERAND (exp, 2);
13277   tree field = TREE_OPERAND (exp, 1);
13278   location_t loc = EXPR_LOCATION (exp);
13279
13280   /* If an offset was specified in the COMPONENT_REF, it's the offset measured
13281      in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT.  So multiply by that
13282      value.  */
13283   if (aligned_offset)
13284     {
13285       /* ??? tree_ssa_useless_type_conversion will eliminate casts to
13286          sizetype from another type of the same width and signedness.  */
13287       if (TREE_TYPE (aligned_offset) != sizetype)
13288         aligned_offset = fold_convert_loc (loc, sizetype, aligned_offset);
13289       return size_binop_loc (loc, MULT_EXPR, aligned_offset,
13290                              size_int (DECL_OFFSET_ALIGN (field)
13291                                        / BITS_PER_UNIT));
13292     }
13293
13294   /* Otherwise, take the offset from that of the field.  Substitute
13295      any PLACEHOLDER_EXPR that we have.  */
13296   else
13297     return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field), exp);
13298 }
13299
13300 /* Return the machine mode of T.  For vectors, returns the mode of the
13301    inner type.  The main use case is to feed the result to HONOR_NANS,
13302    avoiding the BLKmode that a direct TYPE_MODE (T) might return.  */
13303
13304 machine_mode
13305 element_mode (const_tree t)
13306 {
13307   if (!TYPE_P (t))
13308     t = TREE_TYPE (t);
13309   if (VECTOR_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)
13310     t = TREE_TYPE (t);
13311   return TYPE_MODE (t);
13312 }
13313
13314
13315 /* Veirfy that basic properties of T match TV and thus T can be a variant of
13316    TV.  TV should be the more specified variant (i.e. the main variant).  */
13317
13318 static bool
13319 verify_type_variant (const_tree t, tree tv)
13320 {
13321   /* Type variant can differ by:
13322
13323      - TYPE_QUALS: TYPE_READONLY, TYPE_VOLATILE, TYPE_ATOMIC, TYPE_RESTRICT,
13324                    ENCODE_QUAL_ADDR_SPACE.
13325      - main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P
13326        in this case some values may not be set in the variant types
13327        (see TYPE_COMPLETE_P checks).
13328      - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type
13329      - by TYPE_NAME and attributes (i.e. when variant originate by typedef)
13330      - TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants)
13331      - by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN
13332      - during LTO by TYPE_CONTEXT if type is TYPE_FILE_SCOPE_P
13333        this is necessary to make it possible to merge types form different TUs
13334      - arrays, pointers and references may have TREE_TYPE that is a variant
13335        of TREE_TYPE of their main variants.
13336      - aggregates may have new TYPE_FIELDS list that list variants of
13337        the main variant TYPE_FIELDS.
13338      - vector types may differ by TYPE_VECTOR_OPAQUE
13339      - TYPE_METHODS is always NULL for variant types and maintained for
13340        main variant only.
13341    */
13342
13343   /* Convenience macro for matching individual fields.  */
13344 #define verify_variant_match(flag)                                          \
13345   do {                                                                      \
13346     if (flag (tv) != flag (t))                                              \
13347       {                                                                     \
13348         error ("type variant differs by " #flag ".");                       \
13349         debug_tree (tv);                                                    \
13350         return false;                                                       \
13351       }                                                                     \
13352   } while (false)
13353
13354   /* tree_base checks.  */
13355
13356   verify_variant_match (TREE_CODE);
13357   /* FIXME: Ada builds non-artificial variants of artificial types.  */
13358   if (TYPE_ARTIFICIAL (tv) && 0)
13359     verify_variant_match (TYPE_ARTIFICIAL);
13360   if (POINTER_TYPE_P (tv))
13361     verify_variant_match (TYPE_REF_CAN_ALIAS_ALL);
13362   /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build.  */
13363   verify_variant_match (TYPE_UNSIGNED);
13364   verify_variant_match (TYPE_PACKED);
13365   if (TREE_CODE (t) == REFERENCE_TYPE)
13366     verify_variant_match (TYPE_REF_IS_RVALUE);
13367   if (AGGREGATE_TYPE_P (t))
13368     verify_variant_match (TYPE_REVERSE_STORAGE_ORDER);
13369   else
13370     verify_variant_match (TYPE_SATURATING);
13371   /* FIXME: This check trigger during libstdc++ build.  */
13372   if (RECORD_OR_UNION_TYPE_P (t) && COMPLETE_TYPE_P (t) && 0)
13373     verify_variant_match (TYPE_FINAL_P);
13374
13375   /* tree_type_common checks.  */
13376
13377   if (COMPLETE_TYPE_P (t))
13378     {
13379       verify_variant_match (TYPE_MODE);
13380       if (TREE_CODE (TYPE_SIZE (t)) != PLACEHOLDER_EXPR
13381           && TREE_CODE (TYPE_SIZE (tv)) != PLACEHOLDER_EXPR)
13382         verify_variant_match (TYPE_SIZE);
13383       if (TREE_CODE (TYPE_SIZE_UNIT (t)) != PLACEHOLDER_EXPR
13384           && TREE_CODE (TYPE_SIZE_UNIT (tv)) != PLACEHOLDER_EXPR
13385           && TYPE_SIZE_UNIT (t) != TYPE_SIZE_UNIT (tv))
13386         {
13387           gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t),
13388                                         TYPE_SIZE_UNIT (tv), 0));
13389           error ("type variant has different TYPE_SIZE_UNIT");
13390           debug_tree (tv);
13391           error ("type variant's TYPE_SIZE_UNIT");
13392           debug_tree (TYPE_SIZE_UNIT (tv));
13393           error ("type's TYPE_SIZE_UNIT");
13394           debug_tree (TYPE_SIZE_UNIT (t));
13395           return false;
13396         }
13397     }
13398   verify_variant_match (TYPE_PRECISION);
13399   verify_variant_match (TYPE_NEEDS_CONSTRUCTING);
13400   if (RECORD_OR_UNION_TYPE_P (t))
13401     verify_variant_match (TYPE_TRANSPARENT_AGGR);
13402   else if (TREE_CODE (t) == ARRAY_TYPE)
13403     verify_variant_match (TYPE_NONALIASED_COMPONENT);
13404   /* During LTO we merge variant lists from diferent translation units
13405      that may differ BY TYPE_CONTEXT that in turn may point
13406      to TRANSLATION_UNIT_DECL.
13407      Ada also builds variants of types with different TYPE_CONTEXT.   */
13408   if ((!in_lto_p || !TYPE_FILE_SCOPE_P (t)) && 0)
13409     verify_variant_match (TYPE_CONTEXT);
13410   verify_variant_match (TYPE_STRING_FLAG);
13411   if (TYPE_ALIAS_SET_KNOWN_P (t))
13412     {
13413       error ("type variant with TYPE_ALIAS_SET_KNOWN_P");
13414       debug_tree (tv);
13415       return false;
13416     }
13417
13418   /* tree_type_non_common checks.  */
13419
13420   /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13421      and dangle the pointer from time to time.  */
13422   if (RECORD_OR_UNION_TYPE_P (t) && TYPE_VFIELD (t) != TYPE_VFIELD (tv)
13423       && (in_lto_p || !TYPE_VFIELD (tv)
13424           || TREE_CODE (TYPE_VFIELD (tv)) != TREE_LIST))
13425     {
13426       error ("type variant has different TYPE_VFIELD");
13427       debug_tree (tv);
13428       return false;
13429     }
13430   if ((TREE_CODE (t) == ENUMERAL_TYPE && COMPLETE_TYPE_P (t))
13431        || TREE_CODE (t) == INTEGER_TYPE
13432        || TREE_CODE (t) == BOOLEAN_TYPE
13433        || TREE_CODE (t) == REAL_TYPE
13434        || TREE_CODE (t) == FIXED_POINT_TYPE)
13435     {
13436       verify_variant_match (TYPE_MAX_VALUE);
13437       verify_variant_match (TYPE_MIN_VALUE);
13438     }
13439   if (TREE_CODE (t) == METHOD_TYPE)
13440     verify_variant_match (TYPE_METHOD_BASETYPE);
13441   if (RECORD_OR_UNION_TYPE_P (t) && TYPE_METHODS (t))
13442     {
13443       error ("type variant has TYPE_METHODS");
13444       debug_tree (tv);
13445       return false;
13446     }
13447   if (TREE_CODE (t) == OFFSET_TYPE)
13448     verify_variant_match (TYPE_OFFSET_BASETYPE);
13449   if (TREE_CODE (t) == ARRAY_TYPE)
13450     verify_variant_match (TYPE_ARRAY_MAX_SIZE);
13451   /* FIXME: Be lax and allow TYPE_BINFO to be missing in variant types
13452      or even type's main variant.  This is needed to make bootstrap pass
13453      and the bug seems new in GCC 5.
13454      C++ FE should be updated to make this consistent and we should check
13455      that TYPE_BINFO is always NULL for !COMPLETE_TYPE_P and otherwise there
13456      is a match with main variant.
13457
13458      Also disable the check for Java for now because of parser hack that builds
13459      first an dummy BINFO and then sometimes replace it by real BINFO in some
13460      of the copies.  */
13461   if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t) && TYPE_BINFO (tv)
13462       && TYPE_BINFO (t) != TYPE_BINFO (tv)
13463       /* FIXME: Java sometimes keep dump TYPE_BINFOs on variant types.
13464          Since there is no cheap way to tell C++/Java type w/o LTO, do checking
13465          at LTO time only.  */
13466       && (in_lto_p && odr_type_p (t)))
13467     {
13468       error ("type variant has different TYPE_BINFO");
13469       debug_tree (tv);
13470       error ("type variant's TYPE_BINFO");
13471       debug_tree (TYPE_BINFO (tv));
13472       error ("type's TYPE_BINFO");
13473       debug_tree (TYPE_BINFO (t));
13474       return false;
13475     }
13476
13477   /* Check various uses of TYPE_VALUES_RAW.  */
13478   if (TREE_CODE (t) == ENUMERAL_TYPE)
13479     verify_variant_match (TYPE_VALUES);
13480   else if (TREE_CODE (t) == ARRAY_TYPE)
13481     verify_variant_match (TYPE_DOMAIN);
13482   /* Permit incomplete variants of complete type.  While FEs may complete
13483      all variants, this does not happen for C++ templates in all cases.  */
13484   else if (RECORD_OR_UNION_TYPE_P (t)
13485            && COMPLETE_TYPE_P (t)
13486            && TYPE_FIELDS (t) != TYPE_FIELDS (tv))
13487     {
13488       tree f1, f2;
13489
13490       /* Fortran builds qualified variants as new records with items of
13491          qualified type. Verify that they looks same.  */
13492       for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (tv);
13493            f1 && f2;
13494            f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13495         if (TREE_CODE (f1) != FIELD_DECL || TREE_CODE (f2) != FIELD_DECL
13496             || (TYPE_MAIN_VARIANT (TREE_TYPE (f1))
13497                  != TYPE_MAIN_VARIANT (TREE_TYPE (f2))
13498                 /* FIXME: gfc_nonrestricted_type builds all types as variants
13499                    with exception of pointer types.  It deeply copies the type
13500                    which means that we may end up with a variant type
13501                    referring non-variant pointer.  We may change it to
13502                    produce types as variants, too, like
13503                    objc_get_protocol_qualified_type does.  */
13504                 && !POINTER_TYPE_P (TREE_TYPE (f1)))
13505             || DECL_FIELD_OFFSET (f1) != DECL_FIELD_OFFSET (f2)
13506             || DECL_FIELD_BIT_OFFSET (f1) != DECL_FIELD_BIT_OFFSET (f2))
13507           break;
13508       if (f1 || f2)
13509         {
13510           error ("type variant has different TYPE_FIELDS");
13511           debug_tree (tv);
13512           error ("first mismatch is field");
13513           debug_tree (f1);
13514           error ("and field");
13515           debug_tree (f2);
13516           return false;
13517         }
13518     }
13519   else if ((TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE))
13520     verify_variant_match (TYPE_ARG_TYPES);
13521   /* For C++ the qualified variant of array type is really an array type
13522      of qualified TREE_TYPE.
13523      objc builds variants of pointer where pointer to type is a variant, too
13524      in objc_get_protocol_qualified_type.  */
13525   if (TREE_TYPE (t) != TREE_TYPE (tv)
13526       && ((TREE_CODE (t) != ARRAY_TYPE
13527            && !POINTER_TYPE_P (t))
13528           || TYPE_MAIN_VARIANT (TREE_TYPE (t))
13529              != TYPE_MAIN_VARIANT (TREE_TYPE (tv))))
13530     {
13531       error ("type variant has different TREE_TYPE");
13532       debug_tree (tv);
13533       error ("type variant's TREE_TYPE");
13534       debug_tree (TREE_TYPE (tv));
13535       error ("type's TREE_TYPE");
13536       debug_tree (TREE_TYPE (t));
13537       return false;
13538     }
13539   if (type_with_alias_set_p (t)
13540       && !gimple_canonical_types_compatible_p (t, tv, false))
13541     {
13542       error ("type is not compatible with its variant");
13543       debug_tree (tv);
13544       error ("type variant's TREE_TYPE");
13545       debug_tree (TREE_TYPE (tv));
13546       error ("type's TREE_TYPE");
13547       debug_tree (TREE_TYPE (t));
13548       return false;
13549     }
13550   return true;
13551 #undef verify_variant_match
13552 }
13553
13554
13555 /* The TYPE_CANONICAL merging machinery.  It should closely resemble
13556    the middle-end types_compatible_p function.  It needs to avoid
13557    claiming types are different for types that should be treated
13558    the same with respect to TBAA.  Canonical types are also used
13559    for IL consistency checks via the useless_type_conversion_p
13560    predicate which does not handle all type kinds itself but falls
13561    back to pointer-comparison of TYPE_CANONICAL for aggregates
13562    for example.  */
13563
13564 /* Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical
13565    type calculation because we need to allow inter-operability between signed
13566    and unsigned variants.  */
13567
13568 bool
13569 type_with_interoperable_signedness (const_tree type)
13570 {
13571   /* Fortran standard require C_SIGNED_CHAR to be interoperable with both
13572      signed char and unsigned char.  Similarly fortran FE builds
13573      C_SIZE_T as signed type, while C defines it unsigned.  */
13574
13575   return tree_code_for_canonical_type_merging (TREE_CODE (type))
13576            == INTEGER_TYPE
13577          && (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node)
13578              || TYPE_PRECISION (type) == TYPE_PRECISION (size_type_node));
13579 }
13580
13581 /* Return true iff T1 and T2 are structurally identical for what
13582    TBAA is concerned.
13583    This function is used both by lto.c canonical type merging and by the
13584    verifier.  If TRUST_TYPE_CANONICAL we do not look into structure of types
13585    that have TYPE_CANONICAL defined and assume them equivalent.  This is useful
13586    only for LTO because only in these cases TYPE_CANONICAL equivalence
13587    correspond to one defined by gimple_canonical_types_compatible_p.  */
13588
13589 bool
13590 gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
13591                                      bool trust_type_canonical)
13592 {
13593   /* Type variants should be same as the main variant.  When not doing sanity
13594      checking to verify this fact, go to main variants and save some work.  */
13595   if (trust_type_canonical)
13596     {
13597       t1 = TYPE_MAIN_VARIANT (t1);
13598       t2 = TYPE_MAIN_VARIANT (t2);
13599     }
13600
13601   /* Check first for the obvious case of pointer identity.  */
13602   if (t1 == t2)
13603     return true;
13604
13605   /* Check that we have two types to compare.  */
13606   if (t1 == NULL_TREE || t2 == NULL_TREE)
13607     return false;
13608
13609   /* We consider complete types always compatible with incomplete type.
13610      This does not make sense for canonical type calculation and thus we
13611      need to ensure that we are never called on it.
13612
13613      FIXME: For more correctness the function probably should have three modes
13614         1) mode assuming that types are complete mathcing their structure
13615         2) mode allowing incomplete types but producing equivalence classes
13616            and thus ignoring all info from complete types
13617         3) mode allowing incomplete types to match complete but checking
13618            compatibility between complete types.
13619
13620      1 and 2 can be used for canonical type calculation. 3 is the real
13621      definition of type compatibility that can be used i.e. for warnings during
13622      declaration merging.  */
13623
13624   gcc_assert (!trust_type_canonical
13625               || (type_with_alias_set_p (t1) && type_with_alias_set_p (t2)));
13626   /* If the types have been previously registered and found equal
13627      they still are.  */
13628
13629   if (TYPE_CANONICAL (t1) && TYPE_CANONICAL (t2)
13630       && trust_type_canonical)
13631     {
13632       /* Do not use TYPE_CANONICAL of pointer types.  For LTO streamed types
13633          they are always NULL, but they are set to non-NULL for types
13634          constructed by build_pointer_type and variants.  In this case the
13635          TYPE_CANONICAL is more fine grained than the equivalnce we test (where
13636          all pointers are considered equal.  Be sure to not return false
13637          negatives.  */
13638       gcc_checking_assert (canonical_type_used_p (t1)
13639                            && canonical_type_used_p (t2));
13640       return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
13641     }
13642
13643   /* Can't be the same type if the types don't have the same code.  */
13644   enum tree_code code = tree_code_for_canonical_type_merging (TREE_CODE (t1));
13645   if (code != tree_code_for_canonical_type_merging (TREE_CODE (t2)))
13646     return false;
13647
13648   /* Qualifiers do not matter for canonical type comparison purposes.  */
13649
13650   /* Void types and nullptr types are always the same.  */
13651   if (TREE_CODE (t1) == VOID_TYPE
13652       || TREE_CODE (t1) == NULLPTR_TYPE)
13653     return true;
13654
13655   /* Can't be the same type if they have different mode.  */
13656   if (TYPE_MODE (t1) != TYPE_MODE (t2))
13657     return false;
13658
13659   /* Non-aggregate types can be handled cheaply.  */
13660   if (INTEGRAL_TYPE_P (t1)
13661       || SCALAR_FLOAT_TYPE_P (t1)
13662       || FIXED_POINT_TYPE_P (t1)
13663       || TREE_CODE (t1) == VECTOR_TYPE
13664       || TREE_CODE (t1) == COMPLEX_TYPE
13665       || TREE_CODE (t1) == OFFSET_TYPE
13666       || POINTER_TYPE_P (t1))
13667     {
13668       /* Can't be the same type if they have different recision.  */
13669       if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2))
13670         return false;
13671
13672       /* In some cases the signed and unsigned types are required to be
13673          inter-operable.  */
13674       if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2)
13675           && !type_with_interoperable_signedness (t1))
13676         return false;
13677
13678       /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
13679          interoperable with "signed char".  Unless all frontends are revisited
13680          to agree on these types, we must ignore the flag completely.  */
13681
13682       /* Fortran standard define C_PTR type that is compatible with every
13683          C pointer.  For this reason we need to glob all pointers into one.
13684          Still pointers in different address spaces are not compatible.  */
13685       if (POINTER_TYPE_P (t1))
13686         {
13687           if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
13688               != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
13689             return false;
13690         }
13691
13692       /* Tail-recurse to components.  */
13693       if (TREE_CODE (t1) == VECTOR_TYPE
13694           || TREE_CODE (t1) == COMPLEX_TYPE)
13695         return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
13696                                                     TREE_TYPE (t2),
13697                                                     trust_type_canonical);
13698
13699       return true;
13700     }
13701
13702   /* Do type-specific comparisons.  */
13703   switch (TREE_CODE (t1))
13704     {
13705     case ARRAY_TYPE:
13706       /* Array types are the same if the element types are the same and
13707          the number of elements are the same.  */
13708       if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13709                                                 trust_type_canonical)
13710           || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
13711           || TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2)
13712           || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
13713         return false;
13714       else
13715         {
13716           tree i1 = TYPE_DOMAIN (t1);
13717           tree i2 = TYPE_DOMAIN (t2);
13718
13719           /* For an incomplete external array, the type domain can be
13720              NULL_TREE.  Check this condition also.  */
13721           if (i1 == NULL_TREE && i2 == NULL_TREE)
13722             return true;
13723           else if (i1 == NULL_TREE || i2 == NULL_TREE)
13724             return false;
13725           else
13726             {
13727               tree min1 = TYPE_MIN_VALUE (i1);
13728               tree min2 = TYPE_MIN_VALUE (i2);
13729               tree max1 = TYPE_MAX_VALUE (i1);
13730               tree max2 = TYPE_MAX_VALUE (i2);
13731
13732               /* The minimum/maximum values have to be the same.  */
13733               if ((min1 == min2
13734                    || (min1 && min2
13735                        && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
13736                             && TREE_CODE (min2) == PLACEHOLDER_EXPR)
13737                            || operand_equal_p (min1, min2, 0))))
13738                   && (max1 == max2
13739                       || (max1 && max2
13740                           && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
13741                                && TREE_CODE (max2) == PLACEHOLDER_EXPR)
13742                               || operand_equal_p (max1, max2, 0)))))
13743                 return true;
13744               else
13745                 return false;
13746             }
13747         }
13748
13749     case METHOD_TYPE:
13750     case FUNCTION_TYPE:
13751       /* Function types are the same if the return type and arguments types
13752          are the same.  */
13753       if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
13754                                                 trust_type_canonical))
13755         return false;
13756
13757       if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
13758         return true;
13759       else
13760         {
13761           tree parms1, parms2;
13762
13763           for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
13764                parms1 && parms2;
13765                parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
13766             {
13767               if (!gimple_canonical_types_compatible_p
13768                      (TREE_VALUE (parms1), TREE_VALUE (parms2),
13769                       trust_type_canonical))
13770                 return false;
13771             }
13772
13773           if (parms1 || parms2)
13774             return false;
13775
13776           return true;
13777         }
13778
13779     case RECORD_TYPE:
13780     case UNION_TYPE:
13781     case QUAL_UNION_TYPE:
13782       {
13783         tree f1, f2;
13784
13785         /* Don't try to compare variants of an incomplete type, before
13786            TYPE_FIELDS has been copied around.  */
13787         if (!COMPLETE_TYPE_P (t1) && !COMPLETE_TYPE_P (t2))
13788           return true;
13789
13790
13791         if (TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2))
13792           return false;
13793
13794         /* For aggregate types, all the fields must be the same.  */
13795         for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
13796              f1 || f2;
13797              f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
13798           {
13799             /* Skip non-fields and zero-sized fields.  */
13800             while (f1 && (TREE_CODE (f1) != FIELD_DECL
13801                           || (DECL_SIZE (f1)
13802                               && integer_zerop (DECL_SIZE (f1)))))
13803               f1 = TREE_CHAIN (f1);
13804             while (f2 && (TREE_CODE (f2) != FIELD_DECL
13805                           || (DECL_SIZE (f2)
13806                               && integer_zerop (DECL_SIZE (f2)))))
13807               f2 = TREE_CHAIN (f2);
13808             if (!f1 || !f2)
13809               break;
13810             /* The fields must have the same name, offset and type.  */
13811             if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
13812                 || !gimple_compare_field_offset (f1, f2)
13813                 || !gimple_canonical_types_compatible_p
13814                       (TREE_TYPE (f1), TREE_TYPE (f2),
13815                        trust_type_canonical))
13816               return false;
13817           }
13818
13819         /* If one aggregate has more fields than the other, they
13820            are not the same.  */
13821         if (f1 || f2)
13822           return false;
13823
13824         return true;
13825       }
13826
13827     default:
13828       /* Consider all types with language specific trees in them mutually
13829          compatible.  This is executed only from verify_type and false
13830          positives can be tolerated.  */
13831       gcc_assert (!in_lto_p);
13832       return true;
13833     }
13834 }
13835
13836 /* Verify type T.  */
13837
13838 void
13839 verify_type (const_tree t)
13840 {
13841   bool error_found = false;
13842   tree mv = TYPE_MAIN_VARIANT (t);
13843   if (!mv)
13844     {
13845       error ("Main variant is not defined");
13846       error_found = true;
13847     }
13848   else if (mv != TYPE_MAIN_VARIANT (mv))
13849     {
13850       error ("TYPE_MAIN_VARIANT has different TYPE_MAIN_VARIANT");
13851       debug_tree (mv);
13852       error_found = true;
13853     }
13854   else if (t != mv && !verify_type_variant (t, mv))
13855     error_found = true;
13856
13857   tree ct = TYPE_CANONICAL (t);
13858   if (!ct)
13859     ;
13860   else if (TYPE_CANONICAL (t) != ct)
13861     {
13862       error ("TYPE_CANONICAL has different TYPE_CANONICAL");
13863       debug_tree (ct);
13864       error_found = true;
13865     }
13866   /* Method and function types can not be used to address memory and thus
13867      TYPE_CANONICAL really matters only for determining useless conversions.
13868
13869      FIXME: C++ FE produce declarations of builtin functions that are not
13870      compatible with main variants.  */
13871   else if (TREE_CODE (t) == FUNCTION_TYPE)
13872     ;
13873   else if (t != ct
13874            /* FIXME: gimple_canonical_types_compatible_p can not compare types
13875               with variably sized arrays because their sizes possibly
13876               gimplified to different variables.  */
13877            && !variably_modified_type_p (ct, NULL)
13878            && !gimple_canonical_types_compatible_p (t, ct, false))
13879     {
13880       error ("TYPE_CANONICAL is not compatible");
13881       debug_tree (ct);
13882       error_found = true;
13883     }
13884
13885   if (COMPLETE_TYPE_P (t) && TYPE_CANONICAL (t)
13886       && TYPE_MODE (t) != TYPE_MODE (TYPE_CANONICAL (t)))
13887     {
13888       error ("TYPE_MODE of TYPE_CANONICAL is not compatible");
13889       debug_tree (ct);
13890       error_found = true;
13891     }
13892   /* FIXME: this is violated by the C++ FE as discussed in PR70029, when
13893      FUNCTION_*_QUALIFIED flags are set.  */
13894   if (0 && TYPE_MAIN_VARIANT (t) == t && ct && TYPE_MAIN_VARIANT (ct) != ct)
13895    {
13896       error ("TYPE_CANONICAL of main variant is not main variant");
13897       debug_tree (ct);
13898       debug_tree (TYPE_MAIN_VARIANT (ct));
13899       error_found = true;
13900    }
13901
13902
13903   /* Check various uses of TYPE_MINVAL.  */
13904   if (RECORD_OR_UNION_TYPE_P (t))
13905     {
13906       /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS
13907          and danagle the pointer from time to time.  */
13908       if (TYPE_VFIELD (t)
13909           && TREE_CODE (TYPE_VFIELD (t)) != FIELD_DECL
13910           && TREE_CODE (TYPE_VFIELD (t)) != TREE_LIST)
13911         {
13912           error ("TYPE_VFIELD is not FIELD_DECL nor TREE_LIST");
13913           debug_tree (TYPE_VFIELD (t));
13914           error_found = true;
13915         }
13916     }
13917   else if (TREE_CODE (t) == POINTER_TYPE)
13918     {
13919       if (TYPE_NEXT_PTR_TO (t)
13920           && TREE_CODE (TYPE_NEXT_PTR_TO (t)) != POINTER_TYPE)
13921         {
13922           error ("TYPE_NEXT_PTR_TO is not POINTER_TYPE");
13923           debug_tree (TYPE_NEXT_PTR_TO (t));
13924           error_found = true;
13925         }
13926     }
13927   else if (TREE_CODE (t) == REFERENCE_TYPE)
13928     {
13929       if (TYPE_NEXT_REF_TO (t)
13930           && TREE_CODE (TYPE_NEXT_REF_TO (t)) != REFERENCE_TYPE)
13931         {
13932           error ("TYPE_NEXT_REF_TO is not REFERENCE_TYPE");
13933           debug_tree (TYPE_NEXT_REF_TO (t));
13934           error_found = true;
13935         }
13936     }
13937   else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
13938            || TREE_CODE (t) == FIXED_POINT_TYPE)
13939     {
13940       /* FIXME: The following check should pass:
13941           useless_type_conversion_p (const_cast <tree> (t),
13942                                      TREE_TYPE (TYPE_MIN_VALUE (t))
13943          but does not for C sizetypes in LTO.  */
13944     }
13945   /* Java uses TYPE_MINVAL for TYPE_ARGUMENT_SIGNATURE.  */
13946   else if (TYPE_MINVAL (t)
13947            && ((TREE_CODE (t) != METHOD_TYPE && TREE_CODE (t) != FUNCTION_TYPE)
13948                || in_lto_p))
13949     {
13950       error ("TYPE_MINVAL non-NULL");
13951       debug_tree (TYPE_MINVAL (t));
13952       error_found = true;
13953     }
13954
13955   /* Check various uses of TYPE_MAXVAL.  */
13956   if (RECORD_OR_UNION_TYPE_P (t))
13957     {
13958       if (TYPE_METHODS (t) && TREE_CODE (TYPE_METHODS (t)) != FUNCTION_DECL
13959           && TREE_CODE (TYPE_METHODS (t)) != TEMPLATE_DECL
13960           && TYPE_METHODS (t) != error_mark_node)
13961         {
13962           error ("TYPE_METHODS is not FUNCTION_DECL, TEMPLATE_DECL nor error_mark_node");
13963           debug_tree (TYPE_METHODS (t));
13964           error_found = true;
13965         }
13966     }
13967   else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
13968     {
13969       if (TYPE_METHOD_BASETYPE (t)
13970           && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != RECORD_TYPE
13971           && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != UNION_TYPE)
13972         {
13973           error ("TYPE_METHOD_BASETYPE is not record nor union");
13974           debug_tree (TYPE_METHOD_BASETYPE (t));
13975           error_found = true;
13976         }
13977     }
13978   else if (TREE_CODE (t) == OFFSET_TYPE)
13979     {
13980       if (TYPE_OFFSET_BASETYPE (t)
13981           && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != RECORD_TYPE
13982           && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != UNION_TYPE)
13983         {
13984           error ("TYPE_OFFSET_BASETYPE is not record nor union");
13985           debug_tree (TYPE_OFFSET_BASETYPE (t));
13986           error_found = true;
13987         }
13988     }
13989   else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
13990            || TREE_CODE (t) == FIXED_POINT_TYPE)
13991     {
13992       /* FIXME: The following check should pass:
13993           useless_type_conversion_p (const_cast <tree> (t),
13994                                      TREE_TYPE (TYPE_MAX_VALUE (t))
13995          but does not for C sizetypes in LTO.  */
13996     }
13997   else if (TREE_CODE (t) == ARRAY_TYPE)
13998     {
13999       if (TYPE_ARRAY_MAX_SIZE (t)
14000           && TREE_CODE (TYPE_ARRAY_MAX_SIZE (t)) != INTEGER_CST)
14001         {
14002           error ("TYPE_ARRAY_MAX_SIZE not INTEGER_CST");
14003           debug_tree (TYPE_ARRAY_MAX_SIZE (t));
14004           error_found = true;
14005         }
14006     }
14007   else if (TYPE_MAXVAL (t))
14008     {
14009       error ("TYPE_MAXVAL non-NULL");
14010       debug_tree (TYPE_MAXVAL (t));
14011       error_found = true;
14012     }
14013
14014   /* Check various uses of TYPE_BINFO.  */
14015   if (RECORD_OR_UNION_TYPE_P (t))
14016     {
14017       if (!TYPE_BINFO (t))
14018         ;
14019       else if (TREE_CODE (TYPE_BINFO (t)) != TREE_BINFO)
14020         {
14021           error ("TYPE_BINFO is not TREE_BINFO");
14022           debug_tree (TYPE_BINFO (t));
14023           error_found = true;
14024         }
14025       /* FIXME: Java builds invalid empty binfos that do not have
14026          TREE_TYPE set.  */
14027       else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t) && 0)
14028         {
14029           error ("TYPE_BINFO type is not TYPE_MAIN_VARIANT");
14030           debug_tree (TREE_TYPE (TYPE_BINFO (t)));
14031           error_found = true;
14032         }
14033     }
14034   else if (TYPE_LANG_SLOT_1 (t) && in_lto_p)
14035     {
14036       error ("TYPE_LANG_SLOT_1 (binfo) field is non-NULL");
14037       debug_tree (TYPE_LANG_SLOT_1 (t));
14038       error_found = true;
14039     }
14040
14041   /* Check various uses of TYPE_VALUES_RAW.  */
14042   if (TREE_CODE (t) == ENUMERAL_TYPE)
14043     for (tree l = TYPE_VALUES (t); l; l = TREE_CHAIN (l))
14044       {
14045         tree value = TREE_VALUE (l);
14046         tree name = TREE_PURPOSE (l);
14047
14048         /* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
14049            CONST_DECL of ENUMERAL TYPE.  */
14050         if (TREE_CODE (value) != INTEGER_CST && TREE_CODE (value) != CONST_DECL)
14051           {
14052             error ("Enum value is not CONST_DECL or INTEGER_CST");
14053             debug_tree (value);
14054             debug_tree (name);
14055             error_found = true;
14056           }
14057         if (TREE_CODE (TREE_TYPE (value)) != INTEGER_TYPE
14058             && !useless_type_conversion_p (const_cast <tree> (t), TREE_TYPE (value)))
14059           {
14060             error ("Enum value type is not INTEGER_TYPE nor convertible to the enum");
14061             debug_tree (value);
14062             debug_tree (name);
14063             error_found = true;
14064           }
14065         if (TREE_CODE (name) != IDENTIFIER_NODE)
14066           {
14067             error ("Enum value name is not IDENTIFIER_NODE");
14068             debug_tree (value);
14069             debug_tree (name);
14070             error_found = true;
14071           }
14072       }
14073   else if (TREE_CODE (t) == ARRAY_TYPE)
14074     {
14075       if (TYPE_DOMAIN (t) && TREE_CODE (TYPE_DOMAIN (t)) != INTEGER_TYPE)
14076         {
14077           error ("Array TYPE_DOMAIN is not integer type");
14078           debug_tree (TYPE_DOMAIN (t));
14079           error_found = true;
14080         }
14081     }
14082   else if (RECORD_OR_UNION_TYPE_P (t))
14083     {
14084       if (TYPE_FIELDS (t) && !COMPLETE_TYPE_P (t) && in_lto_p)
14085         {
14086           error ("TYPE_FIELDS defined in incomplete type");
14087           error_found = true;
14088         }
14089       for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld))
14090         {
14091           /* TODO: verify properties of decls.  */
14092           if (TREE_CODE (fld) == FIELD_DECL)
14093             ;
14094           else if (TREE_CODE (fld) == TYPE_DECL)
14095             ;
14096           else if (TREE_CODE (fld) == CONST_DECL)
14097             ;
14098           else if (VAR_P (fld))
14099             ;
14100           else if (TREE_CODE (fld) == TEMPLATE_DECL)
14101             ;
14102           else if (TREE_CODE (fld) == USING_DECL)
14103             ;
14104           else
14105             {
14106               error ("Wrong tree in TYPE_FIELDS list");
14107               debug_tree (fld);
14108               error_found = true;
14109             }
14110         }
14111     }
14112   else if (TREE_CODE (t) == INTEGER_TYPE
14113            || TREE_CODE (t) == BOOLEAN_TYPE
14114            || TREE_CODE (t) == OFFSET_TYPE
14115            || TREE_CODE (t) == REFERENCE_TYPE
14116            || TREE_CODE (t) == NULLPTR_TYPE
14117            || TREE_CODE (t) == POINTER_TYPE)
14118     {
14119       if (TYPE_CACHED_VALUES_P (t) != (TYPE_CACHED_VALUES (t) != NULL))
14120         {
14121           error ("TYPE_CACHED_VALUES_P is %i while TYPE_CACHED_VALUES is %p",
14122                  TYPE_CACHED_VALUES_P (t), (void *)TYPE_CACHED_VALUES (t));
14123           error_found = true;
14124         }
14125       else if (TYPE_CACHED_VALUES_P (t) && TREE_CODE (TYPE_CACHED_VALUES (t)) != TREE_VEC)
14126         {
14127           error ("TYPE_CACHED_VALUES is not TREE_VEC");
14128           debug_tree (TYPE_CACHED_VALUES (t));
14129           error_found = true;
14130         }
14131       /* Verify just enough of cache to ensure that no one copied it to new type.
14132          All copying should go by copy_node that should clear it.  */
14133       else if (TYPE_CACHED_VALUES_P (t))
14134         {
14135           int i;
14136           for (i = 0; i < TREE_VEC_LENGTH (TYPE_CACHED_VALUES (t)); i++)
14137             if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)
14138                 && TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)) != t)
14139               {
14140                 error ("wrong TYPE_CACHED_VALUES entry");
14141                 debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i));
14142                 error_found = true;
14143                 break;
14144               }
14145         }
14146     }
14147   else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
14148     for (tree l = TYPE_ARG_TYPES (t); l; l = TREE_CHAIN (l))
14149       {
14150         /* C++ FE uses TREE_PURPOSE to store initial values.  */
14151         if (TREE_PURPOSE (l) && in_lto_p)
14152           {
14153             error ("TREE_PURPOSE is non-NULL in TYPE_ARG_TYPES list");
14154             debug_tree (l);
14155             error_found = true;
14156           }
14157         if (!TYPE_P (TREE_VALUE (l)))
14158           {
14159             error ("Wrong entry in TYPE_ARG_TYPES list");
14160             debug_tree (l);
14161             error_found = true;
14162           }
14163       }
14164   else if (!is_lang_specific (t) && TYPE_VALUES_RAW (t))
14165     {
14166       error ("TYPE_VALUES_RAW field is non-NULL");
14167       debug_tree (TYPE_VALUES_RAW (t));
14168       error_found = true;
14169     }
14170   if (TREE_CODE (t) != INTEGER_TYPE
14171       && TREE_CODE (t) != BOOLEAN_TYPE
14172       && TREE_CODE (t) != OFFSET_TYPE
14173       && TREE_CODE (t) != REFERENCE_TYPE
14174       && TREE_CODE (t) != NULLPTR_TYPE
14175       && TREE_CODE (t) != POINTER_TYPE
14176       && TYPE_CACHED_VALUES_P (t))
14177     {
14178       error ("TYPE_CACHED_VALUES_P is set while it should not");
14179       error_found = true;
14180     }
14181   if (TYPE_STRING_FLAG (t)
14182       && TREE_CODE (t) != ARRAY_TYPE && TREE_CODE (t) != INTEGER_TYPE)
14183     {
14184       error ("TYPE_STRING_FLAG is set on wrong type code");
14185       error_found = true;
14186     }
14187   else if (TYPE_STRING_FLAG (t))
14188     {
14189       const_tree b = t;
14190       if (TREE_CODE (b) == ARRAY_TYPE)
14191         b = TREE_TYPE (t);
14192       /* Java builds arrays with TYPE_STRING_FLAG of promoted_char_type
14193          that is 32bits.  */
14194       if (TREE_CODE (b) != INTEGER_TYPE)
14195         {
14196           error ("TYPE_STRING_FLAG is set on type that does not look like "
14197                  "char nor array of chars");
14198           error_found = true;
14199         }
14200     }
14201
14202   /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always
14203      TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns
14204      of a type. */
14205   if (TREE_CODE (t) == METHOD_TYPE
14206       && TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t)) != TYPE_METHOD_BASETYPE (t))
14207     {
14208         error ("TYPE_METHOD_BASETYPE is not main variant");
14209         error_found = true;
14210     }
14211
14212   if (error_found)
14213     {
14214       debug_tree (const_cast <tree> (t));
14215       internal_error ("verify_type failed");
14216     }
14217 }
14218
14219
14220 /* Return 1 if ARG interpreted as signed in its precision is known to be
14221    always positive or 2 if ARG is known to be always negative, or 3 if
14222    ARG may be positive or negative.  */
14223
14224 int
14225 get_range_pos_neg (tree arg)
14226 {
14227   if (arg == error_mark_node)
14228     return 3;
14229
14230   int prec = TYPE_PRECISION (TREE_TYPE (arg));
14231   int cnt = 0;
14232   if (TREE_CODE (arg) == INTEGER_CST)
14233     {
14234       wide_int w = wi::sext (arg, prec);
14235       if (wi::neg_p (w))
14236         return 2;
14237       else
14238         return 1;
14239     }
14240   while (CONVERT_EXPR_P (arg)
14241          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
14242          && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg, 0))) <= prec)
14243     {
14244       arg = TREE_OPERAND (arg, 0);
14245       /* Narrower value zero extended into wider type
14246          will always result in positive values.  */
14247       if (TYPE_UNSIGNED (TREE_TYPE (arg))
14248           && TYPE_PRECISION (TREE_TYPE (arg)) < prec)
14249         return 1;
14250       prec = TYPE_PRECISION (TREE_TYPE (arg));
14251       if (++cnt > 30)
14252         return 3;
14253     }
14254
14255   if (TREE_CODE (arg) != SSA_NAME)
14256     return 3;
14257   wide_int arg_min, arg_max;
14258   while (get_range_info (arg, &arg_min, &arg_max) != VR_RANGE)
14259     {
14260       gimple *g = SSA_NAME_DEF_STMT (arg);
14261       if (is_gimple_assign (g)
14262           && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (g)))
14263         {
14264           tree t = gimple_assign_rhs1 (g);
14265           if (INTEGRAL_TYPE_P (TREE_TYPE (t))
14266               && TYPE_PRECISION (TREE_TYPE (t)) <= prec)
14267             {
14268               if (TYPE_UNSIGNED (TREE_TYPE (t))
14269                   && TYPE_PRECISION (TREE_TYPE (t)) < prec)
14270                 return 1;
14271               prec = TYPE_PRECISION (TREE_TYPE (t));
14272               arg = t;
14273               if (++cnt > 30)
14274                 return 3;
14275               continue;
14276             }
14277         }
14278       return 3;
14279     }
14280   if (TYPE_UNSIGNED (TREE_TYPE (arg)))
14281     {
14282       /* For unsigned values, the "positive" range comes
14283          below the "negative" range.  */
14284       if (!wi::neg_p (wi::sext (arg_max, prec), SIGNED))
14285         return 1;
14286       if (wi::neg_p (wi::sext (arg_min, prec), SIGNED))
14287         return 2;
14288     }
14289   else
14290     {
14291       if (!wi::neg_p (wi::sext (arg_min, prec), SIGNED))
14292         return 1;
14293       if (wi::neg_p (wi::sext (arg_max, prec), SIGNED))
14294         return 2;
14295     }
14296   return 3;
14297 }
14298
14299
14300
14301
14302 /* Return true if ARG is marked with the nonnull attribute in the
14303    current function signature.  */
14304
14305 bool
14306 nonnull_arg_p (const_tree arg)
14307 {
14308   tree t, attrs, fntype;
14309   unsigned HOST_WIDE_INT arg_num;
14310
14311   gcc_assert (TREE_CODE (arg) == PARM_DECL
14312               && (POINTER_TYPE_P (TREE_TYPE (arg))
14313                   || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE));
14314
14315   /* The static chain decl is always non null.  */
14316   if (arg == cfun->static_chain_decl)
14317     return true;
14318
14319   /* THIS argument of method is always non-NULL.  */
14320   if (TREE_CODE (TREE_TYPE (cfun->decl)) == METHOD_TYPE
14321       && arg == DECL_ARGUMENTS (cfun->decl)
14322       && flag_delete_null_pointer_checks)
14323     return true;
14324
14325   /* Values passed by reference are always non-NULL.  */
14326   if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE
14327       && flag_delete_null_pointer_checks)
14328     return true;
14329
14330   fntype = TREE_TYPE (cfun->decl);
14331   for (attrs = TYPE_ATTRIBUTES (fntype); attrs; attrs = TREE_CHAIN (attrs))
14332     {
14333       attrs = lookup_attribute ("nonnull", attrs);
14334
14335       /* If "nonnull" wasn't specified, we know nothing about the argument.  */
14336       if (attrs == NULL_TREE)
14337         return false;
14338
14339       /* If "nonnull" applies to all the arguments, then ARG is non-null.  */
14340       if (TREE_VALUE (attrs) == NULL_TREE)
14341         return true;
14342
14343       /* Get the position number for ARG in the function signature.  */
14344       for (arg_num = 1, t = DECL_ARGUMENTS (cfun->decl);
14345            t;
14346            t = DECL_CHAIN (t), arg_num++)
14347         {
14348           if (t == arg)
14349             break;
14350         }
14351
14352       gcc_assert (t == arg);
14353
14354       /* Now see if ARG_NUM is mentioned in the nonnull list.  */
14355       for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
14356         {
14357           if (compare_tree_int (TREE_VALUE (t), arg_num) == 0)
14358             return true;
14359         }
14360     }
14361
14362   return false;
14363 }
14364
14365 /* Combine LOC and BLOCK to a combined adhoc loc, retaining any range
14366    information.  */
14367
14368 location_t
14369 set_block (location_t loc, tree block)
14370 {
14371   location_t pure_loc = get_pure_location (loc);
14372   source_range src_range = get_range_from_loc (line_table, loc);
14373   return COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, block);
14374 }
14375
14376 location_t
14377 set_source_range (tree expr, location_t start, location_t finish)
14378 {
14379   source_range src_range;
14380   src_range.m_start = start;
14381   src_range.m_finish = finish;
14382   return set_source_range (expr, src_range);
14383 }
14384
14385 location_t
14386 set_source_range (tree expr, source_range src_range)
14387 {
14388   if (!EXPR_P (expr))
14389     return UNKNOWN_LOCATION;
14390
14391   location_t pure_loc = get_pure_location (EXPR_LOCATION (expr));
14392   location_t adhoc = COMBINE_LOCATION_DATA (line_table,
14393                                             pure_loc,
14394                                             src_range,
14395                                             NULL);
14396   SET_EXPR_LOCATION (expr, adhoc);
14397   return adhoc;
14398 }
14399
14400 /* Return the name of combined function FN, for debugging purposes.  */
14401
14402 const char *
14403 combined_fn_name (combined_fn fn)
14404 {
14405   if (builtin_fn_p (fn))
14406     {
14407       tree fndecl = builtin_decl_explicit (as_builtin_fn (fn));
14408       return IDENTIFIER_POINTER (DECL_NAME (fndecl));
14409     }
14410   else
14411     return internal_fn_name (as_internal_fn (fn));
14412 }
14413
14414 /* Return a bitmap with a bit set corresponding to each argument in
14415    a function call type FNTYPE declared with attribute nonnull,
14416    or null if none of the function's argument are nonnull.  The caller
14417    must free the bitmap.  */
14418
14419 bitmap
14420 get_nonnull_args (const_tree fntype)
14421 {
14422   if (fntype == NULL_TREE)
14423     return NULL;
14424
14425   tree attrs = TYPE_ATTRIBUTES (fntype);
14426   if (!attrs)
14427     return NULL;
14428
14429   bitmap argmap = NULL;
14430
14431   /* A function declaration can specify multiple attribute nonnull,
14432      each with zero or more arguments.  The loop below creates a bitmap
14433      representing a union of all the arguments.  An empty (but non-null)
14434      bitmap means that all arguments have been declaraed nonnull.  */
14435   for ( ; attrs; attrs = TREE_CHAIN (attrs))
14436     {
14437       attrs = lookup_attribute ("nonnull", attrs);
14438       if (!attrs)
14439         break;
14440
14441       if (!argmap)
14442         argmap = BITMAP_ALLOC (NULL);
14443
14444       if (!TREE_VALUE (attrs))
14445         {
14446           /* Clear the bitmap in case a previous attribute nonnull
14447              set it and this one overrides it for all arguments.  */
14448           bitmap_clear (argmap);
14449           return argmap;
14450         }
14451
14452       /* Iterate over the indices of the format arguments declared nonnull
14453          and set a bit for each.  */
14454       for (tree idx = TREE_VALUE (attrs); idx; idx = TREE_CHAIN (idx))
14455         {
14456           unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (idx)) - 1;
14457           bitmap_set_bit (argmap, val);
14458         }
14459     }
14460
14461   return argmap;
14462 }
14463
14464 #if CHECKING_P
14465
14466 namespace selftest {
14467
14468 /* Selftests for tree.  */
14469
14470 /* Verify that integer constants are sane.  */
14471
14472 static void
14473 test_integer_constants ()
14474 {
14475   ASSERT_TRUE (integer_type_node != NULL);
14476   ASSERT_TRUE (build_int_cst (integer_type_node, 0) != NULL);
14477
14478   tree type = integer_type_node;
14479
14480   tree zero = build_zero_cst (type);
14481   ASSERT_EQ (INTEGER_CST, TREE_CODE (zero));
14482   ASSERT_EQ (type, TREE_TYPE (zero));
14483
14484   tree one = build_int_cst (type, 1);
14485   ASSERT_EQ (INTEGER_CST, TREE_CODE (one));
14486   ASSERT_EQ (type, TREE_TYPE (zero));
14487 }
14488
14489 /* Verify identifiers.  */
14490
14491 static void
14492 test_identifiers ()
14493 {
14494   tree identifier = get_identifier ("foo");
14495   ASSERT_EQ (3, IDENTIFIER_LENGTH (identifier));
14496   ASSERT_STREQ ("foo", IDENTIFIER_POINTER (identifier));
14497 }
14498
14499 /* Verify LABEL_DECL.  */
14500
14501 static void
14502 test_labels ()
14503 {
14504   tree identifier = get_identifier ("err");
14505   tree label_decl = build_decl (UNKNOWN_LOCATION, LABEL_DECL,
14506                                 identifier, void_type_node);
14507   ASSERT_EQ (-1, LABEL_DECL_UID (label_decl));
14508   ASSERT_FALSE (FORCED_LABEL (label_decl));
14509 }
14510
14511 /* Run all of the selftests within this file.  */
14512
14513 void
14514 tree_c_tests ()
14515 {
14516   test_integer_constants ();
14517   test_identifiers ();
14518   test_labels ();
14519 }
14520
14521 } // namespace selftest
14522
14523 #endif /* CHECKING_P */
14524
14525 #include "gt-tree.h"