gcc/tree.c

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