gcc/tree.c

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