gcc/tree.c

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