LCOV - code coverage report
Current view: top level - gcc - tree.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 5886 6924 85.0 %
Date: 2020-04-04 11:58:09 Functions: 382 426 89.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Language-independent node constructors for parse phase of GNU compiler.
       2                 :            :    Copyright (C) 1987-2020 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 "langhooks-def.h"
      58                 :            : #include "tree-diagnostic.h"
      59                 :            : #include "except.h"
      60                 :            : #include "builtins.h"
      61                 :            : #include "print-tree.h"
      62                 :            : #include "ipa-utils.h"
      63                 :            : #include "selftest.h"
      64                 :            : #include "stringpool.h"
      65                 :            : #include "attribs.h"
      66                 :            : #include "rtl.h"
      67                 :            : #include "regs.h"
      68                 :            : #include "tree-vector-builder.h"
      69                 :            : #include "gimple-fold.h"
      70                 :            : #include "escaped_string.h"
      71                 :            : 
      72                 :            : /* Tree code classes.  */
      73                 :            : 
      74                 :            : #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
      75                 :            : #define END_OF_BASE_TREE_CODES tcc_exceptional,
      76                 :            : 
      77                 :            : const enum tree_code_class tree_code_type[] = {
      78                 :            : #include "all-tree.def"
      79                 :            : };
      80                 :            : 
      81                 :            : #undef DEFTREECODE
      82                 :            : #undef END_OF_BASE_TREE_CODES
      83                 :            : 
      84                 :            : /* Table indexed by tree code giving number of expression
      85                 :            :    operands beyond the fixed part of the node structure.
      86                 :            :    Not used for types or decls.  */
      87                 :            : 
      88                 :            : #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
      89                 :            : #define END_OF_BASE_TREE_CODES 0,
      90                 :            : 
      91                 :            : const unsigned char tree_code_length[] = {
      92                 :            : #include "all-tree.def"
      93                 :            : };
      94                 :            : 
      95                 :            : #undef DEFTREECODE
      96                 :            : #undef END_OF_BASE_TREE_CODES
      97                 :            : 
      98                 :            : /* Names of tree components.
      99                 :            :    Used for printing out the tree and error messages.  */
     100                 :            : #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
     101                 :            : #define END_OF_BASE_TREE_CODES "@dummy",
     102                 :            : 
     103                 :            : static const char *const tree_code_name[] = {
     104                 :            : #include "all-tree.def"
     105                 :            : };
     106                 :            : 
     107                 :            : #undef DEFTREECODE
     108                 :            : #undef END_OF_BASE_TREE_CODES
     109                 :            : 
     110                 :            : /* Each tree code class has an associated string representation.
     111                 :            :    These must correspond to the tree_code_class entries.  */
     112                 :            : 
     113                 :            : const char *const tree_code_class_strings[] =
     114                 :            : {
     115                 :            :   "exceptional",
     116                 :            :   "constant",
     117                 :            :   "type",
     118                 :            :   "declaration",
     119                 :            :   "reference",
     120                 :            :   "comparison",
     121                 :            :   "unary",
     122                 :            :   "binary",
     123                 :            :   "statement",
     124                 :            :   "vl_exp",
     125                 :            :   "expression"
     126                 :            : };
     127                 :            : 
     128                 :            : /* obstack.[ch] explicitly declined to prototype this.  */
     129                 :            : extern int _obstack_allocated_p (struct obstack *h, void *obj);
     130                 :            : 
     131                 :            : /* Statistics-gathering stuff.  */
     132                 :            : 
     133                 :            : static uint64_t tree_code_counts[MAX_TREE_CODES];
     134                 :            : uint64_t tree_node_counts[(int) all_kinds];
     135                 :            : uint64_t tree_node_sizes[(int) all_kinds];
     136                 :            : 
     137                 :            : /* Keep in sync with tree.h:enum tree_node_kind.  */
     138                 :            : static const char * const tree_node_kind_names[] = {
     139                 :            :   "decls",
     140                 :            :   "types",
     141                 :            :   "blocks",
     142                 :            :   "stmts",
     143                 :            :   "refs",
     144                 :            :   "exprs",
     145                 :            :   "constants",
     146                 :            :   "identifiers",
     147                 :            :   "vecs",
     148                 :            :   "binfos",
     149                 :            :   "ssa names",
     150                 :            :   "constructors",
     151                 :            :   "random kinds",
     152                 :            :   "lang_decl kinds",
     153                 :            :   "lang_type kinds",
     154                 :            :   "omp clauses",
     155                 :            : };
     156                 :            : 
     157                 :            : /* Unique id for next decl created.  */
     158                 :            : static GTY(()) int next_decl_uid;
     159                 :            : /* Unique id for next type created.  */
     160                 :            : static GTY(()) unsigned next_type_uid = 1;
     161                 :            : /* Unique id for next debug decl created.  Use negative numbers,
     162                 :            :    to catch erroneous uses.  */
     163                 :            : static GTY(()) int next_debug_decl_uid;
     164                 :            : 
     165                 :            : /* Since we cannot rehash a type after it is in the table, we have to
     166                 :            :    keep the hash code.  */
     167                 :            : 
     168                 :            : struct GTY((for_user)) type_hash {
     169                 :            :   unsigned long hash;
     170                 :            :   tree type;
     171                 :            : };
     172                 :            : 
     173                 :            : /* Initial size of the hash table (rounded to next prime).  */
     174                 :            : #define TYPE_HASH_INITIAL_SIZE 1000
     175                 :            : 
     176                 :            : struct type_cache_hasher : ggc_cache_ptr_hash<type_hash>
     177                 :            : {
     178                 : 1383370000 :   static hashval_t hash (type_hash *t) { return t->hash; }
     179                 :            :   static bool equal (type_hash *a, type_hash *b);
     180                 :            : 
     181                 :            :   static int
     182                 :  218556000 :   keep_cache_entry (type_hash *&t)
     183                 :            :   {
     184                 :  218556000 :     return ggc_marked_p (t->type);
     185                 :            :   }
     186                 :            : };
     187                 :            : 
     188                 :            : /* Now here is the hash table.  When recording a type, it is added to
     189                 :            :    the slot whose index is the hash code.  Note that the hash table is
     190                 :            :    used for several kinds of types (function types, array types and
     191                 :            :    array index range types, for now).  While all these live in the
     192                 :            :    same table, they are completely independent, and the hash code is
     193                 :            :    computed differently for each of these.  */
     194                 :            : 
     195                 :            : static GTY ((cache)) hash_table<type_cache_hasher> *type_hash_table;
     196                 :            : 
     197                 :            : /* Hash table and temporary node for larger integer const values.  */
     198                 :            : static GTY (()) tree int_cst_node;
     199                 :            : 
     200                 :            : struct int_cst_hasher : ggc_cache_ptr_hash<tree_node>
     201                 :            : {
     202                 :            :   static hashval_t hash (tree t);
     203                 :            :   static bool equal (tree x, tree y);
     204                 :            : };
     205                 :            : 
     206                 :            : static GTY ((cache)) hash_table<int_cst_hasher> *int_cst_hash_table;
     207                 :            : 
     208                 :            : /* Class and variable for making sure that there is a single POLY_INT_CST
     209                 :            :    for a given value.  */
     210                 :            : struct poly_int_cst_hasher : ggc_cache_ptr_hash<tree_node>
     211                 :            : {
     212                 :            :   typedef std::pair<tree, const poly_wide_int *> compare_type;
     213                 :            :   static hashval_t hash (tree t);
     214                 :            :   static bool equal (tree x, const compare_type &y);
     215                 :            : };
     216                 :            : 
     217                 :            : static GTY ((cache)) hash_table<poly_int_cst_hasher> *poly_int_cst_hash_table;
     218                 :            : 
     219                 :            : /* Hash table for optimization flags and target option flags.  Use the same
     220                 :            :    hash table for both sets of options.  Nodes for building the current
     221                 :            :    optimization and target option nodes.  The assumption is most of the time
     222                 :            :    the options created will already be in the hash table, so we avoid
     223                 :            :    allocating and freeing up a node repeatably.  */
     224                 :            : static GTY (()) tree cl_optimization_node;
     225                 :            : static GTY (()) tree cl_target_option_node;
     226                 :            : 
     227                 :            : struct cl_option_hasher : ggc_cache_ptr_hash<tree_node>
     228                 :            : {
     229                 :            :   static hashval_t hash (tree t);
     230                 :            :   static bool equal (tree x, tree y);
     231                 :            : };
     232                 :            : 
     233                 :            : static GTY ((cache)) hash_table<cl_option_hasher> *cl_option_hash_table;
     234                 :            : 
     235                 :            : /* General tree->tree mapping  structure for use in hash tables.  */
     236                 :            : 
     237                 :            : 
     238                 :            : static GTY ((cache))
     239                 :            :      hash_table<tree_decl_map_cache_hasher> *debug_expr_for_decl;
     240                 :            : 
     241                 :            : static GTY ((cache))
     242                 :            :      hash_table<tree_decl_map_cache_hasher> *value_expr_for_decl;
     243                 :            : 
     244                 :            : struct tree_vec_map_cache_hasher : ggc_cache_ptr_hash<tree_vec_map>
     245                 :            : {
     246                 :      87058 :   static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
     247                 :            : 
     248                 :            :   static bool
     249                 :     352575 :   equal (tree_vec_map *a, tree_vec_map *b)
     250                 :            :   {
     251                 :     352575 :     return a->base.from == b->base.from;
     252                 :            :   }
     253                 :            : 
     254                 :            :   static int
     255                 :      28592 :   keep_cache_entry (tree_vec_map *&m)
     256                 :            :   {
     257                 :      28592 :     return ggc_marked_p (m->base.from);
     258                 :            :   }
     259                 :            : };
     260                 :            : 
     261                 :            : static GTY ((cache))
     262                 :            :      hash_table<tree_vec_map_cache_hasher> *debug_args_for_decl;
     263                 :            : 
     264                 :            : static void set_type_quals (tree, int);
     265                 :            : static void print_type_hash_statistics (void);
     266                 :            : static void print_debug_expr_statistics (void);
     267                 :            : static void print_value_expr_statistics (void);
     268                 :            : 
     269                 :            : static tree build_array_type_1 (tree, tree, bool, bool, bool);
     270                 :            : 
     271                 :            : tree global_trees[TI_MAX];
     272                 :            : tree integer_types[itk_none];
     273                 :            : 
     274                 :            : bool int_n_enabled_p[NUM_INT_N_ENTS];
     275                 :            : struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS];
     276                 :            : 
     277                 :            : bool tree_contains_struct[MAX_TREE_CODES][64];
     278                 :            : 
     279                 :            : /* Number of operands for each OpenMP clause.  */
     280                 :            : unsigned const char omp_clause_num_ops[] =
     281                 :            : {
     282                 :            :   0, /* OMP_CLAUSE_ERROR  */
     283                 :            :   1, /* OMP_CLAUSE_PRIVATE  */
     284                 :            :   1, /* OMP_CLAUSE_SHARED  */
     285                 :            :   1, /* OMP_CLAUSE_FIRSTPRIVATE  */
     286                 :            :   2, /* OMP_CLAUSE_LASTPRIVATE  */
     287                 :            :   5, /* OMP_CLAUSE_REDUCTION  */
     288                 :            :   5, /* OMP_CLAUSE_TASK_REDUCTION  */
     289                 :            :   5, /* OMP_CLAUSE_IN_REDUCTION  */
     290                 :            :   1, /* OMP_CLAUSE_COPYIN  */
     291                 :            :   1, /* OMP_CLAUSE_COPYPRIVATE  */
     292                 :            :   3, /* OMP_CLAUSE_LINEAR  */
     293                 :            :   2, /* OMP_CLAUSE_ALIGNED  */
     294                 :            :   1, /* OMP_CLAUSE_DEPEND  */
     295                 :            :   1, /* OMP_CLAUSE_NONTEMPORAL  */
     296                 :            :   1, /* OMP_CLAUSE_UNIFORM  */
     297                 :            :   1, /* OMP_CLAUSE_TO_DECLARE  */
     298                 :            :   1, /* OMP_CLAUSE_LINK  */
     299                 :            :   2, /* OMP_CLAUSE_FROM  */
     300                 :            :   2, /* OMP_CLAUSE_TO  */
     301                 :            :   2, /* OMP_CLAUSE_MAP  */
     302                 :            :   1, /* OMP_CLAUSE_USE_DEVICE_PTR  */
     303                 :            :   1, /* OMP_CLAUSE_USE_DEVICE_ADDR  */
     304                 :            :   1, /* OMP_CLAUSE_IS_DEVICE_PTR  */
     305                 :            :   1, /* OMP_CLAUSE_INCLUSIVE  */
     306                 :            :   1, /* OMP_CLAUSE_EXCLUSIVE  */
     307                 :            :   2, /* OMP_CLAUSE__CACHE_  */
     308                 :            :   2, /* OMP_CLAUSE_GANG  */
     309                 :            :   1, /* OMP_CLAUSE_ASYNC  */
     310                 :            :   1, /* OMP_CLAUSE_WAIT  */
     311                 :            :   0, /* OMP_CLAUSE_AUTO  */
     312                 :            :   0, /* OMP_CLAUSE_SEQ  */
     313                 :            :   1, /* OMP_CLAUSE__LOOPTEMP_  */
     314                 :            :   1, /* OMP_CLAUSE__REDUCTEMP_  */
     315                 :            :   1, /* OMP_CLAUSE__CONDTEMP_  */
     316                 :            :   1, /* OMP_CLAUSE__SCANTEMP_  */
     317                 :            :   1, /* OMP_CLAUSE_IF  */
     318                 :            :   1, /* OMP_CLAUSE_NUM_THREADS  */
     319                 :            :   1, /* OMP_CLAUSE_SCHEDULE  */
     320                 :            :   0, /* OMP_CLAUSE_NOWAIT  */
     321                 :            :   1, /* OMP_CLAUSE_ORDERED  */
     322                 :            :   0, /* OMP_CLAUSE_DEFAULT  */
     323                 :            :   3, /* OMP_CLAUSE_COLLAPSE  */
     324                 :            :   0, /* OMP_CLAUSE_UNTIED   */
     325                 :            :   1, /* OMP_CLAUSE_FINAL  */
     326                 :            :   0, /* OMP_CLAUSE_MERGEABLE  */
     327                 :            :   1, /* OMP_CLAUSE_DEVICE  */
     328                 :            :   1, /* OMP_CLAUSE_DIST_SCHEDULE  */
     329                 :            :   0, /* OMP_CLAUSE_INBRANCH  */
     330                 :            :   0, /* OMP_CLAUSE_NOTINBRANCH  */
     331                 :            :   1, /* OMP_CLAUSE_NUM_TEAMS  */
     332                 :            :   1, /* OMP_CLAUSE_THREAD_LIMIT  */
     333                 :            :   0, /* OMP_CLAUSE_PROC_BIND  */
     334                 :            :   1, /* OMP_CLAUSE_SAFELEN  */
     335                 :            :   1, /* OMP_CLAUSE_SIMDLEN  */
     336                 :            :   0, /* OMP_CLAUSE_DEVICE_TYPE  */
     337                 :            :   0, /* OMP_CLAUSE_FOR  */
     338                 :            :   0, /* OMP_CLAUSE_PARALLEL  */
     339                 :            :   0, /* OMP_CLAUSE_SECTIONS  */
     340                 :            :   0, /* OMP_CLAUSE_TASKGROUP  */
     341                 :            :   1, /* OMP_CLAUSE_PRIORITY  */
     342                 :            :   1, /* OMP_CLAUSE_GRAINSIZE  */
     343                 :            :   1, /* OMP_CLAUSE_NUM_TASKS  */
     344                 :            :   0, /* OMP_CLAUSE_NOGROUP  */
     345                 :            :   0, /* OMP_CLAUSE_THREADS  */
     346                 :            :   0, /* OMP_CLAUSE_SIMD  */
     347                 :            :   1, /* OMP_CLAUSE_HINT  */
     348                 :            :   0, /* OMP_CLAUSE_DEFAULTMAP  */
     349                 :            :   0, /* OMP_CLAUSE_ORDER  */
     350                 :            :   0, /* OMP_CLAUSE_BIND  */
     351                 :            :   1, /* OMP_CLAUSE__SIMDUID_  */
     352                 :            :   0, /* OMP_CLAUSE__SIMT_  */
     353                 :            :   0, /* OMP_CLAUSE_INDEPENDENT  */
     354                 :            :   1, /* OMP_CLAUSE_WORKER  */
     355                 :            :   1, /* OMP_CLAUSE_VECTOR  */
     356                 :            :   1, /* OMP_CLAUSE_NUM_GANGS  */
     357                 :            :   1, /* OMP_CLAUSE_NUM_WORKERS  */
     358                 :            :   1, /* OMP_CLAUSE_VECTOR_LENGTH  */
     359                 :            :   3, /* OMP_CLAUSE_TILE  */
     360                 :            :   2, /* OMP_CLAUSE__GRIDDIM_  */
     361                 :            :   0, /* OMP_CLAUSE_IF_PRESENT */
     362                 :            :   0, /* OMP_CLAUSE_FINALIZE */
     363                 :            : };
     364                 :            : 
     365                 :            : const char * const omp_clause_code_name[] =
     366                 :            : {
     367                 :            :   "error_clause",
     368                 :            :   "private",
     369                 :            :   "shared",
     370                 :            :   "firstprivate",
     371                 :            :   "lastprivate",
     372                 :            :   "reduction",
     373                 :            :   "task_reduction",
     374                 :            :   "in_reduction",
     375                 :            :   "copyin",
     376                 :            :   "copyprivate",
     377                 :            :   "linear",
     378                 :            :   "aligned",
     379                 :            :   "depend",
     380                 :            :   "nontemporal",
     381                 :            :   "uniform",
     382                 :            :   "to",
     383                 :            :   "link",
     384                 :            :   "from",
     385                 :            :   "to",
     386                 :            :   "map",
     387                 :            :   "use_device_ptr",
     388                 :            :   "use_device_addr",
     389                 :            :   "is_device_ptr",
     390                 :            :   "inclusive",
     391                 :            :   "exclusive",
     392                 :            :   "_cache_",
     393                 :            :   "gang",
     394                 :            :   "async",
     395                 :            :   "wait",
     396                 :            :   "auto",
     397                 :            :   "seq",
     398                 :            :   "_looptemp_",
     399                 :            :   "_reductemp_",
     400                 :            :   "_condtemp_",
     401                 :            :   "_scantemp_",
     402                 :            :   "if",
     403                 :            :   "num_threads",
     404                 :            :   "schedule",
     405                 :            :   "nowait",
     406                 :            :   "ordered",
     407                 :            :   "default",
     408                 :            :   "collapse",
     409                 :            :   "untied",
     410                 :            :   "final",
     411                 :            :   "mergeable",
     412                 :            :   "device",
     413                 :            :   "dist_schedule",
     414                 :            :   "inbranch",
     415                 :            :   "notinbranch",
     416                 :            :   "num_teams",
     417                 :            :   "thread_limit",
     418                 :            :   "proc_bind",
     419                 :            :   "safelen",
     420                 :            :   "simdlen",
     421                 :            :   "device_type",
     422                 :            :   "for",
     423                 :            :   "parallel",
     424                 :            :   "sections",
     425                 :            :   "taskgroup",
     426                 :            :   "priority",
     427                 :            :   "grainsize",
     428                 :            :   "num_tasks",
     429                 :            :   "nogroup",
     430                 :            :   "threads",
     431                 :            :   "simd",
     432                 :            :   "hint",
     433                 :            :   "defaultmap",
     434                 :            :   "order",
     435                 :            :   "bind",
     436                 :            :   "_simduid_",
     437                 :            :   "_simt_",
     438                 :            :   "independent",
     439                 :            :   "worker",
     440                 :            :   "vector",
     441                 :            :   "num_gangs",
     442                 :            :   "num_workers",
     443                 :            :   "vector_length",
     444                 :            :   "tile",
     445                 :            :   "_griddim_",
     446                 :            :   "if_present",
     447                 :            :   "finalize",
     448                 :            : };
     449                 :            : 
     450                 :            : 
     451                 :            : /* Return the tree node structure used by tree code CODE.  */
     452                 :            : 
     453                 :            : static inline enum tree_node_structure_enum
     454                 : 6597680000 : tree_node_structure_for_code (enum tree_code code)
     455                 :            : {
     456                 : 6597680000 :   switch (TREE_CODE_CLASS (code))
     457                 :            :     {
     458                 : 1552070000 :     case tcc_declaration:
     459                 : 1552070000 :       switch (code)
     460                 :            :         {
     461                 :            :         case CONST_DECL:        return TS_CONST_DECL;
     462                 :            :         case DEBUG_EXPR_DECL:   return TS_DECL_WRTL;
     463                 :            :         case FIELD_DECL:        return TS_FIELD_DECL;
     464                 :            :         case FUNCTION_DECL:     return TS_FUNCTION_DECL;
     465                 :            :         case LABEL_DECL:        return TS_LABEL_DECL;
     466                 :            :         case PARM_DECL:         return TS_PARM_DECL;
     467                 :            :         case RESULT_DECL:       return TS_RESULT_DECL;
     468                 :            :         case TRANSLATION_UNIT_DECL: return TS_TRANSLATION_UNIT_DECL;
     469                 :            :         case TYPE_DECL:         return TS_TYPE_DECL;
     470                 :            :         case VAR_DECL:          return TS_VAR_DECL;
     471                 :            :         default:                return TS_DECL_NON_COMMON;
     472                 :            :         }
     473                 :            : 
     474                 :            :     case tcc_type:              return TS_TYPE_NON_COMMON;
     475                 :            : 
     476                 : 1507780000 :     case tcc_binary:
     477                 : 1507780000 :     case tcc_comparison:
     478                 : 1507780000 :     case tcc_expression:
     479                 : 1507780000 :     case tcc_reference:
     480                 : 1507780000 :     case tcc_statement:
     481                 : 1507780000 :     case tcc_unary:
     482                 : 1507780000 :     case tcc_vl_exp:            return TS_EXP;
     483                 :            : 
     484                 : 2739270000 :     default:  /* tcc_constant and tcc_exceptional */
     485                 : 2739270000 :       break;
     486                 :            :     }
     487                 :            : 
     488                 : 2739270000 :   switch (code)
     489                 :            :     {
     490                 :            :       /* tcc_constant cases.  */
     491                 :            :     case COMPLEX_CST:           return TS_COMPLEX;
     492                 :     200773 :     case FIXED_CST:             return TS_FIXED_CST;
     493                 :  445342000 :     case INTEGER_CST:           return TS_INT_CST;
     494                 :     200773 :     case POLY_INT_CST:          return TS_POLY_INT_CST;
     495                 :    5411630 :     case REAL_CST:              return TS_REAL_CST;
     496                 :   34791300 :     case STRING_CST:            return TS_STRING;
     497                 :    2741700 :     case VECTOR_CST:            return TS_VECTOR;
     498                 :     616438 :     case VOID_CST:              return TS_TYPED;
     499                 :            : 
     500                 :            :       /* tcc_exceptional cases.  */
     501                 :  142055000 :     case BLOCK:                 return TS_BLOCK;
     502                 :   43350500 :     case CONSTRUCTOR:           return TS_CONSTRUCTOR;
     503                 :    1133430 :     case ERROR_MARK:            return TS_COMMON;
     504                 :    3748440 :     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
     505                 :     381819 :     case OMP_CLAUSE:            return TS_OMP_CLAUSE;
     506                 :    1039880 :     case OPTIMIZATION_NODE:     return TS_OPTIMIZATION;
     507                 :     200773 :     case PLACEHOLDER_EXPR:      return TS_COMMON;
     508                 :  154077000 :     case SSA_NAME:              return TS_SSA_NAME;
     509                 :   74047300 :     case STATEMENT_LIST:        return TS_STATEMENT_LIST;
     510                 :    1256600 :     case TARGET_OPTION_NODE:    return TS_TARGET_OPTION;
     511                 :   63055300 :     case TREE_BINFO:            return TS_BINFO;
     512                 : 1395340000 :     case TREE_LIST:             return TS_LIST;
     513                 :  369935000 :     case TREE_VEC:              return TS_VEC;
     514                 :            : 
     515                 :          0 :     default:
     516                 :          0 :       gcc_unreachable ();
     517                 :            :     }
     518                 :            : }
     519                 :            : 
     520                 :            : 
     521                 :            : /* Initialize tree_contains_struct to describe the hierarchy of tree
     522                 :            :    nodes.  */
     523                 :            : 
     524                 :            : static void
     525                 :     200773 : initialize_tree_contains_struct (void)
     526                 :            : {
     527                 :     200773 :   unsigned i;
     528                 :            : 
     529                 :   46378600 :   for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
     530                 :            :     {
     531                 :   46177800 :       enum tree_code code;
     532                 :   46177800 :       enum tree_node_structure_enum ts_code;
     533                 :            : 
     534                 :   46177800 :       code = (enum tree_code) i;
     535                 :   46177800 :       ts_code = tree_node_structure_for_code (code);
     536                 :            : 
     537                 :            :       /* Mark the TS structure itself.  */
     538                 :   46177800 :       tree_contains_struct[code][ts_code] = 1;
     539                 :            : 
     540                 :            :       /* Mark all the structures that TS is derived from.  */
     541                 :   46177800 :       switch (ts_code)
     542                 :            :         {
     543                 :     803092 :         case TS_TYPED:
     544                 :     803092 :         case TS_BLOCK:
     545                 :     803092 :         case TS_OPTIMIZATION:
     546                 :     803092 :         case TS_TARGET_OPTION:
     547                 :     803092 :           MARK_TS_BASE (code);
     548                 :     803092 :           break;
     549                 :            : 
     550                 :   37946100 :         case TS_COMMON:
     551                 :   37946100 :         case TS_INT_CST:
     552                 :   37946100 :         case TS_POLY_INT_CST:
     553                 :   37946100 :         case TS_REAL_CST:
     554                 :   37946100 :         case TS_FIXED_CST:
     555                 :   37946100 :         case TS_VECTOR:
     556                 :   37946100 :         case TS_STRING:
     557                 :   37946100 :         case TS_COMPLEX:
     558                 :   37946100 :         case TS_SSA_NAME:
     559                 :   37946100 :         case TS_CONSTRUCTOR:
     560                 :   37946100 :         case TS_EXP:
     561                 :   37946100 :         case TS_STATEMENT_LIST:
     562                 :   37946100 :           MARK_TS_TYPED (code);
     563                 :   37946100 :           break;
     564                 :            : 
     565                 :    1003860 :         case TS_IDENTIFIER:
     566                 :    1003860 :         case TS_DECL_MINIMAL:
     567                 :    1003860 :         case TS_TYPE_COMMON:
     568                 :    1003860 :         case TS_LIST:
     569                 :    1003860 :         case TS_VEC:
     570                 :    1003860 :         case TS_BINFO:
     571                 :    1003860 :         case TS_OMP_CLAUSE:
     572                 :    1003860 :           MARK_TS_COMMON (code);
     573                 :    1003860 :           break;
     574                 :            : 
     575                 :          0 :         case TS_TYPE_WITH_LANG_SPECIFIC:
     576                 :          0 :           MARK_TS_TYPE_COMMON (code);
     577                 :          0 :           break;
     578                 :            : 
     579                 :    3814690 :         case TS_TYPE_NON_COMMON:
     580                 :    3814690 :           MARK_TS_TYPE_WITH_LANG_SPECIFIC (code);
     581                 :    3814690 :           break;
     582                 :            : 
     583                 :          0 :         case TS_DECL_COMMON:
     584                 :          0 :           MARK_TS_DECL_MINIMAL (code);
     585                 :          0 :           break;
     586                 :            : 
     587                 :     401546 :         case TS_DECL_WRTL:
     588                 :     401546 :         case TS_CONST_DECL:
     589                 :     401546 :           MARK_TS_DECL_COMMON (code);
     590                 :     401546 :           break;
     591                 :            : 
     592                 :     602319 :         case TS_DECL_NON_COMMON:
     593                 :     602319 :           MARK_TS_DECL_WITH_VIS (code);
     594                 :     602319 :           break;
     595                 :            : 
     596                 :     602319 :         case TS_DECL_WITH_VIS:
     597                 :     602319 :         case TS_PARM_DECL:
     598                 :     602319 :         case TS_LABEL_DECL:
     599                 :     602319 :         case TS_RESULT_DECL:
     600                 :     602319 :           MARK_TS_DECL_WRTL (code);
     601                 :     602319 :           break;
     602                 :            : 
     603                 :     200773 :         case TS_FIELD_DECL:
     604                 :     200773 :           MARK_TS_DECL_COMMON (code);
     605                 :     200773 :           break;
     606                 :            : 
     607                 :     200773 :         case TS_VAR_DECL:
     608                 :     200773 :           MARK_TS_DECL_WITH_VIS (code);
     609                 :     200773 :           break;
     610                 :            : 
     611                 :     401546 :         case TS_TYPE_DECL:
     612                 :     401546 :         case TS_FUNCTION_DECL:
     613                 :     401546 :           MARK_TS_DECL_NON_COMMON (code);
     614                 :     401546 :           break;
     615                 :            : 
     616                 :     200773 :         case TS_TRANSLATION_UNIT_DECL:
     617                 :     200773 :           MARK_TS_DECL_COMMON (code);
     618                 :     200773 :           break;
     619                 :            : 
     620                 :          0 :         default:
     621                 :          0 :           gcc_unreachable ();
     622                 :            :         }
     623                 :            :     }
     624                 :            : 
     625                 :            :   /* Basic consistency checks for attributes used in fold.  */
     626                 :     200773 :   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
     627                 :     200773 :   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
     628                 :     200773 :   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
     629                 :     200773 :   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
     630                 :     200773 :   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
     631                 :     200773 :   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
     632                 :     200773 :   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
     633                 :     200773 :   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
     634                 :     200773 :   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
     635                 :     200773 :   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
     636                 :     200773 :   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
     637                 :     200773 :   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
     638                 :     200773 :   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
     639                 :     200773 :   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
     640                 :     200773 :   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
     641                 :     200773 :   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
     642                 :     200773 :   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
     643                 :     200773 :   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
     644                 :     200773 :   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
     645                 :     200773 :   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
     646                 :     200773 :   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
     647                 :     200773 :   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
     648                 :     200773 :   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
     649                 :     200773 :   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
     650                 :     200773 :   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
     651                 :     200773 :   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
     652                 :     200773 :   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
     653                 :     200773 :   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
     654                 :     200773 :   gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
     655                 :     200773 :   gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
     656                 :     200773 :   gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
     657                 :     200773 :   gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
     658                 :     200773 :   gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
     659                 :     200773 :   gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
     660                 :     200773 :   gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
     661                 :     200773 :   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
     662                 :     200773 :   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
     663                 :     200773 :   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
     664                 :     200773 :   gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
     665                 :     200773 :   gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
     666                 :     200773 : }
     667                 :            : 
     668                 :            : 
     669                 :            : /* Init tree.c.  */
     670                 :            : 
     671                 :            : void
     672                 :     200773 : init_ttree (void)
     673                 :            : {
     674                 :            :   /* Initialize the hash table of types.  */
     675                 :     200773 :   type_hash_table
     676                 :     200773 :     = hash_table<type_cache_hasher>::create_ggc (TYPE_HASH_INITIAL_SIZE);
     677                 :            : 
     678                 :     200773 :   debug_expr_for_decl
     679                 :     200773 :     = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
     680                 :            : 
     681                 :     200773 :   value_expr_for_decl
     682                 :     200773 :     = hash_table<tree_decl_map_cache_hasher>::create_ggc (512);
     683                 :            : 
     684                 :     200773 :   int_cst_hash_table = hash_table<int_cst_hasher>::create_ggc (1024);
     685                 :            : 
     686                 :     200773 :   poly_int_cst_hash_table = hash_table<poly_int_cst_hasher>::create_ggc (64);
     687                 :            : 
     688                 :     200773 :   int_cst_node = make_int_cst (1, 1);
     689                 :            : 
     690                 :     200773 :   cl_option_hash_table = hash_table<cl_option_hasher>::create_ggc (64);
     691                 :            : 
     692                 :     200773 :   cl_optimization_node = make_node (OPTIMIZATION_NODE);
     693                 :     200773 :   cl_target_option_node = make_node (TARGET_OPTION_NODE);
     694                 :            : 
     695                 :            :   /* Initialize the tree_contains_struct array.  */
     696                 :     200773 :   initialize_tree_contains_struct ();
     697                 :     200773 :   lang_hooks.init_ts ();
     698                 :     200773 : }
     699                 :            : 
     700                 :            : 
     701                 :            : /* The name of the object as the assembler will see it (but before any
     702                 :            :    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
     703                 :            :    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
     704                 :            : tree
     705                 : 1726550000 : decl_assembler_name (tree decl)
     706                 :            : {
     707                 : 1726550000 :   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
     708                 :   52833400 :     lang_hooks.set_decl_assembler_name (decl);
     709                 : 1726550000 :   return DECL_ASSEMBLER_NAME_RAW (decl);
     710                 :            : }
     711                 :            : 
     712                 :            : /* The DECL_ASSEMBLER_NAME_RAW of DECL is being explicitly set to NAME
     713                 :            :    (either of which may be NULL).  Inform the FE, if this changes the
     714                 :            :    name.  */
     715                 :            : 
     716                 :            : void
     717                 :  224258000 : overwrite_decl_assembler_name (tree decl, tree name)
     718                 :            : {
     719                 :  224258000 :   if (DECL_ASSEMBLER_NAME_RAW (decl) != name)
     720                 :  170222000 :     lang_hooks.overwrite_decl_assembler_name (decl, name);
     721                 :  224258000 : }
     722                 :            : 
     723                 :            : /* When the target supports COMDAT groups, this indicates which group the
     724                 :            :    DECL is associated with.  This can be either an IDENTIFIER_NODE or a
     725                 :            :    decl, in which case its DECL_ASSEMBLER_NAME identifies the group.  */
     726                 :            : tree
     727                 :   61140900 : decl_comdat_group (const_tree node)
     728                 :            : {
     729                 :   61140900 :   struct symtab_node *snode = symtab_node::get (node);
     730                 :   61140900 :   if (!snode)
     731                 :            :     return NULL;
     732                 :   58996900 :   return snode->get_comdat_group ();
     733                 :            : }
     734                 :            : 
     735                 :            : /* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE.  */
     736                 :            : tree
     737                 :      12296 : decl_comdat_group_id (const_tree node)
     738                 :            : {
     739                 :      12296 :   struct symtab_node *snode = symtab_node::get (node);
     740                 :      12296 :   if (!snode)
     741                 :            :     return NULL;
     742                 :      24592 :   return snode->get_comdat_group_id ();
     743                 :            : }
     744                 :            : 
     745                 :            : /* When the target supports named section, return its name as IDENTIFIER_NODE
     746                 :            :    or NULL if it is in no section.  */
     747                 :            : const char *
     748                 :  353745000 : decl_section_name (const_tree node)
     749                 :            : {
     750                 :  353745000 :   struct symtab_node *snode = symtab_node::get (node);
     751                 :  353745000 :   if (!snode)
     752                 :            :     return NULL;
     753                 :  349198000 :   return snode->get_section ();
     754                 :            : }
     755                 :            : 
     756                 :            : /* Set section name of NODE to VALUE (that is expected to be
     757                 :            :    identifier node) */
     758                 :            : void
     759                 :    5951070 : set_decl_section_name (tree node, const char *value)
     760                 :            : {
     761                 :    5951070 :   struct symtab_node *snode;
     762                 :            : 
     763                 :    5951070 :   if (value == NULL)
     764                 :            :     {
     765                 :    4437970 :       snode = symtab_node::get (node);
     766                 :    4437970 :       if (!snode)
     767                 :            :         return;
     768                 :            :     }
     769                 :    1513100 :   else if (VAR_P (node))
     770                 :    1327020 :     snode = varpool_node::get_create (node);
     771                 :            :   else
     772                 :     186074 :     snode = cgraph_node::get_create (node);
     773                 :    5570800 :   snode->set_section (value);
     774                 :            : }
     775                 :            : 
     776                 :            : /* Return TLS model of a variable NODE.  */
     777                 :            : enum tls_model
     778                 :  138756000 : decl_tls_model (const_tree node)
     779                 :            : {
     780                 :  138756000 :   struct varpool_node *snode = varpool_node::get (node);
     781                 :  138756000 :   if (!snode)
     782                 :            :     return TLS_MODEL_NONE;
     783                 :  127801000 :   return snode->tls_model;
     784                 :            : }
     785                 :            : 
     786                 :            : /* Set TLS model of variable NODE to MODEL.  */
     787                 :            : void
     788                 :       9799 : set_decl_tls_model (tree node, enum tls_model model)
     789                 :            : {
     790                 :       9799 :   struct varpool_node *vnode;
     791                 :            : 
     792                 :       9799 :   if (model == TLS_MODEL_NONE)
     793                 :            :     {
     794                 :       3732 :       vnode = varpool_node::get (node);
     795                 :       3732 :       if (!vnode)
     796                 :            :         return;
     797                 :            :     }
     798                 :            :   else
     799                 :       6067 :     vnode = varpool_node::get_create (node);
     800                 :       6067 :   vnode->tls_model = model;
     801                 :            : }
     802                 :            : 
     803                 :            : /* Compute the number of bytes occupied by a tree with code CODE.
     804                 :            :    This function cannot be used for nodes that have variable sizes,
     805                 :            :    including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR.  */
     806                 :            : size_t
     807                 : 3763620000 : tree_code_size (enum tree_code code)
     808                 :            : {
     809                 : 3763620000 :   switch (TREE_CODE_CLASS (code))
     810                 :            :     {
     811                 :  995233000 :     case tcc_declaration:  /* A decl node */
     812                 :  995233000 :       switch (code)
     813                 :            :         {
     814                 :            :         case FIELD_DECL:        return sizeof (tree_field_decl);
     815                 :  173130000 :         case PARM_DECL:         return sizeof (tree_parm_decl);
     816                 :   57896400 :         case VAR_DECL:          return sizeof (tree_var_decl);
     817                 :   17019100 :         case LABEL_DECL:        return sizeof (tree_label_decl);
     818                 :   43172800 :         case RESULT_DECL:       return sizeof (tree_result_decl);
     819                 :    8132010 :         case CONST_DECL:        return sizeof (tree_const_decl);
     820                 :            :         case TYPE_DECL:         return sizeof (tree_type_decl);
     821                 :  557756000 :         case FUNCTION_DECL:     return sizeof (tree_function_decl);
     822                 :    1371290 :         case DEBUG_EXPR_DECL:   return sizeof (tree_decl_with_rtl);
     823                 :     195799 :         case TRANSLATION_UNIT_DECL: return sizeof (tree_translation_unit_decl);
     824                 :            :         case NAMESPACE_DECL:
     825                 :            :         case IMPORTED_DECL:
     826                 :            :         case NAMELIST_DECL:     return sizeof (tree_decl_non_common);
     827                 :   24829400 :         default:
     828                 :   24829400 :           gcc_checking_assert (code >= NUM_TREE_CODES);
     829                 :   24829400 :           return lang_hooks.tree_size (code);
     830                 :            :         }
     831                 :            : 
     832                 :  615085000 :     case tcc_type:  /* a type node */
     833                 :  615085000 :       switch (code)
     834                 :            :         {
     835                 :            :         case OFFSET_TYPE:
     836                 :            :         case ENUMERAL_TYPE:
     837                 :            :         case BOOLEAN_TYPE:
     838                 :            :         case INTEGER_TYPE:
     839                 :            :         case REAL_TYPE:
     840                 :            :         case POINTER_TYPE:
     841                 :            :         case REFERENCE_TYPE:
     842                 :            :         case NULLPTR_TYPE:
     843                 :            :         case FIXED_POINT_TYPE:
     844                 :            :         case COMPLEX_TYPE:
     845                 :            :         case VECTOR_TYPE:
     846                 :            :         case ARRAY_TYPE:
     847                 :            :         case RECORD_TYPE:
     848                 :            :         case UNION_TYPE:
     849                 :            :         case QUAL_UNION_TYPE:
     850                 :            :         case VOID_TYPE:
     851                 :            :         case FUNCTION_TYPE:
     852                 :            :         case METHOD_TYPE:
     853                 :            :         case LANG_TYPE:         return sizeof (tree_type_non_common);
     854                 :   88228700 :         default:
     855                 :   88228700 :           gcc_checking_assert (code >= NUM_TREE_CODES);
     856                 :   88228700 :           return lang_hooks.tree_size (code);
     857                 :            :         }
     858                 :            : 
     859                 :  699529000 :     case tcc_reference:   /* a reference */
     860                 :  699529000 :     case tcc_expression:  /* an expression */
     861                 :  699529000 :     case tcc_statement:   /* an expression with side effects */
     862                 :  699529000 :     case tcc_comparison:  /* a comparison expression */
     863                 :  699529000 :     case tcc_unary:       /* a unary arithmetic expression */
     864                 :  699529000 :     case tcc_binary:      /* a binary arithmetic expression */
     865                 :  699529000 :       return (sizeof (struct tree_exp)
     866                 :  699529000 :               + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
     867                 :            : 
     868                 :    7663750 :     case tcc_constant:  /* a constant */
     869                 :    7663750 :       switch (code)
     870                 :            :         {
     871                 :            :         case VOID_CST:          return sizeof (tree_typed);
     872                 :          0 :         case INTEGER_CST:       gcc_unreachable ();
     873                 :          0 :         case POLY_INT_CST:      return sizeof (tree_poly_int_cst);
     874                 :    6976470 :         case REAL_CST:          return sizeof (tree_real_cst);
     875                 :         57 :         case FIXED_CST:         return sizeof (tree_fixed_cst);
     876                 :     479499 :         case COMPLEX_CST:       return sizeof (tree_complex);
     877                 :          0 :         case VECTOR_CST:        gcc_unreachable ();
     878                 :          0 :         case STRING_CST:        gcc_unreachable ();
     879                 :       7186 :         default:
     880                 :       7186 :           gcc_checking_assert (code >= NUM_TREE_CODES);
     881                 :       7186 :           return lang_hooks.tree_size (code);
     882                 :            :         }
     883                 :            : 
     884                 : 1446110000 :     case tcc_exceptional:  /* something random, like an identifier.  */
     885                 : 1446110000 :       switch (code)
     886                 :            :         {
     887                 :  789612000 :         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
     888                 :            :         case TREE_LIST:         return sizeof (tree_list);
     889                 :            : 
     890                 :     207573 :         case ERROR_MARK:
     891                 :     207573 :         case PLACEHOLDER_EXPR:  return sizeof (tree_common);
     892                 :            : 
     893                 :          0 :         case TREE_VEC:          gcc_unreachable ();
     894                 :          0 :         case OMP_CLAUSE:        gcc_unreachable ();
     895                 :            : 
     896                 :  122120000 :         case SSA_NAME:          return sizeof (tree_ssa_name);
     897                 :            : 
     898                 :   35207600 :         case STATEMENT_LIST:    return sizeof (tree_statement_list);
     899                 :   68105600 :         case BLOCK:             return sizeof (struct tree_block);
     900                 :   26669600 :         case CONSTRUCTOR:       return sizeof (tree_constructor);
     901                 :     417375 :         case OPTIMIZATION_NODE: return sizeof (tree_optimization_option);
     902                 :     657978 :         case TARGET_OPTION_NODE: return sizeof (tree_target_option);
     903                 :            : 
     904                 :  206233000 :         default:
     905                 :  206233000 :           gcc_checking_assert (code >= NUM_TREE_CODES);
     906                 :  206233000 :           return lang_hooks.tree_size (code);
     907                 :            :         }
     908                 :            : 
     909                 :          0 :     default:
     910                 :          0 :       gcc_unreachable ();
     911                 :            :     }
     912                 :            : }
     913                 :            : 
     914                 :            : /* Compute the number of bytes occupied by NODE.  This routine only
     915                 :            :    looks at TREE_CODE, except for those nodes that have variable sizes.  */
     916                 :            : size_t
     917                 :  599656000 : tree_size (const_tree node)
     918                 :            : {
     919                 :  599656000 :   const enum tree_code code = TREE_CODE (node);
     920                 :  599656000 :   switch (code)
     921                 :            :     {
     922                 :    2356880 :     case INTEGER_CST:
     923                 :    2356880 :       return (sizeof (struct tree_int_cst)
     924                 :    2356880 :               + (TREE_INT_CST_EXT_NUNITS (node) - 1) * sizeof (HOST_WIDE_INT));
     925                 :            : 
     926                 :          0 :     case TREE_BINFO:
     927                 :          0 :       return (offsetof (struct tree_binfo, base_binfos)
     928                 :            :               + vec<tree, va_gc>
     929                 :          0 :                   ::embedded_size (BINFO_N_BASE_BINFOS (node)));
     930                 :            : 
     931                 :   25864000 :     case TREE_VEC:
     932                 :   25864000 :       return (sizeof (struct tree_vec)
     933                 :   25864000 :               + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
     934                 :            : 
     935                 :          0 :     case VECTOR_CST:
     936                 :          0 :       return (sizeof (struct tree_vector)
     937                 :          0 :               + (vector_cst_encoded_nelts (node) - 1) * sizeof (tree));
     938                 :            : 
     939                 :       1709 :     case STRING_CST:
     940                 :       1709 :       return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
     941                 :            : 
     942                 :      18969 :     case OMP_CLAUSE:
     943                 :      18969 :       return (sizeof (struct tree_omp_clause)
     944                 :      18969 :               + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
     945                 :      18969 :                 * sizeof (tree));
     946                 :            : 
     947                 :  571414000 :     default:
     948                 :  571414000 :       if (TREE_CODE_CLASS (code) == tcc_vl_exp)
     949                 :   28223800 :         return (sizeof (struct tree_exp)
     950                 :   28223800 :                 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
     951                 :            :       else
     952                 :  543190000 :         return tree_code_size (code);
     953                 :            :     }
     954                 :            : }
     955                 :            : 
     956                 :            : /* Return tree node kind based on tree CODE.  */
     957                 :            : 
     958                 :            : static tree_node_kind
     959                 :          0 : get_stats_node_kind (enum tree_code code)
     960                 :            : {
     961                 :          0 :   enum tree_code_class type = TREE_CODE_CLASS (code);
     962                 :            : 
     963                 :          0 :   switch (type)
     964                 :            :     {
     965                 :            :     case tcc_declaration:  /* A decl node */
     966                 :            :       return d_kind;
     967                 :          0 :     case tcc_type:  /* a type node */
     968                 :          0 :       return t_kind;
     969                 :          0 :     case tcc_statement:  /* an expression with side effects */
     970                 :          0 :       return s_kind;
     971                 :          0 :     case tcc_reference:  /* a reference */
     972                 :          0 :       return r_kind;
     973                 :          0 :     case tcc_expression:  /* an expression */
     974                 :          0 :     case tcc_comparison:  /* a comparison expression */
     975                 :          0 :     case tcc_unary:  /* a unary arithmetic expression */
     976                 :          0 :     case tcc_binary:  /* a binary arithmetic expression */
     977                 :          0 :       return e_kind;
     978                 :          0 :     case tcc_constant:  /* a constant */
     979                 :          0 :       return c_kind;
     980                 :          0 :     case tcc_exceptional:  /* something random, like an identifier.  */
     981                 :          0 :       switch (code)
     982                 :            :         {
     983                 :            :         case IDENTIFIER_NODE:
     984                 :            :           return id_kind;
     985                 :          0 :         case TREE_VEC:
     986                 :          0 :           return vec_kind;
     987                 :          0 :         case TREE_BINFO:
     988                 :          0 :           return binfo_kind;
     989                 :          0 :         case SSA_NAME:
     990                 :          0 :           return ssa_name_kind;
     991                 :          0 :         case BLOCK:
     992                 :          0 :           return b_kind;
     993                 :          0 :         case CONSTRUCTOR:
     994                 :          0 :           return constr_kind;
     995                 :          0 :         case OMP_CLAUSE:
     996                 :          0 :           return omp_clause_kind;
     997                 :          0 :         default:
     998                 :          0 :           return x_kind;
     999                 :            :         }
    1000                 :          0 :       break;
    1001                 :          0 :     case tcc_vl_exp:
    1002                 :          0 :       return e_kind;
    1003                 :          0 :     default:
    1004                 :          0 :       gcc_unreachable ();
    1005                 :            :     }
    1006                 :            : }
    1007                 :            : 
    1008                 :            : /* Record interesting allocation statistics for a tree node with CODE
    1009                 :            :    and LENGTH.  */
    1010                 :            : 
    1011                 :            : static void
    1012                 : 6944010000 : record_node_allocation_statistics (enum tree_code code, size_t length)
    1013                 :            : {
    1014                 : 6944010000 :   if (!GATHER_STATISTICS)
    1015                 : 6944010000 :     return;
    1016                 :            : 
    1017                 :            :   tree_node_kind kind = get_stats_node_kind (code);
    1018                 :            : 
    1019                 :            :   tree_code_counts[(int) code]++;
    1020                 :            :   tree_node_counts[(int) kind]++;
    1021                 :            :   tree_node_sizes[(int) kind] += length;
    1022                 :            : }
    1023                 :            : 
    1024                 :            : /* Allocate and return a new UID from the DECL_UID namespace.  */
    1025                 :            : 
    1026                 :            : int
    1027                 :  991959000 : allocate_decl_uid (void)
    1028                 :            : {
    1029                 :  991959000 :   return next_decl_uid++;
    1030                 :            : }
    1031                 :            : 
    1032                 :            : /* Return a newly allocated node of code CODE.  For decl and type
    1033                 :            :    nodes, some other fields are initialized.  The rest of the node is
    1034                 :            :    initialized to zero.  This function cannot be used for TREE_VEC,
    1035                 :            :    INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in
    1036                 :            :    tree_code_size.
    1037                 :            : 
    1038                 :            :    Achoo!  I got a code in the node.  */
    1039                 :            : 
    1040                 :            : tree
    1041                 : 3217880000 : make_node (enum tree_code code MEM_STAT_DECL)
    1042                 :            : {
    1043                 : 3217880000 :   tree t;
    1044                 : 3217880000 :   enum tree_code_class type = TREE_CODE_CLASS (code);
    1045                 : 3217880000 :   size_t length = tree_code_size (code);
    1046                 :            : 
    1047                 : 3217880000 :   record_node_allocation_statistics (code, length);
    1048                 :            : 
    1049                 : 3217880000 :   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
    1050                 : 3217880000 :   TREE_SET_CODE (t, code);
    1051                 :            : 
    1052                 : 3217880000 :   switch (type)
    1053                 :            :     {
    1054                 :   68977600 :     case tcc_statement:
    1055                 :   68977600 :       if (code != DEBUG_BEGIN_STMT)
    1056                 :   52071600 :         TREE_SIDE_EFFECTS (t) = 1;
    1057                 :            :       break;
    1058                 :            : 
    1059                 :  831570000 :     case tcc_declaration:
    1060                 :  831570000 :       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
    1061                 :            :         {
    1062                 :  831570000 :           if (code == FUNCTION_DECL)
    1063                 :            :             {
    1064                 :  499383000 :               SET_DECL_ALIGN (t, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY));
    1065                 :  499383000 :               SET_DECL_MODE (t, FUNCTION_MODE);
    1066                 :            :             }
    1067                 :            :           else
    1068                 :  332187000 :             SET_DECL_ALIGN (t, 1);
    1069                 :            :         }
    1070                 :  831570000 :       DECL_SOURCE_LOCATION (t) = input_location;
    1071                 :  831570000 :       if (TREE_CODE (t) == DEBUG_EXPR_DECL)
    1072                 :    1371290 :         DECL_UID (t) = --next_debug_decl_uid;
    1073                 :            :       else
    1074                 :            :         {
    1075                 :  830199000 :           DECL_UID (t) = allocate_decl_uid ();
    1076                 :  830199000 :           SET_DECL_PT_UID (t, -1);
    1077                 :            :         }
    1078                 :  831570000 :       if (TREE_CODE (t) == LABEL_DECL)
    1079                 :   16206800 :         LABEL_DECL_UID (t) = -1;
    1080                 :            : 
    1081                 :            :       break;
    1082                 :            : 
    1083                 :  475729000 :     case tcc_type:
    1084                 :  475729000 :       TYPE_UID (t) = next_type_uid++;
    1085                 :  475729000 :       SET_TYPE_ALIGN (t, BITS_PER_UNIT);
    1086                 :  475729000 :       TYPE_USER_ALIGN (t) = 0;
    1087                 :  475729000 :       TYPE_MAIN_VARIANT (t) = t;
    1088                 :  475729000 :       TYPE_CANONICAL (t) = t;
    1089                 :            : 
    1090                 :            :       /* Default to no attributes for type, but let target change that.  */
    1091                 :  475729000 :       TYPE_ATTRIBUTES (t) = NULL_TREE;
    1092                 :  475729000 :       targetm.set_default_type_attributes (t);
    1093                 :            : 
    1094                 :            :       /* We have not yet computed the alias set for this type.  */
    1095                 :  475729000 :       TYPE_ALIAS_SET (t) = -1;
    1096                 :  475729000 :       break;
    1097                 :            : 
    1098                 :    7663660 :     case tcc_constant:
    1099                 :    7663660 :       TREE_CONSTANT (t) = 1;
    1100                 :    7663660 :       break;
    1101                 :            : 
    1102                 :  228606000 :     case tcc_expression:
    1103                 :  228606000 :       switch (code)
    1104                 :            :         {
    1105                 :   84385700 :         case INIT_EXPR:
    1106                 :   84385700 :         case MODIFY_EXPR:
    1107                 :   84385700 :         case VA_ARG_EXPR:
    1108                 :   84385700 :         case PREDECREMENT_EXPR:
    1109                 :   84385700 :         case PREINCREMENT_EXPR:
    1110                 :   84385700 :         case POSTDECREMENT_EXPR:
    1111                 :   84385700 :         case POSTINCREMENT_EXPR:
    1112                 :            :           /* All of these have side-effects, no matter what their
    1113                 :            :              operands are.  */
    1114                 :   84385700 :           TREE_SIDE_EFFECTS (t) = 1;
    1115                 :   84385700 :           break;
    1116                 :            : 
    1117                 :            :         default:
    1118                 :            :           break;
    1119                 :            :         }
    1120                 :            :       break;
    1121                 :            : 
    1122                 : 1365390000 :     case tcc_exceptional:
    1123                 : 1365390000 :       switch (code)
    1124                 :            :         {
    1125                 :     657978 :         case TARGET_OPTION_NODE:
    1126                 :     657978 :           TREE_TARGET_OPTION(t)
    1127                 :     657978 :                             = ggc_cleared_alloc<struct cl_target_option> ();
    1128                 :     657978 :           break;
    1129                 :            : 
    1130                 :     417375 :         case OPTIMIZATION_NODE:
    1131                 :     417375 :           TREE_OPTIMIZATION (t)
    1132                 :     417375 :                             = ggc_cleared_alloc<struct cl_optimization> ();
    1133                 :     417375 :           break;
    1134                 :            : 
    1135                 :            :         default:
    1136                 :            :           break;
    1137                 :            :         }
    1138                 :            :       break;
    1139                 :            : 
    1140                 :            :     default:
    1141                 :            :       /* Other classes need no special treatment.  */
    1142                 :            :       break;
    1143                 :            :     }
    1144                 :            : 
    1145                 : 3217880000 :   return t;
    1146                 :            : }
    1147                 :            : 
    1148                 :            : /* Free tree node.  */
    1149                 :            : 
    1150                 :            : void
    1151                 :  151728000 : free_node (tree node)
    1152                 :            : {
    1153                 :  151728000 :   enum tree_code code = TREE_CODE (node);
    1154                 :  151728000 :   if (GATHER_STATISTICS)
    1155                 :            :     {
    1156                 :            :       enum tree_node_kind kind = get_stats_node_kind (code);
    1157                 :            : 
    1158                 :            :       gcc_checking_assert (tree_code_counts[(int) TREE_CODE (node)] != 0);
    1159                 :            :       gcc_checking_assert (tree_node_counts[(int) kind] != 0);
    1160                 :            :       gcc_checking_assert (tree_node_sizes[(int) kind] >= tree_size (node));
    1161                 :            : 
    1162                 :            :       tree_code_counts[(int) TREE_CODE (node)]--;
    1163                 :            :       tree_node_counts[(int) kind]--;
    1164                 :            :       tree_node_sizes[(int) kind] -= tree_size (node);
    1165                 :            :     }
    1166                 :  151728000 :   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
    1167                 :        193 :     vec_free (CONSTRUCTOR_ELTS (node));
    1168                 :  151728000 :   else if (code == BLOCK)
    1169                 :          0 :     vec_free (BLOCK_NONLOCALIZED_VARS (node));
    1170                 :  151728000 :   else if (code == TREE_BINFO)
    1171                 :        344 :     vec_free (BINFO_BASE_ACCESSES (node));
    1172                 :  151728000 :   else if (code == OPTIMIZATION_NODE)
    1173                 :        732 :     cl_optimization_option_free (TREE_OPTIMIZATION (node));
    1174                 :  151727000 :   else if (code == TARGET_OPTION_NODE)
    1175                 :        792 :     cl_target_option_free (TREE_TARGET_OPTION (node));
    1176                 :  151728000 :   ggc_free (node);
    1177                 :  151728000 : }
    1178                 :            : 
    1179                 :            : /* Return a new node with the same contents as NODE except that its
    1180                 :            :    TREE_CHAIN, if it has one, is zero and it has a fresh uid.  */
    1181                 :            : 
    1182                 :            : tree
    1183                 :  549726000 : copy_node (tree node MEM_STAT_DECL)
    1184                 :            : {
    1185                 :  549726000 :   tree t;
    1186                 :  549726000 :   enum tree_code code = TREE_CODE (node);
    1187                 :  549726000 :   size_t length;
    1188                 :            : 
    1189                 :  549726000 :   gcc_assert (code != STATEMENT_LIST);
    1190                 :            : 
    1191                 :  549726000 :   length = tree_size (node);
    1192                 :  549726000 :   record_node_allocation_statistics (code, length);
    1193                 :  549726000 :   t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
    1194                 :  549726000 :   memcpy (t, node, length);
    1195                 :            : 
    1196                 :  549726000 :   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
    1197                 :  340572000 :     TREE_CHAIN (t) = 0;
    1198                 :  549726000 :   TREE_ASM_WRITTEN (t) = 0;
    1199                 :  549726000 :   TREE_VISITED (t) = 0;
    1200                 :            : 
    1201                 :  549726000 :   if (TREE_CODE_CLASS (code) == tcc_declaration)
    1202                 :            :     {
    1203                 :  161113000 :       if (code == DEBUG_EXPR_DECL)
    1204                 :          0 :         DECL_UID (t) = --next_debug_decl_uid;
    1205                 :            :       else
    1206                 :            :         {
    1207                 :  161113000 :           DECL_UID (t) = allocate_decl_uid ();
    1208                 :  161113000 :           if (DECL_PT_UID_SET_P (node))
    1209                 :       2287 :             SET_DECL_PT_UID (t, DECL_PT_UID (node));
    1210                 :            :         }
    1211                 :  161113000 :       if ((TREE_CODE (node) == PARM_DECL || VAR_P (node))
    1212                 :  234462000 :           && DECL_HAS_VALUE_EXPR_P (node))
    1213                 :            :         {
    1214                 :      28766 :           SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
    1215                 :      28766 :           DECL_HAS_VALUE_EXPR_P (t) = 1;
    1216                 :            :         }
    1217                 :            :       /* DECL_DEBUG_EXPR is copied explicitely by callers.  */
    1218                 :  161113000 :       if (VAR_P (node))
    1219                 :            :         {
    1220                 :   12861100 :           DECL_HAS_DEBUG_EXPR_P (t) = 0;
    1221                 :   12861100 :           t->decl_with_vis.symtab_node = NULL;
    1222                 :            :         }
    1223                 :  161113000 :       if (VAR_P (node) && DECL_HAS_INIT_PRIORITY_P (node))
    1224                 :            :         {
    1225                 :          0 :           SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
    1226                 :          0 :           DECL_HAS_INIT_PRIORITY_P (t) = 1;
    1227                 :            :         }
    1228                 :  161113000 :       if (TREE_CODE (node) == FUNCTION_DECL)
    1229                 :            :         {
    1230                 :   56000600 :           DECL_STRUCT_FUNCTION (t) = NULL;
    1231                 :   56000600 :           t->decl_with_vis.symtab_node = NULL;
    1232                 :            :         }
    1233                 :            :     }
    1234                 :  388613000 :   else if (TREE_CODE_CLASS (code) == tcc_type)
    1235                 :            :     {
    1236                 :  139356000 :       TYPE_UID (t) = next_type_uid++;
    1237                 :            :       /* The following is so that the debug code for
    1238                 :            :          the copy is different from the original type.
    1239                 :            :          The two statements usually duplicate each other
    1240                 :            :          (because they clear fields of the same union),
    1241                 :            :          but the optimizer should catch that.  */
    1242                 :  139356000 :       TYPE_SYMTAB_ADDRESS (t) = 0;
    1243                 :  139356000 :       TYPE_SYMTAB_DIE (t) = 0;
    1244                 :            : 
    1245                 :            :       /* Do not copy the values cache.  */
    1246                 :  139356000 :       if (TYPE_CACHED_VALUES_P (t))
    1247                 :            :         {
    1248                 :    5445970 :           TYPE_CACHED_VALUES_P (t) = 0;
    1249                 :    5445970 :           TYPE_CACHED_VALUES (t) = NULL_TREE;
    1250                 :            :         }
    1251                 :            :     }
    1252                 :  249257000 :     else if (code == TARGET_OPTION_NODE)
    1253                 :            :       {
    1254                 :          0 :         TREE_TARGET_OPTION (t) = ggc_alloc<struct cl_target_option>();
    1255                 :          0 :         memcpy (TREE_TARGET_OPTION (t), TREE_TARGET_OPTION (node),
    1256                 :            :                 sizeof (struct cl_target_option));
    1257                 :            :       }
    1258                 :  249257000 :     else if (code == OPTIMIZATION_NODE)
    1259                 :            :       {
    1260                 :          0 :         TREE_OPTIMIZATION (t) = ggc_alloc<struct cl_optimization>();
    1261                 :          0 :         memcpy (TREE_OPTIMIZATION (t), TREE_OPTIMIZATION (node),
    1262                 :            :                 sizeof (struct cl_optimization));
    1263                 :            :       }
    1264                 :            : 
    1265                 :  549726000 :   return t;
    1266                 :            : }
    1267                 :            : 
    1268                 :            : /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
    1269                 :            :    For example, this can copy a list made of TREE_LIST nodes.  */
    1270                 :            : 
    1271                 :            : tree
    1272                 :   32515300 : copy_list (tree list)
    1273                 :            : {
    1274                 :   32515300 :   tree head;
    1275                 :   32515300 :   tree prev, next;
    1276                 :            : 
    1277                 :   32515300 :   if (list == 0)
    1278                 :            :     return 0;
    1279                 :            : 
    1280                 :   25836500 :   head = prev = copy_node (list);
    1281                 :   25836500 :   next = TREE_CHAIN (list);
    1282                 :   41652400 :   while (next)
    1283                 :            :     {
    1284                 :   15815900 :       TREE_CHAIN (prev) = copy_node (next);
    1285                 :   15815900 :       prev = TREE_CHAIN (prev);
    1286                 :   15815900 :       next = TREE_CHAIN (next);
    1287                 :            :     }
    1288                 :            :   return head;
    1289                 :            : }
    1290                 :            : 
    1291                 :            : 
    1292                 :            : /* Return the value that TREE_INT_CST_EXT_NUNITS should have for an
    1293                 :            :    INTEGER_CST with value CST and type TYPE.   */
    1294                 :            : 
    1295                 :            : static unsigned int
    1296                 : 3195440000 : get_int_cst_ext_nunits (tree type, const wide_int &cst)
    1297                 :            : {
    1298                 : 3195440000 :   gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type));
    1299                 :            :   /* We need extra HWIs if CST is an unsigned integer with its
    1300                 :            :      upper bit set.  */
    1301                 : 5519060000 :   if (TYPE_UNSIGNED (type) && wi::neg_p (cst))
    1302                 :  294753000 :     return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1;
    1303                 : 2900690000 :   return cst.get_len ();
    1304                 :            : }
    1305                 :            : 
    1306                 :            : /* Return a new INTEGER_CST with value CST and type TYPE.  */
    1307                 :            : 
    1308                 :            : static tree
    1309                 :  151250000 : build_new_int_cst (tree type, const wide_int &cst)
    1310                 :            : {
    1311                 :  151250000 :   unsigned int len = cst.get_len ();
    1312                 :  151250000 :   unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
    1313                 :  151250000 :   tree nt = make_int_cst (len, ext_len);
    1314                 :            : 
    1315                 :  151250000 :   if (len < ext_len)
    1316                 :            :     {
    1317                 :  124382000 :       --ext_len;
    1318                 :  124382000 :       TREE_INT_CST_ELT (nt, ext_len)
    1319                 :  124382000 :         = zext_hwi (-1, cst.get_precision () % HOST_BITS_PER_WIDE_INT);
    1320                 :  131324000 :       for (unsigned int i = len; i < ext_len; ++i)
    1321                 :    6942340 :         TREE_INT_CST_ELT (nt, i) = -1;
    1322                 :            :     }
    1323                 :   26868400 :   else if (TYPE_UNSIGNED (type)
    1324                 :   26868400 :            && cst.get_precision () < len * HOST_BITS_PER_WIDE_INT)
    1325                 :            :     {
    1326                 :    4999100 :       len--;
    1327                 :    4999100 :       TREE_INT_CST_ELT (nt, len)
    1328                 :    9998200 :         = zext_hwi (cst.elt (len),
    1329                 :    4999100 :                     cst.get_precision () % HOST_BITS_PER_WIDE_INT);
    1330                 :            :     }
    1331                 :            : 
    1332                 :  298885000 :   for (unsigned int i = 0; i < len; i++)
    1333                 :  295270000 :     TREE_INT_CST_ELT (nt, i) = cst.elt (i);
    1334                 :  151250000 :   TREE_TYPE (nt) = type;
    1335                 :  151250000 :   return nt;
    1336                 :            : }
    1337                 :            : 
    1338                 :            : /* Return a new POLY_INT_CST with coefficients COEFFS and type TYPE.  */
    1339                 :            : 
    1340                 :            : static tree
    1341                 :          0 : build_new_poly_int_cst (tree type, tree (&coeffs)[NUM_POLY_INT_COEFFS]
    1342                 :            :                         CXX_MEM_STAT_INFO)
    1343                 :            : {
    1344                 :          0 :   size_t length = sizeof (struct tree_poly_int_cst);
    1345                 :          0 :   record_node_allocation_statistics (POLY_INT_CST, length);
    1346                 :            : 
    1347                 :          0 :   tree t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
    1348                 :            : 
    1349                 :          0 :   TREE_SET_CODE (t, POLY_INT_CST);
    1350                 :          0 :   TREE_CONSTANT (t) = 1;
    1351                 :          0 :   TREE_TYPE (t) = type;
    1352                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1353                 :          0 :     POLY_INT_CST_COEFF (t, i) = coeffs[i];
    1354                 :          0 :   return t;
    1355                 :            : }
    1356                 :            : 
    1357                 :            : /* Create a constant tree that contains CST sign-extended to TYPE.  */
    1358                 :            : 
    1359                 :            : tree
    1360                 : 1846960000 : build_int_cst (tree type, poly_int64 cst)
    1361                 :            : {
    1362                 :            :   /* Support legacy code.  */
    1363                 : 1846960000 :   if (!type)
    1364                 :  566443000 :     type = integer_type_node;
    1365                 :            : 
    1366                 : 2567170000 :   return wide_int_to_tree (type, wi::shwi (cst, TYPE_PRECISION (type)));
    1367                 :            : }
    1368                 :            : 
    1369                 :            : /* Create a constant tree that contains CST zero-extended to TYPE.  */
    1370                 :            : 
    1371                 :            : tree
    1372                 :    1856970 : build_int_cstu (tree type, poly_uint64 cst)
    1373                 :            : {
    1374                 :    2243560 :   return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type)));
    1375                 :            : }
    1376                 :            : 
    1377                 :            : /* Create a constant tree that contains CST sign-extended to TYPE.  */
    1378                 :            : 
    1379                 :            : tree
    1380                 :   13311400 : build_int_cst_type (tree type, poly_int64 cst)
    1381                 :            : {
    1382                 :   13311400 :   gcc_assert (type);
    1383                 :   19937300 :   return wide_int_to_tree (type, wi::shwi (cst, TYPE_PRECISION (type)));
    1384                 :            : }
    1385                 :            : 
    1386                 :            : /* Constructs tree in type TYPE from with value given by CST.  Signedness
    1387                 :            :    of CST is assumed to be the same as the signedness of TYPE.  */
    1388                 :            : 
    1389                 :            : tree
    1390                 :    6521150 : double_int_to_tree (tree type, double_int cst)
    1391                 :            : {
    1392                 :    6521150 :   return wide_int_to_tree (type, widest_int::from (cst, TYPE_SIGN (type)));
    1393                 :            : }
    1394                 :            : 
    1395                 :            : /* We force the wide_int CST to the range of the type TYPE by sign or
    1396                 :            :    zero extending it.  OVERFLOWABLE indicates if we are interested in
    1397                 :            :    overflow of the value, when >0 we are only interested in signed
    1398                 :            :    overflow, for <0 we are interested in any overflow.  OVERFLOWED
    1399                 :            :    indicates whether overflow has already occurred.  CONST_OVERFLOWED
    1400                 :            :    indicates whether constant overflow has already occurred.  We force
    1401                 :            :    T's value to be within range of T's type (by setting to 0 or 1 all
    1402                 :            :    the bits outside the type's range).  We set TREE_OVERFLOWED if,
    1403                 :            :         OVERFLOWED is nonzero,
    1404                 :            :         or OVERFLOWABLE is >0 and signed overflow occurs
    1405                 :            :         or OVERFLOWABLE is <0 and any overflow occurs
    1406                 :            :    We return a new tree node for the extended wide_int.  The node
    1407                 :            :    is shared if no overflow flags are set.  */
    1408                 :            : 
    1409                 :            : 
    1410                 :            : tree
    1411                 :  813899000 : force_fit_type (tree type, const poly_wide_int_ref &cst,
    1412                 :            :                 int overflowable, bool overflowed)
    1413                 :            : {
    1414                 :  813899000 :   signop sign = TYPE_SIGN (type);
    1415                 :            : 
    1416                 :            :   /* If we need to set overflow flags, return a new unshared node.  */
    1417                 :  813899000 :   if (overflowed || !wi::fits_to_tree_p (cst, type))
    1418                 :            :     {
    1419                 :    8314520 :       if (overflowed
    1420                 :    8314520 :           || overflowable < 0
    1421                 :    7015220 :           || (overflowable > 0 && sign == SIGNED))
    1422                 :            :         {
    1423                 :    2416450 :           poly_wide_int tmp = poly_wide_int::from (cst, TYPE_PRECISION (type),
    1424                 :    2416450 :                                                    sign);
    1425                 :    2416450 :           tree t;
    1426                 :    2416450 :           if (tmp.is_constant ())
    1427                 :    2416450 :             t = build_new_int_cst (type, tmp.coeffs[0]);
    1428                 :            :           else
    1429                 :            :             {
    1430                 :            :               tree coeffs[NUM_POLY_INT_COEFFS];
    1431                 :            :               for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1432                 :            :                 {
    1433                 :            :                   coeffs[i] = build_new_int_cst (type, tmp.coeffs[i]);
    1434                 :            :                   TREE_OVERFLOW (coeffs[i]) = 1;
    1435                 :            :                 }
    1436                 :            :               t = build_new_poly_int_cst (type, coeffs);
    1437                 :            :             }
    1438                 :    2416450 :           TREE_OVERFLOW (t) = 1;
    1439                 :    2416450 :           return t;
    1440                 :            :         }
    1441                 :            :     }
    1442                 :            : 
    1443                 :            :   /* Else build a shared node.  */
    1444                 :  811483000 :   return wide_int_to_tree (type, cst);
    1445                 :            : }
    1446                 :            : 
    1447                 :            : /* These are the hash table functions for the hash table of INTEGER_CST
    1448                 :            :    nodes of a sizetype.  */
    1449                 :            : 
    1450                 :            : /* Return the hash code X, an INTEGER_CST.  */
    1451                 :            : 
    1452                 :            : hashval_t
    1453                 : 1323220000 : int_cst_hasher::hash (tree x)
    1454                 :            : {
    1455                 : 1323220000 :   const_tree const t = x;
    1456                 : 1323220000 :   hashval_t code = TYPE_UID (TREE_TYPE (t));
    1457                 : 1323220000 :   int i;
    1458                 :            : 
    1459                 : 2648280000 :   for (i = 0; i < TREE_INT_CST_NUNITS (t); i++)
    1460                 : 1325050000 :     code = iterative_hash_host_wide_int (TREE_INT_CST_ELT(t, i), code);
    1461                 :            : 
    1462                 : 1323220000 :   return code;
    1463                 :            : }
    1464                 :            : 
    1465                 :            : /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
    1466                 :            :    is the same as that given by *Y, which is the same.  */
    1467                 :            : 
    1468                 :            : bool
    1469                 : 1359790000 : int_cst_hasher::equal (tree x, tree y)
    1470                 :            : {
    1471                 : 1359790000 :   const_tree const xt = x;
    1472                 : 1359790000 :   const_tree const yt = y;
    1473                 :            : 
    1474                 : 1359790000 :   if (TREE_TYPE (xt) != TREE_TYPE (yt)
    1475                 :  441503000 :       || TREE_INT_CST_NUNITS (xt) != TREE_INT_CST_NUNITS (yt)
    1476                 : 1801240000 :       || TREE_INT_CST_EXT_NUNITS (xt) != TREE_INT_CST_EXT_NUNITS (yt))
    1477                 :            :     return false;
    1478                 :            : 
    1479                 :  755857000 :   for (int i = 0; i < TREE_INT_CST_NUNITS (xt); i++)
    1480                 :  419308000 :     if (TREE_INT_CST_ELT (xt, i) != TREE_INT_CST_ELT (yt, i))
    1481                 :            :       return false;
    1482                 :            : 
    1483                 :            :   return true;
    1484                 :            : }
    1485                 :            : 
    1486                 :            : /* Create an INT_CST node of TYPE and value CST.
    1487                 :            :    The returned node is always shared.  For small integers we use a
    1488                 :            :    per-type vector cache, for larger ones we use a single hash table.
    1489                 :            :    The value is extended from its precision according to the sign of
    1490                 :            :    the type to be a multiple of HOST_BITS_PER_WIDE_INT.  This defines
    1491                 :            :    the upper bits and ensures that hashing and value equality based
    1492                 :            :    upon the underlying HOST_WIDE_INTs works without masking.  */
    1493                 :            : 
    1494                 :            : static tree
    1495                 : 3044190000 : wide_int_to_tree_1 (tree type, const wide_int_ref &pcst)
    1496                 :            : {
    1497                 : 3044190000 :   tree t;
    1498                 : 3044190000 :   int ix = -1;
    1499                 : 3044190000 :   int limit = 0;
    1500                 :            : 
    1501                 : 3044190000 :   gcc_assert (type);
    1502                 : 3044190000 :   unsigned int prec = TYPE_PRECISION (type);
    1503                 : 3044190000 :   signop sgn = TYPE_SIGN (type);
    1504                 :            : 
    1505                 :            :   /* Verify that everything is canonical.  */
    1506                 : 3044190000 :   int l = pcst.get_len ();
    1507                 : 3044190000 :   if (l > 1)
    1508                 :            :     {
    1509                 :    6245930 :       if (pcst.elt (l - 1) == 0)
    1510                 :    3604910 :         gcc_checking_assert (pcst.elt (l - 2) < 0);
    1511                 :    3122960 :       if (pcst.elt (l - 1) == HOST_WIDE_INT_M1)
    1512                 :      18702 :         gcc_checking_assert (pcst.elt (l - 2) >= 0);
    1513                 :            :     }
    1514                 :            : 
    1515                 : 3044190000 :   wide_int cst = wide_int::from (pcst, prec, sgn);
    1516                 : 3044190000 :   unsigned int ext_len = get_int_cst_ext_nunits (type, cst);
    1517                 :            : 
    1518                 : 3044190000 :   if (ext_len == 1)
    1519                 :            :     {
    1520                 :            :       /* We just need to store a single HOST_WIDE_INT.  */
    1521                 : 2918950000 :       HOST_WIDE_INT hwi;
    1522                 : 2918950000 :       if (TYPE_UNSIGNED (type))
    1523                 : 4115600000 :         hwi = cst.to_uhwi ();
    1524                 :            :       else
    1525                 :  861151000 :         hwi = cst.to_shwi ();
    1526                 :            : 
    1527                 : 2918950000 :       switch (TREE_CODE (type))
    1528                 :            :         {
    1529                 :      78486 :         case NULLPTR_TYPE:
    1530                 :      78486 :           gcc_assert (hwi == 0);
    1531                 :            :           /* Fallthru.  */
    1532                 :            : 
    1533                 :  309817000 :         case POINTER_TYPE:
    1534                 :  309817000 :         case REFERENCE_TYPE:
    1535                 :            :           /* Cache NULL pointer and zero bounds.  */
    1536                 :  309817000 :           if (hwi == 0)
    1537                 :            :             {
    1538                 :            :               limit = 1;
    1539                 :            :               ix = 0;
    1540                 :            :             }
    1541                 :            :           break;
    1542                 :            : 
    1543                 :   42821500 :         case BOOLEAN_TYPE:
    1544                 :            :           /* Cache false or true.  */
    1545                 :   42821500 :           limit = 2;
    1546                 :   42821500 :           if (IN_RANGE (hwi, 0, 1))
    1547                 :   42780300 :             ix = hwi;
    1548                 :            :           break;
    1549                 :            : 
    1550                 : 2564450000 :         case INTEGER_TYPE:
    1551                 : 2564450000 :         case OFFSET_TYPE:
    1552                 : 2564450000 :           if (TYPE_SIGN (type) == UNSIGNED)
    1553                 :            :             {
    1554                 :            :               /* Cache [0, N).  */
    1555                 : 1704050000 :               limit = param_integer_share_limit;
    1556                 : 1704050000 :               if (IN_RANGE (hwi, 0, param_integer_share_limit - 1))
    1557                 : 1631820000 :                 ix = hwi;
    1558                 :            :             }
    1559                 :            :           else
    1560                 :            :             {
    1561                 :            :               /* Cache [-1, N).  */
    1562                 :  860403000 :               limit = param_integer_share_limit + 1;
    1563                 :  860403000 :               if (IN_RANGE (hwi, -1, param_integer_share_limit - 1))
    1564                 :  799874000 :                 ix = hwi + 1;
    1565                 :            :             }
    1566                 :            :           break;
    1567                 :            : 
    1568                 :            :         case ENUMERAL_TYPE:
    1569                 :            :           break;
    1570                 :            : 
    1571                 :          0 :         default:
    1572                 :          0 :           gcc_unreachable ();
    1573                 :            :         }
    1574                 :            : 
    1575                 : 2474470000 :       if (ix >= 0)
    1576                 :            :         {
    1577                 :            :           /* Look for it in the type's vector of small shared ints.  */
    1578                 : 2682660000 :           if (!TYPE_CACHED_VALUES_P (type))
    1579                 :            :             {
    1580                 :    6033740 :               TYPE_CACHED_VALUES_P (type) = 1;
    1581                 :    6033740 :               TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
    1582                 :            :             }
    1583                 :            : 
    1584                 : 2682660000 :           t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
    1585                 : 2682660000 :           if (t)
    1586                 :            :             /* Make sure no one is clobbering the shared constant.  */
    1587                 : 5318140000 :             gcc_checking_assert (TREE_TYPE (t) == type
    1588                 :            :                                  && TREE_INT_CST_NUNITS (t) == 1
    1589                 :            :                                  && TREE_INT_CST_OFFSET_NUNITS (t) == 1
    1590                 :            :                                  && TREE_INT_CST_EXT_NUNITS (t) == 1
    1591                 :            :                                  && TREE_INT_CST_ELT (t, 0) == hwi);
    1592                 :            :           else
    1593                 :            :             {
    1594                 :            :               /* Create a new shared int.  */
    1595                 :   23590300 :               t = build_new_int_cst (type, cst);
    1596                 :   23590300 :               TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
    1597                 :            :             }
    1598                 :            :         }
    1599                 :            :       else
    1600                 :            :         {
    1601                 :            :           /* Use the cache of larger shared ints, using int_cst_node as
    1602                 :            :              a temporary.  */
    1603                 :            : 
    1604                 :  236290000 :           TREE_INT_CST_ELT (int_cst_node, 0) = hwi;
    1605                 :  236290000 :           TREE_TYPE (int_cst_node) = type;
    1606                 :            : 
    1607                 :  236290000 :           tree *slot = int_cst_hash_table->find_slot (int_cst_node, INSERT);
    1608                 :  236290000 :           t = *slot;
    1609                 :  236290000 :           if (!t)
    1610                 :            :             {
    1611                 :            :               /* Insert this one into the hash table.  */
    1612                 :   20816500 :               t = int_cst_node;
    1613                 :   20816500 :               *slot = t;
    1614                 :            :               /* Make a new node for next time round.  */
    1615                 :   20816500 :               int_cst_node = make_int_cst (1, 1);
    1616                 :            :             }
    1617                 :            :         }
    1618                 :            :     }
    1619                 :            :   else
    1620                 :            :     {
    1621                 :            :       /* The value either hashes properly or we drop it on the floor
    1622                 :            :          for the gc to take care of.  There will not be enough of them
    1623                 :            :          to worry about.  */
    1624                 :            : 
    1625                 :  125243000 :       tree nt = build_new_int_cst (type, cst);
    1626                 :  125243000 :       tree *slot = int_cst_hash_table->find_slot (nt, INSERT);
    1627                 :  125243000 :       t = *slot;
    1628                 :  125243000 :       if (!t)
    1629                 :            :         {
    1630                 :            :           /* Insert this one into the hash table.  */
    1631                 :    4344820 :           t = nt;
    1632                 :    4344820 :           *slot = t;
    1633                 :            :         }
    1634                 :            :       else
    1635                 :  120899000 :         ggc_free (nt);
    1636                 :            :     }
    1637                 :            : 
    1638                 : 3044190000 :   return t;
    1639                 :            : }
    1640                 :            : 
    1641                 :            : hashval_t
    1642                 :          0 : poly_int_cst_hasher::hash (tree t)
    1643                 :            : {
    1644                 :          0 :   inchash::hash hstate;
    1645                 :            : 
    1646                 :          0 :   hstate.add_int (TYPE_UID (TREE_TYPE (t)));
    1647                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1648                 :          0 :     hstate.add_wide_int (wi::to_wide (POLY_INT_CST_COEFF (t, i)));
    1649                 :            : 
    1650                 :          0 :   return hstate.end ();
    1651                 :            : }
    1652                 :            : 
    1653                 :            : bool
    1654                 :          0 : poly_int_cst_hasher::equal (tree x, const compare_type &y)
    1655                 :            : {
    1656                 :          0 :   if (TREE_TYPE (x) != y.first)
    1657                 :            :     return false;
    1658                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1659                 :          0 :     if (wi::to_wide (POLY_INT_CST_COEFF (x, i)) != y.second->coeffs[i])
    1660                 :            :       return false;
    1661                 :            :   return true;
    1662                 :            : }
    1663                 :            : 
    1664                 :            : /* Build a POLY_INT_CST node with type TYPE and with the elements in VALUES.
    1665                 :            :    The elements must also have type TYPE.  */
    1666                 :            : 
    1667                 :            : tree
    1668                 :          0 : build_poly_int_cst (tree type, const poly_wide_int_ref &values)
    1669                 :            : {
    1670                 :          0 :   unsigned int prec = TYPE_PRECISION (type);
    1671                 :          0 :   gcc_assert (prec <= values.coeffs[0].get_precision ());
    1672                 :          0 :   poly_wide_int c = poly_wide_int::from (values, prec, SIGNED);
    1673                 :            : 
    1674                 :          0 :   inchash::hash h;
    1675                 :          0 :   h.add_int (TYPE_UID (type));
    1676                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1677                 :          0 :     h.add_wide_int (c.coeffs[i]);
    1678                 :          0 :   poly_int_cst_hasher::compare_type comp (type, &c);
    1679                 :          0 :   tree *slot = poly_int_cst_hash_table->find_slot_with_hash (comp, h.end (),
    1680                 :            :                                                              INSERT);
    1681                 :          0 :   if (*slot == NULL_TREE)
    1682                 :            :     {
    1683                 :            :       tree coeffs[NUM_POLY_INT_COEFFS];
    1684                 :          0 :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1685                 :          0 :         coeffs[i] = wide_int_to_tree_1 (type, c.coeffs[i]);
    1686                 :          0 :       *slot = build_new_poly_int_cst (type, coeffs);
    1687                 :            :     }
    1688                 :          0 :   return *slot;
    1689                 :            : }
    1690                 :            : 
    1691                 :            : /* Create a constant tree with value VALUE in type TYPE.  */
    1692                 :            : 
    1693                 :            : tree
    1694                 : 3044190000 : wide_int_to_tree (tree type, const poly_wide_int_ref &value)
    1695                 :            : {
    1696                 : 3044190000 :   if (value.is_constant ())
    1697                 : 3044190000 :     return wide_int_to_tree_1 (type, value.coeffs[0]);
    1698                 :            :   return build_poly_int_cst (type, value);
    1699                 :            : }
    1700                 :            : 
    1701                 :            : void
    1702                 :      22058 : cache_integer_cst (tree t)
    1703                 :            : {
    1704                 :      22058 :   tree type = TREE_TYPE (t);
    1705                 :      22058 :   int ix = -1;
    1706                 :      22058 :   int limit = 0;
    1707                 :      22058 :   int prec = TYPE_PRECISION (type);
    1708                 :            : 
    1709                 :      22058 :   gcc_assert (!TREE_OVERFLOW (t));
    1710                 :            : 
    1711                 :      22058 :   switch (TREE_CODE (type))
    1712                 :            :     {
    1713                 :          0 :     case NULLPTR_TYPE:
    1714                 :          0 :       gcc_assert (integer_zerop (t));
    1715                 :            :       /* Fallthru.  */
    1716                 :            : 
    1717                 :          0 :     case POINTER_TYPE:
    1718                 :          0 :     case REFERENCE_TYPE:
    1719                 :            :       /* Cache NULL pointer.  */
    1720                 :          0 :       if (integer_zerop (t))
    1721                 :            :         {
    1722                 :            :           limit = 1;
    1723                 :            :           ix = 0;
    1724                 :            :         }
    1725                 :            :       break;
    1726                 :            : 
    1727                 :       4814 :     case BOOLEAN_TYPE:
    1728                 :            :       /* Cache false or true.  */
    1729                 :       4814 :       limit = 2;
    1730                 :       4814 :       if (wi::ltu_p (wi::to_wide (t), 2))
    1731                 :       4760 :         ix = TREE_INT_CST_ELT (t, 0);
    1732                 :            :       break;
    1733                 :            : 
    1734                 :      16308 :     case INTEGER_TYPE:
    1735                 :      16308 :     case OFFSET_TYPE:
    1736                 :      16308 :       if (TYPE_UNSIGNED (type))
    1737                 :            :         {
    1738                 :            :           /* Cache 0..N */
    1739                 :       3924 :           limit = param_integer_share_limit;
    1740                 :            : 
    1741                 :            :           /* This is a little hokie, but if the prec is smaller than
    1742                 :            :              what is necessary to hold param_integer_share_limit, then the
    1743                 :            :              obvious test will not get the correct answer.  */
    1744                 :       3924 :           if (prec < HOST_BITS_PER_WIDE_INT)
    1745                 :            :             {
    1746                 :       3894 :               if (tree_to_uhwi (t)
    1747                 :       3894 :                   < (unsigned HOST_WIDE_INT) param_integer_share_limit)
    1748                 :       2424 :                 ix = tree_to_uhwi (t);
    1749                 :            :             }
    1750                 :         30 :           else if (wi::ltu_p (wi::to_wide (t), param_integer_share_limit))
    1751                 :         15 :             ix = tree_to_uhwi (t);
    1752                 :            :         }
    1753                 :            :       else
    1754                 :            :         {
    1755                 :            :           /* Cache -1..N */
    1756                 :      12384 :           limit = param_integer_share_limit + 1;
    1757                 :            : 
    1758                 :      12384 :           if (integer_minus_onep (t))
    1759                 :            :             ix = 0;
    1760                 :      12325 :           else if (!wi::neg_p (wi::to_wide (t)))
    1761                 :            :             {
    1762                 :       6192 :               if (prec < HOST_BITS_PER_WIDE_INT)
    1763                 :            :                 {
    1764                 :       6147 :                   if (tree_to_shwi (t) < param_integer_share_limit)
    1765                 :       5804 :                     ix = tree_to_shwi (t) + 1;
    1766                 :            :                 }
    1767                 :         45 :               else if (wi::ltu_p (wi::to_wide (t), param_integer_share_limit))
    1768                 :          0 :                 ix = tree_to_shwi (t) + 1;
    1769                 :            :             }
    1770                 :            :         }
    1771                 :            :       break;
    1772                 :            : 
    1773                 :            :     case ENUMERAL_TYPE:
    1774                 :            :       break;
    1775                 :            : 
    1776                 :          0 :     default:
    1777                 :          0 :       gcc_unreachable ();
    1778                 :            :     }
    1779                 :            : 
    1780                 :      13003 :   if (ix >= 0)
    1781                 :            :     {
    1782                 :            :       /* Look for it in the type's vector of small shared ints.  */
    1783                 :      13062 :       if (!TYPE_CACHED_VALUES_P (type))
    1784                 :            :         {
    1785                 :      10146 :           TYPE_CACHED_VALUES_P (type) = 1;
    1786                 :      10146 :           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
    1787                 :            :         }
    1788                 :            : 
    1789                 :      13062 :       gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE);
    1790                 :      13062 :       TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
    1791                 :            :     }
    1792                 :            :   else
    1793                 :            :     {
    1794                 :            :       /* Use the cache of larger shared ints.  */
    1795                 :       8996 :       tree *slot = int_cst_hash_table->find_slot (t, INSERT);
    1796                 :            :       /* If there is already an entry for the number verify it's the
    1797                 :            :          same.  */
    1798                 :       8996 :       if (*slot)
    1799                 :          4 :         gcc_assert (wi::to_wide (tree (*slot)) == wi::to_wide (t));
    1800                 :            :       else
    1801                 :            :         /* Otherwise insert this one into the hash table.  */
    1802                 :       8992 :         *slot = t;
    1803                 :            :     }
    1804                 :      22058 : }
    1805                 :            : 
    1806                 :            : 
    1807                 :            : /* Builds an integer constant in TYPE such that lowest BITS bits are ones
    1808                 :            :    and the rest are zeros.  */
    1809                 :            : 
    1810                 :            : tree
    1811                 :    2776140 : build_low_bits_mask (tree type, unsigned bits)
    1812                 :            : {
    1813                 :    2776140 :   gcc_assert (bits <= TYPE_PRECISION (type));
    1814                 :            : 
    1815                 :    2776140 :   return wide_int_to_tree (type, wi::mask (bits, false,
    1816                 :    2776140 :                                            TYPE_PRECISION (type)));
    1817                 :            : }
    1818                 :            : 
    1819                 :            : /* Checks that X is integer constant that can be expressed in (unsigned)
    1820                 :            :    HOST_WIDE_INT without loss of precision.  */
    1821                 :            : 
    1822                 :            : bool
    1823                 :  320034000 : cst_and_fits_in_hwi (const_tree x)
    1824                 :            : {
    1825                 :  320034000 :   return (TREE_CODE (x) == INTEGER_CST
    1826                 :  320034000 :           && (tree_fits_shwi_p (x) || tree_fits_uhwi_p (x)));
    1827                 :            : }
    1828                 :            : 
    1829                 :            : /* Build a newly constructed VECTOR_CST with the given values of
    1830                 :            :    (VECTOR_CST_)LOG2_NPATTERNS and (VECTOR_CST_)NELTS_PER_PATTERN.  */
    1831                 :            : 
    1832                 :            : tree
    1833                 :     787977 : make_vector (unsigned log2_npatterns,
    1834                 :            :              unsigned int nelts_per_pattern MEM_STAT_DECL)
    1835                 :            : {
    1836                 :     787977 :   gcc_assert (IN_RANGE (nelts_per_pattern, 1, 3));
    1837                 :     787977 :   tree t;
    1838                 :     787977 :   unsigned npatterns = 1 << log2_npatterns;
    1839                 :     787977 :   unsigned encoded_nelts = npatterns * nelts_per_pattern;
    1840                 :     787977 :   unsigned length = (sizeof (struct tree_vector)
    1841                 :            :                      + (encoded_nelts - 1) * sizeof (tree));
    1842                 :            : 
    1843                 :     787977 :   record_node_allocation_statistics (VECTOR_CST, length);
    1844                 :            : 
    1845                 :     787977 :   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
    1846                 :            : 
    1847                 :     787977 :   TREE_SET_CODE (t, VECTOR_CST);
    1848                 :     787977 :   TREE_CONSTANT (t) = 1;
    1849                 :     787977 :   VECTOR_CST_LOG2_NPATTERNS (t) = log2_npatterns;
    1850                 :     787977 :   VECTOR_CST_NELTS_PER_PATTERN (t) = nelts_per_pattern;
    1851                 :            : 
    1852                 :     787977 :   return t;
    1853                 :            : }
    1854                 :            : 
    1855                 :            : /* Return a new VECTOR_CST node whose type is TYPE and whose values
    1856                 :            :    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
    1857                 :            : 
    1858                 :            : tree
    1859                 :     358586 : build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v)
    1860                 :            : {
    1861                 :     358586 :   if (vec_safe_length (v) == 0)
    1862                 :       5522 :     return build_zero_cst (type);
    1863                 :            : 
    1864                 :     353064 :   unsigned HOST_WIDE_INT idx, nelts;
    1865                 :     353064 :   tree value;
    1866                 :            : 
    1867                 :            :   /* We can't construct a VECTOR_CST for a variable number of elements.  */
    1868                 :     353064 :   nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
    1869                 :     711650 :   tree_vector_builder vec (type, nelts, 1);
    1870                 :    2109510 :   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
    1871                 :            :     {
    1872                 :    1756450 :       if (TREE_CODE (value) == VECTOR_CST)
    1873                 :            :         {
    1874                 :            :           /* If NELTS is constant then this must be too.  */
    1875                 :        404 :           unsigned int sub_nelts = VECTOR_CST_NELTS (value).to_constant ();
    1876                 :       1980 :           for (unsigned i = 0; i < sub_nelts; ++i)
    1877                 :       1576 :             vec.quick_push (VECTOR_CST_ELT (value, i));
    1878                 :            :         }
    1879                 :            :       else
    1880                 :    3512500 :         vec.quick_push (value);
    1881                 :            :     }
    1882                 :     722304 :   while (vec.length () < nelts)
    1883                 :       8088 :     vec.quick_push (build_zero_cst (TREE_TYPE (type)));
    1884                 :            : 
    1885                 :     353064 :   return vec.build ();
    1886                 :            : }
    1887                 :            : 
    1888                 :            : /* Build a vector of type VECTYPE where all the elements are SCs.  */
    1889                 :            : tree
    1890                 :     228943 : build_vector_from_val (tree vectype, tree sc)
    1891                 :            : {
    1892                 :     228943 :   unsigned HOST_WIDE_INT i, nunits;
    1893                 :            : 
    1894                 :     228943 :   if (sc == error_mark_node)
    1895                 :            :     return sc;
    1896                 :            : 
    1897                 :            :   /* Verify that the vector type is suitable for SC.  Note that there
    1898                 :            :      is some inconsistency in the type-system with respect to restrict
    1899                 :            :      qualifications of pointers.  Vector types always have a main-variant
    1900                 :            :      element type and the qualification is applied to the vector-type.
    1901                 :            :      So TREE_TYPE (vector-type) does not return a properly qualified
    1902                 :            :      vector element-type.  */
    1903                 :     228943 :   gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
    1904                 :            :                                            TREE_TYPE (vectype)));
    1905                 :            : 
    1906                 :     228943 :   if (CONSTANT_CLASS_P (sc))
    1907                 :            :     {
    1908                 :     447740 :       tree_vector_builder v (vectype, 1, 1);
    1909                 :     223870 :       v.quick_push (sc);
    1910                 :     223870 :       return v.build ();
    1911                 :            :     }
    1912                 :       5073 :   else if (!TYPE_VECTOR_SUBPARTS (vectype).is_constant (&nunits))
    1913                 :            :     return fold_build1 (VEC_DUPLICATE_EXPR, vectype, sc);
    1914                 :            :   else
    1915                 :            :     {
    1916                 :       5073 :       vec<constructor_elt, va_gc> *v;
    1917                 :       5073 :       vec_alloc (v, nunits);
    1918                 :      28530 :       for (i = 0; i < nunits; ++i)
    1919                 :      23457 :         CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc);
    1920                 :       5073 :       return build_constructor (vectype, v);
    1921                 :            :     }
    1922                 :            : }
    1923                 :            : 
    1924                 :            : /* If TYPE is not a vector type, just return SC, otherwise return
    1925                 :            :    build_vector_from_val (TYPE, SC).  */
    1926                 :            : 
    1927                 :            : tree
    1928                 :    5202100 : build_uniform_cst (tree type, tree sc)
    1929                 :            : {
    1930                 :    5202100 :   if (!VECTOR_TYPE_P (type))
    1931                 :            :     return sc;
    1932                 :            : 
    1933                 :        123 :   return build_vector_from_val (type, sc);
    1934                 :            : }
    1935                 :            : 
    1936                 :            : /* Build a vector series of type TYPE in which element I has the value
    1937                 :            :    BASE + I * STEP.  The result is a constant if BASE and STEP are constant
    1938                 :            :    and a VEC_SERIES_EXPR otherwise.  */
    1939                 :            : 
    1940                 :            : tree
    1941                 :          0 : build_vec_series (tree type, tree base, tree step)
    1942                 :            : {
    1943                 :          0 :   if (integer_zerop (step))
    1944                 :          0 :     return build_vector_from_val (type, base);
    1945                 :          0 :   if (TREE_CODE (base) == INTEGER_CST && TREE_CODE (step) == INTEGER_CST)
    1946                 :            :     {
    1947                 :          0 :       tree_vector_builder builder (type, 1, 3);
    1948                 :          0 :       tree elt1 = wide_int_to_tree (TREE_TYPE (base),
    1949                 :          0 :                                     wi::to_wide (base) + wi::to_wide (step));
    1950                 :          0 :       tree elt2 = wide_int_to_tree (TREE_TYPE (base),
    1951                 :          0 :                                     wi::to_wide (elt1) + wi::to_wide (step));
    1952                 :          0 :       builder.quick_push (base);
    1953                 :          0 :       builder.quick_push (elt1);
    1954                 :          0 :       builder.quick_push (elt2);
    1955                 :          0 :       return builder.build ();
    1956                 :            :     }
    1957                 :          0 :   return build2 (VEC_SERIES_EXPR, type, base, step);
    1958                 :            : }
    1959                 :            : 
    1960                 :            : /* Return a vector with the same number of units and number of bits
    1961                 :            :    as VEC_TYPE, but in which the elements are a linear series of unsigned
    1962                 :            :    integers { BASE, BASE + STEP, BASE + STEP * 2, ... }.  */
    1963                 :            : 
    1964                 :            : tree
    1965                 :        519 : build_index_vector (tree vec_type, poly_uint64 base, poly_uint64 step)
    1966                 :            : {
    1967                 :        519 :   tree index_vec_type = vec_type;
    1968                 :        519 :   tree index_elt_type = TREE_TYPE (vec_type);
    1969                 :        519 :   poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (vec_type);
    1970                 :       1038 :   if (!INTEGRAL_TYPE_P (index_elt_type) || !TYPE_UNSIGNED (index_elt_type))
    1971                 :            :     {
    1972                 :          2 :       index_elt_type = build_nonstandard_integer_type
    1973                 :          4 :         (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (index_elt_type)), true);
    1974                 :          2 :       index_vec_type = build_vector_type (index_elt_type, nunits);
    1975                 :            :     }
    1976                 :            : 
    1977                 :       1038 :   tree_vector_builder v (index_vec_type, 1, 3);
    1978                 :       2076 :   for (unsigned int i = 0; i < 3; ++i)
    1979                 :       1557 :     v.quick_push (build_int_cstu (index_elt_type, base + i * step));
    1980                 :        519 :   return v.build ();
    1981                 :            : }
    1982                 :            : 
    1983                 :            : /* Return a VECTOR_CST of type VEC_TYPE in which the first NUM_A
    1984                 :            :    elements are A and the rest are B.  */
    1985                 :            : 
    1986                 :            : tree
    1987                 :          0 : build_vector_a_then_b (tree vec_type, unsigned int num_a, tree a, tree b)
    1988                 :            : {
    1989                 :          0 :   gcc_assert (known_le (num_a, TYPE_VECTOR_SUBPARTS (vec_type)));
    1990                 :          0 :   unsigned int count = constant_lower_bound (TYPE_VECTOR_SUBPARTS (vec_type));
    1991                 :            :   /* Optimize the constant case.  */
    1992                 :          0 :   if ((count & 1) == 0 && TYPE_VECTOR_SUBPARTS (vec_type).is_constant ())
    1993                 :          0 :     count /= 2;
    1994                 :          0 :   tree_vector_builder builder (vec_type, count, 2);
    1995                 :          0 :   for (unsigned int i = 0; i < count * 2; ++i)
    1996                 :          0 :     builder.quick_push (i < num_a ? a : b);
    1997                 :          0 :   return builder.build ();
    1998                 :            : }
    1999                 :            : 
    2000                 :            : /* Something has messed with the elements of CONSTRUCTOR C after it was built;
    2001                 :            :    calculate TREE_CONSTANT and TREE_SIDE_EFFECTS.  */
    2002                 :            : 
    2003                 :            : void
    2004                 :   17151300 : recompute_constructor_flags (tree c)
    2005                 :            : {
    2006                 :   17151300 :   unsigned int i;
    2007                 :   17151300 :   tree val;
    2008                 :   17151300 :   bool constant_p = true;
    2009                 :   17151300 :   bool side_effects_p = false;
    2010                 :   17151300 :   vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
    2011                 :            : 
    2012                 :   71018200 :   FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
    2013                 :            :     {
    2014                 :            :       /* Mostly ctors will have elts that don't have side-effects, so
    2015                 :            :          the usual case is to scan all the elements.  Hence a single
    2016                 :            :          loop for both const and side effects, rather than one loop
    2017                 :            :          each (with early outs).  */
    2018                 :   23755100 :       if (!TREE_CONSTANT (val))
    2019                 :    3244990 :         constant_p = false;
    2020                 :   23755100 :       if (TREE_SIDE_EFFECTS (val))
    2021                 :     470996 :         side_effects_p = true;
    2022                 :            :     }
    2023                 :            : 
    2024                 :   17151300 :   TREE_SIDE_EFFECTS (c) = side_effects_p;
    2025                 :   17151300 :   TREE_CONSTANT (c) = constant_p;
    2026                 :   17151300 : }
    2027                 :            : 
    2028                 :            : /* Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for
    2029                 :            :    CONSTRUCTOR C.  */
    2030                 :            : 
    2031                 :            : void
    2032                 :    1921960 : verify_constructor_flags (tree c)
    2033                 :            : {
    2034                 :    1921960 :   unsigned int i;
    2035                 :    1921960 :   tree val;
    2036                 :    1921960 :   bool constant_p = TREE_CONSTANT (c);
    2037                 :    1921960 :   bool side_effects_p = TREE_SIDE_EFFECTS (c);
    2038                 :    1921960 :   vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c);
    2039                 :            : 
    2040                 :    7030160 :   FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val)
    2041                 :            :     {
    2042                 :    4219270 :       if (constant_p && !TREE_CONSTANT (val))
    2043                 :          0 :         internal_error ("non-constant element in constant CONSTRUCTOR");
    2044                 :    4219270 :       if (!side_effects_p && TREE_SIDE_EFFECTS (val))
    2045                 :          0 :         internal_error ("side-effects element in no-side-effects CONSTRUCTOR");
    2046                 :            :     }
    2047                 :    1921960 : }
    2048                 :            : 
    2049                 :            : /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
    2050                 :            :    are in the vec pointed to by VALS.  */
    2051                 :            : tree
    2052                 :   16589900 : build_constructor (tree type, vec<constructor_elt, va_gc> *vals MEM_STAT_DECL)
    2053                 :            : {
    2054                 :   16589900 :   tree c = make_node (CONSTRUCTOR PASS_MEM_STAT);
    2055                 :            : 
    2056                 :   16589900 :   TREE_TYPE (c) = type;
    2057                 :   16589900 :   CONSTRUCTOR_ELTS (c) = vals;
    2058                 :            : 
    2059                 :   16589900 :   recompute_constructor_flags (c);
    2060                 :            : 
    2061                 :   16589900 :   return c;
    2062                 :            : }
    2063                 :            : 
    2064                 :            : /* Build a CONSTRUCTOR node made of a single initializer, with the specified
    2065                 :            :    INDEX and VALUE.  */
    2066                 :            : tree
    2067                 :       1004 : build_constructor_single (tree type, tree index, tree value)
    2068                 :            : {
    2069                 :       1004 :   vec<constructor_elt, va_gc> *v;
    2070                 :       1004 :   constructor_elt elt = {index, value};
    2071                 :            : 
    2072                 :       1004 :   vec_alloc (v, 1);
    2073                 :       1004 :   v->quick_push (elt);
    2074                 :            : 
    2075                 :       1004 :   return build_constructor (type, v);
    2076                 :            : }
    2077                 :            : 
    2078                 :            : 
    2079                 :            : /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
    2080                 :            :    are in a list pointed to by VALS.  */
    2081                 :            : tree
    2082                 :        323 : build_constructor_from_list (tree type, tree vals)
    2083                 :            : {
    2084                 :        323 :   tree t;
    2085                 :        323 :   vec<constructor_elt, va_gc> *v = NULL;
    2086                 :            : 
    2087                 :        323 :   if (vals)
    2088                 :            :     {
    2089                 :        323 :       vec_alloc (v, list_length (vals));
    2090                 :        838 :       for (t = vals; t; t = TREE_CHAIN (t))
    2091                 :        515 :         CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t));
    2092                 :            :     }
    2093                 :            : 
    2094                 :        323 :   return build_constructor (type, v);
    2095                 :            : }
    2096                 :            : 
    2097                 :            : /* Return a new CONSTRUCTOR node whose type is TYPE.  NELTS is the number
    2098                 :            :    of elements, provided as index/value pairs.  */
    2099                 :            : 
    2100                 :            : tree
    2101                 :      48239 : build_constructor_va (tree type, int nelts, ...)
    2102                 :            : {
    2103                 :      48239 :   vec<constructor_elt, va_gc> *v = NULL;
    2104                 :      48239 :   va_list p;
    2105                 :            : 
    2106                 :      48239 :   va_start (p, nelts);
    2107                 :      48239 :   vec_alloc (v, nelts);
    2108                 :     190735 :   while (nelts--)
    2109                 :            :     {
    2110                 :     142496 :       tree index = va_arg (p, tree);
    2111                 :     142496 :       tree value = va_arg (p, tree);
    2112                 :     142496 :       CONSTRUCTOR_APPEND_ELT (v, index, value);
    2113                 :            :     }
    2114                 :      48239 :   va_end (p);
    2115                 :      48239 :   return build_constructor (type, v);
    2116                 :            : }
    2117                 :            : 
    2118                 :            : /* Return a node of type TYPE for which TREE_CLOBBER_P is true.  */
    2119                 :            : 
    2120                 :            : tree
    2121                 :    4259780 : build_clobber (tree type)
    2122                 :            : {
    2123                 :    4259780 :   tree clobber = build_constructor (type, NULL);
    2124                 :    4259780 :   TREE_THIS_VOLATILE (clobber) = true;
    2125                 :    4259780 :   return clobber;
    2126                 :            : }
    2127                 :            : 
    2128                 :            : /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
    2129                 :            : 
    2130                 :            : tree
    2131                 :         57 : build_fixed (tree type, FIXED_VALUE_TYPE f)
    2132                 :            : {
    2133                 :         57 :   tree v;
    2134                 :         57 :   FIXED_VALUE_TYPE *fp;
    2135                 :            : 
    2136                 :         57 :   v = make_node (FIXED_CST);
    2137                 :         57 :   fp = ggc_alloc<fixed_value> ();
    2138                 :         57 :   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
    2139                 :            : 
    2140                 :         57 :   TREE_TYPE (v) = type;
    2141                 :         57 :   TREE_FIXED_CST_PTR (v) = fp;
    2142                 :         57 :   return v;
    2143                 :            : }
    2144                 :            : 
    2145                 :            : /* Return a new REAL_CST node whose type is TYPE and value is D.  */
    2146                 :            : 
    2147                 :            : tree
    2148                 :    6893050 : build_real (tree type, REAL_VALUE_TYPE d)
    2149                 :            : {
    2150                 :    6893050 :   tree v;
    2151                 :    6893050 :   REAL_VALUE_TYPE *dp;
    2152                 :    6893050 :   int overflow = 0;
    2153                 :            : 
    2154                 :            :   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
    2155                 :            :      Consider doing it via real_convert now.  */
    2156                 :            : 
    2157                 :    6893050 :   v = make_node (REAL_CST);
    2158                 :    6893050 :   dp = ggc_alloc<real_value> ();
    2159                 :    6893050 :   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
    2160                 :            : 
    2161                 :    6893050 :   TREE_TYPE (v) = type;
    2162                 :    6893050 :   TREE_REAL_CST_PTR (v) = dp;
    2163                 :    6893050 :   TREE_OVERFLOW (v) = overflow;
    2164                 :    6893050 :   return v;
    2165                 :            : }
    2166                 :            : 
    2167                 :            : /* Like build_real, but first truncate D to the type.  */
    2168                 :            : 
    2169                 :            : tree
    2170                 :     443975 : build_real_truncate (tree type, REAL_VALUE_TYPE d)
    2171                 :            : {
    2172                 :     443975 :   return build_real (type, real_value_truncate (TYPE_MODE (type), d));
    2173                 :            : }
    2174                 :            : 
    2175                 :            : /* Return a new REAL_CST node whose type is TYPE
    2176                 :            :    and whose value is the integer value of the INTEGER_CST node I.  */
    2177                 :            : 
    2178                 :            : REAL_VALUE_TYPE
    2179                 :    1623200 : real_value_from_int_cst (const_tree type, const_tree i)
    2180                 :            : {
    2181                 :    1623200 :   REAL_VALUE_TYPE d;
    2182                 :            : 
    2183                 :            :   /* Clear all bits of the real value type so that we can later do
    2184                 :            :      bitwise comparisons to see if two values are the same.  */
    2185                 :    1623200 :   memset (&d, 0, sizeof d);
    2186                 :            : 
    2187                 :    4827370 :   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, wi::to_wide (i),
    2188                 :    1623200 :                      TYPE_SIGN (TREE_TYPE (i)));
    2189                 :    1623200 :   return d;
    2190                 :            : }
    2191                 :            : 
    2192                 :            : /* Given a tree representing an integer constant I, return a tree
    2193                 :            :    representing the same value as a floating-point constant of type TYPE.  */
    2194                 :            : 
    2195                 :            : tree
    2196                 :    1580970 : build_real_from_int_cst (tree type, const_tree i)
    2197                 :            : {
    2198                 :    1580970 :   tree v;
    2199                 :    1580970 :   int overflow = TREE_OVERFLOW (i);
    2200                 :            : 
    2201                 :    1580970 :   v = build_real (type, real_value_from_int_cst (type, i));
    2202                 :            : 
    2203                 :    1580970 :   TREE_OVERFLOW (v) |= overflow;
    2204                 :    1580970 :   return v;
    2205                 :            : }
    2206                 :            : 
    2207                 :            : /* Return a newly constructed STRING_CST node whose value is
    2208                 :            :    the LEN characters at STR.
    2209                 :            :    Note that for a C string literal, LEN should include the trailing NUL.
    2210                 :            :    The TREE_TYPE is not initialized.  */
    2211                 :            : 
    2212                 :            : tree
    2213                 :   41389100 : build_string (int len, const char *str)
    2214                 :            : {
    2215                 :   41389100 :   tree s;
    2216                 :   41389100 :   size_t length;
    2217                 :            : 
    2218                 :            :   /* Do not waste bytes provided by padding of struct tree_string.  */
    2219                 :   41389100 :   length = len + offsetof (struct tree_string, str) + 1;
    2220                 :            : 
    2221                 :   41389100 :   record_node_allocation_statistics (STRING_CST, length);
    2222                 :            : 
    2223                 :   41389100 :   s = (tree) ggc_internal_alloc (length);
    2224                 :            : 
    2225                 :   41389100 :   memset (s, 0, sizeof (struct tree_typed));
    2226                 :   41389100 :   TREE_SET_CODE (s, STRING_CST);
    2227                 :   41389100 :   TREE_CONSTANT (s) = 1;
    2228                 :   41389100 :   TREE_STRING_LENGTH (s) = len;
    2229                 :   41389100 :   memcpy (s->string.str, str, len);
    2230                 :   41389100 :   s->string.str[len] = '\0';
    2231                 :            : 
    2232                 :   41389100 :   return s;
    2233                 :            : }
    2234                 :            : 
    2235                 :            : /* Return a newly constructed COMPLEX_CST node whose value is
    2236                 :            :    specified by the real and imaginary parts REAL and IMAG.
    2237                 :            :    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
    2238                 :            :    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
    2239                 :            : 
    2240                 :            : tree
    2241                 :     472655 : build_complex (tree type, tree real, tree imag)
    2242                 :            : {
    2243                 :     472655 :   gcc_assert (CONSTANT_CLASS_P (real));
    2244                 :     472655 :   gcc_assert (CONSTANT_CLASS_P (imag));
    2245                 :            : 
    2246                 :     472655 :   tree t = make_node (COMPLEX_CST);
    2247                 :            : 
    2248                 :     472655 :   TREE_REALPART (t) = real;
    2249                 :     472655 :   TREE_IMAGPART (t) = imag;
    2250                 :     526624 :   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
    2251                 :     472655 :   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
    2252                 :     472655 :   return t;
    2253                 :            : }
    2254                 :            : 
    2255                 :            : /* Build a complex (inf +- 0i), such as for the result of cproj.
    2256                 :            :    TYPE is the complex tree type of the result.  If NEG is true, the
    2257                 :            :    imaginary zero is negative.  */
    2258                 :            : 
    2259                 :            : tree
    2260                 :        252 : build_complex_inf (tree type, bool neg)
    2261                 :            : {
    2262                 :        252 :   REAL_VALUE_TYPE rinf, rzero = dconst0;
    2263                 :            : 
    2264                 :        252 :   real_inf (&rinf);
    2265                 :        252 :   rzero.sign = neg;
    2266                 :        504 :   return build_complex (type, build_real (TREE_TYPE (type), rinf),
    2267                 :        252 :                         build_real (TREE_TYPE (type), rzero));
    2268                 :            : }
    2269                 :            : 
    2270                 :            : /* Return the constant 1 in type TYPE.  If TYPE has several elements, each
    2271                 :            :    element is set to 1.  In particular, this is 1 + i for complex types.  */
    2272                 :            : 
    2273                 :            : tree
    2274                 :        865 : build_each_one_cst (tree type)
    2275                 :            : {
    2276                 :        865 :   if (TREE_CODE (type) == COMPLEX_TYPE)
    2277                 :            :     {
    2278                 :          0 :       tree scalar = build_one_cst (TREE_TYPE (type));
    2279                 :          0 :       return build_complex (type, scalar, scalar);
    2280                 :            :     }
    2281                 :            :   else
    2282                 :        865 :     return build_one_cst (type);
    2283                 :            : }
    2284                 :            : 
    2285                 :            : /* Return a constant of arithmetic type TYPE which is the
    2286                 :            :    multiplicative identity of the set TYPE.  */
    2287                 :            : 
    2288                 :            : tree
    2289                 :    4476190 : build_one_cst (tree type)
    2290                 :            : {
    2291                 :    4476190 :   switch (TREE_CODE (type))
    2292                 :            :     {
    2293                 :    4463980 :     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
    2294                 :    4463980 :     case POINTER_TYPE: case REFERENCE_TYPE:
    2295                 :    4463980 :     case OFFSET_TYPE:
    2296                 :    4463980 :       return build_int_cst (type, 1);
    2297                 :            : 
    2298                 :       8929 :     case REAL_TYPE:
    2299                 :       8929 :       return build_real (type, dconst1);
    2300                 :            : 
    2301                 :          0 :     case FIXED_POINT_TYPE:
    2302                 :            :       /* We can only generate 1 for accum types.  */
    2303                 :          0 :       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
    2304                 :          0 :       return build_fixed (type, FCONST1 (TYPE_MODE (type)));
    2305                 :            : 
    2306                 :        294 :     case VECTOR_TYPE:
    2307                 :        294 :       {
    2308                 :        294 :         tree scalar = build_one_cst (TREE_TYPE (type));
    2309                 :            : 
    2310                 :        294 :         return build_vector_from_val (type, scalar);
    2311                 :            :       }
    2312                 :            : 
    2313                 :       2989 :     case COMPLEX_TYPE:
    2314                 :       8967 :       return build_complex (type,
    2315                 :       2989 :                             build_one_cst (TREE_TYPE (type)),
    2316                 :       5978 :                             build_zero_cst (TREE_TYPE (type)));
    2317                 :            : 
    2318                 :          0 :     default:
    2319                 :          0 :       gcc_unreachable ();
    2320                 :            :     }
    2321                 :            : }
    2322                 :            : 
    2323                 :            : /* Return an integer of type TYPE containing all 1's in as much precision as
    2324                 :            :    it contains, or a complex or vector whose subparts are such integers.  */
    2325                 :            : 
    2326                 :            : tree
    2327                 :     122069 : build_all_ones_cst (tree type)
    2328                 :            : {
    2329                 :     122069 :   if (TREE_CODE (type) == COMPLEX_TYPE)
    2330                 :            :     {
    2331                 :          0 :       tree scalar = build_all_ones_cst (TREE_TYPE (type));
    2332                 :          0 :       return build_complex (type, scalar, scalar);
    2333                 :            :     }
    2334                 :            :   else
    2335                 :     122069 :     return build_minus_one_cst (type);
    2336                 :            : }
    2337                 :            : 
    2338                 :            : /* Return a constant of arithmetic type TYPE which is the
    2339                 :            :    opposite of the multiplicative identity of the set TYPE.  */
    2340                 :            : 
    2341                 :            : tree
    2342                 :     536246 : build_minus_one_cst (tree type)
    2343                 :            : {
    2344                 :     536246 :   switch (TREE_CODE (type))
    2345                 :            :     {
    2346                 :     443518 :     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
    2347                 :     443518 :     case POINTER_TYPE: case REFERENCE_TYPE:
    2348                 :     443518 :     case OFFSET_TYPE:
    2349                 :     443518 :       return build_int_cst (type, -1);
    2350                 :            : 
    2351                 :      10180 :     case REAL_TYPE:
    2352                 :      10180 :       return build_real (type, dconstm1);
    2353                 :            : 
    2354                 :          0 :     case FIXED_POINT_TYPE:
    2355                 :            :       /* We can only generate 1 for accum types.  */
    2356                 :          0 :       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
    2357                 :          0 :       return build_fixed (type,
    2358                 :            :                           fixed_from_double_int (double_int_minus_one,
    2359                 :          0 :                                                  SCALAR_TYPE_MODE (type)));
    2360                 :            : 
    2361                 :      82548 :     case VECTOR_TYPE:
    2362                 :      82548 :       {
    2363                 :      82548 :         tree scalar = build_minus_one_cst (TREE_TYPE (type));
    2364                 :            : 
    2365                 :      82548 :         return build_vector_from_val (type, scalar);
    2366                 :            :       }
    2367                 :            : 
    2368                 :          0 :     case COMPLEX_TYPE:
    2369                 :          0 :       return build_complex (type,
    2370                 :          0 :                             build_minus_one_cst (TREE_TYPE (type)),
    2371                 :          0 :                             build_zero_cst (TREE_TYPE (type)));
    2372                 :            : 
    2373                 :          0 :     default:
    2374                 :          0 :       gcc_unreachable ();
    2375                 :            :     }
    2376                 :            : }
    2377                 :            : 
    2378                 :            : /* Build 0 constant of type TYPE.  This is used by constructor folding
    2379                 :            :    and thus the constant should be represented in memory by
    2380                 :            :    zero(es).  */
    2381                 :            : 
    2382                 :            : tree
    2383                 :  110763000 : build_zero_cst (tree type)
    2384                 :            : {
    2385                 :  110763000 :   switch (TREE_CODE (type))
    2386                 :            :     {
    2387                 :  110347000 :     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
    2388                 :  110347000 :     case POINTER_TYPE: case REFERENCE_TYPE:
    2389                 :  110347000 :     case OFFSET_TYPE: case NULLPTR_TYPE:
    2390                 :  110347000 :       return build_int_cst (type, 0);
    2391                 :            : 
    2392                 :     149281 :     case REAL_TYPE:
    2393                 :     149281 :       return build_real (type, dconst0);
    2394                 :            : 
    2395                 :          0 :     case FIXED_POINT_TYPE:
    2396                 :          0 :       return build_fixed (type, FCONST0 (TYPE_MODE (type)));
    2397                 :            : 
    2398                 :     106854 :     case VECTOR_TYPE:
    2399                 :     106854 :       {
    2400                 :     106854 :         tree scalar = build_zero_cst (TREE_TYPE (type));
    2401                 :            : 
    2402                 :     106854 :         return build_vector_from_val (type, scalar);
    2403                 :            :       }
    2404                 :            : 
    2405                 :       2400 :     case COMPLEX_TYPE:
    2406                 :       2400 :       {
    2407                 :       2400 :         tree zero = build_zero_cst (TREE_TYPE (type));
    2408                 :            : 
    2409                 :       2400 :         return build_complex (type, zero, zero);
    2410                 :            :       }
    2411                 :            : 
    2412                 :     157494 :     default:
    2413                 :     157494 :       if (!AGGREGATE_TYPE_P (type))
    2414                 :          1 :         return fold_convert (type, integer_zero_node);
    2415                 :     157493 :       return build_constructor (type, NULL);
    2416                 :            :     }
    2417                 :            : }
    2418                 :            : 
    2419                 :            : 
    2420                 :            : /* Build a BINFO with LEN language slots.  */
    2421                 :            : 
    2422                 :            : tree
    2423                 :   27089500 : make_tree_binfo (unsigned base_binfos MEM_STAT_DECL)
    2424                 :            : {
    2425                 :   27089500 :   tree t;
    2426                 :   27089500 :   size_t length = (offsetof (struct tree_binfo, base_binfos)
    2427                 :   27089500 :                    + vec<tree, va_gc>::embedded_size (base_binfos));
    2428                 :            : 
    2429                 :   27089500 :   record_node_allocation_statistics (TREE_BINFO, length);
    2430                 :            : 
    2431                 :   27089500 :   t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
    2432                 :            : 
    2433                 :   27089500 :   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
    2434                 :            : 
    2435                 :   27089500 :   TREE_SET_CODE (t, TREE_BINFO);
    2436                 :            : 
    2437                 :   27089500 :   BINFO_BASE_BINFOS (t)->embedded_init (base_binfos);
    2438                 :            : 
    2439                 :   27089500 :   return t;
    2440                 :            : }
    2441                 :            : 
    2442                 :            : /* Create a CASE_LABEL_EXPR tree node and return it.  */
    2443                 :            : 
    2444                 :            : tree
    2445                 :    1276750 : build_case_label (tree low_value, tree high_value, tree label_decl)
    2446                 :            : {
    2447                 :    1276750 :   tree t = make_node (CASE_LABEL_EXPR);
    2448                 :            : 
    2449                 :    1276750 :   TREE_TYPE (t) = void_type_node;
    2450                 :    1276750 :   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl));
    2451                 :            : 
    2452                 :    1276750 :   CASE_LOW (t) = low_value;
    2453                 :    1276750 :   CASE_HIGH (t) = high_value;
    2454                 :    1276750 :   CASE_LABEL (t) = label_decl;
    2455                 :    1276750 :   CASE_CHAIN (t) = NULL_TREE;
    2456                 :            : 
    2457                 :    1276750 :   return t;
    2458                 :            : }
    2459                 :            : 
    2460                 :            : /* Build a newly constructed INTEGER_CST node.  LEN and EXT_LEN are the
    2461                 :            :    values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively.
    2462                 :            :    The latter determines the length of the HOST_WIDE_INT vector.  */
    2463                 :            : 
    2464                 :            : tree
    2465                 :  172447000 : make_int_cst (int len, int ext_len MEM_STAT_DECL)
    2466                 :            : {
    2467                 :  172447000 :   tree t;
    2468                 :  172447000 :   int length = ((ext_len - 1) * sizeof (HOST_WIDE_INT)
    2469                 :  172447000 :                 + sizeof (struct tree_int_cst));
    2470                 :            : 
    2471                 :  172447000 :   gcc_assert (len);
    2472                 :  172447000 :   record_node_allocation_statistics (INTEGER_CST, length);
    2473                 :            : 
    2474                 :  172447000 :   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
    2475                 :            : 
    2476                 :  172447000 :   TREE_SET_CODE (t, INTEGER_CST);
    2477                 :  172447000 :   TREE_INT_CST_NUNITS (t) = len;
    2478                 :  172447000 :   TREE_INT_CST_EXT_NUNITS (t) = ext_len;
    2479                 :            :   /* to_offset can only be applied to trees that are offset_int-sized
    2480                 :            :      or smaller.  EXT_LEN is correct if it fits, otherwise the constant
    2481                 :            :      must be exactly the precision of offset_int and so LEN is correct.  */
    2482                 :  172447000 :   if (ext_len <= OFFSET_INT_ELTS)
    2483                 :  165434000 :     TREE_INT_CST_OFFSET_NUNITS (t) = ext_len;
    2484                 :            :   else
    2485                 :    7012940 :     TREE_INT_CST_OFFSET_NUNITS (t) = len;
    2486                 :            : 
    2487                 :  172447000 :   TREE_CONSTANT (t) = 1;
    2488                 :            : 
    2489                 :  172447000 :   return t;
    2490                 :            : }
    2491                 :            : 
    2492                 :            : /* Build a newly constructed TREE_VEC node of length LEN.  */
    2493                 :            : 
    2494                 :            : tree
    2495                 :  653064000 : make_tree_vec (int len MEM_STAT_DECL)
    2496                 :            : {
    2497                 :  653064000 :   tree t;
    2498                 :  653064000 :   size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
    2499                 :            : 
    2500                 :  653064000 :   record_node_allocation_statistics (TREE_VEC, length);
    2501                 :            : 
    2502                 :  653064000 :   t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
    2503                 :            : 
    2504                 :  653064000 :   TREE_SET_CODE (t, TREE_VEC);
    2505                 :  653064000 :   TREE_VEC_LENGTH (t) = len;
    2506                 :            : 
    2507                 :  653064000 :   return t;
    2508                 :            : }
    2509                 :            : 
    2510                 :            : /* Grow a TREE_VEC node to new length LEN.  */
    2511                 :            : 
    2512                 :            : tree
    2513                 :        796 : grow_tree_vec (tree v, int len MEM_STAT_DECL)
    2514                 :            : {
    2515                 :        796 :   gcc_assert (TREE_CODE (v) == TREE_VEC);
    2516                 :            : 
    2517                 :        796 :   int oldlen = TREE_VEC_LENGTH (v);
    2518                 :        796 :   gcc_assert (len > oldlen);
    2519                 :            : 
    2520                 :        796 :   size_t oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec);
    2521                 :        796 :   size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
    2522                 :            : 
    2523                 :        796 :   record_node_allocation_statistics (TREE_VEC, length - oldlength);
    2524                 :            : 
    2525                 :        796 :   v = (tree) ggc_realloc (v, length PASS_MEM_STAT);
    2526                 :            : 
    2527                 :        796 :   TREE_VEC_LENGTH (v) = len;
    2528                 :            : 
    2529                 :        796 :   return v;
    2530                 :            : }
    2531                 :            : 
    2532                 :            : /* Return 1 if EXPR is the constant zero, whether it is integral, float or
    2533                 :            :    fixed, and scalar, complex or vector.  */
    2534                 :            : 
    2535                 :            : bool
    2536                 :    2676250 : zerop (const_tree expr)
    2537                 :            : {
    2538                 :    2676250 :   return (integer_zerop (expr)
    2539                 :    2419580 :           || real_zerop (expr)
    2540                 :    5095030 :           || fixed_zerop (expr));
    2541                 :            : }
    2542                 :            : 
    2543                 :            : /* Return 1 if EXPR is the integer constant zero or a complex constant
    2544                 :            :    of zero, or a location wrapper for such a constant.  */
    2545                 :            : 
    2546                 :            : bool
    2547                 : 2182560000 : integer_zerop (const_tree expr)
    2548                 :            : {
    2549                 : 2182560000 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2550                 :            : 
    2551                 : 2182560000 :   switch (TREE_CODE (expr))
    2552                 :            :     {
    2553                 : 1860340000 :     case INTEGER_CST:
    2554                 : 1860340000 :       return wi::to_wide (expr) == 0;
    2555                 :     695361 :     case COMPLEX_CST:
    2556                 :     695361 :       return (integer_zerop (TREE_REALPART (expr))
    2557                 :     696909 :               && integer_zerop (TREE_IMAGPART (expr)));
    2558                 :     514803 :     case VECTOR_CST:
    2559                 :     514803 :       return (VECTOR_CST_NPATTERNS (expr) == 1
    2560                 :     498054 :               && VECTOR_CST_DUPLICATE_P (expr)
    2561                 :     993316 :               && integer_zerop (VECTOR_CST_ENCODED_ELT (expr, 0)));
    2562                 :            :     default:
    2563                 :            :       return false;
    2564                 :            :     }
    2565                 :            : }
    2566                 :            : 
    2567                 :            : /* Return 1 if EXPR is the integer constant one or the corresponding
    2568                 :            :    complex constant, or a location wrapper for such a constant.  */
    2569                 :            : 
    2570                 :            : bool
    2571                 :  334353000 : integer_onep (const_tree expr)
    2572                 :            : {
    2573                 :  334353000 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2574                 :            : 
    2575                 :  334353000 :   switch (TREE_CODE (expr))
    2576                 :            :     {
    2577                 :  288211000 :     case INTEGER_CST:
    2578                 :  288211000 :       return wi::eq_p (wi::to_widest (expr), 1);
    2579                 :      15788 :     case COMPLEX_CST:
    2580                 :      15788 :       return (integer_onep (TREE_REALPART (expr))
    2581                 :      15804 :               && integer_zerop (TREE_IMAGPART (expr)));
    2582                 :      41999 :     case VECTOR_CST:
    2583                 :      41999 :       return (VECTOR_CST_NPATTERNS (expr) == 1
    2584                 :      35211 :               && VECTOR_CST_DUPLICATE_P (expr)
    2585                 :      72892 :               && integer_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
    2586                 :            :     default:
    2587                 :            :       return false;
    2588                 :            :     }
    2589                 :            : }
    2590                 :            : 
    2591                 :            : /* Return 1 if EXPR is the integer constant one.  For complex and vector,
    2592                 :            :    return 1 if every piece is the integer constant one.
    2593                 :            :    Also return 1 for location wrappers for such a constant.  */
    2594                 :            : 
    2595                 :            : bool
    2596                 :     275053 : integer_each_onep (const_tree expr)
    2597                 :            : {
    2598                 :     275053 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2599                 :            : 
    2600                 :     275053 :   if (TREE_CODE (expr) == COMPLEX_CST)
    2601                 :         12 :     return (integer_onep (TREE_REALPART (expr))
    2602                 :         14 :             && integer_onep (TREE_IMAGPART (expr)));
    2603                 :            :   else
    2604                 :     275041 :     return integer_onep (expr);
    2605                 :            : }
    2606                 :            : 
    2607                 :            : /* Return 1 if EXPR is an integer containing all 1's in as much precision as
    2608                 :            :    it contains, or a complex or vector whose subparts are such integers,
    2609                 :            :    or a location wrapper for such a constant.  */
    2610                 :            : 
    2611                 :            : bool
    2612                 :  100487000 : integer_all_onesp (const_tree expr)
    2613                 :            : {
    2614                 :  100487000 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2615                 :            : 
    2616                 :  100487000 :   if (TREE_CODE (expr) == COMPLEX_CST
    2617                 :         73 :       && integer_all_onesp (TREE_REALPART (expr))
    2618                 :  100487000 :       && integer_all_onesp (TREE_IMAGPART (expr)))
    2619                 :            :     return true;
    2620                 :            : 
    2621                 :  100487000 :   else if (TREE_CODE (expr) == VECTOR_CST)
    2622                 :     160418 :     return (VECTOR_CST_NPATTERNS (expr) == 1
    2623                 :     154241 :             && VECTOR_CST_DUPLICATE_P (expr)
    2624                 :     307674 :             && integer_all_onesp (VECTOR_CST_ENCODED_ELT (expr, 0)));
    2625                 :            : 
    2626                 :  100327000 :   else if (TREE_CODE (expr) != INTEGER_CST)
    2627                 :            :     return false;
    2628                 :            : 
    2629                 :   63993500 :   return (wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED)
    2630                 :  127987000 :           == wi::to_wide (expr));
    2631                 :            : }
    2632                 :            : 
    2633                 :            : /* Return 1 if EXPR is the integer constant minus one, or a location wrapper
    2634                 :            :    for such a constant.  */
    2635                 :            : 
    2636                 :            : bool
    2637                 :   64879800 : integer_minus_onep (const_tree expr)
    2638                 :            : {
    2639                 :   64879800 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2640                 :            : 
    2641                 :   64879800 :   if (TREE_CODE (expr) == COMPLEX_CST)
    2642                 :       8585 :     return (integer_all_onesp (TREE_REALPART (expr))
    2643                 :       8587 :             && integer_zerop (TREE_IMAGPART (expr)));
    2644                 :            :   else
    2645                 :   64871200 :     return integer_all_onesp (expr);
    2646                 :            : }
    2647                 :            : 
    2648                 :            : /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
    2649                 :            :    one bit on), or a location wrapper for such a constant.  */
    2650                 :            : 
    2651                 :            : bool
    2652                 :    6721100 : integer_pow2p (const_tree expr)
    2653                 :            : {
    2654                 :    6721100 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2655                 :            : 
    2656                 :    6721100 :   if (TREE_CODE (expr) == COMPLEX_CST
    2657                 :          1 :       && integer_pow2p (TREE_REALPART (expr))
    2658                 :    6721100 :       && integer_zerop (TREE_IMAGPART (expr)))
    2659                 :            :     return true;
    2660                 :            : 
    2661                 :    6721100 :   if (TREE_CODE (expr) != INTEGER_CST)
    2662                 :            :     return false;
    2663                 :            : 
    2664                 :    4376720 :   return wi::popcount (wi::to_wide (expr)) == 1;
    2665                 :            : }
    2666                 :            : 
    2667                 :            : /* Return 1 if EXPR is an integer constant other than zero or a
    2668                 :            :    complex constant other than zero, or a location wrapper for such a
    2669                 :            :    constant.  */
    2670                 :            : 
    2671                 :            : bool
    2672                 :   31211000 : integer_nonzerop (const_tree expr)
    2673                 :            : {
    2674                 :   31211000 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2675                 :            : 
    2676                 :   31211000 :   return ((TREE_CODE (expr) == INTEGER_CST
    2677                 :   16450100 :            && wi::to_wide (expr) != 0)
    2678                 :   33528000 :           || (TREE_CODE (expr) == COMPLEX_CST
    2679                 :         12 :               && (integer_nonzerop (TREE_REALPART (expr))
    2680                 :          8 :                   || integer_nonzerop (TREE_IMAGPART (expr)))));
    2681                 :            : }
    2682                 :            : 
    2683                 :            : /* Return 1 if EXPR is the integer constant one.  For vector,
    2684                 :            :    return 1 if every piece is the integer constant minus one
    2685                 :            :    (representing the value TRUE).
    2686                 :            :    Also return 1 for location wrappers for such a constant.  */
    2687                 :            : 
    2688                 :            : bool
    2689                 :      50669 : integer_truep (const_tree expr)
    2690                 :            : {
    2691                 :      50669 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2692                 :            : 
    2693                 :      50669 :   if (TREE_CODE (expr) == VECTOR_CST)
    2694                 :          0 :     return integer_all_onesp (expr);
    2695                 :      50669 :   return integer_onep (expr);
    2696                 :            : }
    2697                 :            : 
    2698                 :            : /* Return 1 if EXPR is the fixed-point constant zero, or a location wrapper
    2699                 :            :    for such a constant.  */
    2700                 :            : 
    2701                 :            : bool
    2702                 :    3817430 : fixed_zerop (const_tree expr)
    2703                 :            : {
    2704                 :    3817430 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2705                 :            : 
    2706                 :    3817430 :   return (TREE_CODE (expr) == FIXED_CST
    2707                 :    3817430 :           && TREE_FIXED_CST (expr).data.is_zero ());
    2708                 :            : }
    2709                 :            : 
    2710                 :            : /* Return the power of two represented by a tree node known to be a
    2711                 :            :    power of two.  */
    2712                 :            : 
    2713                 :            : int
    2714                 :     172287 : tree_log2 (const_tree expr)
    2715                 :            : {
    2716                 :     172287 :   if (TREE_CODE (expr) == COMPLEX_CST)
    2717                 :          0 :     return tree_log2 (TREE_REALPART (expr));
    2718                 :            : 
    2719                 :     172287 :   return wi::exact_log2 (wi::to_wide (expr));
    2720                 :            : }
    2721                 :            : 
    2722                 :            : /* Similar, but return the largest integer Y such that 2 ** Y is less
    2723                 :            :    than or equal to EXPR.  */
    2724                 :            : 
    2725                 :            : int
    2726                 :     729931 : tree_floor_log2 (const_tree expr)
    2727                 :            : {
    2728                 :     729931 :   if (TREE_CODE (expr) == COMPLEX_CST)
    2729                 :          0 :     return tree_log2 (TREE_REALPART (expr));
    2730                 :            : 
    2731                 :     729931 :   return wi::floor_log2 (wi::to_wide (expr));
    2732                 :            : }
    2733                 :            : 
    2734                 :            : /* Return number of known trailing zero bits in EXPR, or, if the value of
    2735                 :            :    EXPR is known to be zero, the precision of it's type.  */
    2736                 :            : 
    2737                 :            : unsigned int
    2738                 :   10390600 : tree_ctz (const_tree expr)
    2739                 :            : {
    2740                 :   20780800 :   if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
    2741                 :   10391600 :       && !POINTER_TYPE_P (TREE_TYPE (expr)))
    2742                 :            :     return 0;
    2743                 :            : 
    2744                 :   10390600 :   unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr));
    2745                 :   10390600 :   switch (TREE_CODE (expr))
    2746                 :            :     {
    2747                 :    4392780 :     case INTEGER_CST:
    2748                 :    4392780 :       ret1 = wi::ctz (wi::to_wide (expr));
    2749                 :    4392780 :       return MIN (ret1, prec);
    2750                 :    1796570 :     case SSA_NAME:
    2751                 :    1796570 :       ret1 = wi::ctz (get_nonzero_bits (expr));
    2752                 :    1796570 :       return MIN (ret1, prec);
    2753                 :     794506 :     case PLUS_EXPR:
    2754                 :     794506 :     case MINUS_EXPR:
    2755                 :     794506 :     case BIT_IOR_EXPR:
    2756                 :     794506 :     case BIT_XOR_EXPR:
    2757                 :     794506 :     case MIN_EXPR:
    2758                 :     794506 :     case MAX_EXPR:
    2759                 :     794506 :       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2760                 :     794506 :       if (ret1 == 0)
    2761                 :            :         return ret1;
    2762                 :     248074 :       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
    2763                 :     248074 :       return MIN (ret1, ret2);
    2764                 :          0 :     case POINTER_PLUS_EXPR:
    2765                 :          0 :       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2766                 :          0 :       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
    2767                 :            :       /* Second operand is sizetype, which could be in theory
    2768                 :            :          wider than pointer's precision.  Make sure we never
    2769                 :            :          return more than prec.  */
    2770                 :          0 :       ret2 = MIN (ret2, prec);
    2771                 :          0 :       return MIN (ret1, ret2);
    2772                 :          0 :     case BIT_AND_EXPR:
    2773                 :          0 :       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2774                 :          0 :       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
    2775                 :          0 :       return MAX (ret1, ret2);
    2776                 :    1607750 :     case MULT_EXPR:
    2777                 :    1607750 :       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2778                 :    1607750 :       ret2 = tree_ctz (TREE_OPERAND (expr, 1));
    2779                 :    1607750 :       return MIN (ret1 + ret2, prec);
    2780                 :          0 :     case LSHIFT_EXPR:
    2781                 :          0 :       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2782                 :          0 :       if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
    2783                 :          0 :           && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
    2784                 :            :         {
    2785                 :          0 :           ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
    2786                 :          0 :           return MIN (ret1 + ret2, prec);
    2787                 :            :         }
    2788                 :            :       return ret1;
    2789                 :          0 :     case RSHIFT_EXPR:
    2790                 :          0 :       if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1))
    2791                 :          0 :           && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec))
    2792                 :            :         {
    2793                 :          0 :           ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2794                 :          0 :           ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1));
    2795                 :          0 :           if (ret1 > ret2)
    2796                 :          0 :             return ret1 - ret2;
    2797                 :            :         }
    2798                 :            :       return 0;
    2799                 :        915 :     case TRUNC_DIV_EXPR:
    2800                 :        915 :     case CEIL_DIV_EXPR:
    2801                 :        915 :     case FLOOR_DIV_EXPR:
    2802                 :        915 :     case ROUND_DIV_EXPR:
    2803                 :        915 :     case EXACT_DIV_EXPR:
    2804                 :        915 :       if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
    2805                 :        915 :           && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1)
    2806                 :            :         {
    2807                 :        915 :           int l = tree_log2 (TREE_OPERAND (expr, 1));
    2808                 :        915 :           if (l >= 0)
    2809                 :            :             {
    2810                 :        915 :               ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2811                 :        915 :               ret2 = l;
    2812                 :        915 :               if (ret1 > ret2)
    2813                 :          0 :                 return ret1 - ret2;
    2814                 :            :             }
    2815                 :            :         }
    2816                 :            :       return 0;
    2817                 :    1787960 :     CASE_CONVERT:
    2818                 :    1787960 :       ret1 = tree_ctz (TREE_OPERAND (expr, 0));
    2819                 :    1787960 :       if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
    2820                 :            :         ret1 = prec;
    2821                 :    1787960 :       return MIN (ret1, prec);
    2822                 :          0 :     case SAVE_EXPR:
    2823                 :          0 :       return tree_ctz (TREE_OPERAND (expr, 0));
    2824                 :       1057 :     case COND_EXPR:
    2825                 :       1057 :       ret1 = tree_ctz (TREE_OPERAND (expr, 1));
    2826                 :       1057 :       if (ret1 == 0)
    2827                 :            :         return 0;
    2828                 :         13 :       ret2 = tree_ctz (TREE_OPERAND (expr, 2));
    2829                 :         13 :       return MIN (ret1, ret2);
    2830                 :          0 :     case COMPOUND_EXPR:
    2831                 :          0 :       return tree_ctz (TREE_OPERAND (expr, 1));
    2832                 :          2 :     case ADDR_EXPR:
    2833                 :          2 :       ret1 = get_pointer_alignment (CONST_CAST_TREE (expr));
    2834                 :          2 :       if (ret1 > BITS_PER_UNIT)
    2835                 :            :         {
    2836                 :          2 :           ret1 = ctz_hwi (ret1 / BITS_PER_UNIT);
    2837                 :          2 :           return MIN (ret1, prec);
    2838                 :            :         }
    2839                 :            :       return 0;
    2840                 :            :     default:
    2841                 :            :       return 0;
    2842                 :            :     }
    2843                 :            : }
    2844                 :            : 
    2845                 :            : /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
    2846                 :            :    decimal float constants, so don't return 1 for them.
    2847                 :            :    Also return 1 for location wrappers around such a constant.  */
    2848                 :            : 
    2849                 :            : bool
    2850                 :  286844000 : real_zerop (const_tree expr)
    2851                 :            : {
    2852                 :  286844000 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2853                 :            : 
    2854                 :  286844000 :   switch (TREE_CODE (expr))
    2855                 :            :     {
    2856                 :    3822540 :     case REAL_CST:
    2857                 :    3822540 :       return real_equal (&TREE_REAL_CST (expr), &dconst0)
    2858                 :    4497590 :              && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
    2859                 :      39065 :     case COMPLEX_CST:
    2860                 :      39065 :       return real_zerop (TREE_REALPART (expr))
    2861                 :      50340 :              && real_zerop (TREE_IMAGPART (expr));
    2862                 :      95331 :     case VECTOR_CST:
    2863                 :      95331 :       {
    2864                 :            :         /* Don't simply check for a duplicate because the predicate
    2865                 :            :            accepts both +0.0 and -0.0.  */
    2866                 :      95331 :         unsigned count = vector_cst_encoded_nelts (expr);
    2867                 :     104077 :         for (unsigned int i = 0; i < count; ++i)
    2868                 :      95739 :           if (!real_zerop (VECTOR_CST_ENCODED_ELT (expr, i)))
    2869                 :            :             return false;
    2870                 :            :         return true;
    2871                 :            :       }
    2872                 :            :     default:
    2873                 :            :       return false;
    2874                 :            :     }
    2875                 :            : }
    2876                 :            : 
    2877                 :            : /* Return 1 if EXPR is the real constant one in real or complex form.
    2878                 :            :    Trailing zeroes matter for decimal float constants, so don't return
    2879                 :            :    1 for them.
    2880                 :            :    Also return 1 for location wrappers around such a constant.  */
    2881                 :            : 
    2882                 :            : bool
    2883                 :   44543900 : real_onep (const_tree expr)
    2884                 :            : {
    2885                 :   44543900 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2886                 :            : 
    2887                 :   44543900 :   switch (TREE_CODE (expr))
    2888                 :            :     {
    2889                 :    1051070 :     case REAL_CST:
    2890                 :    1051070 :       return real_equal (&TREE_REAL_CST (expr), &dconst1)
    2891                 :    1085250 :              && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
    2892                 :      11751 :     case COMPLEX_CST:
    2893                 :      11751 :       return real_onep (TREE_REALPART (expr))
    2894                 :      15102 :              && real_zerop (TREE_IMAGPART (expr));
    2895                 :      20397 :     case VECTOR_CST:
    2896                 :      20397 :       return (VECTOR_CST_NPATTERNS (expr) == 1
    2897                 :      17503 :               && VECTOR_CST_DUPLICATE_P (expr)
    2898                 :      33969 :               && real_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
    2899                 :            :     default:
    2900                 :            :       return false;
    2901                 :            :     }
    2902                 :            : }
    2903                 :            : 
    2904                 :            : /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
    2905                 :            :    matter for decimal float constants, so don't return 1 for them.
    2906                 :            :    Also return 1 for location wrappers around such a constant.  */
    2907                 :            : 
    2908                 :            : bool
    2909                 :   45154200 : real_minus_onep (const_tree expr)
    2910                 :            : {
    2911                 :   45154200 :   STRIP_ANY_LOCATION_WRAPPER (expr);
    2912                 :            : 
    2913                 :   45154200 :   switch (TREE_CODE (expr))
    2914                 :            :     {
    2915                 :    1009580 :     case REAL_CST:
    2916                 :    1009580 :       return real_equal (&TREE_REAL_CST (expr), &dconstm1)
    2917                 :    1015840 :              && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
    2918                 :      11730 :     case COMPLEX_CST:
    2919                 :      11730 :       return real_minus_onep (TREE_REALPART (expr))
    2920                 :      13908 :              && real_zerop (TREE_IMAGPART (expr));
    2921                 :      20666 :     case VECTOR_CST:
    2922                 :      20666 :       return (VECTOR_CST_NPATTERNS (expr) == 1
    2923                 :      17756 :               && VECTOR_CST_DUPLICATE_P (expr)
    2924                 :      34474 :               && real_minus_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
    2925                 :            :     default:
    2926                 :            :       return false;
    2927                 :            :     }
    2928                 :            : }
    2929                 :            : 
    2930                 :            : /* Nonzero if EXP is a constant or a cast of a constant.  */
    2931                 :            : 
    2932                 :            : bool
    2933                 :       2289 : really_constant_p (const_tree exp)
    2934                 :            : {
    2935                 :            :   /* This is not quite the same as STRIP_NOPS.  It does more.  */
    2936                 :       2393 :   while (CONVERT_EXPR_P (exp)
    2937                 :       2393 :          || TREE_CODE (exp) == NON_LVALUE_EXPR)
    2938                 :        104 :     exp = TREE_OPERAND (exp, 0);
    2939                 :       2289 :   return TREE_CONSTANT (exp);
    2940                 :            : }
    2941                 :            : 
    2942                 :            : /* Return true if T holds a polynomial pointer difference, storing it in
    2943                 :            :    *VALUE if so.  A true return means that T's precision is no greater
    2944                 :            :    than 64 bits, which is the largest address space we support, so *VALUE
    2945                 :            :    never loses precision.  However, the signedness of the result does
    2946                 :            :    not necessarily match the signedness of T: sometimes an unsigned type
    2947                 :            :    like sizetype is used to encode a value that is actually negative.  */
    2948                 :            : 
    2949                 :            : bool
    2950                 :    4191320 : ptrdiff_tree_p (const_tree t, poly_int64_pod *value)
    2951                 :            : {
    2952                 :    4191320 :   if (!t)
    2953                 :            :     return false;
    2954                 :    4191320 :   if (TREE_CODE (t) == INTEGER_CST)
    2955                 :            :     {
    2956                 :    2169560 :       if (!cst_and_fits_in_hwi (t))
    2957                 :            :         return false;
    2958                 :    2169440 :       *value = int_cst_value (t);
    2959                 :    2169440 :       return true;
    2960                 :            :     }
    2961                 :            :   if (POLY_INT_CST_P (t))
    2962                 :            :     {
    2963                 :            :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    2964                 :            :         if (!cst_and_fits_in_hwi (POLY_INT_CST_COEFF (t, i)))
    2965                 :            :           return false;
    2966                 :            :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    2967                 :            :         value->coeffs[i] = int_cst_value (POLY_INT_CST_COEFF (t, i));
    2968                 :            :       return true;
    2969                 :            :     }
    2970                 :            :   return false;
    2971                 :            : }
    2972                 :            : 
    2973                 :            : poly_int64
    2974                 :   44707300 : tree_to_poly_int64 (const_tree t)
    2975                 :            : {
    2976                 :   44707300 :   gcc_assert (tree_fits_poly_int64_p (t));
    2977                 :   44707300 :   if (POLY_INT_CST_P (t))
    2978                 :            :     return poly_int_cst_value (t).force_shwi ();
    2979                 :   44707300 :   return TREE_INT_CST_LOW (t);
    2980                 :            : }
    2981                 :            : 
    2982                 :            : poly_uint64
    2983                 :  176076000 : tree_to_poly_uint64 (const_tree t)
    2984                 :            : {
    2985                 :  176076000 :   gcc_assert (tree_fits_poly_uint64_p (t));
    2986                 :  176076000 :   if (POLY_INT_CST_P (t))
    2987                 :            :     return poly_int_cst_value (t).force_uhwi ();
    2988                 :  176076000 :   return TREE_INT_CST_LOW (t);
    2989                 :            : }
    2990                 :            : 
    2991                 :            : /* Return first list element whose TREE_VALUE is ELEM.
    2992                 :            :    Return 0 if ELEM is not in LIST.  */
    2993                 :            : 
    2994                 :            : tree
    2995                 :     697669 : value_member (tree elem, tree list)
    2996                 :            : {
    2997                 :    1788990 :   while (list)
    2998                 :            :     {
    2999                 :    1485900 :       if (elem == TREE_VALUE (list))
    3000                 :     394576 :         return list;
    3001                 :    1091320 :       list = TREE_CHAIN (list);
    3002                 :            :     }
    3003                 :            :   return NULL_TREE;
    3004                 :            : }
    3005                 :            : 
    3006                 :            : /* Return first list element whose TREE_PURPOSE is ELEM.
    3007                 :            :    Return 0 if ELEM is not in LIST.  */
    3008                 :            : 
    3009                 :            : tree
    3010                 :   34333800 : purpose_member (const_tree elem, tree list)
    3011                 :            : {
    3012                 :   35729900 :   while (list)
    3013                 :            :     {
    3014                 :    2283360 :       if (elem == TREE_PURPOSE (list))
    3015                 :     887229 :         return list;
    3016                 :    1396140 :       list = TREE_CHAIN (list);
    3017                 :            :     }
    3018                 :            :   return NULL_TREE;
    3019                 :            : }
    3020                 :            : 
    3021                 :            : /* Return true if ELEM is in V.  */
    3022                 :            : 
    3023                 :            : bool
    3024                 :     114525 : vec_member (const_tree elem, vec<tree, va_gc> *v)
    3025                 :            : {
    3026                 :     114525 :   unsigned ix;
    3027                 :     114525 :   tree t;
    3028                 :    1734230 :   FOR_EACH_VEC_SAFE_ELT (v, ix, t)
    3029                 :    1620040 :     if (elem == t)
    3030                 :            :       return true;
    3031                 :            :   return false;
    3032                 :            : }
    3033                 :            : 
    3034                 :            : /* Returns element number IDX (zero-origin) of chain CHAIN, or
    3035                 :            :    NULL_TREE.  */
    3036                 :            : 
    3037                 :            : tree
    3038                 :    2742710 : chain_index (int idx, tree chain)
    3039                 :            : {
    3040                 :    3287950 :   for (; chain && idx > 0; --idx)
    3041                 :     545244 :     chain = TREE_CHAIN (chain);
    3042                 :    2742710 :   return chain;
    3043                 :            : }
    3044                 :            : 
    3045                 :            : /* Return nonzero if ELEM is part of the chain CHAIN.  */
    3046                 :            : 
    3047                 :            : bool
    3048                 :      26442 : chain_member (const_tree elem, const_tree chain)
    3049                 :            : {
    3050                 :      45269 :   while (chain)
    3051                 :            :     {
    3052                 :      45232 :       if (elem == chain)
    3053                 :            :         return true;
    3054                 :      18827 :       chain = DECL_CHAIN (chain);
    3055                 :            :     }
    3056                 :            : 
    3057                 :            :   return false;
    3058                 :            : }
    3059                 :            : 
    3060                 :            : /* Return the length of a chain of nodes chained through TREE_CHAIN.
    3061                 :            :    We expect a null pointer to mark the end of the chain.
    3062                 :            :    This is the Lisp primitive `length'.  */
    3063                 :            : 
    3064                 :            : int
    3065                 :  747675000 : list_length (const_tree t)
    3066                 :            : {
    3067                 :  747675000 :   const_tree p = t;
    3068                 :            : #ifdef ENABLE_TREE_CHECKING
    3069                 :  747675000 :   const_tree q = t;
    3070                 :            : #endif
    3071                 :  747675000 :   int len = 0;
    3072                 :            : 
    3073                 :  994820000 :   while (p)
    3074                 :            :     {
    3075                 :  247145000 :       p = TREE_CHAIN (p);
    3076                 :            : #ifdef ENABLE_TREE_CHECKING
    3077                 :  247145000 :       if (len % 2)
    3078                 :   94062300 :         q = TREE_CHAIN (q);
    3079                 :  247145000 :       gcc_assert (p != q);
    3080                 :            : #endif
    3081                 :  247145000 :       len++;
    3082                 :            :     }
    3083                 :            : 
    3084                 :  747675000 :   return len;
    3085                 :            : }
    3086                 :            : 
    3087                 :            : /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
    3088                 :            :    UNION_TYPE TYPE, or NULL_TREE if none.  */
    3089                 :            : 
    3090                 :            : tree
    3091                 :      34199 : first_field (const_tree type)
    3092                 :            : {
    3093                 :      34345 :   tree t = TYPE_FIELDS (type);
    3094                 :    2415880 :   while (t && TREE_CODE (t) != FIELD_DECL)
    3095                 :    2381680 :     t = TREE_CHAIN (t);
    3096                 :      34199 :   return t;
    3097                 :            : }
    3098                 :            : 
    3099                 :            : /* Returns the last FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
    3100                 :            :    UNION_TYPE TYPE, or NULL_TREE if none.  */
    3101                 :            : 
    3102                 :            : tree
    3103                 :       5689 : last_field (const_tree type)
    3104                 :            : {
    3105                 :       5689 :   tree last = NULL_TREE;
    3106                 :            : 
    3107                 :      93064 :   for (tree fld = TYPE_FIELDS (type); fld; fld = TREE_CHAIN (fld))
    3108                 :            :     {
    3109                 :      87375 :       if (TREE_CODE (fld) != FIELD_DECL)
    3110                 :      52373 :         continue;
    3111                 :            : 
    3112                 :            :       last = fld;
    3113                 :            :     }
    3114                 :            : 
    3115                 :       5689 :   return last;
    3116                 :            : }
    3117                 :            : 
    3118                 :            : /* Concatenate two chains of nodes (chained through TREE_CHAIN)
    3119                 :            :    by modifying the last node in chain 1 to point to chain 2.
    3120                 :            :    This is the Lisp primitive `nconc'.  */
    3121                 :            : 
    3122                 :            : tree
    3123                 : 1456040000 : chainon (tree op1, tree op2)
    3124                 :            : {
    3125                 : 1456040000 :   tree t1;
    3126                 :            : 
    3127                 : 1456040000 :   if (!op1)
    3128                 :            :     return op2;
    3129                 :  164799000 :   if (!op2)
    3130                 :            :     return op1;
    3131                 :            : 
    3132                 :  270606000 :   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
    3133                 :  137513000 :     continue;
    3134                 :  133093000 :   TREE_CHAIN (t1) = op2;
    3135                 :            : 
    3136                 :            : #ifdef ENABLE_TREE_CHECKING
    3137                 :  133093000 :   {
    3138                 :  133093000 :     tree t2;
    3139                 :  626683000 :     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
    3140                 :  493590000 :       gcc_assert (t2 != t1);
    3141                 :            :   }
    3142                 :            : #endif
    3143                 :            : 
    3144                 :            :   return op1;
    3145                 :            : }
    3146                 :            : 
    3147                 :            : /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
    3148                 :            : 
    3149                 :            : tree
    3150                 :    7148210 : tree_last (tree chain)
    3151                 :            : {
    3152                 :    7148210 :   tree next;
    3153                 :    7148210 :   if (chain)
    3154                 :   14015500 :     while ((next = TREE_CHAIN (chain)))
    3155                 :            :       chain = next;
    3156                 :    7148210 :   return chain;
    3157                 :            : }
    3158                 :            : 
    3159                 :            : /* Reverse the order of elements in the chain T,
    3160                 :            :    and return the new head of the chain (old last element).  */
    3161                 :            : 
    3162                 :            : tree
    3163                 :  206801000 : nreverse (tree t)
    3164                 :            : {
    3165                 :  206801000 :   tree prev = 0, decl, next;
    3166                 :  610030000 :   for (decl = t; decl; decl = next)
    3167                 :            :     {
    3168                 :            :       /* We shouldn't be using this function to reverse BLOCK chains; we
    3169                 :            :          have blocks_nreverse for that.  */
    3170                 :  403229000 :       gcc_checking_assert (TREE_CODE (decl) != BLOCK);
    3171                 :  403229000 :       next = TREE_CHAIN (decl);
    3172                 :  403229000 :       TREE_CHAIN (decl) = prev;
    3173                 :  403229000 :       prev = decl;
    3174                 :            :     }
    3175                 :  206801000 :   return prev;
    3176                 :            : }
    3177                 :            : 
    3178                 :            : /* Return a newly created TREE_LIST node whose
    3179                 :            :    purpose and value fields are PARM and VALUE.  */
    3180                 :            : 
    3181                 :            : tree
    3182                 :  182830000 : build_tree_list (tree parm, tree value MEM_STAT_DECL)
    3183                 :            : {
    3184                 :  182830000 :   tree t = make_node (TREE_LIST PASS_MEM_STAT);
    3185                 :  182830000 :   TREE_PURPOSE (t) = parm;
    3186                 :  182830000 :   TREE_VALUE (t) = value;
    3187                 :  182830000 :   return t;
    3188                 :            : }
    3189                 :            : 
    3190                 :            : /* Build a chain of TREE_LIST nodes from a vector.  */
    3191                 :            : 
    3192                 :            : tree
    3193                 :    7703260 : build_tree_list_vec (const vec<tree, va_gc> *vec MEM_STAT_DECL)
    3194                 :            : {
    3195                 :    7703260 :   tree ret = NULL_TREE;
    3196                 :    7703260 :   tree *pp = &ret;
    3197                 :    7703260 :   unsigned int i;
    3198                 :    7703260 :   tree t;
    3199                 :   16802800 :   FOR_EACH_VEC_SAFE_ELT (vec, i, t)
    3200                 :            :     {
    3201                 :    9099540 :       *pp = build_tree_list (NULL, t PASS_MEM_STAT);
    3202                 :    9099540 :       pp = &TREE_CHAIN (*pp);
    3203                 :            :     }
    3204                 :    7703260 :   return ret;
    3205                 :            : }
    3206                 :            : 
    3207                 :            : /* Return a newly created TREE_LIST node whose
    3208                 :            :    purpose and value fields are PURPOSE and VALUE
    3209                 :            :    and whose TREE_CHAIN is CHAIN.  */
    3210                 :            : 
    3211                 :            : tree 
    3212                 : 1563630000 : tree_cons (tree purpose, tree value, tree chain MEM_STAT_DECL)
    3213                 :            : {
    3214                 : 1563630000 :   tree node;
    3215                 :            : 
    3216                 : 1563630000 :   node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
    3217                 : 1563630000 :   memset (node, 0, sizeof (struct tree_common));
    3218                 :            : 
    3219                 : 1563630000 :   record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
    3220                 :            : 
    3221                 : 1563630000 :   TREE_SET_CODE (node, TREE_LIST);
    3222                 : 1563630000 :   TREE_CHAIN (node) = chain;
    3223                 : 1563630000 :   TREE_PURPOSE (node) = purpose;
    3224                 : 1563630000 :   TREE_VALUE (node) = value;
    3225                 : 1563630000 :   return node;
    3226                 :            : }
    3227                 :            : 
    3228                 :            : /* Return the values of the elements of a CONSTRUCTOR as a vector of
    3229                 :            :    trees.  */
    3230                 :            : 
    3231                 :            : vec<tree, va_gc> *
    3232                 :          0 : ctor_to_vec (tree ctor)
    3233                 :            : {
    3234                 :          0 :   vec<tree, va_gc> *vec;
    3235                 :          0 :   vec_alloc (vec, CONSTRUCTOR_NELTS (ctor));
    3236                 :          0 :   unsigned int ix;
    3237                 :          0 :   tree val;
    3238                 :            : 
    3239                 :          0 :   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
    3240                 :          0 :     vec->quick_push (val);
    3241                 :            : 
    3242                 :          0 :   return vec;
    3243                 :            : }
    3244                 :            : 
    3245                 :            : /* Return the size nominally occupied by an object of type TYPE
    3246                 :            :    when it resides in memory.  The value is measured in units of bytes,
    3247                 :            :    and its data type is that normally used for type sizes
    3248                 :            :    (which is the first type created by make_signed_type or
    3249                 :            :    make_unsigned_type).  */
    3250                 :            : 
    3251                 :            : tree
    3252                 :   14617800 : size_in_bytes_loc (location_t loc, const_tree type)
    3253                 :            : {
    3254                 :   14617800 :   tree t;
    3255                 :            : 
    3256                 :   14617800 :   if (type == error_mark_node)
    3257                 :          0 :     return integer_zero_node;
    3258                 :            : 
    3259                 :   14617800 :   type = TYPE_MAIN_VARIANT (type);
    3260                 :   14617800 :   t = TYPE_SIZE_UNIT (type);
    3261                 :            : 
    3262                 :   14617800 :   if (t == 0)
    3263                 :            :     {
    3264                 :         47 :       lang_hooks.types.incomplete_type_error (loc, NULL_TREE, type);
    3265                 :         47 :       return size_zero_node;
    3266                 :            :     }
    3267                 :            : 
    3268                 :            :   return t;
    3269                 :            : }
    3270                 :            : 
    3271                 :            : /* Return the size of TYPE (in bytes) as a wide integer
    3272                 :            :    or return -1 if the size can vary or is larger than an integer.  */
    3273                 :            : 
    3274                 :            : HOST_WIDE_INT
    3275                 :  247222000 : int_size_in_bytes (const_tree type)
    3276                 :            : {
    3277                 :  247222000 :   tree t;
    3278                 :            : 
    3279                 :  247222000 :   if (type == error_mark_node)
    3280                 :            :     return 0;
    3281                 :            : 
    3282                 :  247222000 :   type = TYPE_MAIN_VARIANT (type);
    3283                 :  247222000 :   t = TYPE_SIZE_UNIT (type);
    3284                 :            : 
    3285                 :  247222000 :   if (t && tree_fits_uhwi_p (t))
    3286                 :  247209000 :     return TREE_INT_CST_LOW (t);
    3287                 :            :   else
    3288                 :            :     return -1;
    3289                 :            : }
    3290                 :            : 
    3291                 :            : /* Return the maximum size of TYPE (in bytes) as a wide integer
    3292                 :            :    or return -1 if the size can vary or is larger than an integer.  */
    3293                 :            : 
    3294                 :            : HOST_WIDE_INT
    3295                 :       8459 : max_int_size_in_bytes (const_tree type)
    3296                 :            : {
    3297                 :       8459 :   HOST_WIDE_INT size = -1;
    3298                 :       8459 :   tree size_tree;
    3299                 :            : 
    3300                 :            :   /* If this is an array type, check for a possible MAX_SIZE attached.  */
    3301                 :            : 
    3302                 :       8459 :   if (TREE_CODE (type) == ARRAY_TYPE)
    3303                 :            :     {
    3304                 :       7789 :       size_tree = TYPE_ARRAY_MAX_SIZE (type);
    3305                 :            : 
    3306                 :       7789 :       if (size_tree && tree_fits_uhwi_p (size_tree))
    3307                 :          0 :         size = tree_to_uhwi (size_tree);
    3308                 :            :     }
    3309                 :            : 
    3310                 :            :   /* If we still haven't been able to get a size, see if the language
    3311                 :            :      can compute a maximum size.  */
    3312                 :            : 
    3313                 :          0 :   if (size == -1)
    3314                 :            :     {
    3315                 :       8459 :       size_tree = lang_hooks.types.max_size (type);
    3316                 :            : 
    3317                 :       8459 :       if (size_tree && tree_fits_uhwi_p (size_tree))
    3318                 :          0 :         size = tree_to_uhwi (size_tree);
    3319                 :            :     }
    3320                 :            : 
    3321                 :       8459 :   return size;
    3322                 :            : }
    3323                 :            : 
    3324                 :            : /* Return the bit position of FIELD, in bits from the start of the record.
    3325                 :            :    This is a tree of type bitsizetype.  */
    3326                 :            : 
    3327                 :            : tree
    3328                 :   30568100 : bit_position (const_tree field)
    3329                 :            : {
    3330                 :   30568100 :   return bit_from_pos (DECL_FIELD_OFFSET (field),
    3331                 :   30568100 :                        DECL_FIELD_BIT_OFFSET (field));
    3332                 :            : }
    3333                 :            : 
    3334                 :            : /* Return the byte position of FIELD, in bytes from the start of the record.
    3335                 :            :    This is a tree of type sizetype.  */
    3336                 :            : 
    3337                 :            : tree
    3338                 :   16682200 : byte_position (const_tree field)
    3339                 :            : {
    3340                 :   16682200 :   return byte_from_pos (DECL_FIELD_OFFSET (field),
    3341                 :   16682200 :                         DECL_FIELD_BIT_OFFSET (field));
    3342                 :            : }
    3343                 :            : 
    3344                 :            : /* Likewise, but return as an integer.  It must be representable in
    3345                 :            :    that way (since it could be a signed value, we don't have the
    3346                 :            :    option of returning -1 like int_size_in_byte can.  */
    3347                 :            : 
    3348                 :            : HOST_WIDE_INT
    3349                 :    8176990 : int_byte_position (const_tree field)
    3350                 :            : {
    3351                 :    8176990 :   return tree_to_shwi (byte_position (field));
    3352                 :            : }
    3353                 :            : 
    3354                 :            : /* Return the strictest alignment, in bits, that T is known to have.  */
    3355                 :            : 
    3356                 :            : unsigned int
    3357                 :          0 : expr_align (const_tree t)
    3358                 :            : {
    3359                 :          0 :   unsigned int align0, align1;
    3360                 :            : 
    3361                 :          0 :   switch (TREE_CODE (t))
    3362                 :            :     {
    3363                 :          0 :     CASE_CONVERT:  case NON_LVALUE_EXPR:
    3364                 :            :       /* If we have conversions, we know that the alignment of the
    3365                 :            :          object must meet each of the alignments of the types.  */
    3366                 :          0 :       align0 = expr_align (TREE_OPERAND (t, 0));
    3367                 :          0 :       align1 = TYPE_ALIGN (TREE_TYPE (t));
    3368                 :          0 :       return MAX (align0, align1);
    3369                 :            : 
    3370                 :          0 :     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
    3371                 :          0 :     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
    3372                 :          0 :     case CLEANUP_POINT_EXPR:
    3373                 :            :       /* These don't change the alignment of an object.  */
    3374                 :          0 :       return expr_align (TREE_OPERAND (t, 0));
    3375                 :            : 
    3376                 :          0 :     case COND_EXPR:
    3377                 :            :       /* The best we can do is say that the alignment is the least aligned
    3378                 :            :          of the two arms.  */
    3379                 :          0 :       align0 = expr_align (TREE_OPERAND (t, 1));
    3380                 :          0 :       align1 = expr_align (TREE_OPERAND (t, 2));
    3381                 :          0 :       return MIN (align0, align1);
    3382                 :            : 
    3383                 :            :       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
    3384                 :            :          meaningfully, it's always 1.  */
    3385                 :          0 :     case LABEL_DECL:     case CONST_DECL:
    3386                 :          0 :     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
    3387                 :          0 :     case FUNCTION_DECL:
    3388                 :          0 :       gcc_assert (DECL_ALIGN (t) != 0);
    3389                 :          0 :       return DECL_ALIGN (t);
    3390                 :            : 
    3391                 :          0 :     default:
    3392                 :          0 :       break;
    3393                 :            :     }
    3394                 :            : 
    3395                 :            :   /* Otherwise take the alignment from that of the type.  */
    3396                 :          0 :   return TYPE_ALIGN (TREE_TYPE (t));
    3397                 :            : }
    3398                 :            : 
    3399                 :            : /* Return, as a tree node, the number of elements for TYPE (which is an
    3400                 :            :    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
    3401                 :            : 
    3402                 :            : tree
    3403                 :   14125500 : array_type_nelts (const_tree type)
    3404                 :            : {
    3405                 :   14125500 :   tree index_type, min, max;
    3406                 :            : 
    3407                 :            :   /* If they did it with unspecified bounds, then we should have already
    3408                 :            :      given an error about it before we got here.  */
    3409                 :   14125500 :   if (! TYPE_DOMAIN (type))
    3410                 :    2089160 :     return error_mark_node;
    3411                 :            : 
    3412                 :   12036300 :   index_type = TYPE_DOMAIN (type);
    3413                 :   12036300 :   min = TYPE_MIN_VALUE (index_type);
    3414                 :   12036300 :   max = TYPE_MAX_VALUE (index_type);
    3415                 :            : 
    3416                 :            :   /* TYPE_MAX_VALUE may not be set if the array has unknown length.  */
    3417                 :   12036300 :   if (!max)
    3418                 :     410063 :     return error_mark_node;
    3419                 :            : 
    3420                 :   11626200 :   return (integer_zerop (min)
    3421                 :   11626200 :           ? max
    3422                 :     650754 :           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
    3423                 :            : }
    3424                 :            : 
    3425                 :            : /* If arg is static -- a reference to an object in static storage -- then
    3426                 :            :    return the object.  This is not the same as the C meaning of `static'.
    3427                 :            :    If arg isn't static, return NULL.  */
    3428                 :            : 
    3429                 :            : tree
    3430                 :  445117000 : staticp (tree arg)
    3431                 :            : {
    3432                 :  445185000 :   switch (TREE_CODE (arg))
    3433                 :            :     {
    3434                 :            :     case FUNCTION_DECL:
    3435                 :            :       /* Nested functions are static, even though taking their address will
    3436                 :            :          involve a trampoline as we unnest the nested function and create
    3437                 :            :          the trampoline on the tree level.  */
    3438                 :            :       return arg;
    3439                 :            : 
    3440                 :  323838000 :     case VAR_DECL:
    3441                 :  249409000 :       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
    3442                 :  140112000 :               && ! DECL_THREAD_LOCAL_P (arg)
    3443                 :  105819000 :               && ! DECL_DLLIMPORT_P (arg)
    3444                 :  323838000 :               ? arg : NULL);
    3445                 :            : 
    3446                 :     380373 :     case CONST_DECL:
    3447                 :          0 :       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
    3448                 :     380373 :               ? arg : NULL);
    3449                 :            : 
    3450                 :          0 :     case CONSTRUCTOR:
    3451                 :          0 :       return TREE_STATIC (arg) ? arg : NULL;
    3452                 :            : 
    3453                 :            :     case LABEL_DECL:
    3454                 :            :     case STRING_CST:
    3455                 :            :       return arg;
    3456                 :            : 
    3457                 :      47069 :     case COMPONENT_REF:
    3458                 :            :       /* If the thing being referenced is not a field, then it is
    3459                 :            :          something language specific.  */
    3460                 :      47069 :       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
    3461                 :            : 
    3462                 :            :       /* If we are referencing a bitfield, we can't evaluate an
    3463                 :            :          ADDR_EXPR at compile time and so it isn't a constant.  */
    3464                 :      47069 :       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
    3465                 :            :         return NULL;
    3466                 :            : 
    3467                 :      47069 :       return staticp (TREE_OPERAND (arg, 0));
    3468                 :            : 
    3469                 :          0 :     case BIT_FIELD_REF:
    3470                 :          0 :       return NULL;
    3471                 :            : 
    3472                 :      12901 :     case INDIRECT_REF:
    3473                 :      12901 :       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
    3474                 :            : 
    3475                 :      20773 :     case ARRAY_REF:
    3476                 :      20773 :     case ARRAY_RANGE_REF:
    3477                 :      20773 :       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
    3478                 :      20773 :           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
    3479                 :      20509 :         return staticp (TREE_OPERAND (arg, 0));
    3480                 :            :       else
    3481                 :            :         return NULL;
    3482                 :            : 
    3483                 :        843 :     case COMPOUND_LITERAL_EXPR:
    3484                 :        843 :       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
    3485                 :            : 
    3486                 :   24226800 :     default:
    3487                 :   24226800 :       return NULL;
    3488                 :            :     }
    3489                 :            : }
    3490                 :            : 
    3491                 :            : 
    3492                 :            : 
    3493                 :            : 
    3494                 :            : /* Return whether OP is a DECL whose address is function-invariant.  */
    3495                 :            : 
    3496                 :            : bool
    3497                 : 2694640000 : decl_address_invariant_p (const_tree op)
    3498                 :            : {
    3499                 :            :   /* The conditions below are slightly less strict than the one in
    3500                 :            :      staticp.  */
    3501                 :            : 
    3502                 : 2694640000 :   switch (TREE_CODE (op))
    3503                 :            :     {
    3504                 :            :     case PARM_DECL:
    3505                 :            :     case RESULT_DECL:
    3506                 :            :     case LABEL_DECL:
    3507                 :            :     case FUNCTION_DECL:
    3508                 :            :       return true;
    3509                 :            : 
    3510                 : 1452150000 :     case VAR_DECL:
    3511                 : 1116520000 :       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
    3512                 : 1001110000 :           || DECL_THREAD_LOCAL_P (op)
    3513                 : 1001110000 :           || DECL_CONTEXT (op) == current_function_decl
    3514                 : 1454970000 :           || decl_function_context (op) == current_function_decl)
    3515                 : 1449330000 :         return true;
    3516                 :            :       break;
    3517                 :            : 
    3518                 :   11867200 :     case CONST_DECL:
    3519                 :          0 :       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
    3520                 :   11867200 :           || decl_function_context (op) == current_function_decl)
    3521                 :   11867200 :         return true;
    3522                 :            :       break;
    3523                 :            : 
    3524                 :            :     default:
    3525                 :            :       break;
    3526                 :            :     }
    3527                 :            : 
    3528                 :            :   return false;
    3529                 :            : }
    3530                 :            : 
    3531                 :            : /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
    3532                 :            : 
    3533                 :            : bool
    3534                 :     692197 : decl_address_ip_invariant_p (const_tree op)
    3535                 :            : {
    3536                 :            :   /* The conditions below are slightly less strict than the one in
    3537                 :            :      staticp.  */
    3538                 :            : 
    3539                 :     692197 :   switch (TREE_CODE (op))
    3540                 :            :     {
    3541                 :            :     case LABEL_DECL:
    3542                 :            :     case FUNCTION_DECL:
    3543                 :            :     case STRING_CST:
    3544                 :            :       return true;
    3545                 :            : 
    3546                 :     615318 :     case VAR_DECL:
    3547                 :     441670 :       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
    3548                 :     217399 :            && !DECL_DLLIMPORT_P (op))
    3549                 :    1411160 :           || DECL_THREAD_LOCAL_P (op))
    3550                 :     217399 :         return true;
    3551                 :            :       break;
    3552                 :            : 
    3553                 :      26869 :     case CONST_DECL:
    3554                 :      26869 :       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
    3555                 :      26869 :         return true;
    3556                 :            :       break;
    3557                 :            : 
    3558                 :            :     default:
    3559                 :            :       break;
    3560                 :            :     }
    3561                 :            : 
    3562                 :            :   return false;
    3563                 :            : }
    3564                 :            : 
    3565                 :            : 
    3566                 :            : /* Return true if T is function-invariant (internal function, does
    3567                 :            :    not handle arithmetic; that's handled in skip_simple_arithmetic and
    3568                 :            :    tree_invariant_p).  */
    3569                 :            : 
    3570                 :            : static bool
    3571                 :    1968760 : tree_invariant_p_1 (tree t)
    3572                 :            : {
    3573                 :    1968760 :   tree op;
    3574                 :            : 
    3575                 :    1968760 :   if (TREE_CONSTANT (t)
    3576                 :    1968760 :       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
    3577                 :            :     return true;
    3578                 :            : 
    3579                 :    1200110 :   switch (TREE_CODE (t))
    3580                 :            :     {
    3581                 :            :     case SAVE_EXPR:
    3582                 :            :       return true;
    3583                 :            : 
    3584                 :      14134 :     case ADDR_EXPR:
    3585                 :      14134 :       op = TREE_OPERAND (t, 0);
    3586                 :      20014 :       while (handled_component_p (op))
    3587                 :            :         {
    3588                 :       6383 :           switch (TREE_CODE (op))
    3589                 :            :             {
    3590                 :        815 :             case ARRAY_REF:
    3591                 :        815 :             case ARRAY_RANGE_REF:
    3592                 :        815 :               if (!tree_invariant_p (TREE_OPERAND (op, 1))
    3593                 :        312 :                   || TREE_OPERAND (op, 2) != NULL_TREE
    3594                 :       1127 :                   || TREE_OPERAND (op, 3) != NULL_TREE)
    3595                 :            :                 return false;
    3596                 :            :               break;
    3597                 :            : 
    3598                 :       5527 :             case COMPONENT_REF:
    3599                 :       5527 :               if (TREE_OPERAND (op, 2) != NULL_TREE)
    3600                 :            :                 return false;
    3601                 :            :               break;
    3602                 :            : 
    3603                 :       5880 :             default:;
    3604                 :            :             }
    3605                 :       5880 :           op = TREE_OPERAND (op, 0);
    3606                 :            :         }
    3607                 :            : 
    3608                 :      13631 :       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
    3609                 :            : 
    3610                 :    1124340 :     default:
    3611                 :    1124340 :       break;
    3612                 :            :     }
    3613                 :            : 
    3614                 :    1124340 :   return false;
    3615                 :            : }
    3616                 :            : 
    3617                 :            : /* Return true if T is function-invariant.  */
    3618                 :            : 
    3619                 :            : bool
    3620                 :    1067210 : tree_invariant_p (tree t)
    3621                 :            : {
    3622                 :    1067210 :   tree inner = skip_simple_arithmetic (t);
    3623                 :    1067210 :   return tree_invariant_p_1 (inner);
    3624                 :            : }
    3625                 :            : 
    3626                 :            : /* Wrap a SAVE_EXPR around EXPR, if appropriate.
    3627                 :            :    Do this to any expression which may be used in more than one place,
    3628                 :            :    but must be evaluated only once.
    3629                 :            : 
    3630                 :            :    Normally, expand_expr would reevaluate the expression each time.
    3631                 :            :    Calling save_expr produces something that is evaluated and recorded
    3632                 :            :    the first time expand_expr is called on it.  Subsequent calls to
    3633                 :            :    expand_expr just reuse the recorded value.
    3634                 :            : 
    3635                 :            :    The call to expand_expr that generates code that actually computes
    3636                 :            :    the value is the first call *at compile time*.  Subsequent calls
    3637                 :            :    *at compile time* generate code to use the saved value.
    3638                 :            :    This produces correct result provided that *at run time* control
    3639                 :            :    always flows through the insns made by the first expand_expr
    3640                 :            :    before reaching the other places where the save_expr was evaluated.
    3641                 :            :    You, the caller of save_expr, must make sure this is so.
    3642                 :            : 
    3643                 :            :    Constants, and certain read-only nodes, are returned with no
    3644                 :            :    SAVE_EXPR because that is safe.  Expressions containing placeholders
    3645                 :            :    are not touched; see tree.def for an explanation of what these
    3646                 :            :    are used for.  */
    3647                 :            : 
    3648                 :            : tree
    3649                 :     901561 : save_expr (tree expr)
    3650                 :            : {
    3651                 :     901561 :   tree inner;
    3652                 :            : 
    3653                 :            :   /* If the tree evaluates to a constant, then we don't want to hide that
    3654                 :            :      fact (i.e. this allows further folding, and direct checks for constants).
    3655                 :            :      However, a read-only object that has side effects cannot be bypassed.
    3656                 :            :      Since it is no problem to reevaluate literals, we just return the
    3657                 :            :      literal node.  */
    3658                 :     901561 :   inner = skip_simple_arithmetic (expr);
    3659                 :     901561 :   if (TREE_CODE (inner) == ERROR_MARK)
    3660                 :            :     return inner;
    3661                 :            : 
    3662                 :     901549 :   if (tree_invariant_p_1 (inner))
    3663                 :            :     return expr;
    3664                 :            : 
    3665                 :            :   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
    3666                 :            :      it means that the size or offset of some field of an object depends on
    3667                 :            :      the value within another field.
    3668                 :            : 
    3669                 :            :      Note that it must not be the case that EXPR contains both a PLACEHOLDER_EXPR
    3670                 :            :      and some variable since it would then need to be both evaluated once and
    3671                 :            :      evaluated more than once.  Front-ends must assure this case cannot
    3672                 :            :      happen by surrounding any such subexpressions in their own SAVE_EXPR
    3673                 :            :      and forcing evaluation at the proper time.  */
    3674                 :     624615 :   if (contains_placeholder_p (inner))
    3675                 :            :     return expr;
    3676                 :            : 
    3677                 :     624615 :   expr = build1_loc (EXPR_LOCATION (expr), SAVE_EXPR, TREE_TYPE (expr), expr);
    3678                 :            : 
    3679                 :            :   /* This expression might be placed ahead of a jump to ensure that the
    3680                 :            :      value was computed on both sides of the jump.  So make sure it isn't
    3681                 :            :      eliminated as dead.  */
    3682                 :     624615 :   TREE_SIDE_EFFECTS (expr) = 1;
    3683                 :     624615 :   return expr;
    3684                 :            : }
    3685                 :            : 
    3686                 :            : /* Look inside EXPR into any simple arithmetic operations.  Return the
    3687                 :            :    outermost non-arithmetic or non-invariant node.  */
    3688                 :            : 
    3689                 :            : tree
    3690                 :    1968770 : skip_simple_arithmetic (tree expr)
    3691                 :            : {
    3692                 :            :   /* We don't care about whether this can be used as an lvalue in this
    3693                 :            :      context.  */
    3694                 :    2055470 :   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    3695                 :      86701 :     expr = TREE_OPERAND (expr, 0);
    3696                 :            : 
    3697                 :            :   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
    3698                 :            :      a constant, it will be more efficient to not make another SAVE_EXPR since
    3699                 :            :      it will allow better simplification and GCSE will be able to merge the
    3700                 :            :      computations if they actually occur.  */
    3701                 :    3153970 :   while (true)
    3702                 :            :     {
    3703                 :    3153970 :       if (UNARY_CLASS_P (expr))
    3704                 :     936759 :         expr = TREE_OPERAND (expr, 0);
    3705                 :    2217220 :       else if (BINARY_CLASS_P (expr))
    3706                 :            :         {
    3707                 :     268734 :           if (tree_invariant_p (TREE_OPERAND (expr, 1)))
    3708                 :     238948 :             expr = TREE_OPERAND (expr, 0);
    3709                 :      29786 :           else if (tree_invariant_p (TREE_OPERAND (expr, 0)))
    3710                 :       9496 :             expr = TREE_OPERAND (expr, 1);
    3711                 :            :           else
    3712                 :            :             break;
    3713                 :            :         }
    3714                 :            :       else
    3715                 :            :         break;
    3716                 :            :     }
    3717                 :            : 
    3718                 :    1968770 :   return expr;
    3719                 :            : }
    3720                 :            : 
    3721                 :            : /* Look inside EXPR into simple arithmetic operations involving constants.
    3722                 :            :    Return the outermost non-arithmetic or non-constant node.  */
    3723                 :            : 
    3724                 :            : tree
    3725                 :          0 : skip_simple_constant_arithmetic (tree expr)
    3726                 :            : {
    3727                 :          0 :   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
    3728                 :          0 :     expr = TREE_OPERAND (expr, 0);
    3729                 :            : 
    3730                 :          0 :   while (true)
    3731                 :            :     {
    3732                 :          0 :       if (UNARY_CLASS_P (expr))
    3733                 :          0 :         expr = TREE_OPERAND (expr, 0);
    3734                 :          0 :       else if (BINARY_CLASS_P (expr))
    3735                 :            :         {
    3736                 :          0 :           if (TREE_CONSTANT (TREE_OPERAND (expr, 1)))
    3737                 :          0 :             expr = TREE_OPERAND (expr, 0);
    3738                 :          0 :           else if (TREE_CONSTANT (TREE_OPERAND (expr, 0)))
    3739                 :          0 :             expr = TREE_OPERAND (expr, 1);
    3740                 :            :           else
    3741                 :            :             break;
    3742                 :            :         }
    3743                 :            :       else
    3744                 :            :         break;
    3745                 :            :     }
    3746                 :            : 
    3747                 :          0 :   return expr;
    3748                 :            : }
    3749                 :            : 
    3750                 :            : /* Return which tree structure is used by T.  */
    3751                 :            : 
    3752                 :            : enum tree_node_structure_enum
    3753                 : 6551510000 : tree_node_structure (const_tree t)
    3754                 :            : {
    3755                 : 6551510000 :   const enum tree_code code = TREE_CODE (t);
    3756                 : 6551510000 :   return tree_node_structure_for_code (code);
    3757                 :            : }
    3758                 :            : 
    3759                 :            : /* Set various status flags when building a CALL_EXPR object T.  */
    3760                 :            : 
    3761                 :            : static void
    3762                 :   59355700 : process_call_operands (tree t)
    3763                 :            : {
    3764                 :   59355700 :   bool side_effects = TREE_SIDE_EFFECTS (t);
    3765                 :   59355700 :   bool read_only = false;
    3766                 :   59355700 :   int i = call_expr_flags (t);
    3767                 :            : 
    3768                 :            :   /* Calls have side-effects, except those to const or pure functions.  */
    3769                 :   59355700 :   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
    3770                 :   40655600 :     side_effects = true;
    3771                 :            :   /* Propagate TREE_READONLY of arguments for const functions.  */
    3772                 :   59355700 :   if (i & ECF_CONST)
    3773                 :            :     read_only = true;
    3774                 :            : 
    3775                 :   59355700 :   if (!side_effects || read_only)
    3776                 :  123535000 :     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
    3777                 :            :       {
    3778                 :  102643000 :         tree op = TREE_OPERAND (t, i);
    3779                 :  184395000 :         if (op && TREE_SIDE_EFFECTS (op))
    3780                 :            :           side_effects = true;
    3781                 :  184395000 :         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
    3782                 :            :           read_only = false;
    3783                 :            :       }
    3784                 :            : 
    3785                 :   59355700 :   TREE_SIDE_EFFECTS (t) = side_effects;
    3786                 :   59355700 :   TREE_READONLY (t) = read_only;
    3787                 :   59355700 : }
    3788                 :            : 
    3789                 :            : /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
    3790                 :            :    size or offset that depends on a field within a record.  */
    3791                 :            : 
    3792                 :            : bool
    3793                 :    2538210 : contains_placeholder_p (const_tree exp)
    3794                 :            : {
    3795                 :    2538210 :   enum tree_code code;
    3796                 :            : 
    3797                 :    2538210 :   if (!exp)
    3798                 :            :     return 0;
    3799                 :            : 
    3800                 :    2538210 :   code = TREE_CODE (exp);
    3801                 :    2538210 :   if (code == PLACEHOLDER_EXPR)
    3802                 :            :     return 1;
    3803                 :            : 
    3804                 :    2538210 :   switch (TREE_CODE_CLASS (code))
    3805                 :            :     {
    3806                 :     263495 :     case tcc_reference:
    3807                 :            :       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
    3808                 :            :          position computations since they will be converted into a
    3809                 :            :          WITH_RECORD_EXPR involving the reference, which will assume
    3810                 :            :          here will be valid.  */
    3811                 :     263495 :       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
    3812                 :            : 
    3813                 :     277993 :     case tcc_exceptional:
    3814                 :     277993 :       if (code == TREE_LIST)
    3815                 :          0 :         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
    3816                 :          0 :                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
    3817                 :            :       break;
    3818                 :            : 
    3819                 :    1131360 :     case tcc_unary:
    3820                 :    1131360 :     case tcc_binary:
    3821                 :    1131360 :     case tcc_comparison:
    3822                 :    1131360 :     case tcc_expression:
    3823                 :    1131360 :       switch (code)
    3824                 :            :         {
    3825                 :       3607 :         case COMPOUND_EXPR:
    3826                 :            :           /* Ignoring the first operand isn't quite right, but works best.  */
    3827                 :       3607 :           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
    3828                 :            : 
    3829                 :        408 :         case COND_EXPR:
    3830                 :        816 :           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
    3831                 :        408 :                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
    3832                 :        816 :                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
    3833                 :            : 
    3834                 :            :         case SAVE_EXPR:
    3835                 :            :           /* The save_expr function never wraps anything containing
    3836                 :            :              a PLACEHOLDER_EXPR. */
    3837                 :            :           return 0;
    3838                 :            : 
    3839                 :     993268 :         default:
    3840                 :     993268 :           break;
    3841                 :            :         }
    3842                 :            : 
    3843                 :     993268 :       switch (TREE_CODE_LENGTH (code))
    3844                 :            :         {
    3845                 :     658700 :         case 1:
    3846                 :     658700 :           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
    3847                 :     331278 :         case 2:
    3848                 :     661666 :           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
    3849                 :     661666 :                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
    3850                 :            :         default:
    3851                 :            :           return 0;
    3852                 :            :         }
    3853                 :            : 
    3854                 :     193023 :     case tcc_vl_exp:
    3855                 :     193023 :       switch (code)
    3856                 :            :         {
    3857                 :     193023 :         case CALL_EXPR:
    3858                 :     193023 :           {
    3859                 :     193023 :             const_tree arg;
    3860                 :     193023 :             const_call_expr_arg_iterator iter;
    3861                 :     399153 :             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
    3862                 :     206130 :               if (CONTAINS_PLACEHOLDER_P (arg))
    3863                 :            :                 return 1;
    3864                 :            :             return 0;
    3865                 :            :           }
    3866                 :            :         default:
    3867                 :            :           return 0;
    3868                 :            :         }
    3869                 :            : 
    3870                 :            :     default:
    3871                 :            :       return 0;
    3872                 :            :     }
    3873                 :            :   return 0;
    3874                 :            : }
    3875                 :            : 
    3876                 :            : /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
    3877                 :            :    directly.  This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
    3878                 :            :    field positions.  */
    3879                 :            : 
    3880                 :            : static bool
    3881                 :     509632 : type_contains_placeholder_1 (const_tree type)
    3882                 :            : {
    3883                 :            :   /* If the size contains a placeholder or the parent type (component type in
    3884                 :            :      the case of arrays) type involves a placeholder, this type does.  */
    3885                 :    1008280 :   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
    3886                 :     509632 :       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
    3887                 :    1019260 :       || (!POINTER_TYPE_P (type)
    3888                 :     419637 :           && TREE_TYPE (type)
    3889                 :      67617 :           && type_contains_placeholder_p (TREE_TYPE (type))))
    3890                 :          0 :     return true;
    3891                 :            : 
    3892                 :            :   /* Now do type-specific checks.  Note that the last part of the check above
    3893                 :            :      greatly limits what we have to do below.  */
    3894                 :     509632 :   switch (TREE_CODE (type))
    3895                 :            :     {
    3896                 :            :     case VOID_TYPE:
    3897                 :            :     case COMPLEX_TYPE:
    3898                 :            :     case ENUMERAL_TYPE:
    3899                 :            :     case BOOLEAN_TYPE:
    3900                 :            :     case POINTER_TYPE:
    3901                 :            :     case OFFSET_TYPE:
    3902                 :            :     case REFERENCE_TYPE:
    3903                 :            :     case METHOD_TYPE:
    3904                 :            :     case FUNCTION_TYPE:
    3905                 :            :     case VECTOR_TYPE:
    3906                 :            :     case NULLPTR_TYPE:
    3907                 :            :       return false;
    3908                 :            : 
    3909                 :     115651 :     case INTEGER_TYPE:
    3910                 :     115651 :     case REAL_TYPE:
    3911                 :     115651 :     case FIXED_POINT_TYPE:
    3912                 :            :       /* Here we just check the bounds.  */
    3913                 :     224484 :       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
    3914                 :     224484 :               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
    3915                 :            : 
    3916                 :      33035 :     case ARRAY_TYPE:
    3917                 :            :       /* We have already checked the component type above, so just check
    3918                 :            :          the domain type.  Flexible array members have a null domain.  */
    3919                 :      66062 :       return TYPE_DOMAIN (type) ?
    3920                 :      33027 :         type_contains_placeholder_p (TYPE_DOMAIN (type)) : false;
    3921                 :            : 
    3922                 :     254809 :     case RECORD_TYPE:
    3923                 :     254809 :     case UNION_TYPE:
    3924                 :     254809 :     case QUAL_UNION_TYPE:
    3925                 :     254809 :       {
    3926                 :     254809 :         tree field;
    3927                 :            : 
    3928                 :    7050080 :         for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
    3929                 :    6789340 :           if (TREE_CODE (field) == FIELD_DECL
    3930                 :    6789340 :               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
    3931                 :     561374 :                   || (TREE_CODE (type) == QUAL_UNION_TYPE
    3932                 :          0 :                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
    3933                 :     561374 :                   || type_contains_placeholder_p (TREE_TYPE (field))))
    3934                 :          0 :             return true;
    3935                 :            : 
    3936                 :            :         return false;
    3937                 :            :       }
    3938                 :            : 
    3939                 :          0 :     default:
    3940                 :          0 :       gcc_unreachable ();
    3941                 :            :     }
    3942                 :            : }
    3943                 :            : 
    3944                 :            : /* Wrapper around above function used to cache its result.  */
    3945                 :            : 
    3946                 :            : bool
    3947                 :    2437360 : type_contains_placeholder_p (tree type)
    3948                 :            : {
    3949                 :    2437360 :   bool result;
    3950                 :            : 
    3951                 :            :   /* If the contains_placeholder_bits field has been initialized,
    3952                 :            :      then we know the answer.  */
    3953                 :    2437360 :   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
    3954                 :    1927730 :     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
    3955                 :            : 
    3956                 :            :   /* Indicate that we've seen this type node, and the answer is false.
    3957                 :            :      This is what we want to return if we run into recursion via fields.  */
    3958                 :     509632 :   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
    3959                 :            : 
    3960                 :            :   /* Compute the real value.  */
    3961                 :     509632 :   result = type_contains_placeholder_1 (type);
    3962                 :            : 
    3963                 :            :   /* Store the real value.  */
    3964                 :     509632 :   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
    3965                 :            : 
    3966                 :     509632 :   return result;
    3967                 :            : }
    3968                 :            : 
    3969                 :            : /* Push tree EXP onto vector QUEUE if it is not already present.  */
    3970                 :            : 
    3971                 :            : static void
    3972                 :          0 : push_without_duplicates (tree exp, vec<tree> *queue)
    3973                 :            : {
    3974                 :          0 :   unsigned int i;
    3975                 :          0 :   tree iter;
    3976                 :            : 
    3977                 :          0 :   FOR_EACH_VEC_ELT (*queue, i, iter)
    3978                 :          0 :     if (simple_cst_equal (iter, exp) == 1)
    3979                 :            :       break;
    3980                 :            : 
    3981                 :          0 :   if (!iter)
    3982                 :          0 :     queue->safe_push (exp);
    3983                 :          0 : }
    3984                 :            : 
    3985                 :            : /* Given a tree EXP, find all occurrences of references to fields
    3986                 :            :    in a PLACEHOLDER_EXPR and place them in vector REFS without
    3987                 :            :    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
    3988                 :            :    we assume here that EXP contains only arithmetic expressions
    3989                 :            :    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
    3990                 :            :    argument list.  */
    3991                 :            : 
    3992                 :            : void
    3993                 :          0 : find_placeholder_in_expr (tree exp, vec<tree> *refs)
    3994                 :            : {
    3995                 :          0 :   enum tree_code code = TREE_CODE (exp);
    3996                 :          0 :   tree inner;
    3997                 :          0 :   int i;
    3998                 :            : 
    3999                 :            :   /* We handle TREE_LIST and COMPONENT_REF separately.  */
    4000                 :          0 :   if (code == TREE_LIST)
    4001                 :            :     {
    4002                 :          0 :       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
    4003                 :          0 :       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
    4004                 :            :     }
    4005                 :          0 :   else if (code == COMPONENT_REF)
    4006                 :            :     {
    4007                 :          0 :       for (inner = TREE_OPERAND (exp, 0);
    4008                 :          0 :            REFERENCE_CLASS_P (inner);
    4009                 :          0 :            inner = TREE_OPERAND (inner, 0))
    4010                 :            :         ;
    4011                 :            : 
    4012                 :          0 :       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
    4013                 :          0 :         push_without_duplicates (exp, refs);
    4014                 :            :       else
    4015                 :          0 :         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
    4016                 :            :    }
    4017                 :            :   else
    4018                 :          0 :     switch (TREE_CODE_CLASS (code))
    4019                 :            :       {
    4020                 :            :       case tcc_constant:
    4021                 :            :         break;
    4022                 :            : 
    4023                 :          0 :       case tcc_declaration:
    4024                 :            :         /* Variables allocated to static storage can stay.  */
    4025                 :          0 :         if (!TREE_STATIC (exp))
    4026                 :          0 :           push_without_duplicates (exp, refs);
    4027                 :            :         break;
    4028                 :            : 
    4029                 :          0 :       case tcc_expression:
    4030                 :            :         /* This is the pattern built in ada/make_aligning_type.  */
    4031                 :          0 :         if (code == ADDR_EXPR
    4032                 :          0 :             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
    4033                 :            :           {
    4034                 :          0 :             push_without_duplicates (exp, refs);
    4035                 :          0 :             break;
    4036                 :            :           }
    4037                 :            : 
    4038                 :            :         /* Fall through.  */
    4039                 :            : 
    4040                 :            :       case tcc_exceptional:
    4041                 :            :       case tcc_unary:
    4042                 :            :       case tcc_binary:
    4043                 :            :       case tcc_comparison:
    4044                 :            :       case tcc_reference:
    4045                 :          0 :         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
    4046                 :          0 :           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
    4047                 :            :         break;
    4048                 :            : 
    4049                 :            :       case tcc_vl_exp:
    4050                 :          0 :         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
    4051                 :          0 :           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
    4052                 :            :         break;
    4053                 :            : 
    4054                 :          0 :       default:
    4055                 :          0 :         gcc_unreachable ();
    4056                 :            :       }
    4057                 :          0 : }
    4058                 :            : 
    4059                 :            : /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
    4060                 :            :    return a tree with all occurrences of references to F in a
    4061                 :            :    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
    4062                 :            :    CONST_DECLs.  Note that we assume here that EXP contains only
    4063                 :            :    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
    4064                 :            :    occurring only in their argument list.  */
    4065                 :            : 
    4066                 :            : tree
    4067                 :          0 : substitute_in_expr (tree exp, tree f, tree r)
    4068                 :            : {
    4069                 :          0 :   enum tree_code code = TREE_CODE (exp);
    4070                 :          0 :   tree op0, op1, op2, op3;
    4071                 :          0 :   tree new_tree;
    4072                 :            : 
    4073                 :            :   /* We handle TREE_LIST and COMPONENT_REF separately.  */
    4074                 :          0 :   if (code == TREE_LIST)
    4075                 :            :     {
    4076                 :          0 :       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
    4077                 :          0 :       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
    4078                 :          0 :       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
    4079                 :            :         return exp;
    4080                 :            : 
    4081                 :          0 :       return tree_cons (TREE_PURPOSE (exp), op1, op0);
    4082                 :            :     }
    4083                 :          0 :   else if (code == COMPONENT_REF)
    4084                 :            :     {
    4085                 :          0 :       tree inner;
    4086                 :            : 
    4087                 :            :       /* If this expression is getting a value from a PLACEHOLDER_EXPR
    4088                 :            :          and it is the right field, replace it with R.  */
    4089                 :          0 :       for (inner = TREE_OPERAND (exp, 0);
    4090                 :          0 :            REFERENCE_CLASS_P (inner);
    4091                 :          0 :            inner = TREE_OPERAND (inner, 0))
    4092                 :            :         ;
    4093                 :            : 
    4094                 :            :       /* The field.  */
    4095                 :          0 :       op1 = TREE_OPERAND (exp, 1);
    4096                 :            : 
    4097                 :          0 :       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
    4098                 :            :         return r;
    4099                 :            : 
    4100                 :            :       /* If this expression hasn't been completed let, leave it alone.  */
    4101                 :          0 :       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
    4102                 :            :         return exp;
    4103                 :            : 
    4104                 :          0 :       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
    4105                 :          0 :       if (op0 == TREE_OPERAND (exp, 0))
    4106                 :            :         return exp;
    4107                 :            : 
    4108                 :          0 :       new_tree
    4109                 :          0 :         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
    4110                 :            :    }
    4111                 :            :   else
    4112                 :          0 :     switch (TREE_CODE_CLASS (code))
    4113                 :            :       {
    4114                 :            :       case tcc_constant:
    4115                 :            :         return exp;
    4116                 :            : 
    4117                 :          0 :       case tcc_declaration:
    4118                 :          0 :         if (exp == f)
    4119                 :            :           return r;
    4120                 :            :         else
    4121                 :          0 :           return exp;
    4122                 :            : 
    4123                 :          0 :       case tcc_expression:
    4124                 :          0 :         if (exp == f)
    4125                 :            :           return r;
    4126                 :            : 
    4127                 :            :         /* Fall through.  */
    4128                 :            : 
    4129                 :          0 :       case tcc_exceptional:
    4130                 :          0 :       case tcc_unary:
    4131                 :          0 :       case tcc_binary:
    4132                 :          0 :       case tcc_comparison:
    4133                 :          0 :       case tcc_reference:
    4134                 :          0 :         switch (TREE_CODE_LENGTH (code))
    4135                 :            :           {
    4136                 :            :           case 0:
    4137                 :            :             return exp;
    4138                 :            : 
    4139                 :          0 :           case 1:
    4140                 :          0 :             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
    4141                 :          0 :             if (op0 == TREE_OPERAND (exp, 0))
    4142                 :            :               return exp;
    4143                 :            : 
    4144                 :          0 :             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
    4145                 :          0 :             break;
    4146                 :            : 
    4147                 :          0 :           case 2:
    4148                 :          0 :             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
    4149                 :          0 :             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
    4150                 :            : 
    4151                 :          0 :             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
    4152                 :            :               return exp;
    4153                 :            : 
    4154                 :          0 :             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
    4155                 :          0 :             break;
    4156                 :            : 
    4157                 :          0 :           case 3:
    4158                 :          0 :             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
    4159                 :          0 :             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
    4160                 :          0 :             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
    4161                 :            : 
    4162                 :          0 :             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
    4163                 :          0 :                 && op2 == TREE_OPERAND (exp, 2))
    4164                 :            :               return exp;
    4165                 :            : 
    4166                 :          0 :             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
    4167                 :          0 :             break;
    4168                 :            : 
    4169                 :          0 :           case 4:
    4170                 :          0 :             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
    4171                 :          0 :             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
    4172                 :          0 :             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
    4173                 :          0 :             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
    4174                 :            : 
    4175                 :          0 :             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
    4176                 :          0 :                 && op2 == TREE_OPERAND (exp, 2)
    4177                 :          0 :                 && op3 == TREE_OPERAND (exp, 3))
    4178                 :            :               return exp;
    4179                 :            : 
    4180                 :          0 :             new_tree
    4181                 :          0 :               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
    4182                 :          0 :             break;
    4183                 :            : 
    4184                 :          0 :           default:
    4185                 :          0 :             gcc_unreachable ();
    4186                 :            :           }
    4187                 :            :         break;
    4188                 :            : 
    4189                 :          0 :       case tcc_vl_exp:
    4190                 :          0 :         {
    4191                 :          0 :           int i;
    4192                 :            : 
    4193                 :          0 :           new_tree = NULL_TREE;
    4194                 :            : 
    4195                 :            :           /* If we are trying to replace F with a constant or with another
    4196                 :            :              instance of one of the arguments of the call, inline back
    4197                 :            :              functions which do nothing else than computing a value from
    4198                 :            :              the arguments they are passed.  This makes it possible to
    4199                 :            :              fold partially or entirely the replacement expression.  */
    4200                 :          0 :           if (code == CALL_EXPR)
    4201                 :            :             {
    4202                 :          0 :               bool maybe_inline = false;
    4203                 :          0 :               if (CONSTANT_CLASS_P (r))
    4204                 :            :                 maybe_inline = true;
    4205                 :            :               else
    4206                 :          0 :                 for (i = 3; i < TREE_OPERAND_LENGTH (exp); i++)
    4207                 :          0 :                   if (operand_equal_p (TREE_OPERAND (exp, i), r, 0))
    4208                 :            :                     {
    4209                 :            :                       maybe_inline = true;
    4210                 :            :                       break;
    4211                 :            :                     }
    4212                 :          0 :               if (maybe_inline)
    4213                 :            :                 {
    4214                 :          0 :                   tree t = maybe_inline_call_in_expr (exp);
    4215                 :          0 :                   if (t)
    4216                 :          0 :                     return SUBSTITUTE_IN_EXPR (t, f, r);
    4217                 :            :                 }
    4218                 :            :             }
    4219                 :            : 
    4220                 :          0 :           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
    4221                 :            :             {
    4222                 :          0 :               tree op = TREE_OPERAND (exp, i);
    4223                 :          0 :               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
    4224                 :          0 :               if (new_op != op)
    4225                 :            :                 {
    4226                 :          0 :                   if (!new_tree)
    4227                 :          0 :                     new_tree = copy_node (exp);
    4228                 :          0 :                   TREE_OPERAND (new_tree, i) = new_op;
    4229                 :            :                 }
    4230                 :            :             }
    4231                 :            : 
    4232                 :          0 :           if (new_tree)
    4233                 :            :             {
    4234                 :          0 :               new_tree = fold (new_tree);
    4235                 :          0 :               if (TREE_CODE (new_tree) == CALL_EXPR)
    4236                 :          0 :                 process_call_operands (new_tree);
    4237                 :            :             }
    4238                 :            :           else
    4239                 :            :             return exp;
    4240                 :            :         }
    4241                 :            :         break;
    4242                 :            : 
    4243                 :          0 :       default:
    4244                 :          0 :         gcc_unreachable ();
    4245                 :            :       }
    4246                 :            : 
    4247                 :          0 :   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
    4248                 :            : 
    4249                 :          0 :   if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
    4250                 :          0 :     TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
    4251                 :            : 
    4252                 :            :   return new_tree;
    4253                 :            : }
    4254                 :            : 
    4255                 :            : /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
    4256                 :            :    for it within OBJ, a tree that is an object or a chain of references.  */
    4257                 :            : 
    4258                 :            : tree
    4259                 :     165931 : substitute_placeholder_in_expr (tree exp, tree obj)
    4260                 :            : {
    4261                 :     165931 :   enum tree_code code = TREE_CODE (exp);
    4262                 :     165931 :   tree op0, op1, op2, op3;
    4263                 :     165931 :   tree new_tree;
    4264                 :            : 
    4265                 :            :   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
    4266                 :            :      in the chain of OBJ.  */
    4267                 :     165931 :   if (code == PLACEHOLDER_EXPR)
    4268                 :            :     {
    4269                 :          0 :       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
    4270                 :          0 :       tree elt;
    4271                 :            : 
    4272                 :          0 :       for (elt = obj; elt != 0;
    4273                 :            :            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
    4274                 :          0 :                    || TREE_CODE (elt) == COND_EXPR)
    4275                 :          0 :                   ? TREE_OPERAND (elt, 1)
    4276                 :          0 :                   : (REFERENCE_CLASS_P (elt)
    4277                 :          0 :                      || UNARY_CLASS_P (elt)
    4278                 :          0 :                      || BINARY_CLASS_P (elt)
    4279                 :          0 :                      || VL_EXP_CLASS_P (elt)
    4280                 :          0 :                      || EXPRESSION_CLASS_P (elt))
    4281                 :          0 :                   ? TREE_OPERAND (elt, 0) : 0))
    4282                 :          0 :         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
    4283                 :          0 :           return elt;
    4284                 :            : 
    4285                 :          0 :       for (elt = obj; elt != 0;
    4286                 :            :            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
    4287                 :          0 :                    || TREE_CODE (elt) == COND_EXPR)
    4288                 :          0 :                   ? TREE_OPERAND (elt, 1)
    4289                 :          0 :                   : (REFERENCE_CLASS_P (elt)
    4290                 :          0 :                      || UNARY_CLASS_P (elt)
    4291                 :          0 :                      || BINARY_CLASS_P (elt)
    4292                 :          0 :                      || VL_EXP_CLASS_P (elt)
    4293                 :          0 :                      || EXPRESSION_CLASS_P (elt))
    4294                 :          0 :                   ? TREE_OPERAND (elt, 0) : 0))
    4295                 :          0 :         if (POINTER_TYPE_P (TREE_TYPE (elt))
    4296                 :          0 :             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
    4297                 :            :                 == need_type))
    4298                 :          0 :           return fold_build1 (INDIRECT_REF, need_type, elt);
    4299                 :            : 
    4300                 :            :       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
    4301                 :            :          survives until RTL generation, there will be an error.  */
    4302                 :            :       return exp;
    4303                 :            :     }
    4304                 :            : 
    4305                 :            :   /* TREE_LIST is special because we need to look at TREE_VALUE
    4306                 :            :      and TREE_CHAIN, not TREE_OPERANDS.  */
    4307                 :     165931 :   else if (code == TREE_LIST)
    4308                 :            :     {
    4309                 :          0 :       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
    4310                 :          0 :       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
    4311                 :          0 :       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
    4312                 :            :         return exp;
    4313                 :            : 
    4314                 :          0 :       return tree_cons (TREE_PURPOSE (exp), op1, op0);
    4315                 :            :     }
    4316                 :            :   else
    4317                 :     165931 :     switch (TREE_CODE_CLASS (code))
    4318                 :            :       {
    4319                 :            :       case tcc_constant:
    4320                 :            :       case tcc_declaration:
    4321                 :            :         return exp;
    4322                 :            : 
    4323                 :       8846 :       case tcc_exceptional:
    4324                 :       8846 :       case tcc_unary:
    4325                 :       8846 :       case tcc_binary:
    4326                 :       8846 :       case tcc_comparison:
    4327                 :       8846 :       case tcc_expression:
    4328                 :       8846 :       case tcc_reference:
    4329                 :       8846 :       case tcc_statement:
    4330                 :       8846 :         switch (TREE_CODE_LENGTH (code))
    4331                 :            :           {
    4332                 :            :           case 0:
    4333                 :            :             return exp;
    4334                 :            : 
    4335                 :       6843 :           case 1:
    4336                 :       6843 :             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
    4337                 :       6843 :             if (op0 == TREE_OPERAND (exp, 0))
    4338                 :            :               return exp;
    4339                 :            : 
    4340                 :          0 :             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
    4341                 :          0 :             break;
    4342                 :            : 
    4343                 :       1987 :           case 2:
    4344                 :       1987 :             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
    4345                 :       1987 :             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
    4346                 :            : 
    4347                 :       1987 :             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
    4348                 :            :               return exp;
    4349                 :            : 
    4350                 :          0 :             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
    4351                 :          0 :             break;
    4352                 :            : 
    4353                 :         16 :           case 3:
    4354                 :         16 :             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
    4355                 :         16 :             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
    4356                 :         16 :             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
    4357                 :            : 
    4358                 :         32 :             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
    4359                 :         32 :                 && op2 == TREE_OPERAND (exp, 2))
    4360                 :            :               return exp;
    4361                 :            : 
    4362                 :          0 :             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
    4363                 :          0 :             break;
    4364                 :            : 
    4365                 :          0 :           case 4:
    4366                 :          0 :             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
    4367                 :          0 :             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
    4368                 :          0 :             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
    4369                 :          0 :             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
    4370                 :            : 
    4371                 :          0 :             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
    4372                 :          0 :                 && op2 == TREE_OPERAND (exp, 2)
    4373                 :          0 :                 && op3 == TREE_OPERAND (exp, 3))
    4374                 :            :               return exp;
    4375                 :            : 
    4376                 :          0 :             new_tree
    4377                 :          0 :               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
    4378                 :          0 :             break;
    4379                 :            : 
    4380                 :          0 :           default:
    4381                 :          0 :             gcc_unreachable ();
    4382                 :            :           }
    4383                 :            :         break;
    4384                 :            : 
    4385                 :            :       case tcc_vl_exp:
    4386                 :            :         {
    4387                 :            :           int i;
    4388                 :            : 
    4389                 :            :           new_tree = NULL_TREE;
    4390                 :            : 
    4391                 :          0 :           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
    4392                 :            :             {
    4393                 :          0 :               tree op = TREE_OPERAND (exp, i);
    4394                 :          0 :               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
    4395                 :          0 :               if (new_op != op)
    4396                 :            :                 {
    4397                 :          0 :                   if (!new_tree)
    4398                 :          0 :                     new_tree = copy_node (exp);
    4399                 :          0 :                   TREE_OPERAND (new_tree, i) = new_op;
    4400                 :            :                 }
    4401                 :            :             }
    4402                 :            : 
    4403                 :          0 :           if (new_tree)
    4404                 :            :             {
    4405                 :          0 :               new_tree = fold (new_tree);
    4406                 :          0 :               if (TREE_CODE (new_tree) == CALL_EXPR)
    4407                 :          0 :                 process_call_operands (new_tree);
    4408                 :            :             }
    4409                 :            :           else
    4410                 :            :             return exp;
    4411                 :            :         }
    4412                 :            :         break;
    4413                 :            : 
    4414                 :          0 :       default:
    4415                 :          0 :         gcc_unreachable ();
    4416                 :            :       }
    4417                 :            : 
    4418                 :          0 :   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
    4419                 :            : 
    4420                 :          0 :   if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
    4421                 :          0 :     TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
    4422                 :            : 
    4423                 :            :   return new_tree;
    4424                 :            : }
    4425                 :            : 
    4426                 :            : 
    4427                 :            : /* Subroutine of stabilize_reference; this is called for subtrees of
    4428                 :            :    references.  Any expression with side-effects must be put in a SAVE_EXPR
    4429                 :            :    to ensure that it is only evaluated once.
    4430                 :            : 
    4431                 :            :    We don't put SAVE_EXPR nodes around everything, because assigning very
    4432                 :            :    simple expressions to temporaries causes us to miss good opportunities
    4433                 :            :    for optimizations.  Among other things, the opportunity to fold in the
    4434                 :            :    addition of a constant into an addressing mode often gets lost, e.g.
    4435                 :            :    "y[i+1] += x;".  In general, we take the approach that we should not make
    4436                 :            :    an assignment unless we are forced into it - i.e., that any non-side effect
    4437                 :            :    operator should be allowed, and that cse should take care of coalescing
    4438                 :            :    multiple utterances of the same expression should that prove fruitful.  */
    4439                 :            : 
    4440                 :            : static tree
    4441                 :     493202 : stabilize_reference_1 (tree e)
    4442                 :            : {
    4443                 :     493202 :   tree result;
    4444                 :     493202 :   enum tree_code code = TREE_CODE (e);
    4445                 :            : 
    4446                 :            :   /* We cannot ignore const expressions because it might be a reference
    4447                 :            :      to a const array but whose index contains side-effects.  But we can
    4448                 :            :      ignore things that are actual constant or that already have been
    4449                 :            :      handled by this function.  */
    4450                 :            : 
    4451                 :     493202 :   if (tree_invariant_p (e))
    4452                 :            :     return e;
    4453                 :            : 
    4454                 :     184132 :   switch (TREE_CODE_CLASS (code))
    4455                 :            :     {
    4456                 :          0 :     case tcc_exceptional:
    4457                 :            :       /* Always wrap STATEMENT_LIST into SAVE_EXPR, even if it doesn't
    4458                 :            :          have side-effects.  */
    4459                 :          0 :       if (code == STATEMENT_LIST)
    4460                 :          0 :         return save_expr (e);
    4461                 :            :       /* FALLTHRU */
    4462                 :     102542 :     case tcc_type:
    4463                 :     102542 :     case tcc_declaration:
    4464                 :     102542 :     case tcc_comparison:
    4465                 :     102542 :     case tcc_statement:
    4466                 :     102542 :     case tcc_expression:
    4467                 :     102542 :     case tcc_reference:
    4468                 :     102542 :     case tcc_vl_exp:
    4469                 :            :       /* If the expression has side-effects, then encase it in a SAVE_EXPR
    4470                 :            :          so that it will only be evaluated once.  */
    4471                 :            :       /* The reference (r) and comparison (<) classes could be handled as
    4472                 :            :          below, but it is generally faster to only evaluate them once.  */
    4473                 :     102542 :       if (TREE_SIDE_EFFECTS (e))
    4474                 :      19524 :         return save_expr (e);
    4475                 :            :       return e;
    4476                 :            : 
    4477                 :            :     case tcc_constant:
    4478                 :            :       /* Constants need no processing.  In fact, we should never reach
    4479                 :            :          here.  */
    4480                 :            :       return e;
    4481                 :            : 
    4482                 :      18287 :     case tcc_binary:
    4483                 :            :       /* Division is slow and tends to be compiled with jumps,
    4484                 :            :          especially the division by powers of 2 that is often
    4485                 :            :          found inside of an array reference.  So do it just once.  */
    4486                 :      18287 :       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
    4487                 :      16209 :           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
    4488                 :      16209 :           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
    4489                 :      16209 :           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
    4490                 :       2078 :         return save_expr (e);
    4491                 :            :       /* Recursively stabilize each operand.  */
    4492                 :      16209 :       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
    4493                 :      16209 :                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
    4494                 :      16209 :       break;
    4495                 :            : 
    4496                 :      63303 :     case tcc_unary:
    4497                 :            :       /* Recursively stabilize each operand.  */
    4498                 :      63303 :       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
    4499                 :      63303 :       break;
    4500                 :            : 
    4501                 :          0 :     default:
    4502                 :          0 :       gcc_unreachable ();
    4503                 :            :     }
    4504                 :            : 
    4505                 :      79512 :   TREE_TYPE (result) = TREE_TYPE (e);
    4506                 :      79512 :   TREE_READONLY (result) = TREE_READONLY (e);
    4507                 :      79512 :   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
    4508                 :      79512 :   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
    4509                 :            : 
    4510                 :      79512 :   return result;
    4511                 :            : }
    4512                 :            : 
    4513                 :            : /* Stabilize a reference so that we can use it any number of times
    4514                 :            :    without causing its operands to be evaluated more than once.
    4515                 :            :    Returns the stabilized reference.  This works by means of save_expr,
    4516                 :            :    so see the caveats in the comments about save_expr.
    4517                 :            : 
    4518                 :            :    Also allows conversion expressions whose operands are references.
    4519                 :            :    Any other kind of expression is returned unchanged.  */
    4520                 :            : 
    4521                 :            : tree
    4522                 :     827824 : stabilize_reference (tree ref)
    4523                 :            : {
    4524                 :     827824 :   tree result;
    4525                 :     827824 :   enum tree_code code = TREE_CODE (ref);
    4526                 :            : 
    4527                 :     827824 :   switch (code)
    4528                 :            :     {
    4529                 :            :     case VAR_DECL:
    4530                 :            :     case PARM_DECL:
    4531                 :            :     case RESULT_DECL:
    4532                 :            :       /* No action is needed in this case.  */
    4533                 :            :       return ref;
    4534                 :            : 
    4535                 :          0 :     CASE_CONVERT:
    4536                 :          0 :     case FLOAT_EXPR:
    4537                 :          0 :     case FIX_TRUNC_EXPR:
    4538                 :          0 :       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
    4539                 :          0 :       break;
    4540                 :            : 
    4541                 :     370984 :     case INDIRECT_REF:
    4542                 :     370984 :       result = build_nt (INDIRECT_REF,
    4543                 :     370984 :                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
    4544                 :     370984 :       break;
    4545                 :            : 
    4546                 :      58948 :     case COMPONENT_REF:
    4547                 :      58948 :       result = build_nt (COMPONENT_REF,
    4548                 :      58948 :                          stabilize_reference (TREE_OPERAND (ref, 0)),
    4549                 :      58948 :                          TREE_OPERAND (ref, 1), NULL_TREE);
    4550                 :      58948 :       break;
    4551                 :            : 
    4552                 :          0 :     case BIT_FIELD_REF:
    4553                 :          0 :       result = build_nt (BIT_FIELD_REF,
    4554                 :          0 :                          stabilize_reference (TREE_OPERAND (ref, 0)),
    4555                 :          0 :                          TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2));
    4556                 :          0 :       REF_REVERSE_STORAGE_ORDER (result) = REF_REVERSE_STORAGE_ORDER (ref);
    4557                 :          0 :       break;
    4558                 :            : 
    4559                 :      26497 :     case ARRAY_REF:
    4560                 :      52994 :       result = build_nt (ARRAY_REF,
    4561                 :      26497 :                          stabilize_reference (TREE_OPERAND (ref, 0)),
    4562                 :      26497 :                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
    4563                 :      26497 :                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
    4564                 :      26497 :       break;
    4565                 :            : 
    4566                 :          0 :     case ARRAY_RANGE_REF:
    4567                 :          0 :       result = build_nt (ARRAY_RANGE_REF,
    4568                 :          0 :                          stabilize_reference (TREE_OPERAND (ref, 0)),
    4569                 :          0 :                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
    4570                 :          0 :                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
    4571                 :          0 :       break;
    4572                 :            : 
    4573                 :          0 :     case COMPOUND_EXPR:
    4574                 :            :       /* We cannot wrap the first expression in a SAVE_EXPR, as then
    4575                 :            :          it wouldn't be ignored.  This matters when dealing with
    4576                 :            :          volatiles.  */
    4577                 :          0 :       return stabilize_reference_1 (ref);
    4578                 :            : 
    4579                 :            :       /* If arg isn't a kind of lvalue we recognize, make no change.
    4580                 :            :          Caller should recognize the error for an invalid lvalue.  */
    4581                 :            :     default:
    4582                 :            :       return ref;
    4583                 :            : 
    4584                 :          0 :     case ERROR_MARK:
    4585                 :          0 :       return error_mark_node;
    4586                 :            :     }
    4587                 :            : 
    4588                 :     456429 :   TREE_TYPE (result) = TREE_TYPE (ref);
    4589                 :     456429 :   TREE_READONLY (result) = TREE_READONLY (ref);
    4590                 :     456429 :   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
    4591                 :     456429 :   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
    4592                 :            : 
    4593                 :     456429 :   return result;
    4594                 :            : }
    4595                 :            : 
    4596                 :            : /* Low-level constructors for expressions.  */
    4597                 :            : 
    4598                 :            : /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
    4599                 :            :    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
    4600                 :            : 
    4601                 :            : void
    4602                 :  548320000 : recompute_tree_invariant_for_addr_expr (tree t)
    4603                 :            : {
    4604                 :  548320000 :   tree node;
    4605                 :  548320000 :   bool tc = true, se = false;
    4606                 :            : 
    4607                 :  548320000 :   gcc_assert (TREE_CODE (t) == ADDR_EXPR);
    4608                 :            : 
    4609                 :            :   /* We started out assuming this address is both invariant and constant, but
    4610                 :            :      does not have side effects.  Now go down any handled components and see if
    4611                 :            :      any of them involve offsets that are either non-constant or non-invariant.
    4612                 :            :      Also check for side-effects.
    4613                 :            : 
    4614                 :            :      ??? Note that this code makes no attempt to deal with the case where
    4615                 :            :      taking the address of something causes a copy due to misalignment.  */
    4616                 :            : 
    4617                 :            : #define UPDATE_FLAGS(NODE)  \
    4618                 :            : do { tree _node = (NODE); \
    4619                 :            :      if (_node && !TREE_CONSTANT (_node)) tc = false; \
    4620                 :            :      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
    4621                 :            : 
    4622                 :  645390000 :   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
    4623                 :   97069500 :        node = TREE_OPERAND (node, 0))
    4624                 :            :     {
    4625                 :            :       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
    4626                 :            :          array reference (probably made temporarily by the G++ front end),
    4627                 :            :          so ignore all the operands.  */
    4628                 :   97069500 :       if ((TREE_CODE (node) == ARRAY_REF
    4629                 :   97069500 :            || TREE_CODE (node) == ARRAY_RANGE_REF)
    4630                 :   97069500 :           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
    4631                 :            :         {
    4632                 :   53995900 :           UPDATE_FLAGS (TREE_OPERAND (node, 1));
    4633                 :   17998600 :           if (TREE_OPERAND (node, 2))
    4634                 :      44286 :             UPDATE_FLAGS (TREE_OPERAND (node, 2));
    4635                 :   17998600 :           if (TREE_OPERAND (node, 3))
    4636                 :    1277540 :             UPDATE_FLAGS (TREE_OPERAND (node, 3));
    4637                 :            :         }
    4638                 :            :       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
    4639                 :            :          FIELD_DECL, apparently.  The G++ front end can put something else
    4640                 :            :          there, at least temporarily.  */
    4641                 :   79070800 :       else if (TREE_CODE (node) == COMPONENT_REF
    4642                 :   79070800 :                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
    4643                 :            :         {
    4644                 :   78919300 :           if (TREE_OPERAND (node, 2))
    4645                 :      38859 :             UPDATE_FLAGS (TREE_OPERAND (node, 2));
    4646                 :            :         }
    4647                 :            :     }
    4648                 :            : 
    4649                 :  548320000 :   node = lang_hooks.expr_to_decl (node, &tc, &se);
    4650                 :            : 
    4651                 :            :   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
    4652                 :            :      the address, since &(*a)->b is a form of addition.  If it's a constant, the
    4653                 :            :      address is constant too.  If it's a decl, its address is constant if the
    4654                 :            :      decl is static.  Everything else is not constant and, furthermore,
    4655                 :            :      taking the address of a volatile variable is not volatile.  */
    4656                 :  548320000 :   if (TREE_CODE (node) == INDIRECT_REF
    4657                 :  541764000 :       || TREE_CODE (node) == MEM_REF)
    4658                 :  216542000 :     UPDATE_FLAGS (TREE_OPERAND (node, 0));
    4659                 :  476139000 :   else if (CONSTANT_CLASS_P (node))
    4660                 :            :     ;
    4661                 :  435986000 :   else if (DECL_P (node))
    4662                 :  432394000 :     tc &= (staticp (node) != NULL_TREE);
    4663                 :            :   else
    4664                 :            :     {
    4665                 :    3592550 :       tc = false;
    4666                 :    3592550 :       se |= TREE_SIDE_EFFECTS (node);
    4667                 :            :     }
    4668                 :            : 
    4669                 :            : 
    4670                 :  548320000 :   TREE_CONSTANT (t) = tc;
    4671                 :  548320000 :   TREE_SIDE_EFFECTS (t) = se;
    4672                 :            : #undef UPDATE_FLAGS
    4673                 :  548320000 : }
    4674                 :            : 
    4675                 :            : /* Build an expression of code CODE, data type TYPE, and operands as
    4676                 :            :    specified.  Expressions and reference nodes can be created this way.
    4677                 :            :    Constants, decls, types and misc nodes cannot be.
    4678                 :            : 
    4679                 :            :    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
    4680                 :            :    enough for all extant tree codes.  */
    4681                 :            : 
    4682                 :            : tree
    4683                 :   17778900 : build0 (enum tree_code code, tree tt MEM_STAT_DECL)
    4684                 :            : {
    4685                 :   17778900 :   tree t;
    4686                 :            : 
    4687                 :   17778900 :   gcc_assert (TREE_CODE_LENGTH (code) == 0);
    4688                 :            : 
    4689                 :   17778900 :   t = make_node (code PASS_MEM_STAT);
    4690                 :   17778900 :   TREE_TYPE (t) = tt;
    4691                 :            : 
    4692                 :   17778900 :   return t;
    4693                 :            : }
    4694                 :            : 
    4695                 :            : tree
    4696                 :  638824000 : build1 (enum tree_code code, tree type, tree node MEM_STAT_DECL)
    4697                 :            : {
    4698                 :  638824000 :   int length = sizeof (struct tree_exp);
    4699                 :  638824000 :   tree t;
    4700                 :            : 
    4701                 :  638824000 :   record_node_allocation_statistics (code, length);
    4702                 :            : 
    4703                 :  638824000 :   gcc_assert (TREE_CODE_LENGTH (code) == 1);
    4704                 :            : 
    4705                 :  638824000 :   t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
    4706                 :            : 
    4707                 :  638824000 :   memset (t, 0, sizeof (struct tree_common));
    4708                 :            : 
    4709                 :  638824000 :   TREE_SET_CODE (t, code);
    4710                 :            : 
    4711                 :  638824000 :   TREE_TYPE (t) = type;
    4712                 :  638824000 :   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
    4713                 :  638824000 :   TREE_OPERAND (t, 0) = node;
    4714                 :  638824000 :   if (node && !TYPE_P (node))
    4715                 :            :     {
    4716                 :  638214000 :       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
    4717                 :  638214000 :       TREE_READONLY (t) = TREE_READONLY (node);
    4718                 :            :     }
    4719                 :            : 
    4720                 :  638824000 :   if (TREE_CODE_CLASS (code) == tcc_statement)
    4721                 :            :     {
    4722                 :    8036340 :       if (code != DEBUG_BEGIN_STMT)
    4723                 :    8036340 :         TREE_SIDE_EFFECTS (t) = 1;
    4724                 :            :     }
    4725                 :  630788000 :   else switch (code)
    4726                 :            :     {
    4727                 :      34962 :     case VA_ARG_EXPR:
    4728                 :            :       /* All of these have side-effects, no matter what their
    4729                 :            :          operands are.  */
    4730                 :      34962 :       TREE_SIDE_EFFECTS (t) = 1;
    4731                 :      34962 :       TREE_READONLY (t) = 0;
    4732                 :      34962 :       break;
    4733                 :            : 
    4734                 :   63685600 :     case INDIRECT_REF:
    4735                 :            :       /* Whether a dereference is readonly has nothing to do with whether
    4736                 :            :          its operand is readonly.  */
    4737                 :   63685600 :       TREE_READONLY (t) = 0;
    4738                 :   63685600 :       break;
    4739                 :            : 
    4740                 :  168509000 :     case ADDR_EXPR:
    4741                 :  168509000 :       if (node)
    4742                 :  168509000 :         recompute_tree_invariant_for_addr_expr (t);
    4743                 :            :       break;
    4744                 :            : 
    4745                 :  398558000 :     default:
    4746                 :  151040000 :       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
    4747                 :  365474000 :           && node && !TYPE_P (node)
    4748                 :  763936000 :           && TREE_CONSTANT (node))
    4749                 :   75002100 :         TREE_CONSTANT (t) = 1;
    4750                 :  398558000 :       if (TREE_CODE_CLASS (code) == tcc_reference
    4751                 :  118674000 :           && node && TREE_THIS_VOLATILE (node))
    4752                 :     442722 :         TREE_THIS_VOLATILE (t) = 1;
    4753                 :            :       break;
    4754                 :            :     }
    4755                 :            : 
    4756                 :  638824000 :   return t;
    4757                 :            : }
    4758                 :            : 
    4759                 :            : #define PROCESS_ARG(N)                          \
    4760                 :            :   do {                                          \
    4761                 :            :     TREE_OPERAND (t, N) = arg##N;               \
    4762                 :            :     if (arg##N &&!TYPE_P (arg##N))              \
    4763                 :            :       {                                         \
    4764                 :            :         if (TREE_SIDE_EFFECTS (arg##N))         \
    4765                 :            :           side_effects = 1;                     \
    4766                 :            :         if (!TREE_READONLY (arg##N)             \
    4767                 :            :             && !CONSTANT_CLASS_P (arg##N))      \
    4768                 :            :           (void) (read_only = 0);               \
    4769                 :            :         if (!TREE_CONSTANT (arg##N))            \
    4770                 :            :           (void) (constant = 0);                \
    4771                 :            :       }                                         \
    4772                 :            :   } while (0)
    4773                 :            : 
    4774                 :            : tree
    4775                 :  324822000 : build2 (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
    4776                 :            : {
    4777                 :  324822000 :   bool constant, read_only, side_effects, div_by_zero;
    4778                 :  324822000 :   tree t;
    4779                 :            : 
    4780                 :  324822000 :   gcc_assert (TREE_CODE_LENGTH (code) == 2);
    4781                 :            : 
    4782                 :  324822000 :   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
    4783                 :   52345400 :       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
    4784                 :            :       /* When sizetype precision doesn't match that of pointers
    4785                 :            :          we need to be able to build explicit extensions or truncations
    4786                 :            :          of the offset argument.  */
    4787                 :  324822000 :       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
    4788                 :          0 :     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
    4789                 :            :                 && TREE_CODE (arg1) == INTEGER_CST);
    4790                 :            : 
    4791                 :  324822000 :   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
    4792                 :   24487100 :     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
    4793                 :            :                 && ptrofftype_p (TREE_TYPE (arg1)));
    4794                 :            : 
    4795                 :  324822000 :   t = make_node (code PASS_MEM_STAT);
    4796                 :  324822000 :   TREE_TYPE (t) = tt;
    4797                 :            : 
    4798                 :            :   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
    4799                 :            :      result based on those same flags for the arguments.  But if the
    4800                 :            :      arguments aren't really even `tree' expressions, we shouldn't be trying
    4801                 :            :      to do this.  */
    4802                 :            : 
    4803                 :            :   /* Expressions without side effects may be constant if their
    4804                 :            :      arguments are as well.  */
    4805                 :  649644000 :   constant = (TREE_CODE_CLASS (code) == tcc_comparison
    4806                 :  324822000 :               || TREE_CODE_CLASS (code) == tcc_binary);
    4807                 :  324822000 :   read_only = 1;
    4808                 :  324822000 :   side_effects = TREE_SIDE_EFFECTS (t);
    4809                 :            : 
    4810                 :  324822000 :   switch (code)
    4811                 :            :     {
    4812                 :    2393140 :     case TRUNC_DIV_EXPR:
    4813                 :    2393140 :     case CEIL_DIV_EXPR:
    4814                 :    2393140 :     case FLOOR_DIV_EXPR:
    4815                 :    2393140 :     case ROUND_DIV_EXPR:
    4816                 :    2393140 :     case EXACT_DIV_EXPR:
    4817                 :    2393140 :     case CEIL_MOD_EXPR:
    4818                 :    2393140 :     case FLOOR_MOD_EXPR:
    4819                 :    2393140 :     case ROUND_MOD_EXPR:
    4820                 :    2393140 :     case TRUNC_MOD_EXPR:
    4821                 :    2393140 :       div_by_zero = integer_zerop (arg1);
    4822                 :    2393140 :       break;
    4823                 :            :     default:
    4824                 :            :       div_by_zero = false;
    4825                 :            :     }
    4826                 :            : 
    4827                 :  598291000 :   PROCESS_ARG (0);
    4828                 :  489319000 :   PROCESS_ARG (1);
    4829                 :            : 
    4830                 :  324822000 :   TREE_SIDE_EFFECTS (t) = side_effects;
    4831                 :  324822000 :   if (code == MEM_REF)
    4832                 :            :     {
    4833                 :   29869300 :       if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
    4834                 :            :         {
    4835                 :    5144840 :           tree o = TREE_OPERAND (arg0, 0);
    4836                 :    5144840 :           TREE_READONLY (t) = TREE_READONLY (o);
    4837                 :    5144840 :           TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
    4838                 :            :         }
    4839                 :            :     }
    4840                 :            :   else
    4841                 :            :     {
    4842                 :  294953000 :       TREE_READONLY (t) = read_only;
    4843                 :            :       /* Don't mark X / 0 as constant.  */
    4844                 :  294953000 :       TREE_CONSTANT (t) = constant && !div_by_zero;
    4845                 :  294953000 :       TREE_THIS_VOLATILE (t)
    4846                 :  294953000 :         = (TREE_CODE_CLASS (code) == tcc_reference
    4847                 :  294953000 :            && arg0 && TREE_THIS_VOLATILE (arg0));
    4848                 :            :     }
    4849                 :            : 
    4850                 :  324822000 :   return t;
    4851                 :            : }
    4852                 :            : 
    4853                 :            : 
    4854                 :            : tree
    4855                 :   72449400 : build3 (enum tree_code code, tree tt, tree arg0, tree arg1,
    4856                 :            :         tree arg2 MEM_STAT_DECL)
    4857                 :            : {
    4858                 :   72449400 :   bool constant, read_only, side_effects;
    4859                 :   72449400 :   tree t;
    4860                 :            : 
    4861                 :   72449400 :   gcc_assert (TREE_CODE_LENGTH (code) == 3);
    4862                 :   72449400 :   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
    4863                 :            : 
    4864                 :   72449400 :   t = make_node (code PASS_MEM_STAT);
    4865                 :   72449400 :   TREE_TYPE (t) = tt;
    4866                 :            : 
    4867                 :   72449400 :   read_only = 1;
    4868                 :            : 
    4869                 :            :   /* As a special exception, if COND_EXPR has NULL branches, we
    4870                 :            :      assume that it is a gimple statement and always consider
    4871                 :            :      it to have side effects.  */
    4872                 :   72449400 :   if (code == COND_EXPR
    4873                 :    8153330 :       && tt == void_type_node
    4874                 :    5522420 :       && arg1 == NULL_TREE
    4875                 :    5522420 :       && arg2 == NULL_TREE)
    4876                 :            :     side_effects = true;
    4877                 :            :   else
    4878                 :   72449400 :     side_effects = TREE_SIDE_EFFECTS (t);
    4879                 :            : 
    4880                 :   76706000 :   PROCESS_ARG (0);
    4881                 :  140054000 :   PROCESS_ARG (1);
    4882                 :  105281000 :   PROCESS_ARG (2);
    4883                 :            : 
    4884                 :   72449400 :   if (code == COND_EXPR)
    4885                 :    8153330 :     TREE_READONLY (t) = read_only;
    4886                 :            : 
    4887                 :   72449400 :   TREE_SIDE_EFFECTS (t) = side_effects;
    4888                 :   72449400 :   TREE_THIS_VOLATILE (t)
    4889                 :   72449400 :     = (TREE_CODE_CLASS (code) == tcc_reference
    4890                 :   72449400 :        && arg0 && TREE_THIS_VOLATILE (arg0));
    4891                 :            : 
    4892                 :   72449400 :   return t;
    4893                 :            : }
    4894                 :            : 
    4895                 :            : tree
    4896                 :    8231170 : build4 (enum tree_code code, tree tt, tree arg0, tree arg1,
    4897                 :            :         tree arg2, tree arg3 MEM_STAT_DECL)
    4898                 :            : {
    4899                 :    8231170 :   bool constant, read_only, side_effects;
    4900                 :    8231170 :   tree t;
    4901                 :            : 
    4902                 :    8231170 :   gcc_assert (TREE_CODE_LENGTH (code) == 4);
    4903                 :            : 
    4904                 :    8231170 :   t = make_node (code PASS_MEM_STAT);
    4905                 :    8231170 :   TREE_TYPE (t) = tt;
    4906                 :            : 
    4907                 :    8231170 :   side_effects = TREE_SIDE_EFFECTS (t);
    4908                 :            : 
    4909                 :    8231170 :   PROCESS_ARG (0);
    4910                 :    8231170 :   PROCESS_ARG (1);
    4911                 :    8231170 :   PROCESS_ARG (2);
    4912                 :    8231170 :   PROCESS_ARG (3);
    4913                 :            : 
    4914                 :    8231170 :   TREE_SIDE_EFFECTS (t) = side_effects;
    4915                 :    8231170 :   TREE_THIS_VOLATILE (t)
    4916                 :   16462300 :     = (TREE_CODE_CLASS (code) == tcc_reference
    4917                 :    8231170 :        && arg0 && TREE_THIS_VOLATILE (arg0));
    4918                 :            : 
    4919                 :    8231170 :   return t;
    4920                 :            : }
    4921                 :            : 
    4922                 :            : tree
    4923                 :     510058 : build5 (enum tree_code code, tree tt, tree arg0, tree arg1,
    4924                 :            :         tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
    4925                 :            : {
    4926                 :     510058 :   bool constant, read_only, side_effects;
    4927                 :     510058 :   tree t;
    4928                 :            : 
    4929                 :     510058 :   gcc_assert (TREE_CODE_LENGTH (code) == 5);
    4930                 :            : 
    4931                 :     510058 :   t = make_node (code PASS_MEM_STAT);
    4932                 :     510058 :   TREE_TYPE (t) = tt;
    4933                 :            : 
    4934                 :     510058 :   side_effects = TREE_SIDE_EFFECTS (t);
    4935                 :            : 
    4936                 :     510058 :   PROCESS_ARG (0);
    4937                 :     510058 :   PROCESS_ARG (1);
    4938                 :     510058 :   PROCESS_ARG (2);
    4939                 :     510058 :   PROCESS_ARG (3);
    4940                 :     510058 :   PROCESS_ARG (4);
    4941                 :            : 
    4942                 :     510058 :   TREE_SIDE_EFFECTS (t) = side_effects;
    4943                 :     510058 :   if (code == TARGET_MEM_REF)
    4944                 :            :     {
    4945                 :     505499 :       if (arg0 && TREE_CODE (arg0) == ADDR_EXPR)
    4946                 :            :         {
    4947                 :     119616 :           tree o = TREE_OPERAND (arg0, 0);
    4948                 :     119616 :           TREE_READONLY (t) = TREE_READONLY (o);
    4949                 :     119616 :           TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o);
    4950                 :            :         }
    4951                 :            :     }
    4952                 :            :   else
    4953                 :       4559 :     TREE_THIS_VOLATILE (t)
    4954                 :       4559 :       = (TREE_CODE_CLASS (code) == tcc_reference
    4955                 :       4559 :          && arg0 && TREE_THIS_VOLATILE (arg0));
    4956                 :            : 
    4957                 :     510058 :   return t;
    4958                 :            : }
    4959                 :            : 
    4960                 :            : /* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
    4961                 :            :    on the pointer PTR.  */
    4962                 :            : 
    4963                 :            : tree
    4964                 :     353265 : build_simple_mem_ref_loc (location_t loc, tree ptr)
    4965                 :            : {
    4966                 :     353265 :   poly_int64 offset = 0;
    4967                 :     353265 :   tree ptype = TREE_TYPE (ptr);
    4968                 :     353265 :   tree tem;
    4969                 :            :   /* For convenience allow addresses that collapse to a simple base
    4970                 :            :      and offset.  */
    4971                 :     353265 :   if (TREE_CODE (ptr) == ADDR_EXPR
    4972                 :     353265 :       && (handled_component_p (TREE_OPERAND (ptr, 0))
    4973                 :      10200 :           || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
    4974                 :            :     {
    4975                 :        174 :       ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
    4976                 :        174 :       gcc_assert (ptr);
    4977                 :        174 :       if (TREE_CODE (ptr) == MEM_REF)
    4978                 :            :         {
    4979                 :         73 :           offset += mem_ref_offset (ptr).force_shwi ();
    4980                 :         73 :           ptr = TREE_OPERAND (ptr, 0);
    4981                 :            :         }
    4982                 :            :       else
    4983                 :        101 :         ptr = build_fold_addr_expr (ptr);
    4984                 :        174 :       gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
    4985                 :            :     }
    4986                 :     353265 :   tem = build2 (MEM_REF, TREE_TYPE (ptype),
    4987                 :            :                 ptr, build_int_cst (ptype, offset));
    4988                 :     353265 :   SET_EXPR_LOCATION (tem, loc);
    4989                 :     353265 :   return tem;
    4990                 :            : }
    4991                 :            : 
    4992                 :            : /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T.  */
    4993                 :            : 
    4994                 :            : poly_offset_int
    4995                 :  935460000 : mem_ref_offset (const_tree t)
    4996                 :            : {
    4997                 :  935460000 :   return poly_offset_int::from (wi::to_poly_wide (TREE_OPERAND (t, 1)),
    4998                 :  935460000 :                                 SIGNED);
    4999                 :            : }
    5000                 :            : 
    5001                 :            : /* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE
    5002                 :            :    offsetted by OFFSET units.  */
    5003                 :            : 
    5004                 :            : tree
    5005                 :      85963 : build_invariant_address (tree type, tree base, poly_int64 offset)
    5006                 :            : {
    5007                 :      85963 :   tree ref = fold_build2 (MEM_REF, TREE_TYPE (type),
    5008                 :            :                           build_fold_addr_expr (base),
    5009                 :            :                           build_int_cst (ptr_type_node, offset));
    5010                 :      85963 :   tree addr = build1 (ADDR_EXPR, type, ref);
    5011                 :      85963 :   recompute_tree_invariant_for_addr_expr (addr);
    5012                 :      85963 :   return addr;
    5013                 :            : }
    5014                 :            : 
    5015                 :            : /* Similar except don't specify the TREE_TYPE
    5016                 :            :    and leave the TREE_SIDE_EFFECTS as 0.
    5017                 :            :    It is permissible for arguments to be null,
    5018                 :            :    or even garbage if their values do not matter.  */
    5019                 :            : 
    5020                 :            : tree
    5021                 :    7722790 : build_nt (enum tree_code code, ...)
    5022                 :            : {
    5023                 :    7722790 :   tree t;
    5024                 :    7722790 :   int length;
    5025                 :    7722790 :   int i;
    5026                 :    7722790 :   va_list p;
    5027                 :            : 
    5028                 :    7722790 :   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
    5029                 :            : 
    5030                 :    7722790 :   va_start (p, code);
    5031                 :            : 
    5032                 :    7722790 :   t = make_node (code);
    5033                 :    7722790 :   length = TREE_CODE_LENGTH (code);
    5034                 :            : 
    5035                 :   16822500 :   for (i = 0; i < length; i++)
    5036                 :    9099700 :     TREE_OPERAND (t, i) = va_arg (p, tree);
    5037                 :            : 
    5038                 :    7722790 :   va_end (p);
    5039                 :    7722790 :   return t;
    5040                 :            : }
    5041                 :            : 
    5042                 :            : /* Similar to build_nt, but for creating a CALL_EXPR object with a
    5043                 :            :    tree vec.  */
    5044                 :            : 
    5045                 :            : tree
    5046                 :          0 : build_nt_call_vec (tree fn, vec<tree, va_gc> *args)
    5047                 :            : {
    5048                 :          0 :   tree ret, t;
    5049                 :          0 :   unsigned int ix;
    5050                 :            : 
    5051                 :          0 :   ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
    5052                 :          0 :   CALL_EXPR_FN (ret) = fn;
    5053                 :          0 :   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
    5054                 :          0 :   FOR_EACH_VEC_SAFE_ELT (args, ix, t)
    5055                 :          0 :     CALL_EXPR_ARG (ret, ix) = t;
    5056                 :          0 :   return ret;
    5057                 :            : }
    5058                 :            : 
    5059                 :            : /* Create a DECL_... node of code CODE, name NAME  (if non-null)
    5060                 :            :    and data type TYPE.
    5061                 :            :    We do NOT enter this node in any sort of symbol table.
    5062                 :            : 
    5063                 :            :    LOC is the location of the decl.
    5064                 :            : 
    5065                 :            :    layout_decl is used to set up the decl's storage layout.
    5066                 :            :    Other slots are initialized to 0 or null pointers.  */
    5067                 :            : 
    5068                 :            : tree
    5069                 :  829256000 : build_decl (location_t loc, enum tree_code code, tree name,
    5070                 :            :                  tree type MEM_STAT_DECL)
    5071                 :            : {
    5072                 :  829256000 :   tree t;
    5073                 :            : 
    5074                 :  829256000 :   t = make_node (code PASS_MEM_STAT);
    5075                 :  829256000 :   DECL_SOURCE_LOCATION (t) = loc;
    5076                 :            : 
    5077                 :            : /*  if (type == error_mark_node)
    5078                 :            :     type = integer_type_node; */
    5079                 :            : /* That is not done, deliberately, so that having error_mark_node
    5080                 :            :    as the type can suppress useless errors in the use of this variable.  */
    5081                 :            : 
    5082                 :  829256000 :   DECL_NAME (t) = name;
    5083                 :  829256000 :   TREE_TYPE (t) = type;
    5084                 :            : 
    5085                 :  829256000 :   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
    5086                 :  198153000 :     layout_decl (t, 0);
    5087                 :            : 
    5088                 :  829256000 :   return t;
    5089                 :            : }
    5090                 :            : 
    5091                 :            : /* Builds and returns function declaration with NAME and TYPE.  */
    5092                 :            : 
    5093                 :            : tree
    5094                 :       5579 : build_fn_decl (const char *name, tree type)
    5095                 :            : {
    5096                 :       5579 :   tree id = get_identifier (name);
    5097                 :       5579 :   tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
    5098                 :            : 
    5099                 :       5579 :   DECL_EXTERNAL (decl) = 1;
    5100                 :       5579 :   TREE_PUBLIC (decl) = 1;
    5101                 :       5579 :   DECL_ARTIFICIAL (decl) = 1;
    5102                 :       5579 :   TREE_NOTHROW (decl) = 1;
    5103                 :            : 
    5104                 :       5579 :   return decl;
    5105                 :            : }
    5106                 :            : 
    5107                 :            : vec<tree, va_gc> *all_translation_units;
    5108                 :            : 
    5109                 :            : /* Builds a new translation-unit decl with name NAME, queues it in the
    5110                 :            :    global list of translation-unit decls and returns it.   */
    5111                 :            : 
    5112                 :            : tree
    5113                 :     180375 : build_translation_unit_decl (tree name)
    5114                 :            : {
    5115                 :     180375 :   tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
    5116                 :     180375 :                         name, NULL_TREE);
    5117                 :     180375 :   TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
    5118                 :     180375 :   vec_safe_push (all_translation_units, tu);
    5119                 :     180375 :   return tu;
    5120                 :            : }
    5121                 :            : 
    5122                 :            : 
    5123                 :            : /* BLOCK nodes are used to represent the structure of binding contours
    5124                 :            :    and declarations, once those contours have been exited and their contents
    5125                 :            :    compiled.  This information is used for outputting debugging info.  */
    5126                 :            : 
    5127                 :            : tree
    5128                 :     424644 : build_block (tree vars, tree subblocks, tree supercontext, tree chain)
    5129                 :            : {
    5130                 :     424644 :   tree block = make_node (BLOCK);
    5131                 :            : 
    5132                 :     424644 :   BLOCK_VARS (block) = vars;
    5133                 :     424644 :   BLOCK_SUBBLOCKS (block) = subblocks;
    5134                 :     424644 :   BLOCK_SUPERCONTEXT (block) = supercontext;
    5135                 :     424644 :   BLOCK_CHAIN (block) = chain;
    5136                 :     424644 :   return block;
    5137                 :            : }
    5138                 :            : 
    5139                 :            : 
    5140                 :            : /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
    5141                 :            : 
    5142                 :            :    LOC is the location to use in tree T.  */
    5143                 :            : 
    5144                 :            : void
    5145                 : 1013550000 : protected_set_expr_location (tree t, location_t loc)
    5146                 :            : {
    5147                 : 1013550000 :   if (CAN_HAVE_LOCATION_P (t))
    5148                 :  262918000 :     SET_EXPR_LOCATION (t, loc);
    5149                 :  750636000 :   else if (t && TREE_CODE (t) == STATEMENT_LIST)
    5150                 :            :     {
    5151                 :      10894 :       t = expr_single (t);
    5152                 :      10894 :       if (t && CAN_HAVE_LOCATION_P (t))
    5153                 :         31 :         SET_EXPR_LOCATION (t, loc);
    5154                 :            :     }
    5155                 : 1013550000 : }
    5156                 :            : 
    5157                 :            : /* Like PROTECTED_SET_EXPR_LOCATION, but only do that if T has
    5158                 :            :    UNKNOWN_LOCATION.  */
    5159                 :            : 
    5160                 :            : void
    5161                 :    2596950 : protected_set_expr_location_if_unset (tree t, location_t loc)
    5162                 :            : {
    5163                 :    2596950 :   t = expr_single (t);
    5164                 :    2596950 :   if (t && !EXPR_HAS_LOCATION (t))
    5165                 :    2268240 :     protected_set_expr_location (t, loc);
    5166                 :    2596950 : }
    5167                 :            : 
    5168                 :            : /* Data used when collecting DECLs and TYPEs for language data removal.  */
    5169                 :            : 
    5170                 :            : class free_lang_data_d
    5171                 :            : {
    5172                 :            : public:
    5173                 :     163437 :   free_lang_data_d () : decls (100), types (100) {}
    5174                 :            : 
    5175                 :            :   /* Worklist to avoid excessive recursion.  */
    5176                 :            :   auto_vec<tree> worklist;
    5177                 :            : 
    5178                 :            :   /* Set of traversed objects.  Used to avoid duplicate visits.  */
    5179                 :            :   hash_set<tree> pset;
    5180                 :            : 
    5181                 :            :   /* Array of symbols to process with free_lang_data_in_decl.  */
    5182                 :            :   auto_vec<tree> decls;
    5183                 :            : 
    5184                 :            :   /* Array of types to process with free_lang_data_in_type.  */
    5185                 :            :   auto_vec<tree> types;
    5186                 :            : };
    5187                 :            : 
    5188                 :            : 
    5189                 :            : /* Add type or decl T to one of the list of tree nodes that need their
    5190                 :            :    language data removed.  The lists are held inside FLD.  */
    5191                 :            : 
    5192                 :            : static void
    5193                 :    9937300 : add_tree_to_fld_list (tree t, class free_lang_data_d *fld)
    5194                 :            : {
    5195                 :    9937300 :   if (DECL_P (t))
    5196                 :    7186760 :     fld->decls.safe_push (t);
    5197                 :    2750540 :   else if (TYPE_P (t))
    5198                 :    2750540 :     fld->types.safe_push (t);
    5199                 :            :   else
    5200                 :          0 :     gcc_unreachable ();
    5201                 :    9937300 : }
    5202                 :            : 
    5203                 :            : /* Push tree node T into FLD->WORKLIST.  */
    5204                 :            : 
    5205                 :            : static inline void
    5206                 :  115715000 : fld_worklist_push (tree t, class free_lang_data_d *fld)
    5207                 :            : {
    5208                 :  115715000 :   if (t && !is_lang_specific (t) && !fld->pset.contains (t))
    5209                 :   25812200 :     fld->worklist.safe_push ((t));
    5210                 :  115715000 : }
    5211                 :            : 
    5212                 :            : 
    5213                 :            : 
    5214                 :            : /* Return simplified TYPE_NAME of TYPE.  */
    5215                 :            : 
    5216                 :            : static tree
    5217                 :    3369680 : fld_simplified_type_name (tree type)
    5218                 :            : {
    5219                 :    3369680 :   if (!TYPE_NAME (type) || TREE_CODE (TYPE_NAME (type)) != TYPE_DECL)
    5220                 :    3369680 :     return TYPE_NAME (type);
    5221                 :            :   /* Drop TYPE_DECLs in TYPE_NAME in favor of the identifier in the
    5222                 :            :      TYPE_DECL if the type doesn't have linkage.
    5223                 :            :      this must match fld_  */
    5224                 :     407031 :   if (type != TYPE_MAIN_VARIANT (type)
    5225                 :     407031 :       || (!DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type))
    5226                 :     189326 :           && (TREE_CODE (type) != RECORD_TYPE
    5227                 :      26151 :               || !TYPE_BINFO (type)
    5228                 :          0 :               || !BINFO_VTABLE (TYPE_BINFO (type)))))
    5229                 :     355536 :     return DECL_NAME (TYPE_NAME (type));
    5230                 :    3369680 :   return TYPE_NAME (type);
    5231                 :            : }
    5232                 :            : 
    5233                 :            : /* Do same comparsion as check_qualified_type skipping lang part of type
    5234                 :            :    and be more permissive about type names: we only care that names are
    5235                 :            :    same (for diagnostics) and that ODR names are the same.
    5236                 :            :    If INNER_TYPE is non-NULL, be sure that TREE_TYPE match it.  */
    5237                 :            : 
    5238                 :            : static bool
    5239                 :     371802 : fld_type_variant_equal_p (tree t, tree v, tree inner_type)
    5240                 :            : {
    5241                 :     371802 :   if (TYPE_QUALS (t) != TYPE_QUALS (v)
    5242                 :            :       /* We want to match incomplete variants with complete types.
    5243                 :            :          In this case we need to ignore alignment.   */
    5244                 :     296145 :       || ((!RECORD_OR_UNION_TYPE_P (t) || COMPLETE_TYPE_P (v))
    5245                 :     217150 :           && (TYPE_ALIGN (t) != TYPE_ALIGN (v)
    5246                 :     217136 :               || TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (v)))
    5247                 :     296131 :       || fld_simplified_type_name (t) != fld_simplified_type_name (v)
    5248                 :     263892 :       || !attribute_list_equal (TYPE_ATTRIBUTES (t),
    5249                 :     263892 :                                 TYPE_ATTRIBUTES (v))
    5250                 :     635714 :       || (inner_type && TREE_TYPE (v) != inner_type))
    5251                 :     107910 :     return false;
    5252                 :            : 
    5253                 :            :   return true;
    5254                 :            : }
    5255                 :            : 
    5256                 :            : /* Find variant of FIRST that match T and create new one if necessary.
    5257                 :            :    Set TREE_TYPE to INNER_TYPE if non-NULL.  */
    5258                 :            : 
    5259                 :            : static tree
    5260                 :     263892 : fld_type_variant (tree first, tree t, class free_lang_data_d *fld,
    5261                 :            :                   tree inner_type = NULL)
    5262                 :            : {
    5263                 :     263892 :   if (first == TYPE_MAIN_VARIANT (t))
    5264                 :            :     return t;
    5265                 :     371802 :   for (tree v = first; v; v = TYPE_NEXT_VARIANT (v))
    5266                 :     341311 :     if (fld_type_variant_equal_p (t, v, inner_type))
    5267                 :     233401 :       return v;
    5268                 :      30491 :   tree v = build_variant_type_copy (first);
    5269                 :      30491 :   TYPE_READONLY (v) = TYPE_READONLY (t);
    5270                 :      30491 :   TYPE_VOLATILE (v) = TYPE_VOLATILE (t);
    5271                 :      30491 :   TYPE_ATOMIC (v) = TYPE_ATOMIC (t);
    5272                 :      30491 :   TYPE_RESTRICT (v) = TYPE_RESTRICT (t);
    5273                 :      30491 :   TYPE_ADDR_SPACE (v) = TYPE_ADDR_SPACE (t);
    5274                 :      30491 :   TYPE_NAME (v) = TYPE_NAME (t);
    5275                 :      30491 :   TYPE_ATTRIBUTES (v) = TYPE_ATTRIBUTES (t);
    5276                 :      30491 :   TYPE_CANONICAL (v) = TYPE_CANONICAL (t);
    5277                 :            :   /* Variants of incomplete types should have alignment 
    5278                 :            :      set to BITS_PER_UNIT.  Do not copy the actual alignment.  */
    5279                 :      30491 :   if (!RECORD_OR_UNION_TYPE_P (v) || COMPLETE_TYPE_P (v))
    5280                 :            :     {
    5281                 :      13848 :       SET_TYPE_ALIGN (v, TYPE_ALIGN (t));
    5282                 :      13848 :       TYPE_USER_ALIGN (v) = TYPE_USER_ALIGN (t);
    5283                 :            :     }
    5284                 :      30491 :   if (inner_type)
    5285                 :         20 :     TREE_TYPE (v) = inner_type;
    5286                 :      30491 :   gcc_checking_assert (fld_type_variant_equal_p (t,v, inner_type));
    5287                 :      30491 :   if (!fld->pset.add (v))
    5288                 :      30491 :     add_tree_to_fld_list (v, fld);
    5289                 :      30491 :   return v;
    5290                 :            : }
    5291                 :            : 
    5292                 :            : /* Map complete types to incomplete types.  */
    5293                 :            : 
    5294                 :            : static hash_map<tree, tree> *fld_incomplete_types;
    5295                 :            : 
    5296                 :            : /* Map types to simplified types.  */
    5297                 :            : 
    5298                 :            : static hash_map<tree, tree> *fld_simplified_types;
    5299                 :            : 
    5300                 :            : /* Produce variant of T whose TREE_TYPE is T2. If it is main variant,
    5301                 :            :    use MAP to prevent duplicates.  */
    5302                 :            : 
    5303                 :            : static tree
    5304                 :        589 : fld_process_array_type (tree t, tree t2, hash_map<tree, tree> *map,
    5305                 :            :                         class free_lang_data_d *fld)
    5306                 :            : {
    5307                 :        589 :   if (TREE_TYPE (t) == t2)
    5308                 :            :     return t;
    5309                 :            : 
    5310                 :        132 :   if (TYPE_MAIN_VARIANT (t) != t)
    5311                 :            :     {
    5312                 :         20 :       return fld_type_variant
    5313                 :         40 :                (fld_process_array_type (TYPE_MAIN_VARIANT (t),
    5314                 :         20 :                                         TYPE_MAIN_VARIANT (t2), map, fld),
    5315                 :         20 :                 t, fld, t2);
    5316                 :            :     }
    5317                 :            : 
    5318                 :        112 :   bool existed;
    5319                 :        112 :   tree &array
    5320                 :        112 :      = map->get_or_insert (t, &existed);
    5321                 :        112 :   if (!existed)
    5322                 :            :     {
    5323                 :         30 :       array
    5324                 :         60 :         = build_array_type_1 (t2, TYPE_DOMAIN (t), TYPE_TYPELESS_STORAGE (t),
    5325                 :         30 :                               false, false);
    5326                 :         30 :       TYPE_CANONICAL (array) = TYPE_CANONICAL (t);
    5327                 :         30 :       if (!fld->pset.add (array))
    5328                 :         30 :         add_tree_to_fld_list (array, fld);
    5329                 :            :     }
    5330                 :        112 :   return array;
    5331                 :            : }
    5332                 :            : 
    5333                 :            : /* Return CTX after removal of contexts that are not relevant  */
    5334                 :            : 
    5335                 :            : static tree
    5336                 :    6957790 : fld_decl_context (tree ctx)
    5337                 :            : {
    5338                 :            :   /* Variably modified types are needed for tree_is_indexable to decide
    5339                 :            :      whether the type needs to go to local or global section.
    5340                 :            :      This code is semi-broken but for now it is easiest to keep contexts
    5341                 :            :      as expected.  */
    5342                 :    6003070 :   if (ctx && TYPE_P (ctx)
    5343                 :    7017720 :       && !variably_modified_type_p (ctx, NULL_TREE))
    5344                 :            :      {
    5345                 :     126198 :        while (ctx && TYPE_P (ctx))
    5346                 :      66266 :          ctx = TYPE_CONTEXT (ctx);
    5347                 :            :      }
    5348                 :    6957790 :   return ctx;
    5349                 :            : }
    5350                 :            : 
    5351                 :            : /* For T being aggregate type try to turn it into a incomplete variant.
    5352                 :            :    Return T if no simplification is possible.  */
    5353                 :            : 
    5354                 :            : static tree
    5355                 :    4362090 : fld_incomplete_type_of (tree t, class free_lang_data_d *fld)
    5356                 :            : {
    5357                 :    4362090 :   if (!t)
    5358                 :            :     return NULL;
    5359                 :    4362090 :   if (POINTER_TYPE_P (t))
    5360                 :            :     {
    5361                 :    2180140 :       tree t2 = fld_incomplete_type_of (TREE_TYPE (t), fld);
    5362                 :    2180140 :       if (t2 != TREE_TYPE (t))
    5363                 :            :         {
    5364                 :     212814 :           tree first;
    5365                 :     212814 :           if (TREE_CODE (t) == POINTER_TYPE)
    5366                 :     189698 :             first = build_pointer_type_for_mode (t2, TYPE_MODE (t),
    5367                 :     189698 :                                                 TYPE_REF_CAN_ALIAS_ALL (t));
    5368                 :            :           else
    5369                 :      23116 :             first = build_reference_type_for_mode (t2, TYPE_MODE (t),
    5370                 :      46232 :                                                 TYPE_REF_CAN_ALIAS_ALL (t));
    5371                 :     212814 :           gcc_assert (TYPE_CANONICAL (t2) != t2
    5372                 :            :                       && TYPE_CANONICAL (t2) == TYPE_CANONICAL (TREE_TYPE (t)));
    5373                 :     212814 :           if (!fld->pset.add (first))
    5374                 :      45179 :             add_tree_to_fld_list (first, fld);
    5375                 :     212814 :           return fld_type_variant (first, t, fld);
    5376                 :            :         }
    5377                 :            :       return t;
    5378                 :            :     }
    5379                 :    2181950 :   if (TREE_CODE (t) == ARRAY_TYPE)
    5380                 :        569 :     return fld_process_array_type (t,
    5381                 :        569 :                                    fld_incomplete_type_of (TREE_TYPE (t), fld),
    5382                 :        569 :                                    fld_incomplete_types, fld);
    5383                 :    1851680 :   if ((!RECORD_OR_UNION_TYPE_P (t) && TREE_CODE (t) != ENUMERAL_TYPE)
    5384                 :    2182490 :       || !COMPLETE_TYPE_P (t))
    5385                 :            :     return t;
    5386                 :     262467 :   if (TYPE_MAIN_VARIANT (t) == t)
    5387                 :            :     {
    5388                 :     211409 :       bool existed;
    5389                 :     211409 :       tree &copy
    5390                 :     211409 :          = fld_incomplete_types->get_or_insert (t, &existed);
    5391                 :            : 
    5392                 :     211409 :       if (!existed)
    5393                 :            :         {
    5394                 :      26783 :           copy = build_distinct_type_copy (t);
    5395                 :            : 
    5396                 :            :           /* It is possible that type was not seen by free_lang_data yet.  */
    5397                 :      26783 :           if (!fld->pset.add (copy))
    5398                 :      26783 :             add_tree_to_fld_list (copy, fld);
    5399                 :      26783 :           TYPE_SIZE (copy) = NULL;
    5400                 :      26783 :           TYPE_USER_ALIGN (copy) = 0;
    5401                 :      26783 :           TYPE_SIZE_UNIT (copy) = NULL;
    5402                 :      26783 :           TYPE_CANONICAL (copy) = TYPE_CANONICAL (t);
    5403                 :      26783 :           TREE_ADDRESSABLE (copy) = 0;
    5404                 :      26783 :           if (AGGREGATE_TYPE_P (t))
    5405                 :            :             {
    5406                 :      26747 :               SET_TYPE_MODE (copy, VOIDmode);
    5407                 :      26747 :               SET_TYPE_ALIGN (copy, BITS_PER_UNIT);
    5408                 :      26747 :               TYPE_TYPELESS_STORAGE (copy) = 0;
    5409                 :      26747 :               TYPE_FIELDS (copy) = NULL;
    5410                 :      26747 :               TYPE_BINFO (copy) = NULL;
    5411                 :      26747 :               TYPE_FINAL_P (copy) = 0;
    5412                 :      26747 :               TYPE_EMPTY_P (copy) = 0;
    5413                 :            :             }
    5414                 :            :           else
    5415                 :            :             {
    5416                 :         36 :               TYPE_VALUES (copy) = NULL;
    5417                 :         36 :               ENUM_IS_OPAQUE (copy) = 0;
    5418                 :         36 :               ENUM_IS_SCOPED (copy) = 0;
    5419                 :            :             }
    5420                 :            : 
    5421                 :            :           /* Build copy of TYPE_DECL in TYPE_NAME if necessary.
    5422                 :            :              This is needed for ODR violation warnings to come out right (we
    5423                 :            :              want duplicate TYPE_DECLs whenever the type is duplicated because
    5424                 :            :              of ODR violation.  Because lang data in the TYPE_DECL may not
    5425                 :            :              have been freed yet, rebuild it from scratch and copy relevant
    5426                 :            :              fields.  */
    5427                 :      26783 :           TYPE_NAME (copy) = fld_simplified_type_name (copy);
    5428                 :      26783 :           tree name = TYPE_NAME (copy);
    5429                 :            : 
    5430                 :      26783 :           if (name && TREE_CODE (name) == TYPE_DECL)
    5431                 :            :             {
    5432                 :       7988 :               gcc_checking_assert (TREE_TYPE (name) == t);
    5433                 :       7988 :               tree name2 = build_decl (DECL_SOURCE_LOCATION (name), TYPE_DECL,
    5434                 :       7988 :                                        DECL_NAME (name), copy);
    5435                 :       7988 :               if (DECL_ASSEMBLER_NAME_SET_P (name))
    5436                 :       7988 :                 SET_DECL_ASSEMBLER_NAME (name2, DECL_ASSEMBLER_NAME (name));
    5437                 :       7988 :               SET_DECL_ALIGN (name2, 0);
    5438                 :       7988 :               DECL_CONTEXT (name2) = fld_decl_context
    5439                 :       7988 :                                          (DECL_CONTEXT (name));
    5440                 :       7988 :               TYPE_NAME (copy) = name2;
    5441                 :            :             }
    5442                 :            :         }
    5443                 :     211409 :       return copy;
    5444                 :            :    }
    5445                 :      51058 :   return (fld_type_variant
    5446                 :      51058 :             (fld_incomplete_type_of (TYPE_MAIN_VARIANT (t), fld), t, fld));
    5447                 :            : }
    5448                 :            : 
    5449                 :            : /* Simplify type T for scenarios where we do not need complete pointer
    5450                 :            :    types.  */
    5451                 :            : 
    5452                 :            : static tree
    5453                 :   12530900 : fld_simplified_type (tree t, class free_lang_data_d *fld)
    5454                 :            : {
    5455                 :   12530900 :   if (!t)
    5456                 :            :     return t;
    5457                 :   12530900 :   if (POINTER_TYPE_P (t))
    5458                 :    2130320 :     return fld_incomplete_type_of (t, fld);
    5459                 :            :   /* FIXME: This triggers verification error, see PR88140.  */
    5460                 :            :   if (TREE_CODE (t) == ARRAY_TYPE && 0)
    5461                 :            :     return fld_process_array_type (t, fld_simplified_type (TREE_TYPE (t), fld),
    5462                 :            :                                    fld_simplified_types, fld);
    5463                 :            :   return t;
    5464                 :            : }
    5465                 :            : 
    5466                 :            : /* Reset the expression *EXPR_P, a size or position.
    5467                 :            : 
    5468                 :            :    ??? We could reset all non-constant sizes or positions.  But it's cheap
    5469                 :            :    enough to not do so and refrain from adding workarounds to dwarf2out.c.
    5470                 :            : 
    5471                 :            :    We need to reset self-referential sizes or positions because they cannot
    5472                 :            :    be gimplified and thus can contain a CALL_EXPR after the gimplification
    5473                 :            :    is finished, which will run afoul of LTO streaming.  And they need to be
    5474                 :            :    reset to something essentially dummy but not constant, so as to preserve
    5475                 :            :    the properties of the object they are attached to.  */
    5476                 :            : 
    5477                 :            : static inline void
    5478                 :   20600900 : free_lang_data_in_one_sizepos (tree *expr_p)
    5479                 :            : {
    5480                 :   20600900 :   tree expr = *expr_p;
    5481                 :   29616100 :   if (CONTAINS_PLACEHOLDER_P (expr))
    5482                 :          0 :     *expr_p = build0 (PLACEHOLDER_EXPR, TREE_TYPE (expr));
    5483                 :   20600900 : }
    5484                 :            : 
    5485                 :            : 
    5486                 :            : /* Reset all the fields in a binfo node BINFO.  We only keep
    5487                 :            :    BINFO_VTABLE, which is used by gimple_fold_obj_type_ref.  */
    5488                 :            : 
    5489                 :            : static void
    5490                 :      55136 : free_lang_data_in_binfo (tree binfo)
    5491                 :            : {
    5492                 :      55136 :   unsigned i;
    5493                 :      55136 :   tree t;
    5494                 :            : 
    5495                 :      55136 :   gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
    5496                 :            : 
    5497                 :      55136 :   BINFO_VIRTUALS (binfo) = NULL_TREE;
    5498                 :      55136 :   BINFO_BASE_ACCESSES (binfo) = NULL;
    5499                 :      55136 :   BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
    5500                 :      55136 :   BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
    5501                 :      55136 :   BINFO_VPTR_FIELD (binfo) = NULL_TREE;
    5502                 :      55136 :   TREE_PUBLIC (binfo) = 0;
    5503                 :            : 
    5504                 :      80281 :   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t)
    5505                 :      25145 :     free_lang_data_in_binfo (t);
    5506                 :      55136 : }
    5507                 :            : 
    5508                 :            : 
    5509                 :            : /* Reset all language specific information still present in TYPE.  */
    5510                 :            : 
    5511                 :            : static void
    5512                 :    2750630 : free_lang_data_in_type (tree type, class free_lang_data_d *fld)
    5513                 :            : {
    5514                 :    2750630 :   gcc_assert (TYPE_P (type));
    5515                 :            : 
    5516                 :            :   /* Give the FE a chance to remove its own data first.  */
    5517                 :    2750630 :   lang_hooks.free_lang_data (type);
    5518                 :            : 
    5519                 :    2750630 :   TREE_LANG_FLAG_0 (type) = 0;
    5520                 :    2750630 :   TREE_LANG_FLAG_1 (type) = 0;
    5521                 :    2750630 :   TREE_LANG_FLAG_2 (type) = 0;
    5522                 :    2750630 :   TREE_LANG_FLAG_3 (type) = 0;
    5523                 :    2750630 :   TREE_LANG_FLAG_4 (type) = 0;
    5524                 :    2750630 :   TREE_LANG_FLAG_5 (type) = 0;
    5525                 :    2750630 :   TREE_LANG_FLAG_6 (type) = 0;
    5526                 :            : 
    5527                 :    2750630 :   TYPE_NEEDS_CONSTRUCTING (type) = 0;
    5528                 :            : 
    5529                 :            :   /* Purge non-marked variants from the variants chain, so that they
    5530                 :            :      don't reappear in the IL after free_lang_data.  */
    5531                 :    6227890 :   while (TYPE_NEXT_VARIANT (type)
    5532                 :    3113950 :          && !fld->pset.contains (TYPE_NEXT_VARIANT (type)))
    5533                 :            :     {
    5534                 :     363317 :       tree t = TYPE_NEXT_VARIANT (type);
    5535                 :     363317 :       TYPE_NEXT_VARIANT (type) = TYPE_NEXT_VARIANT (t);
    5536                 :            :       /* Turn the removed types into distinct types.  */
    5537                 :     363317 :       TYPE_MAIN_VARIANT (t) = t;
    5538                 :     363317 :       TYPE_NEXT_VARIANT (t) = NULL_TREE;
    5539                 :            :     }
    5540                 :            : 
    5541                 :    2750630 :   if (TREE_CODE (type) == FUNCTION_TYPE)
    5542                 :            :     {
    5543                 :    1619810 :       TREE_TYPE (type) = fld_simplified_type (TREE_TYPE (type), fld);
    5544                 :            :       /* Remove the const and volatile qualifiers from arguments.  The
    5545                 :            :          C++ front end removes them, but the C front end does not,
    5546                 :            :          leading to false ODR violation errors when merging two
    5547                 :            :          instances of the same function signature compiled by
    5548                 :            :          different front ends.  */
    5549                 :    6842540 :       for (tree p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
    5550                 :            :         {
    5551                 :    5222730 :           TREE_VALUE (p) = fld_simplified_type (TREE_VALUE (p), fld);
    5552                 :    5222730 :           tree arg_type = TREE_VALUE (p);
    5553                 :            : 
    5554                 :    5222730 :           if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
    5555                 :            :             {
    5556                 :       3681 :               int quals = TYPE_QUALS (arg_type)
    5557                 :            :                           & ~TYPE_QUAL_CONST
    5558                 :       3681 :                           & ~TYPE_QUAL_VOLATILE;
    5559                 :       3681 :               TREE_VALUE (p) = build_qualified_type (arg_type, quals);
    5560                 :       3681 :               if (!fld->pset.add (TREE_VALUE (p)))
    5561                 :         92 :                 free_lang_data_in_type (TREE_VALUE (p), fld);
    5562                 :            :             }
    5563                 :            :           /* C++ FE uses TREE_PURPOSE to store initial values.  */
    5564                 :    5222730 :           TREE_PURPOSE (p) = NULL;
    5565                 :            :         }
    5566                 :            :     }
    5567                 :    1130820 :   else if (TREE_CODE (type) == METHOD_TYPE)
    5568                 :            :     {
    5569                 :      55123 :       TREE_TYPE (type) = fld_simplified_type (TREE_TYPE (type), fld);
    5570                 :     277930 :       for (tree p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
    5571                 :            :         {
    5572                 :            :           /* C++ FE uses TREE_PURPOSE to store initial values.  */
    5573                 :     167684 :           TREE_VALUE (p) = fld_simplified_type (TREE_VALUE (p), fld);
    5574                 :     167684 :           TREE_PURPOSE (p) = NULL;
    5575                 :            :         }
    5576                 :            :     }
    5577                 :    1075700 :   else if (RECORD_OR_UNION_TYPE_P (type))
    5578                 :            :     {
    5579                 :            :       /* Remove members that are not FIELD_DECLs from the field list
    5580                 :            :          of an aggregate.  These occur in C++.  */
    5581                 :     766991 :       for (tree *prev = &TYPE_FIELDS (type), member; (member = *prev);)
    5582                 :     613709 :         if (TREE_CODE (member) == FIELD_DECL)
    5583                 :     286232 :           prev = &DECL_CHAIN (member);
    5584                 :            :         else
    5585                 :     327477 :           *prev = DECL_CHAIN (member);
    5586                 :            : 
    5587                 :     153282 :       TYPE_VFIELD (type) = NULL_TREE;
    5588                 :            : 
    5589                 :     161012 :       if (TYPE_BINFO (type))
    5590                 :            :         {
    5591                 :      30453 :           free_lang_data_in_binfo (TYPE_BINFO (type));
    5592                 :            :           /* We need to preserve link to bases and virtual table for all
    5593                 :            :              polymorphic types to make devirtualization machinery working.  */
    5594                 :      30453 :           if (!BINFO_VTABLE (TYPE_BINFO (type)))
    5595                 :      25899 :             TYPE_BINFO (type) = NULL;
    5596                 :            :         }
    5597                 :            :     }
    5598                 :     922413 :   else if (INTEGRAL_TYPE_P (type)
    5599                 :     922413 :            || SCALAR_FLOAT_TYPE_P (type)
    5600                 :     668188 :            || FIXED_POINT_TYPE_P (type))
    5601                 :            :     {
    5602                 :     254225 :       if (TREE_CODE (type) == ENUMERAL_TYPE)
    5603                 :            :         {
    5604                 :        933 :           ENUM_IS_OPAQUE (type) = 0;
    5605                 :        933 :           ENUM_IS_SCOPED (type) = 0;
    5606                 :            :           /* Type values are used only for C++ ODR checking.  Drop them
    5607                 :            :              for all type variants and non-ODR types.
    5608                 :            :              For ODR types the data is freed in free_odr_warning_data.  */
    5609                 :        933 :           if (TYPE_MAIN_VARIANT (type) != type
    5610                 :        933 :               || !type_with_linkage_p (type))
    5611                 :        504 :             TYPE_VALUES (type) = NULL;
    5612                 :            :           else
    5613                 :            :           /* Simplify representation by recording only values rather
    5614                 :            :              than const decls.  */
    5615                 :       2414 :             for (tree e = TYPE_VALUES (type); e; e = TREE_CHAIN (e))
    5616                 :       1985 :               if (TREE_CODE (TREE_VALUE (e)) == CONST_DECL)
    5617                 :       1985 :                 TREE_VALUE (e) = DECL_INITIAL (TREE_VALUE (e));
    5618                 :            :         }
    5619                 :     254225 :       free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type));
    5620                 :     254225 :       free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type));
    5621                 :            :     }
    5622                 :            : 
    5623                 :    2750630 :   TYPE_LANG_SLOT_1 (type) = NULL_TREE;
    5624                 :            : 
    5625                 :    2750630 :   free_lang_data_in_one_sizepos (&TYPE_SIZE (type));
    5626                 :    2750630 :   free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type));
    5627                 :            : 
    5628                 :    2750630 :   if (TYPE_CONTEXT (type)
    5629                 :    2750630 :       && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK)
    5630                 :            :     {
    5631                 :         96 :       tree ctx = TYPE_CONTEXT (type);
    5632                 :         96 :       do
    5633                 :            :         {
    5634                 :         96 :           ctx = BLOCK_SUPERCONTEXT (ctx);
    5635                 :            :         }
    5636                 :         96 :       while (ctx && TREE_CODE (ctx) == BLOCK);
    5637                 :         40 :       TYPE_CONTEXT (type) = ctx;
    5638                 :            :     }
    5639                 :            : 
    5640                 :    2750630 :   TYPE_STUB_DECL (type) = NULL;
    5641                 :    2750630 :   TYPE_NAME (type) = fld_simplified_type_name (type);
    5642                 :    2750630 : }
    5643                 :            : 
    5644                 :            : 
    5645                 :            : /* Return true if DECL may need an assembler name to be set.  */
    5646                 :            : 
    5647                 :            : static inline bool
    5648                 :    9124420 : need_assembler_name_p (tree decl)
    5649                 :            : {
    5650                 :            :   /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition
    5651                 :            :      Rule merging.  This makes type_odr_p to return true on those types during
    5652                 :            :      LTO and by comparing the mangled name, we can say what types are intended
    5653                 :            :      to be equivalent across compilation unit.
    5654                 :            : 
    5655                 :            :      We do not store names of type_in_anonymous_namespace_p.
    5656                 :            : 
    5657                 :            :      Record, union and enumeration type have linkage that allows use
    5658                 :            :      to check type_in_anonymous_namespace_p. We do not mangle compound types
    5659                 :            :      that always can be compared structurally.
    5660                 :            : 
    5661                 :            :      Similarly for builtin types, we compare properties of their main variant.
    5662                 :            :      A special case are integer types where mangling do make differences
    5663                 :            :      between char/signed char/unsigned char etc.  Storing name for these makes
    5664                 :            :      e.g.  -fno-signed-char/-fsigned-char mismatches to be handled well.
    5665                 :            :      See cp/mangle.c:write_builtin_type for details.  */
    5666                 :            : 
    5667                 :    9124420 :   if (TREE_CODE (decl) == TYPE_DECL)
    5668                 :            :     {
    5669                 :     301223 :       if (DECL_NAME (decl)
    5670                 :     254807 :           && decl == TYPE_NAME (TREE_TYPE (decl))
    5671                 :     247645 :           && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TREE_TYPE (decl)
    5672                 :     213286 :           && !TYPE_ARTIFICIAL (TREE_TYPE (decl))
    5673                 :     213212 :           && ((TREE_CODE (TREE_TYPE (decl)) != RECORD_TYPE
    5674                 :     181764 :                && TREE_CODE (TREE_TYPE (decl)) != UNION_TYPE)
    5675                 :      32120 :               || TYPE_CXX_ODR_P (TREE_TYPE (decl)))
    5676                 :     199775 :           && (type_with_linkage_p (TREE_TYPE (decl))
    5677                 :     184682 :               || TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE)
    5678                 :     414097 :           && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
    5679                 :     112874 :         return !DECL_ASSEMBLER_NAME_SET_P (decl);
    5680                 :     188349 :       return false;
    5681                 :            :     }
    5682                 :            :   /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
    5683                 :    8823200 :   if (!VAR_OR_FUNCTION_DECL_P (decl))
    5684                 :            :     return false;
    5685                 :            : 
    5686                 :            :   /* If DECL already has its assembler name set, it does not need a
    5687                 :            :      new one.  */
    5688                 :    7951800 :   if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
    5689                 :    7951800 :       || DECL_ASSEMBLER_NAME_SET_P (decl))
    5690                 :            :     return false;
    5691                 :            : 
    5692                 :            :   /* Abstract decls do not need an assembler name.  */
    5693                 :    4559200 :   if (DECL_ABSTRACT_P (decl))
    5694                 :            :     return false;
    5695                 :            : 
    5696                 :            :   /* For VAR_DECLs, only static, public and external symbols need an
    5697                 :            :      assembler name.  */
    5698                 :    4555960 :   if (VAR_P (decl)
    5699                 :            :       && !TREE_STATIC (decl)
    5700                 :    4555960 :       && !TREE_PUBLIC (decl)
    5701                 :    4555960 :       && !DECL_EXTERNAL (decl))
    5702                 :            :     return false;
    5703                 :            : 
    5704                 :    4051600 :   if (TREE_CODE (decl) == FUNCTION_DECL)
    5705                 :            :     {
    5706                 :            :       /* Do not set assembler name on builtins.  Allow RTL expansion to
    5707                 :            :          decide whether to expand inline or via a regular call.  */
    5708                 :    4049060 :       if (fndecl_built_in_p (decl)
    5709                 :    4049060 :           && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
    5710                 :            :         return false;
    5711                 :            : 
    5712                 :            :       /* Functions represented in the callgraph need an assembler name.  */
    5713                 :     560596 :       if (cgraph_node::get (decl) != NULL)
    5714                 :            :         return true;
    5715                 :            : 
    5716                 :            :       /* Unused and not public functions don't need an assembler name.  */
    5717                 :      99834 :       if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
    5718                 :        848 :         return false;
    5719                 :            :     }
    5720                 :            : 
    5721                 :            :   return true;
    5722                 :            : }
    5723                 :            : 
    5724                 :            : 
    5725                 :            : /* Reset all language specific information still present in symbol
    5726                 :            :    DECL.  */
    5727                 :            : 
    5728                 :            : static void
    5729                 :    7186760 : free_lang_data_in_decl (tree decl, class free_lang_data_d *fld)
    5730                 :            : {
    5731                 :    7186760 :   gcc_assert (DECL_P (decl));
    5732                 :            : 
    5733                 :            :   /* Give the FE a chance to remove its own data first.  */
    5734                 :    7186760 :   lang_hooks.free_lang_data (decl);
    5735                 :            : 
    5736                 :    7186760 :   TREE_LANG_FLAG_0 (decl) = 0;
    5737                 :    7186760 :   TREE_LANG_FLAG_1 (decl) = 0;
    5738                 :    7186760 :   TREE_LANG_FLAG_2 (decl) = 0;
    5739                 :    7186760 :   TREE_LANG_FLAG_3 (decl) = 0;
    5740                 :    7186760 :   TREE_LANG_FLAG_4 (decl) = 0;
    5741                 :    7186760 :   TREE_LANG_FLAG_5 (decl) = 0;
    5742                 :    7186760 :   TREE_LANG_FLAG_6 (decl) = 0;
    5743                 :            : 
    5744                 :    7186760 :   free_lang_data_in_one_sizepos (&DECL_SIZE (decl));
    5745                 :    7186760 :   free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl));
    5746                 :    7186760 :   if (TREE_CODE (decl) == FIELD_DECL)
    5747                 :            :     {
    5748                 :     217628 :       DECL_FCONTEXT (decl) = NULL;
    5749                 :     217628 :       free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl));
    5750                 :     217628 :       if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE)
    5751                 :          0 :         DECL_QUALIFIER (decl) = NULL_TREE;
    5752                 :            :     }
    5753                 :            : 
    5754                 :    7186760 :  if (TREE_CODE (decl) == FUNCTION_DECL)
    5755                 :            :     {
    5756                 :    5247880 :       struct cgraph_node *node;
    5757                 :            :       /* Frontends do not set TREE_ADDRESSABLE on public variables even though
    5758                 :            :          the address may be taken in other unit, so this flag has no practical
    5759                 :            :          use for middle-end.
    5760                 :            : 
    5761                 :            :          It would make more sense if frontends set TREE_ADDRESSABLE to 0 only
    5762                 :            :          for public objects that indeed cannot be adressed, but it is not
    5763                 :            :          the case.  Set the flag to true so we do not get merge failures for
    5764                 :            :          i.e. virtual tables between units that take address of it and
    5765                 :            :          units that don't.  */
    5766                 :    5247880 :       if (TREE_PUBLIC (decl))
    5767                 :    5238120 :         TREE_ADDRESSABLE (decl) = true;
    5768                 :    5247880 :       TREE_TYPE (decl) = fld_simplified_type (TREE_TYPE (decl), fld);
    5769                 :    5247880 :       if (!(node = cgraph_node::get (decl))
    5770                 :    5247880 :           || (!node->definition && !node->clones))
    5771                 :            :         {
    5772                 :    5144640 :           if (node)
    5773                 :     228646 :             node->release_body ();
    5774                 :            :           else
    5775                 :            :             {
    5776                 :    4916000 :               release_function_body (decl);
    5777                 :    4916000 :               DECL_ARGUMENTS (decl) = NULL;
    5778                 :    4916000 :               DECL_RESULT (decl) = NULL;
    5779                 :    4916000 :               DECL_INITIAL (decl) = error_mark_node;
    5780                 :            :             }
    5781                 :            :         }
    5782                 :    5247880 :       if (gimple_has_body_p (decl) || (node && node->thunk.thunk_p))
    5783                 :            :         {
    5784                 :      97816 :           tree t;
    5785                 :            : 
    5786                 :            :           /* If DECL has a gimple body, then the context for its
    5787                 :            :              arguments must be DECL.  Otherwise, it doesn't really
    5788                 :            :              matter, as we will not be emitting any code for DECL.  In
    5789                 :            :              general, there may be other instances of DECL created by
    5790                 :            :              the front end and since PARM_DECLs are generally shared,
    5791                 :            :              their DECL_CONTEXT changes as the replicas of DECL are
    5792                 :            :              created.  The only time where DECL_CONTEXT is important
    5793                 :            :              is for the FUNCTION_DECLs that have a gimple body (since
    5794                 :            :              the PARM_DECL will be used in the function's body).  */
    5795                 :     415973 :           for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
    5796                 :     318157 :             DECL_CONTEXT (t) = decl;
    5797                 :      97816 :           if (!DECL_FUNCTION_SPECIFIC_TARGET (decl))
    5798                 :      97815 :             DECL_FUNCTION_SPECIFIC_TARGET (decl)
    5799                 :      97815 :               = target_option_default_node;
    5800                 :      97816 :           if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl))
    5801                 :      97766 :             DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl)
    5802                 :      97766 :               = optimization_default_node;
    5803                 :            :         }
    5804                 :            : 
    5805                 :            :       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
    5806                 :            :          At this point, it is not needed anymore.  */
    5807                 :    5247880 :       DECL_SAVED_TREE (decl) = NULL_TREE;
    5808                 :            : 
    5809                 :            :       /* Clear the abstract origin if it refers to a method.
    5810                 :            :          Otherwise dwarf2out.c will ICE as we splice functions out of
    5811                 :            :          TYPE_FIELDS and thus the origin will not be output
    5812                 :            :          correctly.  */
    5813                 :    5247880 :       if (DECL_ABSTRACT_ORIGIN (decl)
    5814                 :      23009 :           && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))
    5815                 :    5270880 :           && RECORD_OR_UNION_TYPE_P
    5816                 :            :                (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl))))
    5817                 :      12304 :         DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE;
    5818                 :            : 
    5819                 :    5247880 :       DECL_VINDEX (decl) = NULL_TREE;
    5820                 :            :     }
    5821                 :    1938890 :   else if (VAR_P (decl))
    5822                 :            :     {
    5823                 :            :       /* See comment above why we set the flag for functions.  */
    5824                 :     766266 :       if (TREE_PUBLIC (decl))
    5825                 :     234253 :         TREE_ADDRESSABLE (decl) = true;
    5826                 :     766266 :       if ((DECL_EXTERNAL (decl)
    5827                 :      12434 :            && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
    5828                 :     770333 :           || (decl_function_context (decl) && !TREE_STATIC (decl)))
    5829                 :     502852 :         DECL_INITIAL (decl) = NULL_TREE;
    5830                 :            :     }
    5831                 :    1172620 :   else if (TREE_CODE (decl) == TYPE_DECL)
    5832                 :            :     {
    5833                 :     301223 :       DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
    5834                 :     301223 :       DECL_VISIBILITY_SPECIFIED (decl) = 0;
    5835                 :     301223 :       TREE_PUBLIC (decl) = 0;
    5836                 :     301223 :       TREE_PRIVATE (decl) = 0;
    5837                 :     301223 :       DECL_ARTIFICIAL (decl) = 0;
    5838                 :     301223 :       TYPE_DECL_SUPPRESS_DEBUG (decl) = 0;
    5839                 :     301223 :       DECL_INITIAL (decl) = NULL_TREE;
    5840                 :     301223 :       DECL_ORIGINAL_TYPE (decl) = NULL_TREE;
    5841                 :     301223 :       DECL_MODE (decl) = VOIDmode;
    5842                 :     301223 :       SET_DECL_ALIGN (decl, 0);
    5843                 :            :       /* TREE_TYPE is cleared at WPA time in free_odr_warning_data.  */
    5844                 :            :     }
    5845                 :     871397 :   else if (TREE_CODE (decl) == FIELD_DECL)
    5846                 :            :     {
    5847                 :     217628 :       TREE_TYPE (decl) = fld_simplified_type (TREE_TYPE (decl), fld);
    5848                 :     217628 :       DECL_INITIAL (decl) = NULL_TREE;
    5849                 :            :     }
    5850                 :     653769 :   else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL
    5851                 :      16203 :            && DECL_INITIAL (decl)
    5852                 :     666819 :            && TREE_CODE (DECL_INITIAL (decl)) == BLOCK)
    5853                 :            :     {
    5854                 :            :       /* Strip builtins from the translation-unit BLOCK.  We still have targets
    5855                 :            :          without builtin_decl_explicit support and also builtins are shared
    5856                 :            :          nodes and thus we can't use TREE_CHAIN in multiple lists.  */
    5857                 :      13050 :       tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl));
    5858                 :      13050 :       while (*nextp)
    5859                 :            :         {
    5860                 :          0 :           tree var = *nextp;
    5861                 :          0 :           if (TREE_CODE (var) == FUNCTION_DECL
    5862                 :          0 :               && fndecl_built_in_p (var))
    5863                 :          0 :             *nextp = TREE_CHAIN (var);
    5864                 :            :           else
    5865                 :          0 :             nextp = &TREE_CHAIN (var);
    5866                 :            :         }
    5867                 :            :     }
    5868                 :            :   /* We need to keep field decls associated with their trees. Otherwise tree
    5869                 :            :      merging may merge some fileds and keep others disjoint wich in turn will
    5870                 :            :      not do well with TREE_CHAIN pointers linking them.
    5871                 :            : 
    5872                 :            :      Also do not drop containing types for virtual methods and tables because
    5873                 :            :      these are needed by devirtualization.
    5874                 :            :      C++ destructors are special because C++ frontends sometimes produces
    5875                 :            :      virtual destructor as an alias of non-virtual destructor.  In
    5876                 :            :      devirutalization code we always walk through aliases and we need
    5877                 :            :      context to be preserved too.  See PR89335  */
    5878                 :    7186760 :   if (TREE_CODE (decl) != FIELD_DECL
    5879                 :    7186760 :       && ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
    5880                 :    6014140 :           || (!DECL_VIRTUAL_P (decl)
    5881                 :    6001410 :               && (TREE_CODE (decl) != FUNCTION_DECL
    5882                 :    5241810 :                   || !DECL_CXX_DESTRUCTOR_P (decl)))))
    5883                 :    6949800 :     DECL_CONTEXT (decl) = fld_decl_context (DECL_CONTEXT (decl));
    5884                 :    7186760 : }
    5885                 :            : 
    5886                 :            : 
    5887                 :            : /* Operand callback helper for free_lang_data_in_node.  *TP is the
    5888                 :            :    subtree operand being considered.  */
    5889                 :            : 
    5890                 :            : static tree
    5891                 :   34325500 : find_decls_types_r (tree *tp, int *ws, void *data)
    5892                 :            : {
    5893                 :   34325500 :   tree t = *tp;
    5894                 :   34325500 :   class free_lang_data_d *fld = (class free_lang_data_d *) data;
    5895                 :            : 
    5896                 :   34325500 :   if (TREE_CODE (t) == TREE_LIST)
    5897                 :            :     return NULL_TREE;
    5898                 :            : 
    5899                 :            :   /* Language specific nodes will be removed, so there is no need
    5900                 :            :      to gather anything under them.  */
    5901                 :   20056600 :   if (is_lang_specific (t))
    5902                 :            :     {
    5903                 :          8 :       *ws = 0;
    5904                 :          8 :       return NULL_TREE;
    5905                 :            :     }
    5906                 :            : 
    5907                 :   20056600 :   if (DECL_P (t))
    5908                 :            :     {
    5909                 :            :       /* Note that walk_tree does not traverse every possible field in
    5910                 :            :          decls, so we have to do our own traversals here.  */
    5911                 :    7186760 :       add_tree_to_fld_list (t, fld);
    5912                 :            : 
    5913                 :    7186760 :       fld_worklist_push (DECL_NAME (t), fld);
    5914                 :    7186760 :       fld_worklist_push (DECL_CONTEXT (t), fld);
    5915                 :    7186760 :       fld_worklist_push (DECL_SIZE (t), fld);
    5916                 :    7186760 :       fld_worklist_push (DECL_SIZE_UNIT (t), fld);
    5917                 :            : 
    5918                 :            :       /* We are going to remove everything under DECL_INITIAL for
    5919                 :            :          TYPE_DECLs.  No point walking them.  */
    5920                 :    7186760 :       if (TREE_CODE (t) != TYPE_DECL)
    5921                 :    6885540 :         fld_worklist_push (DECL_INITIAL (t), fld);
    5922                 :            : 
    5923                 :    7186760 :       fld_worklist_push (DECL_ATTRIBUTES (t), fld);
    5924                 :    7186760 :       fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
    5925                 :            : 
    5926                 :    7186760 :       if (TREE_CODE (t) == FUNCTION_DECL)
    5927                 :            :         {
    5928                 :    5247880 :           fld_worklist_push (DECL_ARGUMENTS (t), fld);
    5929                 :    5247880 :           fld_worklist_push (DECL_RESULT (t), fld);
    5930                 :            :         }
    5931                 :    1938890 :       else if (TREE_CODE (t) == FIELD_DECL)
    5932                 :            :         {
    5933                 :     217628 :           fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
    5934                 :     217628 :           fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
    5935                 :     217628 :           fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
    5936                 :     217628 :           fld_worklist_push (DECL_FCONTEXT (t), fld);
    5937                 :            :         }
    5938                 :            : 
    5939                 :    6420500 :       if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL)
    5940                 :    8457780 :           && DECL_HAS_VALUE_EXPR_P (t))
    5941                 :        968 :         fld_worklist_push (DECL_VALUE_EXPR (t), fld);
    5942                 :            : 
    5943                 :    7186760 :       if (TREE_CODE (t) != FIELD_DECL
    5944                 :    6969130 :           && TREE_CODE (t) != TYPE_DECL)
    5945                 :    6667910 :         fld_worklist_push (TREE_CHAIN (t), fld);
    5946                 :    7186760 :       *ws = 0;
    5947                 :            :     }
    5948                 :   12869900 :   else if (TYPE_P (t))
    5949                 :            :     {
    5950                 :            :       /* Note that walk_tree does not traverse every possible field in
    5951                 :            :          types, so we have to do our own traversals here.  */
    5952                 :    2648060 :       add_tree_to_fld_list (t, fld);
    5953                 :            : 
    5954                 :    2648060 :       if (!RECORD_OR_UNION_TYPE_P (t))
    5955                 :    2538160 :         fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
    5956                 :    2648060 :       fld_worklist_push (TYPE_SIZE (t), fld);
    5957                 :    2648060 :       fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
    5958                 :    2648060 :       fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
    5959                 :    2648060 :       fld_worklist_push (TYPE_POINTER_TO (t), fld);
    5960                 :    2648060 :       fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
    5961                 :    2648060 :       fld_worklist_push (TYPE_NAME (t), fld);
    5962                 :            :       /* While we do not stream TYPE_POINTER_TO and TYPE_REFERENCE_TO
    5963                 :            :          lists, we may look types up in these lists and use them while
    5964                 :            :          optimizing the function body.  Thus we need to free lang data
    5965                 :            :          in them.  */
    5966                 :    2648060 :       if (TREE_CODE (t) == POINTER_TYPE)
    5967                 :     479754 :         fld_worklist_push (TYPE_NEXT_PTR_TO (t), fld);
    5968                 :    2648060 :       if (TREE_CODE (t) == REFERENCE_TYPE)
    5969                 :      38010 :         fld_worklist_push (TYPE_NEXT_REF_TO (t), fld);
    5970                 :    2648060 :       if (!POINTER_TYPE_P (t))
    5971                 :    2130290 :         fld_worklist_push (TYPE_MIN_VALUE_RAW (t), fld);
    5972                 :            :       /* TYPE_MAX_VALUE_RAW is TYPE_BINFO for record types.  */
    5973                 :    2648060 :       if (!RECORD_OR_UNION_TYPE_P (t))
    5974                 :    2538160 :         fld_worklist_push (TYPE_MAX_VALUE_RAW (t), fld);
    5975                 :    2648060 :       fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
    5976                 :            :       /* Do not walk TYPE_NEXT_VARIANT.  We do not stream it and thus
    5977                 :            :          do not and want not to reach unused variants this way.  */
    5978                 :    2648060 :       if (TYPE_CONTEXT (t))
    5979                 :            :         {
    5980                 :     123220 :           tree ctx = TYPE_CONTEXT (t);
    5981                 :            :           /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one.
    5982                 :            :              So push that instead.  */
    5983                 :     123220 :           while (ctx && TREE_CODE (ctx) == BLOCK)
    5984                 :         96 :             ctx = BLOCK_SUPERCONTEXT (ctx);
    5985                 :     123124 :           fld_worklist_push (ctx, fld);
    5986                 :            :         }
    5987                 :    2648060 :       fld_worklist_push (TYPE_CANONICAL (t), fld);
    5988                 :            : 
    5989                 :    2648060 :       if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
    5990                 :            :         {
    5991                 :            :           unsigned i;
    5992                 :            :           tree tem;
    5993                 :      40602 :           FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem)
    5994                 :      10149 :             fld_worklist_push (TREE_TYPE (tem), fld);
    5995                 :      30453 :           fld_worklist_push (BINFO_TYPE (TYPE_BINFO (t)), fld);
    5996                 :      30453 :           fld_worklist_push (BINFO_VTABLE (TYPE_BINFO (t)), fld);
    5997                 :            :         }
    5998                 :    2648060 :       if (RECORD_OR_UNION_TYPE_P (t))
    5999                 :            :         {
    6000                 :     109890 :           tree tem;
    6001                 :            :           /* Push all TYPE_FIELDS - there can be interleaving interesting
    6002                 :            :              and non-interesting things.  */
    6003                 :     109890 :           tem = TYPE_FIELDS (t);
    6004                 :     926735 :           while (tem)
    6005                 :            :             {
    6006                 :     816845 :               if (TREE_CODE (tem) == FIELD_DECL)
    6007                 :     286228 :                 fld_worklist_push (tem, fld);
    6008                 :     816845 :               tem = TREE_CHAIN (tem);
    6009                 :            :             }
    6010                 :            :         }
    6011                 :    2648060 :       if (FUNC_OR_METHOD_TYPE_P (t))
    6012                 :    1674940 :         fld_worklist_push (TYPE_METHOD_BASETYPE (t), fld);
    6013                 :            : 
    6014                 :    2648060 :       fld_worklist_push (TYPE_STUB_DECL (t), fld);
    6015                 :    2648060 :       *ws = 0;
    6016                 :            :     }
    6017                 :   10221800 :   else if (TREE_CODE (t) == BLOCK)
    6018                 :            :     {
    6019                 :     815543 :       for (tree *tem = &BLOCK_VARS (t); *tem; )
    6020                 :            :         {
    6021                 :     649656 :           if (TREE_CODE (*tem) != LABEL_DECL
    6022                 :     649656 :               && (TREE_CODE (*tem) != VAR_DECL
    6023                 :     350420 :                   || !auto_var_in_fn_p (*tem, DECL_CONTEXT (*tem))))
    6024                 :            :             {
    6025                 :     316883 :               gcc_assert (TREE_CODE (*tem) != RESULT_DECL
    6026                 :            :                           && TREE_CODE (*tem) != PARM_DECL);
    6027                 :     316883 :               *tem = TREE_CHAIN (*tem);
    6028                 :            :             }
    6029                 :            :           else 
    6030                 :            :             {
    6031                 :     332773 :               fld_worklist_push (*tem, fld);
    6032                 :     332773 :               tem = &TREE_CHAIN (*tem);
    6033                 :            :             }
    6034                 :            :         }
    6035                 :     210056 :       for (tree tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
    6036                 :      44169 :         fld_worklist_push (tem, fld);
    6037                 :     165887 :       fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
    6038                 :            :     }
    6039                 :            : 
    6040                 :   20056600 :   if (TREE_CODE (t) != IDENTIFIER_NODE
    6041                 :   13585900 :       && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED))
    6042                 :   13420000 :     fld_worklist_push (TREE_TYPE (t), fld);
    6043                 :            : 
    6044                 :            :   return NULL_TREE;
    6045                 :            : }
    6046                 :            : 
    6047                 :            : 
    6048                 :            : /* Find decls and types in T.  */
    6049                 :            : 
    6050                 :            : static void
    6051                 :    6176020 : find_decls_types (tree t, class free_lang_data_d *fld)
    6052                 :            : {
    6053                 :   25812200 :   while (1)
    6054                 :            :     {
    6055                 :   31988200 :       if (!fld->pset.contains (t))
    6056                 :   25314600 :         walk_tree (&t, find_decls_types_r, fld, &fld->pset);
    6057                 :   31988200 :       if (fld->worklist.is_empty ())
    6058                 :            :         break;
    6059                 :   25812200 :       t = fld->worklist.pop ();
    6060                 :            :     }
    6061                 :    6176020 : }
    6062                 :            : 
    6063                 :            : /* Translate all the types in LIST with the corresponding runtime
    6064                 :            :    types.  */
    6065                 :            : 
    6066                 :            : static tree
    6067                 :        577 : get_eh_types_for_runtime (tree list)
    6068                 :            : {
    6069                 :        577 :   tree head, prev;
    6070                 :            : 
    6071                 :        577 :   if (list == NULL_TREE)
    6072                 :            :     return NULL_TREE;
    6073                 :            : 
    6074                 :        162 :   head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
    6075                 :        162 :   prev = head;
    6076                 :        162 :   list = TREE_CHAIN (list);
    6077                 :        186 :   while (list)
    6078                 :            :     {
    6079                 :         24 :       tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
    6080                 :         24 :       TREE_CHAIN (prev) = n;
    6081                 :         24 :       prev = TREE_CHAIN (prev);
    6082                 :         24 :       list = TREE_CHAIN (list);
    6083                 :            :     }
    6084                 :            : 
    6085                 :            :   return head;
    6086                 :            : }
    6087                 :            : 
    6088                 :            : 
    6089                 :            : /* Find decls and types referenced in EH region R and store them in
    6090                 :            :    FLD->DECLS and FLD->TYPES.  */
    6091                 :            : 
    6092                 :            : static void
    6093                 :      30291 : find_decls_types_in_eh_region (eh_region r, class free_lang_data_d *fld)
    6094                 :            : {
    6095                 :      30291 :   switch (r->type)
    6096                 :            :     {
    6097                 :            :     case ERT_CLEANUP:
    6098                 :            :       break;
    6099                 :            : 
    6100                 :        456 :     case ERT_TRY:
    6101                 :        456 :       {
    6102                 :        456 :         eh_catch c;
    6103                 :            : 
    6104                 :            :         /* The types referenced in each catch must first be changed to the
    6105                 :            :            EH types used at runtime.  This removes references to FE types
    6106                 :            :            in the region.  */
    6107                 :        778 :         for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
    6108                 :            :           {
    6109                 :        322 :             c->type_list = get_eh_types_for_runtime (c->type_list);
    6110                 :        322 :             walk_tree (&c->type_list, find_decls_types_r, fld, &fld->pset);
    6111                 :            :           }
    6112                 :            :       }
    6113                 :            :       break;
    6114                 :            : 
    6115                 :        255 :     case ERT_ALLOWED_EXCEPTIONS:
    6116                 :        255 :       r->u.allowed.type_list
    6117                 :        255 :         = get_eh_types_for_runtime (r->u.allowed.type_list);
    6118                 :        255 :       walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, &fld->pset);
    6119                 :        255 :       break;
    6120                 :            : 
    6121                 :       9758 :     case ERT_MUST_NOT_THROW:
    6122                 :       9758 :       walk_tree (&r->u.must_not_throw.failure_decl,
    6123                 :            :                  find_decls_types_r, fld, &fld->pset);
    6124                 :       9758 :       break;
    6125                 :            :     }
    6126                 :      30291 : }
    6127                 :            : 
    6128                 :            : 
    6129                 :            : /* Find decls and types referenced in cgraph node N and store them in
    6130                 :            :    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
    6131                 :            :    look for *every* kind of DECL and TYPE node reachable from N,
    6132                 :            :    including those embedded inside types and decls (i.e,, TYPE_DECLs,
    6133                 :            :    NAMESPACE_DECLs, etc).  */
    6134                 :            : 
    6135                 :            : static void
    6136                 :     331881 : find_decls_types_in_node (struct cgraph_node *n, class free_lang_data_d *fld)
    6137                 :            : {
    6138                 :     331881 :   basic_block bb;
    6139                 :     331881 :   struct function *fn;
    6140                 :     331881 :   unsigned ix;
    6141                 :     331881 :   tree t;
    6142                 :            : 
    6143                 :     331881 :   find_decls_types (n->decl, fld);
    6144                 :            : 
    6145                 :     331881 :   if (!gimple_has_body_p (n->decl))
    6146                 :     331881 :     return;
    6147                 :            : 
    6148                 :      97613 :   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
    6149                 :            : 
    6150                 :      97613 :   fn = DECL_STRUCT_FUNCTION (n->decl);
    6151                 :            : 
    6152                 :            :   /* Traverse locals. */
    6153                 :     694349 :   FOR_EACH_LOCAL_DECL (fn, ix, t)
    6154                 :     517139 :     find_decls_types (t, fld);
    6155                 :            : 
    6156                 :            :   /* Traverse EH regions in FN.  */
    6157                 :      97613 :   {
    6158                 :      97613 :     eh_region r;
    6159                 :     158195 :     FOR_ALL_EH_REGION_FN (r, fn)
    6160                 :      30291 :       find_decls_types_in_eh_region (r, fld);
    6161                 :            :   }
    6162                 :            : 
    6163                 :            :   /* Traverse every statement in FN.  */
    6164                 :     630881 :   FOR_EACH_BB_FN (bb, fn)
    6165                 :            :     {
    6166                 :     533268 :       gphi_iterator psi;
    6167                 :     533268 :       gimple_stmt_iterator si;
    6168                 :     533268 :       unsigned i;
    6169                 :            : 
    6170                 :     533299 :       for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
    6171                 :            :         {
    6172                 :         31 :           gphi *phi = psi.phi ();
    6173                 :            : 
    6174                 :         92 :           for (i = 0; i < gimple_phi_num_args (phi); i++)
    6175                 :            :             {
    6176                 :         61 :               tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
    6177                 :         61 :               find_decls_types (*arg_p, fld);
    6178                 :            :             }
    6179                 :            :         }
    6180                 :            : 
    6181                 :    2793480 :       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
    6182                 :            :         {
    6183                 :    1726940 :           gimple *stmt = gsi_stmt (si);
    6184                 :            : 
    6185                 :    1726940 :           if (is_gimple_call (stmt))
    6186                 :     328637 :             find_decls_types (gimple_call_fntype (stmt), fld);
    6187                 :            : 
    6188                 :    6458240 :           for (i = 0; i < gimple_num_ops (stmt); i++)
    6189                 :            :             {
    6190                 :    4731290 :               tree arg = gimple_op (stmt, i);
    6191                 :    4731290 :               find_decls_types (arg, fld);
    6192                 :            :               /* find_decls_types doesn't walk TREE_PURPOSE of TREE_LISTs,
    6193                 :            :                  which we need for asm stmts.  */
    6194                 :    4731290 :               if (arg
    6195                 :    3580740 :                   && TREE_CODE (arg) == TREE_LIST
    6196                 :      15946 :                   && TREE_PURPOSE (arg)
    6197                 :    4746050 :                   && gimple_code (stmt) == GIMPLE_ASM)
    6198                 :      14759 :                 find_decls_types (TREE_PURPOSE (arg), fld);
    6199                 :            :             }
    6200                 :            :         }
    6201                 :            :     }
    6202                 :            : }
    6203                 :            : 
    6204                 :            : 
    6205                 :            : /* Find decls and types referenced in varpool node N and store them in
    6206                 :            :    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
    6207                 :            :    look for *every* kind of DECL and TYPE node reachable from N,
    6208                 :            :    including those embedded inside types and decls (i.e,, TYPE_DECLs,
    6209                 :            :    NAMESPACE_DECLs, etc).  */
    6210                 :            : 
    6211                 :            : static void
    6212                 :     252253 : find_decls_types_in_var (varpool_node *v, class free_lang_data_d *fld)
    6213                 :            : {
    6214                 :          0 :   find_decls_types (v->decl, fld);
    6215                 :          0 : }
    6216                 :            : 
    6217                 :            : /* If T needs an assembler name, have one created for it.  */
    6218                 :            : 
    6219                 :            : void
    6220                 :    9124420 : assign_assembler_name_if_needed (tree t)
    6221                 :            : {
    6222                 :    9124420 :   if (need_assembler_name_p (t))
    6223                 :            :     {
    6224                 :            :       /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
    6225                 :            :          diagnostics that use input_location to show locus
    6226                 :            :          information.  The problem here is that, at this point,
    6227                 :            :          input_location is generally anchored to the end of the file
    6228                 :            :          (since the parser is long gone), so we don't have a good
    6229                 :            :          position to pin it to.
    6230                 :            : 
    6231                 :            :          To alleviate this problem, this uses the location of T's
    6232                 :            :          declaration.  Examples of this are
    6233                 :            :          testsuite/g++.dg/template/cond2.C and
    6234                 :            :          testsuite/g++.dg/template/pr35240.C.  */
    6235                 :     674990 :       location_t saved_location = input_location;
    6236                 :     674990 :       input_location = DECL_SOURCE_LOCATION (t);
    6237                 :            : 
    6238                 :     674990 :       decl_assembler_name (t);
    6239                 :            : 
    6240                 :     674990 :       input_location = saved_location;
    6241                 :            :     }
    6242                 :    9124420 : }
    6243                 :            : 
    6244                 :            : 
    6245                 :            : /* Free language specific information for every operand and expression
    6246                 :            :    in every node of the call graph.  This process operates in three stages:
    6247                 :            : 
    6248                 :            :    1- Every callgraph node and varpool node is traversed looking for
    6249                 :            :       decls and types embedded in them.  This is a more exhaustive
    6250                 :            :       search than that done by find_referenced_vars, because it will
    6251                 :            :       also collect individual fields, decls embedded in types, etc.
    6252                 :            : 
    6253                 :            :    2- All the decls found are sent to free_lang_data_in_decl.
    6254                 :            : 
    6255                 :            :    3- All the types found are sent to free_lang_data_in_type.
    6256                 :            : 
    6257                 :            :    The ordering between decls and types is important because
    6258                 :            :    free_lang_data_in_decl sets assembler names, which includes
    6259                 :            :    mangling.  So types cannot be freed up until assembler names have
    6260                 :            :    been set up.  */
    6261                 :            : 
    6262                 :            : static void
    6263                 :      16453 : free_lang_data_in_cgraph (class free_lang_data_d *fld)
    6264                 :            : {
    6265                 :      16453 :   struct cgraph_node *n;
    6266                 :      16453 :   varpool_node *v;
    6267                 :      16453 :   tree t;
    6268                 :      16453 :   unsigned i;
    6269                 :      16453 :   alias_pair *p;
    6270                 :            : 
    6271                 :            :   /* Find decls and types in the body of every function in the callgraph.  */
    6272                 :     696668 :   FOR_EACH_FUNCTION (n)
    6273                 :     331881 :     find_decls_types_in_node (n, fld);
    6274                 :            : 
    6275                 :      16453 :   FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
    6276                 :          0 :     find_decls_types (p->decl, fld);
    6277                 :            : 
    6278                 :            :   /* Find decls and types in every varpool symbol.  */
    6279                 :     285159 :   FOR_EACH_VARIABLE (v)
    6280                 :     252253 :     find_decls_types_in_var (v, fld);
    6281                 :            : 
    6282                 :            :   /* Set the assembler name on every decl found.  We need to do this
    6283                 :            :      now because free_lang_data_in_decl will invalidate data needed
    6284                 :            :      for mangling.  This breaks mangling on interdependent decls.  */
    6285                 :    7203220 :   FOR_EACH_VEC_ELT (fld->decls, i, t)
    6286                 :    7186760 :     assign_assembler_name_if_needed (t);
    6287                 :            : 
    6288                 :            :   /* Traverse every decl found freeing its language data.  */
    6289                 :    7203220 :   FOR_EACH_VEC_ELT (fld->decls, i, t)
    6290                 :    7186760 :     free_lang_data_in_decl (t, fld);
    6291                 :            : 
    6292                 :            :   /* Traverse every type found freeing its language data.  */
    6293                 :    2766990 :   FOR_EACH_VEC_ELT (fld->types, i, t)
    6294                 :    2750540 :     free_lang_data_in_type (t, fld);
    6295                 :      16453 : }
    6296                 :            : 
    6297                 :            : 
    6298                 :            : /* Free resources that are used by FE but are not needed once they are done. */
    6299                 :            : 
    6300                 :            : static unsigned
    6301                 :     163437 : free_lang_data (void)
    6302                 :            : {
    6303                 :     163437 :   unsigned i;
    6304                 :     326874 :   class free_lang_data_d fld;
    6305                 :            : 
    6306                 :            :   /* If we are the LTO frontend we have freed lang-specific data already.  */
    6307                 :     163437 :   if (in_lto_p
    6308                 :     163437 :       || (!flag_generate_lto && !flag_generate_offload))
    6309                 :            :     {
    6310                 :            :       /* Rebuild type inheritance graph even when not doing LTO to get
    6311                 :            :          consistent profile data.  */
    6312                 :     146984 :       rebuild_type_inheritance_graph ();
    6313                 :     146984 :       return 0;
    6314                 :            :     }
    6315                 :            : 
    6316                 :      16453 :   fld_incomplete_types = new hash_map<tree, tree>;
    6317                 :      16453 :   fld_simplified_types = new hash_map<tree, tree>;
    6318                 :            : 
    6319                 :            :   /* Provide a dummy TRANSLATION_UNIT_DECL if the FE failed to provide one.  */
    6320                 :      16453 :   if (vec_safe_is_empty (all_translation_units))
    6321                 :         32 :     build_translation_unit_decl (NULL_TREE);
    6322                 :            : 
    6323                 :            :   /* Allocate and assign alias sets to the standard integer types
    6324                 :            :      while the slots are still in the way the frontends generated them.  */
    6325                 :     329060 :   for (i = 0; i < itk_none; ++i)
    6326                 :     312607 :     if (integer_types[i])
    6327                 :     213889 :       TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
    6328                 :            : 
    6329                 :            :   /* Traverse the IL resetting language specific information for
    6330                 :            :      operands, expressions, etc.  */
    6331                 :      16453 :   free_lang_data_in_cgraph (&fld);
    6332                 :            : 
    6333                 :            :   /* Create gimple variants for common types.  */
    6334                 :      16453 :   for (unsigned i = 0;
    6335                 :     115171 :        i < sizeof (builtin_structptr_types) / sizeof (builtin_structptr_type);
    6336                 :            :        ++i)
    6337                 :      98718 :     builtin_structptr_types[i].node = builtin_structptr_types[i].base;
    6338                 :            : 
    6339                 :            :   /* Reset some langhooks.  Do not reset types_compatible_p, it may
    6340                 :            :      still be used indirectly via the get_alias_set langhook.  */
    6341                 :      16453 :   lang_hooks.dwarf_name = lhd_dwarf_name;
    6342                 :      16453 :   lang_hooks.decl_printable_name = gimple_decl_printable_name;
    6343                 :      16453 :   lang_hooks.gimplify_expr = lhd_gimplify_expr;
    6344                 :      16453 :   lang_hooks.overwrite_decl_assembler_name = lhd_overwrite_decl_assembler_name;
    6345                 :      16453 :   lang_hooks.print_xnode = lhd_print_tree_nothing;
    6346                 :      16453 :   lang_hooks.print_decl = lhd_print_tree_nothing;
    6347                 :      16453 :   lang_hooks.print_type = lhd_print_tree_nothing;
    6348                 :      16453 :   lang_hooks.print_identifier = lhd_print_tree_nothing;
    6349                 :            : 
    6350                 :      16453 :   lang_hooks.tree_inlining.var_mod_type_p = hook_bool_tree_tree_false;
    6351                 :            : 
    6352                 :      16453 :   if (flag_checking)
    6353                 :            :     {
    6354                 :            :       int i;
    6355                 :            :       tree t;
    6356                 :            : 
    6357                 :    2766970 :       FOR_EACH_VEC_ELT (fld.types, i, t)
    6358                 :    2750520 :         verify_type (t);
    6359                 :            :     }
    6360                 :            : 
    6361                 :            :   /* We do not want the default decl_assembler_name implementation,
    6362                 :            :      rather if we have fixed everything we want a wrapper around it
    6363                 :            :      asserting that all non-local symbols already got their assembler
    6364                 :            :      name and only produce assembler names for local symbols.  Or rather
    6365                 :            :      make sure we never call decl_assembler_name on local symbols and
    6366                 :            :      devise a separate, middle-end private scheme for it.  */
    6367                 :            : 
    6368                 :            :   /* Reset diagnostic machinery.  */
    6369                 :      16453 :   tree_diagnostics_defaults (global_dc);
    6370                 :            : 
    6371                 :      16453 :   rebuild_type_inheritance_graph ();
    6372                 :            : 
    6373                 :      32906 :   delete fld_incomplete_types;
    6374                 :      32906 :   delete fld_simplified_types;
    6375                 :            : 
    6376                 :            :   return 0;
    6377                 :            : }
    6378                 :            : 
    6379                 :            : 
    6380                 :            : namespace {
    6381                 :            : 
    6382                 :            : const pass_data pass_data_ipa_free_lang_data =
    6383                 :            : {
    6384                 :            :   SIMPLE_IPA_PASS, /* type */
    6385                 :            :   "*free_lang_data", /* name */
    6386                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    6387                 :            :   TV_IPA_FREE_LANG_DATA, /* tv_id */
    6388                 :            :   0, /* properties_required */
    6389                 :            :   0, /* properties_provided */
    6390                 :            :   0, /* properties_destroyed */
    6391                 :            :   0, /* todo_flags_start */
    6392                 :            :   0, /* todo_flags_finish */
    6393                 :            : };
    6394                 :            : 
    6395                 :            : class pass_ipa_free_lang_data : public simple_ipa_opt_pass
    6396                 :            : {
    6397                 :            : public:
    6398                 :     200773 :   pass_ipa_free_lang_data (gcc::context *ctxt)
    6399                 :     401546 :     : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
    6400                 :            :   {}
    6401                 :            : 
    6402                 :            :   /* opt_pass methods: */
    6403                 :     163437 :   virtual unsigned int execute (function *) { return free_lang_data (); }
    6404                 :            : 
    6405                 :            : }; // class pass_ipa_free_lang_data
    6406                 :            : 
    6407                 :            : } // anon namespace
    6408                 :            : 
    6409                 :            : simple_ipa_opt_pass *
    6410                 :     200773 : make_pass_ipa_free_lang_data (gcc::context *ctxt)
    6411                 :            : {
    6412                 :     200773 :   return new pass_ipa_free_lang_data (ctxt);
    6413                 :            : }
    6414                 :            : 
    6415                 :            : /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
    6416                 :            :    of the various TYPE_QUAL values.  */
    6417                 :            : 
    6418                 :            : static void
    6419                 :   15456200 : set_type_quals (tree type, int type_quals)
    6420                 :            : {
    6421                 :   15456200 :   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
    6422                 :   15456200 :   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
    6423                 :   15456200 :   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
    6424                 :   15456200 :   TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
    6425                 :   15456200 :   TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
    6426                 :   15456200 : }
    6427                 :            : 
    6428                 :            : /* Returns true iff CAND and BASE have equivalent language-specific
    6429                 :            :    qualifiers.  */
    6430                 :            : 
    6431                 :            : bool
    6432                 :  232085000 : check_lang_type (const_tree cand, const_tree base)
    6433                 :            : {
    6434                 :  232085000 :   if (lang_hooks.types.type_hash_eq == NULL)
    6435                 :            :     return true;
    6436                 :            :   /* type_hash_eq currently only applies to these types.  */
    6437                 :  203240000 :   if (TREE_CODE (cand) != FUNCTION_TYPE
    6438                 :  203240000 :       && TREE_CODE (cand) != METHOD_TYPE)
    6439                 :            :     return true;
    6440                 :     154956 :   return lang_hooks.types.type_hash_eq (cand, base);
    6441                 :            : }
    6442                 :            : 
    6443                 :            : /* This function checks to see if TYPE matches the size one of the built-in 
    6444                 :            :    atomic types, and returns that core atomic type.  */
    6445                 :            : 
    6446                 :            : static tree
    6447                 :       6721 : find_atomic_core_type (const_tree type)
    6448                 :            : {
    6449                 :       6721 :   tree base_atomic_type;
    6450                 :            : 
    6451                 :            :   /* Only handle complete types.  */
    6452                 :       6721 :   if (!tree_fits_uhwi_p (TYPE_SIZE (type)))
    6453                 :            :     return NULL_TREE;
    6454                 :            : 
    6455                 :       6719 :   switch (tree_to_uhwi (TYPE_SIZE (type)))
    6456                 :            :     {
    6457                 :       2003 :     case 8:
    6458                 :       2003 :       base_atomic_type = atomicQI_type_node;
    6459                 :       2003 :       break;
    6460                 :            : 
    6461                 :        655 :     case 16:
    6462                 :        655 :       base_atomic_type = atomicHI_type_node;
    6463                 :        655 :       break;
    6464                 :            : 
    6465                 :        825 :     case 32:
    6466                 :        825 :       base_atomic_type = atomicSI_type_node;
    6467                 :        825 :       break;
    6468                 :            : 
    6469                 :       2351 :     case 64:
    6470                 :       2351 :       base_atomic_type = atomicDI_type_node;
    6471                 :       2351 :       break;
    6472                 :            : 
    6473                 :        778 :     case 128:
    6474                 :        778 :       base_atomic_type = atomicTI_type_node;
    6475                 :        778 :       break;
    6476                 :            : 
    6477                 :            :     default:
    6478                 :            :       base_atomic_type = NULL_TREE;
    6479                 :            :     }
    6480                 :            : 
    6481                 :            :   return base_atomic_type;
    6482                 :            : }
    6483                 :            : 
    6484                 :            : /* Returns true iff unqualified CAND and BASE are equivalent.  */
    6485                 :            : 
    6486                 :            : bool
    6487                 :  402790000 : check_base_type (const_tree cand, const_tree base)
    6488                 :            : {
    6489                 :  402790000 :   if (TYPE_NAME (cand) != TYPE_NAME (base)
    6490                 :            :       /* Apparently this is needed for Objective-C.  */
    6491                 :  365641000 :       || TYPE_CONTEXT (cand) != TYPE_CONTEXT (base)
    6492                 :  768431000 :       || !attribute_list_equal (TYPE_ATTRIBUTES (cand),
    6493                 :  365641000 :                                 TYPE_ATTRIBUTES (base)))
    6494                 :   37149000 :     return false;
    6495                 :            :   /* Check alignment.  */
    6496                 :  731282000 :   if (TYPE_ALIGN (cand) == TYPE_ALIGN (base))
    6497                 :            :     return true;
    6498                 :            :   /* Atomic types increase minimal alignment.  We must to do so as well
    6499                 :            :      or we get duplicated canonical types. See PR88686.  */
    6500                 :       6059 :   if ((TYPE_QUALS (cand) & TYPE_QUAL_ATOMIC))
    6501                 :            :     {
    6502                 :            :       /* See if this object can map to a basic atomic type.  */
    6503                 :       1255 :       tree atomic_type = find_atomic_core_type (cand);
    6504                 :       2510 :       if (atomic_type && TYPE_ALIGN (atomic_type) == TYPE_ALIGN (cand))
    6505                 :       1255 :        return true;
    6506                 :            :     }
    6507                 :            :   return false;
    6508                 :            : }
    6509                 :            : 
    6510                 :            : /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
    6511                 :            : 
    6512                 :            : bool
    6513                 :  429933000 : check_qualified_type (const_tree cand, const_tree base, int type_quals)
    6514                 :            : {
    6515                 :  429933000 :   return (TYPE_QUALS (cand) == type_quals
    6516                 :  268649000 :           && check_base_type (cand, base)
    6517                 :  661453000 :           && check_lang_type (cand, base));
    6518                 :            : }
    6519                 :            : 
    6520                 :            : /* Returns true iff CAND is equivalent to BASE with ALIGN.  */
    6521                 :            : 
    6522                 :            : static bool
    6523                 :    1063300 : check_aligned_type (const_tree cand, const_tree base, unsigned int align)
    6524                 :            : {
    6525                 :    1063300 :   return (TYPE_QUALS (cand) == TYPE_QUALS (base)
    6526                 :     972845 :           && TYPE_NAME (cand) == TYPE_NAME (base)
    6527                 :            :           /* Apparently this is needed for Objective-C.  */
    6528                 :     793813 :           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
    6529                 :            :           /* Check alignment.  */
    6530                 :     793813 :           && TYPE_ALIGN (cand) == align
    6531                 :     366343 :           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
    6532                 :     366343 :                                    TYPE_ATTRIBUTES (base))
    6533                 :    1429640 :           && check_lang_type (cand, base));
    6534                 :            : }
    6535                 :            : 
    6536                 :            : /* Return a version of the TYPE, qualified as indicated by the
    6537                 :            :    TYPE_QUALS, if one exists.  If no qualified version exists yet,
    6538                 :            :    return NULL_TREE.  */
    6539                 :            : 
    6540                 :            : tree
    6541                 :  463893000 : get_qualified_type (tree type, int type_quals)
    6542                 :            : {
    6543                 :  463893000 :   if (TYPE_QUALS (type) == type_quals)
    6544                 :            :     return type;
    6545                 :            : 
    6546                 :  246983000 :   tree mv = TYPE_MAIN_VARIANT (type);
    6547                 :  246983000 :   if (check_qualified_type (mv, type, type_quals))
    6548                 :            :     return mv;
    6549                 :            : 
    6550                 :            :   /* Search the chain of variants to see if there is already one there just
    6551                 :            :      like the one we need to have.  If so, use that existing one.  We must
    6552                 :            :      preserve the TYPE_NAME, since there is code that depends on this.  */
    6553                 :  198413000 :   for (tree *tp = &TYPE_NEXT_VARIANT (mv); *tp; tp = &TYPE_NEXT_VARIANT (*tp))
    6554                 :  182900000 :     if (check_qualified_type (*tp, type, type_quals))
    6555                 :            :       {
    6556                 :            :         /* Put the found variant at the head of the variant list so
    6557                 :            :            frequently searched variants get found faster.  The C++ FE
    6558                 :            :            benefits greatly from this.  */
    6559                 :  117787000 :         tree t = *tp;
    6560                 :  117787000 :         *tp = TYPE_NEXT_VARIANT (t);
    6561                 :  117787000 :         TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
    6562                 :  117787000 :         TYPE_NEXT_VARIANT (mv) = t;
    6563                 :  117787000 :         return t;
    6564                 :            :       }
    6565                 :            : 
    6566                 :            :   return NULL_TREE;
    6567                 :            : }
    6568                 :            : 
    6569                 :            : /* Like get_qualified_type, but creates the type if it does not
    6570                 :            :    exist.  This function never returns NULL_TREE.  */
    6571                 :            : 
    6572                 :            : tree
    6573                 :  394678000 : build_qualified_type (tree type, int type_quals MEM_STAT_DECL)
    6574                 :            : {
    6575                 :  394678000 :   tree t;
    6576                 :            : 
    6577                 :            :   /* See if we already have the appropriate qualified variant.  */
    6578                 :  394678000 :   t = get_qualified_type (type, type_quals);
    6579                 :            : 
    6580                 :            :   /* If not, build it.  */
    6581                 :  394678000 :   if (!t)
    6582                 :            :     {
    6583                 :   14453500 :       t = build_variant_type_copy (type PASS_MEM_STAT);
    6584                 :   14453500 :       set_type_quals (t, type_quals);
    6585                 :            : 
    6586                 :   14453500 :       if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC))
    6587                 :            :         {
    6588                 :            :           /* See if this object can map to a basic atomic type.  */
    6589                 :       5466 :           tree atomic_type = find_atomic_core_type (type);
    6590                 :       5466 :           if (atomic_type)
    6591                 :            :             {
    6592                 :            :               /* Ensure the alignment of this type is compatible with
    6593                 :            :                  the required alignment of the atomic type.  */
    6594                 :      10714 :               if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t))
    6595                 :         84 :                 SET_TYPE_ALIGN (t, TYPE_ALIGN (atomic_type));
    6596                 :            :             }
    6597                 :            :         }
    6598                 :            : 
    6599                 :   14453500 :       if (TYPE_STRUCTURAL_EQUALITY_P (type))
    6600                 :            :         /* Propagate structural equality. */
    6601                 :     678491 :         SET_TYPE_STRUCTURAL_EQUALITY (t);
    6602                 :   13775100 :       else if (TYPE_CANONICAL (type) != type)
    6603                 :            :         /* Build the underlying canonical type, since it is different
    6604                 :            :            from TYPE. */
    6605                 :            :         {
    6606                 :    2764760 :           tree c = build_qualified_type (TYPE_CANONICAL (type), type_quals);
    6607                 :    2764760 :           TYPE_CANONICAL (t) = TYPE_CANONICAL (c);
    6608                 :            :         }
    6609                 :            :       else
    6610                 :            :         /* T is its own canonical type. */
    6611                 :   11010300 :         TYPE_CANONICAL (t) = t;
    6612                 :            : 
    6613                 :            :     }
    6614                 :            : 
    6615                 :  394678000 :   return t;
    6616                 :            : }
    6617                 :            : 
    6618                 :            : /* Create a variant of type T with alignment ALIGN.  */
    6619                 :            : 
    6620                 :            : tree
    6621                 :     500788 : build_aligned_type (tree type, unsigned int align)
    6622                 :            : {
    6623                 :     500788 :   tree t;
    6624                 :            : 
    6625                 :     500788 :   if (TYPE_PACKED (type)
    6626                 :     500788 :       || TYPE_ALIGN (type) == align)
    6627                 :            :     return type;
    6628                 :            : 
    6629                 :    1097780 :   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
    6630                 :    1063300 :     if (check_aligned_type (t, type, align))
    6631                 :     366343 :       return t;
    6632                 :            : 
    6633                 :      34482 :   t = build_variant_type_copy (type);
    6634                 :      34482 :   SET_TYPE_ALIGN (t, align);
    6635                 :      34482 :   TYPE_USER_ALIGN (t) = 1;
    6636                 :            : 
    6637                 :      34482 :   return t;
    6638                 :            : }
    6639                 :            : 
    6640                 :            : /* Create a new distinct copy of TYPE.  The new type is made its own
    6641                 :            :    MAIN_VARIANT. If TYPE requires structural equality checks, the
    6642                 :            :    resulting type requires structural equality checks; otherwise, its
    6643                 :            :    TYPE_CANONICAL points to itself. */
    6644                 :            : 
    6645                 :            : tree
    6646                 :  136848000 : build_distinct_type_copy (tree type MEM_STAT_DECL)
    6647                 :            : {
    6648                 :  136848000 :   tree t = copy_node (type PASS_MEM_STAT);
    6649                 :            : 
    6650                 :  136848000 :   TYPE_POINTER_TO (t) = 0;
    6651                 :  136848000 :   TYPE_REFERENCE_TO (t) = 0;
    6652                 :            : 
    6653                 :            :   /* Set the canonical type either to a new equivalence class, or
    6654                 :            :      propagate the need for structural equality checks. */
    6655                 :  136848000 :   if (TYPE_STRUCTURAL_EQUALITY_P (type))
    6656                 :    8929560 :     SET_TYPE_STRUCTURAL_EQUALITY (t);
    6657                 :            :   else
    6658                 :  127918000 :     TYPE_CANONICAL (t) = t;
    6659                 :            : 
    6660                 :            :   /* Make it its own variant.  */
    6661                 :  136848000 :   TYPE_MAIN_VARIANT (t) = t;
    6662                 :  136848000 :   TYPE_NEXT_VARIANT (t) = 0;
    6663                 :            : 
    6664                 :            :   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
    6665                 :            :      whose TREE_TYPE is not t.  This can also happen in the Ada
    6666                 :            :      frontend when using subtypes.  */
    6667                 :            : 
    6668                 :  136848000 :   return t;
    6669                 :            : }
    6670                 :            : 
    6671                 :            : /* Create a new variant of TYPE, equivalent but distinct.  This is so
    6672                 :            :    the caller can modify it. TYPE_CANONICAL for the return type will
    6673                 :            :    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
    6674                 :            :    are considered equal by the language itself (or that both types
    6675                 :            :    require structural equality checks). */
    6676                 :            : 
    6677                 :            : tree
    6678                 :   66269900 : build_variant_type_copy (tree type MEM_STAT_DECL)
    6679                 :            : {
    6680                 :   66269900 :   tree t, m = TYPE_MAIN_VARIANT (type);
    6681                 :            : 
    6682                 :   66269900 :   t = build_distinct_type_copy (type PASS_MEM_STAT);
    6683                 :            : 
    6684                 :            :   /* Since we're building a variant, assume that it is a non-semantic
    6685                 :            :      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
    6686                 :   66269900 :   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
    6687                 :            :   /* Type variants have no alias set defined.  */
    6688                 :   66269900 :   TYPE_ALIAS_SET (t) = -1;
    6689                 :            : 
    6690                 :            :   /* Add the new type to the chain of variants of TYPE.  */
    6691                 :   66269900 :   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
    6692                 :   66269900 :   TYPE_NEXT_VARIANT (m) = t;
    6693                 :   66269900 :   TYPE_MAIN_VARIANT (t) = m;
    6694                 :            : 
    6695                 :   66269900 :   return t;
    6696                 :            : }
    6697                 :            : 
    6698                 :            : /* Return true if the from tree in both tree maps are equal.  */
    6699                 :            : 
    6700                 :            : int
    6701                 :  416600000 : tree_map_base_eq (const void *va, const void *vb)
    6702                 :            : {
    6703                 :  416600000 :   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
    6704                 :  416600000 :     *const b = (const struct tree_map_base *) vb;
    6705                 :  416600000 :   return (a->from == b->from);
    6706                 :            : }
    6707                 :            : 
    6708                 :            : /* Hash a from tree in a tree_base_map.  */
    6709                 :            : 
    6710                 :            : unsigned int
    6711                 :          0 : tree_map_base_hash (const void *item)
    6712                 :            : {
    6713                 :          0 :   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
    6714                 :            : }
    6715                 :            : 
    6716                 :            : /* Return true if this tree map structure is marked for garbage collection
    6717                 :            :    purposes.  We simply return true if the from tree is marked, so that this
    6718                 :            :    structure goes away when the from tree goes away.  */
    6719                 :            : 
    6720                 :            : int
    6721                 :          0 : tree_map_base_marked_p (const void *p)
    6722                 :            : {
    6723                 :          0 :   return ggc_marked_p (((const struct tree_map_base *) p)->from);
    6724                 :            : }
    6725                 :            : 
    6726                 :            : /* Hash a from tree in a tree_map.  */
    6727                 :            : 
    6728                 :            : unsigned int
    6729                 :        187 : tree_map_hash (const void *item)
    6730                 :            : {
    6731                 :        187 :   return (((const struct tree_map *) item)->hash);
    6732                 :            : }
    6733                 :            : 
    6734                 :            : /* Hash a from tree in a tree_decl_map.  */
    6735                 :            : 
    6736                 :            : unsigned int
    6737                 :  121146000 : tree_decl_map_hash (const void *item)
    6738                 :            : {
    6739                 :  121146000 :   return DECL_UID (((const struct tree_decl_map *) item)->base.from);
    6740                 :            : }
    6741                 :            : 
    6742                 :            : /* Return the initialization priority for DECL.  */
    6743                 :            : 
    6744                 :            : priority_type
    6745                 :      12380 : decl_init_priority_lookup (tree decl)
    6746                 :            : {
    6747                 :      12380 :   symtab_node *snode = symtab_node::get (decl);
    6748                 :            : 
    6749                 :      12380 :   if (!snode)
    6750                 :            :     return DEFAULT_INIT_PRIORITY;
    6751                 :      12380 :   return
    6752                 :      12380 :     snode->get_init_priority ();
    6753                 :            : }
    6754                 :            : 
    6755                 :            : /* Return the finalization priority for DECL.  */
    6756                 :            : 
    6757                 :            : priority_type
    6758                 :       1410 : decl_fini_priority_lookup (tree decl)
    6759                 :            : {
    6760                 :       1410 :   cgraph_node *node = cgraph_node::get (decl);
    6761                 :            : 
    6762                 :       1410 :   if (!node)
    6763                 :            :     return DEFAULT_INIT_PRIORITY;
    6764                 :       1410 :   return
    6765                 :       1410 :     node->get_fini_priority ();
    6766                 :            : }
    6767                 :            : 
    6768                 :            : /* Set the initialization priority for DECL to PRIORITY.  */
    6769                 :            : 
    6770                 :            : void
    6771                 :      13630 : decl_init_priority_insert (tree decl, priority_type priority)
    6772                 :            : {
    6773                 :      13630 :   struct symtab_node *snode;
    6774                 :            : 
    6775                 :      13630 :   if (priority == DEFAULT_INIT_PRIORITY)
    6776                 :            :     {
    6777                 :      11119 :       snode = symtab_node::get (decl);
    6778                 :      11119 :       if (!snode)
    6779                 :            :         return;
    6780                 :            :     }
    6781                 :       2511 :   else if (VAR_P (decl))
    6782                 :         26 :     snode = varpool_node::get_create (decl);
    6783                 :            :   else
    6784                 :       2485 :     snode = cgraph_node::get_create (decl);
    6785                 :      13172 :   snode->set_init_priority (priority);
    6786                 :            : }
    6787                 :            : 
    6788                 :            : /* Set the finalization priority for DECL to PRIORITY.  */
    6789                 :            : 
    6790                 :            : void
    6791                 :       1425 : decl_fini_priority_insert (tree decl, priority_type priority)
    6792                 :            : {
    6793                 :       1425 :   struct cgraph_node *node;
    6794                 :            : 
    6795                 :       1425 :   if (priority == DEFAULT_INIT_PRIORITY)
    6796                 :            :     {
    6797                 :         95 :       node = cgraph_node::get (decl);
    6798                 :         95 :       if (!node)
    6799                 :            :         return;
    6800                 :            :     }
    6801                 :            :   else
    6802                 :       1330 :     node = cgraph_node::get_create (decl);
    6803                 :       1338 :   node->set_fini_priority (priority);
    6804                 :            : }
    6805                 :            : 
    6806                 :            : /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
    6807                 :            : 
    6808                 :            : static void
    6809                 :          0 : print_debug_expr_statistics (void)
    6810                 :            : {
    6811                 :          0 :   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
    6812                 :          0 :            (long) debug_expr_for_decl->size (),
    6813                 :          0 :            (long) debug_expr_for_decl->elements (),
    6814                 :            :            debug_expr_for_decl->collisions ());
    6815                 :          0 : }
    6816                 :            : 
    6817                 :            : /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
    6818                 :            : 
    6819                 :            : static void
    6820                 :          0 : print_value_expr_statistics (void)
    6821                 :            : {
    6822                 :          0 :   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
    6823                 :          0 :            (long) value_expr_for_decl->size (),
    6824                 :          0 :            (long) value_expr_for_decl->elements (),
    6825                 :            :            value_expr_for_decl->collisions ());
    6826                 :          0 : }
    6827                 :            : 
    6828                 :            : /* Lookup a debug expression for FROM, and return it if we find one.  */
    6829                 :            : 
    6830                 :            : tree
    6831                 :  247154000 : decl_debug_expr_lookup (tree from)
    6832                 :            : {
    6833                 :  247154000 :   struct tree_decl_map *h, in;
    6834                 :  247154000 :   in.base.from = from;
    6835                 :            : 
    6836                 :  247154000 :   h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
    6837                 :  247154000 :   if (h)
    6838                 :  247154000 :     return h->to;
    6839                 :            :   return NULL_TREE;
    6840                 :            : }
    6841                 :            : 
    6842                 :            : /* Insert a mapping FROM->TO in the debug expression hashtable.  */
    6843                 :            : 
    6844                 :            : void
    6845                 :     868494 : decl_debug_expr_insert (tree from, tree to)
    6846                 :            : {
    6847                 :     868494 :   struct tree_decl_map *h;
    6848                 :            : 
    6849                 :     868494 :   h = ggc_alloc<tree_decl_map> ();
    6850                 :     868494 :   h->base.from = from;
    6851                 :     868494 :   h->to = to;
    6852                 :     868494 :   *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
    6853                 :     868494 : }
    6854                 :            : 
    6855                 :            : /* Lookup a value expression for FROM, and return it if we find one.  */
    6856                 :            : 
    6857                 :            : tree
    6858                 :     930017 : decl_value_expr_lookup (tree from)
    6859                 :            : {
    6860                 :     930017 :   struct tree_decl_map *h, in;
    6861                 :     930017 :   in.base.from = from;
    6862                 :            : 
    6863                 :     930017 :   h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
    6864                 :     930017 :   if (h)
    6865                 :     930017 :     return h->to;
    6866                 :            :   return NULL_TREE;
    6867                 :            : }
    6868                 :            : 
    6869                 :            : /* Insert a mapping FROM->TO in the value expression hashtable.  */
    6870                 :            : 
    6871                 :            : void
    6872                 :     348927 : decl_value_expr_insert (tree from, tree to)
    6873                 :            : {
    6874                 :     348927 :   struct tree_decl_map *h;
    6875                 :            : 
    6876                 :     348927 :   h = ggc_alloc<tree_decl_map> ();
    6877                 :     348927 :   h->base.from = from;
    6878                 :     348927 :   h->to = to;
    6879                 :     348927 :   *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h;
    6880                 :     348927 : }
    6881                 :            : 
    6882                 :            : /* Lookup a vector of debug arguments for FROM, and return it if we
    6883                 :            :    find one.  */
    6884                 :            : 
    6885                 :            : vec<tree, va_gc> **
    6886                 :     355406 : decl_debug_args_lookup (tree from)
    6887                 :            : {
    6888                 :     355406 :   struct tree_vec_map *h, in;
    6889                 :            : 
    6890                 :     355406 :   if (!DECL_HAS_DEBUG_ARGS_P (from))
    6891                 :            :     return NULL;
    6892                 :     250445 :   gcc_checking_assert (debug_args_for_decl != NULL);
    6893                 :     250445 :   in.base.from = from;
    6894                 :     250445 :   h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from));
    6895                 :     250445 :   if (h)
    6896                 :     248709 :     return &h->to;
    6897                 :            :   return NULL;
    6898                 :            : }
    6899                 :            : 
    6900                 :            : /* Insert a mapping FROM->empty vector of debug arguments in the value
    6901                 :            :    expression hashtable.  */
    6902                 :            : 
    6903                 :            : vec<tree, va_gc> **
    6904                 :     110625 : decl_debug_args_insert (tree from)
    6905                 :            : {
    6906                 :     110625 :   struct tree_vec_map *h;
    6907                 :     110625 :   tree_vec_map **loc;
    6908                 :            : 
    6909                 :     110625 :   if (DECL_HAS_DEBUG_ARGS_P (from))
    6910                 :      70759 :     return decl_debug_args_lookup (from);
    6911                 :      39866 :   if (debug_args_for_decl == NULL)
    6912                 :       8147 :     debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64);
    6913                 :      39866 :   h = ggc_alloc<tree_vec_map> ();
    6914                 :      39866 :   h->base.from = from;
    6915                 :      39866 :   h->to = NULL;
    6916                 :      39866 :   loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT);
    6917                 :      39866 :   *loc = h;
    6918                 :      39866 :   DECL_HAS_DEBUG_ARGS_P (from) = 1;
    6919                 :      39866 :   return &h->to;
    6920                 :            : }
    6921                 :            : 
    6922                 :            : /* Hashing of types so that we don't make duplicates.
    6923                 :            :    The entry point is `type_hash_canon'.  */
    6924                 :            : 
    6925                 :            : /* Generate the default hash code for TYPE.  This is designed for
    6926                 :            :    speed, rather than maximum entropy.  */
    6927                 :            : 
    6928                 :            : hashval_t
    6929                 :  368194000 : type_hash_canon_hash (tree type)
    6930                 :            : {
    6931                 :  368194000 :   inchash::hash hstate;
    6932                 :            : 
    6933                 :  368194000 :   hstate.add_int (TREE_CODE (type));
    6934                 :            : 
    6935                 :  368194000 :   if (TREE_TYPE (type))
    6936                 :  368193000 :     hstate.add_object (TYPE_HASH (TREE_TYPE (type)));
    6937                 :            : 
    6938                 :  453418000 :   for (tree t = TYPE_ATTRIBUTES (type); t; t = TREE_CHAIN (t))
    6939                 :            :     /* Just the identifier is adequate to distinguish.  */
    6940                 :   85223800 :     hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (t)));
    6941                 :            : 
    6942                 :  368194000 :   switch (TREE_CODE (type))
    6943                 :            :     {
    6944                 :   29769200 :     case METHOD_TYPE:
    6945                 :   59538300 :       hstate.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type)));
    6946                 :            :       /* FALLTHROUGH. */
    6947                 :  332756000 :     case FUNCTION_TYPE:
    6948                 : 1425930000 :       for (tree t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
    6949                 : 1063400000 :         if (TREE_VALUE (t) != error_mark_node)
    6950                 : 2126800000 :           hstate.add_object (TYPE_HASH (TREE_VALUE (t)));
    6951                 :            :       break;
    6952                 :            : 
    6953                 :     428326 :     case OFFSET_TYPE:
    6954                 :     428326 :       hstate.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type)));
    6955                 :            :       break;
    6956                 :            : 
    6957                 :   12367300 :     case ARRAY_TYPE:
    6958                 :   12367300 :       {
    6959                 :   12367300 :         if (TYPE_DOMAIN (type))
    6960                 :   11792700 :           hstate.add_object (TYPE_HASH (TYPE_DOMAIN (type)));
    6961                 :   12367300 :         if (!AGGREGATE_TYPE_P (TREE_TYPE (type)))
    6962                 :            :           {
    6963                 :   11886300 :             unsigned typeless = TYPE_TYPELESS_STORAGE (type);
    6964                 :   11886300 :             hstate.add_object (typeless);
    6965                 :            :           }
    6966                 :            :       }
    6967                 :            :       break;
    6968                 :            : 
    6969                 :    9033320 :     case INTEGER_TYPE:
    6970                 :    9033320 :       {
    6971                 :    9033320 :         tree t = TYPE_MAX_VALUE (type);
    6972                 :    9033320 :         if (!t)
    6973                 :     190889 :           t = TYPE_MIN_VALUE (type);
    6974                 :   18066600 :         for (int i = 0; i < TREE_INT_CST_NUNITS (t); i++)
    6975                 :    9033320 :           hstate.add_object (TREE_INT_CST_ELT (t, i));
    6976                 :            :         break;
    6977                 :            :       }
    6978                 :            :       
    6979                 :         45 :     case REAL_TYPE:
    6980                 :         45 :     case FIXED_POINT_TYPE:
    6981                 :         45 :       {
    6982                 :         45 :         unsigned prec = TYPE_PRECISION (type);
    6983                 :         45 :         hstate.add_object (prec);
    6984                 :         45 :         break;
    6985                 :            :       }
    6986                 :            : 
    6987                 :   11355700 :     case VECTOR_TYPE:
    6988                 :   11355700 :       hstate.add_poly_int (TYPE_VECTOR_SUBPARTS (type));
    6989                 :   11355700 :       break;
    6990                 :            : 
    6991                 :            :     default:
    6992                 :            :       break;
    6993                 :            :     }
    6994                 :            : 
    6995                 :  368194000 :   return hstate.end ();
    6996                 :            : }
    6997                 :            : 
    6998                 :            : /* These are the Hashtable callback functions.  */
    6999                 :            : 
    7000                 :            : /* Returns true iff the types are equivalent.  */
    7001                 :            : 
    7002                 :            : bool
    7003                 : 1764360000 : type_cache_hasher::equal (type_hash *a, type_hash *b)
    7004                 :            : {
    7005                 :            :   /* First test the things that are the same for all types.  */
    7006                 : 1764360000 :   if (a->hash != b->hash
    7007                 :  158368000 :       || TREE_CODE (a->type) != TREE_CODE (b->type)
    7008                 :  158367000 :       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
    7009                 :  158367000 :       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
    7010                 :  158367000 :                                  TYPE_ATTRIBUTES (b->type))
    7011                 : 1918510000 :       || (TREE_CODE (a->type) != COMPLEX_TYPE
    7012                 :  153903000 :           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
    7013                 : 1610600000 :     return 0;
    7014                 :            : 
    7015                 :            :   /* Be careful about comparing arrays before and after the element type
    7016                 :            :      has been completed; don't compare TYPE_ALIGN unless both types are
    7017                 :            :      complete.  */
    7018                 :  306910000 :   if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
    7019                 :  306910000 :       && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
    7020                 :  153159000 :           || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
    7021                 :        285 :     return 0;
    7022                 :            : 
    7023                 :  153750000 :   switch (TREE_CODE (a->type))
    7024                 :            :     {
    7025                 :            :     case VOID_TYPE:
    7026                 :            :     case COMPLEX_TYPE:
    7027                 :            :     case POINTER_TYPE:
    7028                 :            :     case REFERENCE_TYPE:
    7029                 :            :     case NULLPTR_TYPE:
    7030                 :            :       return 1;
    7031                 :            : 
    7032                 :    8443820 :     case VECTOR_TYPE:
    7033                 :    8443820 :       return known_eq (TYPE_VECTOR_SUBPARTS (a->type),
    7034                 :            :                        TYPE_VECTOR_SUBPARTS (b->type));
    7035                 :            : 
    7036                 :          0 :     case ENUMERAL_TYPE:
    7037                 :          0 :       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
    7038                 :          0 :           && !(TYPE_VALUES (a->type)
    7039                 :          0 :                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
    7040                 :          0 :                && TYPE_VALUES (b->type)
    7041                 :          0 :                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
    7042                 :          0 :                && type_list_equal (TYPE_VALUES (a->type),
    7043                 :          0 :                                    TYPE_VALUES (b->type))))
    7044                 :          0 :         return 0;
    7045                 :            : 
    7046                 :            :       /* fall through */
    7047                 :            : 
    7048                 :    7851660 :     case INTEGER_TYPE:
    7049                 :    7851660 :     case REAL_TYPE:
    7050                 :    7851660 :     case BOOLEAN_TYPE:
    7051                 :    7851660 :       if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
    7052                 :            :         return false;
    7053                 :    7849260 :       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
    7054                 :     232386 :                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
    7055                 :     232386 :                                       TYPE_MAX_VALUE (b->type)))
    7056                 :    7980580 :               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
    7057                 :     212312 :                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
    7058                 :     212312 :                                          TYPE_MIN_VALUE (b->type))));
    7059                 :            : 
    7060                 :          0 :     case FIXED_POINT_TYPE:
    7061                 :          0 :       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
    7062                 :            : 
    7063                 :     363171 :     case OFFSET_TYPE:
    7064                 :     363171 :       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
    7065                 :            : 
    7066                 :   11203000 :     case METHOD_TYPE:
    7067                 :   22406000 :       if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
    7068                 :   33609000 :           && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
    7069                 :   22400400 :               || (TYPE_ARG_TYPES (a->type)
    7070                 :   22400400 :                   && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
    7071                 :   22400400 :                   && TYPE_ARG_TYPES (b->type)
    7072                 :   22400400 :                   && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
    7073                 :   11200200 :                   && type_list_equal (TYPE_ARG_TYPES (a->type),
    7074                 :   22400400 :                                       TYPE_ARG_TYPES (b->type)))))
    7075                 :            :         break;
    7076                 :            :       return 0;
    7077                 :    8942540 :     case ARRAY_TYPE:
    7078                 :            :       /* Don't compare TYPE_TYPELESS_STORAGE flag on aggregates,
    7079                 :            :          where the flag should be inherited from the element type
    7080                 :            :          and can change after ARRAY_TYPEs are created; on non-aggregates
    7081                 :            :          compare it and hash it, scalars will never have that flag set
    7082                 :            :          and we need to differentiate between arrays created by different
    7083                 :            :          front-ends or middle-end created arrays.  */
    7084                 :    8942540 :       return (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
    7085                 :    8942540 :               && (AGGREGATE_TYPE_P (TREE_TYPE (a->type))
    7086                 :    8788200 :                   || (TYPE_TYPELESS_STORAGE (a->type)
    7087                 :    8788200 :                       == TYPE_TYPELESS_STORAGE (b->type))));
    7088                 :            : 
    7089                 :          0 :     case RECORD_TYPE:
    7090                 :          0 :     case UNION_TYPE:
    7091                 :          0 :     case QUAL_UNION_TYPE:
    7092                 :          0 :       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
    7093                 :          0 :               || (TYPE_FIELDS (a->type)
    7094                 :          0 :                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
    7095                 :          0 :                   && TYPE_FIELDS (b->type)
    7096                 :          0 :                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
    7097                 :          0 :                   && type_list_equal (TYPE_FIELDS (a->type),
    7098                 :          0 :                                       TYPE_FIELDS (b->type))));
    7099                 :            : 
    7100                 :  116699000 :     case FUNCTION_TYPE:
    7101                 :  116699000 :       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
    7102                 :  116699000 :           || (TYPE_ARG_TYPES (a->type)
    7103                 :   62645000 :               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
    7104                 :   62645000 :               && TYPE_ARG_TYPES (b->type)
    7105                 :   62645000 :               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
    7106                 :   62645000 :               && type_list_equal (TYPE_ARG_TYPES (a->type),
    7107                 :   62645000 :                                   TYPE_ARG_TYPES (b->type))))
    7108                 :            :         break;
    7109                 :            :       return 0;
    7110                 :            : 
    7111                 :          0 :     default:
    7112                 :          0 :       return 0;
    7113                 :            :     }
    7114                 :            : 
    7115                 :  125926000 :   if (lang_hooks.types.type_hash_eq != NULL)
    7116                 :   53557400 :     return lang_hooks.types.type_hash_eq (a->type, b->type);
    7117                 :            : 
    7118                 :            :   return 1;
    7119                 :            : }
    7120                 :            : 
    7121                 :            : /* Given TYPE, and HASHCODE its hash code, return the canonical
    7122                 :            :    object for an identical type if one already exists.
    7123                 :            :    Otherwise, return TYPE, and record it as the canonical object.
    7124                 :            : 
    7125                 :            :    To use this function, first create a type of the sort you want.
    7126                 :            :    Then compute its hash code from the fields of the type that
    7127                 :            :    make it different from other similar types.
    7128                 :            :    Then call this function and use the value.  */
    7129                 :            : 
    7130                 :            : tree
    7131                 :  368664000 : type_hash_canon (unsigned int hashcode, tree type)
    7132                 :            : {
    7133                 :  368664000 :   type_hash in;
    7134                 :  368664000 :   type_hash **loc;
    7135                 :            : 
    7136                 :            :   /* The hash table only contains main variants, so ensure that's what we're
    7137                 :            :      being passed.  */
    7138                 :  368664000 :   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
    7139                 :            : 
    7140                 :            :   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
    7141                 :            :      must call that routine before comparing TYPE_ALIGNs.  */
    7142                 :  368664000 :   layout_type (type);
    7143                 :            : 
    7144                 :  368664000 :   in.hash = hashcode;
    7145                 :  368664000 :   in.type = type;
    7146                 :            : 
    7147                 :  368664000 :   loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT);
    7148                 :  368664000 :   if (*loc)
    7149                 :            :     {
    7150                 :  151591000 :       tree t1 = ((type_hash *) *loc)->type;
    7151                 :  151591000 :       gcc_assert (TYPE_MAIN_VARIANT (t1) == t1
    7152                 :            :                   && t1 != type);
    7153                 :  151591000 :       if (TYPE_UID (type) + 1 == next_type_uid)
    7154                 :  149181000 :         --next_type_uid;
    7155                 :            :       /* Free also min/max values and the cache for integer
    7156                 :            :          types.  This can't be done in free_node, as LTO frees
    7157                 :            :          those on its own.  */
    7158                 :  151591000 :       if (TREE_CODE (type) == INTEGER_TYPE)
    7159                 :            :         {
    7160                 :    7667190 :           if (TYPE_MIN_VALUE (type)
    7161                 :    7667190 :               && TREE_TYPE (TYPE_MIN_VALUE (type)) == type)
    7162                 :            :             {
    7163                 :            :               /* Zero is always in TYPE_CACHED_VALUES.  */
    7164                 :     131270 :               if (! TYPE_UNSIGNED (type))
    7165                 :      46085 :                 int_cst_hash_table->remove_elt (TYPE_MIN_VALUE (type));
    7166                 :     131270 :               ggc_free (TYPE_MIN_VALUE (type));
    7167                 :            :             }
    7168                 :    7667190 :           if (TYPE_MAX_VALUE (type)
    7169                 :    7667190 :               && TREE_TYPE (TYPE_MAX_VALUE (type)) == type)
    7170                 :            :             {
    7171                 :     131270 :               int_cst_hash_table->remove_elt (TYPE_MAX_VALUE (type));
    7172                 :     131270 :               ggc_free (TYPE_MAX_VALUE (type));
    7173                 :            :             }
    7174                 :    7667190 :           if (TYPE_CACHED_VALUES_P (type))
    7175                 :      85185 :             ggc_free (TYPE_CACHED_VALUES (type));
    7176                 :            :         }
    7177                 :  151591000 :       free_node (type);
    7178                 :  151591000 :       return t1;
    7179                 :            :     }
    7180                 :            :   else
    7181                 :            :     {
    7182                 :  217073000 :       struct type_hash *h;
    7183                 :            : 
    7184                 :  217073000 :       h = ggc_alloc<type_hash> ();
    7185                 :  217073000 :       h->hash = hashcode;
    7186                 :  217073000 :       h->type = type;
    7187                 :  217073000 :       *loc = h;
    7188                 :            : 
    7189                 :  217073000 :       return type;
    7190                 :            :     }
    7191                 :            : }
    7192                 :            : 
    7193                 :            : static void
    7194                 :          0 : print_type_hash_statistics (void)
    7195                 :            : {
    7196                 :          0 :   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
    7197                 :          0 :            (long) type_hash_table->size (),
    7198                 :          0 :            (long) type_hash_table->elements (),
    7199                 :            :            type_hash_table->collisions ());
    7200                 :          0 : }
    7201                 :            : 
    7202                 :            : /* Given two lists of types
    7203                 :            :    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
    7204                 :            :    return 1 if the lists contain the same types in the same order.
    7205                 :            :    Also, the TREE_PURPOSEs must match.  */
    7206                 :            : 
    7207                 :            : bool
    7208                 :   73845600 : type_list_equal (const_tree l1, const_tree l2)
    7209                 :            : {
    7210                 :   73845600 :   const_tree t1, t2;
    7211                 :            : 
    7212                 :  301055000 :   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
    7213                 :  229184000 :     if (TREE_VALUE (t1) != TREE_VALUE (t2)
    7214                 :  229184000 :         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
    7215                 :    1976040 :             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
    7216                 :        876 :                   && (TREE_TYPE (TREE_PURPOSE (t1))
    7217                 :        876 :                       == TREE_TYPE (TREE_PURPOSE (t2))))))
    7218                 :    1975270 :       return false;
    7219                 :            : 
    7220                 :   71870300 :   return t1 == t2;
    7221                 :            : }
    7222                 :            : 
    7223                 :            : /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
    7224                 :            :    given by TYPE.  If the argument list accepts variable arguments,
    7225                 :            :    then this function counts only the ordinary arguments.  */
    7226                 :            : 
    7227                 :            : int
    7228                 :   29526500 : type_num_arguments (const_tree fntype)
    7229                 :            : {
    7230                 :   29526500 :   int i = 0;
    7231                 :            : 
    7232                 :  107568000 :   for (tree t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
    7233                 :            :     /* If the function does not take a variable number of arguments,
    7234                 :            :        the last element in the list will have type `void'.  */
    7235                 :   93650400 :     if (VOID_TYPE_P (TREE_VALUE (t)))
    7236                 :            :       break;
    7237                 :            :     else
    7238                 :   78041000 :       ++i;
    7239                 :            : 
    7240                 :   29526500 :   return i;
    7241                 :            : }
    7242                 :            : 
    7243                 :            : /* Return the type of the function TYPE's argument ARGNO if known.
    7244                 :            :    For vararg function's where ARGNO refers to one of the variadic
    7245                 :            :    arguments return null.  Otherwise, return a void_type_node for
    7246                 :            :    out-of-bounds ARGNO.  */
    7247                 :            : 
    7248                 :            : tree
    7249                 :   29343200 : type_argument_type (const_tree fntype, unsigned argno)
    7250                 :            : {
    7251                 :            :   /* Treat zero the same as an out-of-bounds argument number.  */
    7252                 :   29343200 :   if (!argno)
    7253                 :          0 :     return void_type_node;
    7254                 :            : 
    7255                 :   29343200 :   function_args_iterator iter;
    7256                 :            : 
    7257                 :   29343200 :   tree argtype;
    7258                 :   29343200 :   unsigned i = 1;
    7259                 :   65253500 :   FOREACH_FUNCTION_ARGS (fntype, argtype, iter)
    7260                 :            :     {
    7261                 :            :       /* A vararg function's argument list ends in a null.  Otherwise,
    7262                 :            :          an ordinary function's argument list ends with void.  Return
    7263                 :            :          null if ARGNO refers to a vararg argument, void_type_node if
    7264                 :            :          it's out of bounds, and the formal argument type otherwise.  */
    7265                 :   61081500 :       if (!argtype)
    7266                 :            :         break;
    7267                 :            : 
    7268                 :   61081500 :       if (i == argno || VOID_TYPE_P (argtype))
    7269                 :   25171200 :         return argtype;
    7270                 :            : 
    7271                 :   35910300 :       ++i;
    7272                 :            :     }
    7273                 :            : 
    7274                 :            :   return NULL_TREE;
    7275                 :            : }
    7276                 :            : 
    7277                 :            : /* Nonzero if integer constants T1 and T2
    7278                 :            :    represent the same constant value.  */
    7279                 :            : 
    7280                 :            : int
    7281                 :  887406000 : tree_int_cst_equal (const_tree t1, const_tree t2)
    7282                 :            : {
    7283                 :  887406000 :   if (t1 == t2)
    7284                 :            :     return 1;
    7285                 :            : 
    7286                 :  667276000 :   if (t1 == 0 || t2 == 0)
    7287                 :            :     return 0;
    7288                 :            : 
    7289                 :  667155000 :   STRIP_ANY_LOCATION_WRAPPER (t1);
    7290                 :  667155000 :   STRIP_ANY_LOCATION_WRAPPER (t2);
    7291                 :            : 
    7292                 :  667155000 :   if (TREE_CODE (t1) == INTEGER_CST
    7293                 :  665231000 :       && TREE_CODE (t2) == INTEGER_CST
    7294                 : 1332390000 :       && wi::to_widest (t1) == wi::to_widest (t2))
    7295                 :   19969600 :     return 1;
    7296                 :            : 
    7297                 :            :   return 0;
    7298                 :            : }
    7299                 :            : 
    7300                 :            : /* Return true if T is an INTEGER_CST whose numerical value (extended
    7301                 :            :    according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.  */
    7302                 :            : 
    7303                 :            : bool
    7304                 :  854825000 : tree_fits_shwi_p (const_tree t)
    7305                 :            : {
    7306                 :  854825000 :   return (t != NULL_TREE
    7307                 :  854825000 :           && TREE_CODE (t) == INTEGER_CST
    7308                 : 1708220000 :           && wi::fits_shwi_p (wi::to_widest (t)));
    7309                 :            : }
    7310                 :            : 
    7311                 :            : /* Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
    7312                 :            :    value (extended according to TYPE_UNSIGNED) fits in a poly_int64.  */
    7313                 :            : 
    7314                 :            : bool
    7315                 :   91181100 : tree_fits_poly_int64_p (const_tree t)
    7316                 :            : {
    7317                 :   91181100 :   if (t == NULL_TREE)
    7318                 :            :     return false;
    7319                 :   91181100 :   if (POLY_INT_CST_P (t))
    7320                 :            :     {
    7321                 :            :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; i++)
    7322                 :            :         if (!wi::fits_shwi_p (wi::to_wide (POLY_INT_CST_COEFF (t, i))))
    7323                 :            :           return false;
    7324                 :            :       return true;
    7325                 :            :     }
    7326                 :   91181100 :   return (TREE_CODE (t) == INTEGER_CST
    7327                 :  180673000 :           && wi::fits_shwi_p (wi::to_widest (t)));
    7328                 :            : }
    7329                 :            : 
    7330                 :            : /* Return true if T is an INTEGER_CST whose numerical value (extended
    7331                 :            :    according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.  */
    7332                 :            : 
    7333                 :            : bool
    7334                 : 1248790000 : tree_fits_uhwi_p (const_tree t)
    7335                 :            : {
    7336                 : 1248790000 :   return (t != NULL_TREE
    7337                 : 1248730000 :           && TREE_CODE (t) == INTEGER_CST
    7338                 : 2494740000 :           && wi::fits_uhwi_p (wi::to_widest (t)));
    7339                 :            : }
    7340                 :            : 
    7341                 :            : /* Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
    7342                 :            :    value (extended according to TYPE_UNSIGNED) fits in a poly_uint64.  */
    7343                 :            : 
    7344                 :            : bool
    7345                 :  338889000 : tree_fits_poly_uint64_p (const_tree t)
    7346                 :            : {
    7347                 :  338889000 :   if (t == NULL_TREE)
    7348                 :            :     return false;
    7349                 :  338810000 :   if (POLY_INT_CST_P (t))
    7350                 :            :     {
    7351                 :            :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; i++)
    7352                 :            :         if (!wi::fits_uhwi_p (wi::to_widest (POLY_INT_CST_COEFF (t, i))))
    7353                 :            :           return false;
    7354                 :            :       return true;
    7355                 :            :     }
    7356                 :  338810000 :   return (TREE_CODE (t) == INTEGER_CST
    7357                 :  676979000 :           && wi::fits_uhwi_p (wi::to_widest (t)));
    7358                 :            : }
    7359                 :            : 
    7360                 :            : /* T is an INTEGER_CST whose numerical value (extended according to
    7361                 :            :    TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.  Return that
    7362                 :            :    HOST_WIDE_INT.  */
    7363                 :            : 
    7364                 :            : HOST_WIDE_INT
    7365                 :  400321000 : tree_to_shwi (const_tree t)
    7366                 :            : {
    7367                 :  400321000 :   gcc_assert (tree_fits_shwi_p (t));
    7368                 :  400321000 :   return TREE_INT_CST_LOW (t);
    7369                 :            : }
    7370                 :            : 
    7371                 :            : /* T is an INTEGER_CST whose numerical value (extended according to
    7372                 :            :    TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.  Return that
    7373                 :            :    HOST_WIDE_INT.  */
    7374                 :            : 
    7375                 :            : unsigned HOST_WIDE_INT
    7376                 :  319288000 : tree_to_uhwi (const_tree t)
    7377                 :            : {
    7378                 :  319288000 :   gcc_assert (tree_fits_uhwi_p (t));
    7379                 :  319288000 :   return TREE_INT_CST_LOW (t);
    7380                 :            : }
    7381                 :            : 
    7382                 :            : /* Return the most significant (sign) bit of T.  */
    7383                 :            : 
    7384                 :            : int
    7385                 :   18879300 : tree_int_cst_sign_bit (const_tree t)
    7386                 :            : {
    7387                 :   18879300 :   unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1;
    7388                 :            : 
    7389                 :   18879300 :   return wi::extract_uhwi (wi::to_wide (t), bitno, 1);
    7390                 :            : }
    7391                 :            : 
    7392                 :            : /* Return an indication of the sign of the integer constant T.
    7393                 :            :    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
    7394                 :            :    Note that -1 will never be returned if T's type is unsigned.  */
    7395                 :            : 
    7396                 :            : int
    7397                 :  446074000 : tree_int_cst_sgn (const_tree t)
    7398                 :            : {
    7399                 :  446074000 :   if (wi::to_wide (t) == 0)
    7400                 :            :     return 0;
    7401                 :  411046000 :   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
    7402                 :            :     return 1;
    7403                 :   25504400 :   else if (wi::neg_p (wi::to_wide (t)))
    7404                 :            :     return -1;
    7405                 :            :   else
    7406                 :   23697300 :     return 1;
    7407                 :            : }
    7408                 :            : 
    7409                 :            : /* Return the minimum number of bits needed to represent VALUE in a
    7410                 :            :    signed or unsigned type, UNSIGNEDP says which.  */
    7411                 :            : 
    7412                 :            : unsigned int
    7413                 :     962483 : tree_int_cst_min_precision (tree value, signop sgn)
    7414                 :            : {
    7415                 :            :   /* If the value is negative, compute its negative minus 1.  The latter
    7416                 :            :      adjustment is because the absolute value of the largest negative value
    7417                 :            :      is one larger than the largest positive value.  This is equivalent to
    7418                 :            :      a bit-wise negation, so use that operation instead.  */
    7419                 :            : 
    7420                 :     962483 :   if (tree_int_cst_sgn (value) < 0)
    7421                 :      20799 :     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
    7422                 :            : 
    7423                 :            :   /* Return the number of bits needed, taking into account the fact
    7424                 :            :      that we need one more bit for a signed than unsigned type.
    7425                 :            :      If value is 0 or -1, the minimum precision is 1 no matter
    7426                 :            :      whether unsignedp is true or false.  */
    7427                 :            : 
    7428                 :     962483 :   if (integer_zerop (value))
    7429                 :            :     return 1;
    7430                 :            :   else
    7431                 :    1207460 :     return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
    7432                 :            : }
    7433                 :            : 
    7434                 :            : /* Return truthvalue of whether T1 is the same tree structure as T2.
    7435                 :            :    Return 1 if they are the same.
    7436                 :            :    Return 0 if they are understandably different.
    7437                 :            :    Return -1 if either contains tree structure not understood by
    7438                 :            :    this function.  */
    7439                 :            : 
    7440                 :            : int
    7441                 :   39480800 : simple_cst_equal (const_tree t1, const_tree t2)
    7442                 :            : {
    7443                 :   39480800 :   enum tree_code code1, code2;
    7444                 :   39480800 :   int cmp;
    7445                 :   39480800 :   int i;
    7446                 :            : 
    7447                 :   39480800 :   if (t1 == t2)
    7448                 :            :     return 1;
    7449                 :   18243900 :   if (t1 == 0 || t2 == 0)
    7450                 :            :     return 0;
    7451                 :            : 
    7452                 :            :   /* For location wrappers to be the same, they must be at the same
    7453                 :            :      source location (and wrap the same thing).  */
    7454                 :   16650100 :   if (location_wrapper_p (t1) && location_wrapper_p (t2))
    7455                 :            :     {
    7456                 :     971510 :       if (EXPR_LOCATION (t1) != EXPR_LOCATION (t2))
    7457                 :            :         return 0;
    7458                 :          0 :       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
    7459                 :            :     }
    7460                 :            : 
    7461                 :   15678600 :   code1 = TREE_CODE (t1);
    7462                 :   15678600 :   code2 = TREE_CODE (t2);
    7463                 :            : 
    7464                 :   15678600 :   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
    7465                 :            :     {
    7466                 :     235284 :       if (CONVERT_EXPR_CODE_P (code2)
    7467                 :     234976 :           || code2 == NON_LVALUE_EXPR)
    7468                 :        308 :         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
    7469                 :            :       else
    7470                 :     234976 :         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
    7471                 :            :     }
    7472                 :            : 
    7473                 :   15443300 :   else if (CONVERT_EXPR_CODE_P (code2)
    7474                 :   15443300 :            || code2 == NON_LVALUE_EXPR)
    7475                 :         76 :     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
    7476                 :            : 
    7477                 :   15443300 :   if (code1 != code2)
    7478                 :            :     return 0;
    7479                 :            : 
    7480                 :   15062300 :   switch (code1)
    7481                 :            :     {
    7482                 :   12907600 :     case INTEGER_CST:
    7483                 :   12907600 :       return wi::to_widest (t1) == wi::to_widest (t2);
    7484                 :            : 
    7485                 :       7920 :     case REAL_CST:
    7486                 :       7920 :       return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
    7487                 :            : 
    7488                 :          0 :     case FIXED_CST:
    7489                 :          0 :       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
    7490                 :            : 
    7491                 :    1687290 :     case STRING_CST:
    7492                 :    1687290 :       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
    7493                 :    1687290 :               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
    7494                 :    1919350 :                          TREE_STRING_LENGTH (t1)));
    7495                 :            : 
    7496                 :         21 :     case CONSTRUCTOR:
    7497                 :         21 :       {
    7498                 :         21 :         unsigned HOST_WIDE_INT idx;
    7499                 :         21 :         vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1);
    7500                 :         21 :         vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2);
    7501                 :            : 
    7502                 :         43 :         if (vec_safe_length (v1) != vec_safe_length (v2))
    7503                 :            :           return false;
    7504                 :            : 
    7505                 :         48 :         for (idx = 0; idx < vec_safe_length (v1); ++idx)
    7506                 :            :           /* ??? Should we handle also fields here? */
    7507                 :         11 :           if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
    7508                 :            :             return false;
    7509                 :            :         return true;
    7510                 :            :       }
    7511                 :            : 
    7512                 :          0 :     case SAVE_EXPR:
    7513                 :          0 :       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
    7514                 :            : 
    7515                 :      14418 :     case CALL_EXPR:
    7516                 :      14418 :       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
    7517                 :      14418 :       if (cmp <= 0)
    7518                 :            :         return cmp;
    7519                 :       7348 :       if (call_expr_nargs (t1) != call_expr_nargs (t2))
    7520                 :            :         return 0;
    7521                 :       7348 :       {
    7522                 :       7348 :         const_tree arg1, arg2;
    7523                 :       7348 :         const_call_expr_arg_iterator iter1, iter2;
    7524                 :      14696 :         for (arg1 = first_const_call_expr_arg (t1, &iter1),
    7525                 :       7348 :                arg2 = first_const_call_expr_arg (t2, &iter2);
    7526                 :       7360 :              arg1 && arg2;
    7527                 :         12 :              arg1 = next_const_call_expr_arg (&iter1),
    7528                 :         12 :                arg2 = next_const_call_expr_arg (&iter2))
    7529                 :            :           {
    7530                 :       7346 :             cmp = simple_cst_equal (arg1, arg2);
    7531                 :       7346 :             if (cmp <= 0)
    7532                 :       7334 :               return cmp;
    7533                 :            :           }
    7534                 :         14 :         return arg1 == arg2;
    7535                 :            :       }
    7536                 :            : 
    7537                 :       2103 :     case TARGET_EXPR:
    7538                 :            :       /* Special case: if either target is an unallocated VAR_DECL,
    7539                 :            :          it means that it's going to be unified with whatever the
    7540                 :            :          TARGET_EXPR is really supposed to initialize, so treat it
    7541                 :            :          as being equivalent to anything.  */
    7542                 :       2103 :       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
    7543                 :       2103 :            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
    7544                 :       2103 :            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
    7545                 :       2103 :           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
    7546                 :          0 :               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
    7547                 :          0 :               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
    7548                 :            :         cmp = 1;
    7549                 :            :       else
    7550                 :          0 :         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
    7551                 :            : 
    7552                 :          0 :       if (cmp <= 0)
    7553                 :            :         return cmp;
    7554                 :            : 
    7555                 :       2103 :       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
    7556                 :            : 
    7557                 :          0 :     case WITH_CLEANUP_EXPR:
    7558                 :          0 :       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
    7559                 :          0 :       if (cmp <= 0)
    7560                 :            :         return cmp;
    7561                 :            : 
    7562                 :          0 :       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
    7563                 :            : 
    7564                 :          7 :     case COMPONENT_REF:
    7565                 :          7 :       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
    7566                 :          7 :         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
    7567                 :            : 
    7568                 :            :       return 0;
    7569                 :            : 
    7570                 :            :     case VAR_DECL:
    7571                 :            :     case PARM_DECL:
    7572                 :            :     case CONST_DECL:
    7573                 :            :     case FUNCTION_DECL:
    7574                 :            :       return 0;
    7575                 :            : 
    7576                 :     442862 :     default:
    7577                 :     442862 :       if (POLY_INT_CST_P (t1))
    7578                 :            :         /* A false return means maybe_ne rather than known_ne.  */
    7579                 :            :         return known_eq (poly_widest_int::from (poly_int_cst_value (t1),
    7580                 :            :                                                 TYPE_SIGN (TREE_TYPE (t1))),
    7581                 :            :                          poly_widest_int::from (poly_int_cst_value (t2),
    7582                 :            :                                                 TYPE_SIGN (TREE_TYPE (t2))));
    7583                 :     442862 :       break;
    7584                 :            :     }
    7585                 :            : 
    7586                 :            :   /* This general rule works for most tree codes.  All exceptions should be
    7587                 :            :      handled above.  If this is a language-specific tree code, we can't
    7588                 :            :      trust what might be in the operand, so say we don't know
    7589                 :            :      the situation.  */
    7590                 :     442862 :   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
    7591                 :            :     return -1;
    7592                 :            : 
    7593                 :       3330 :   switch (TREE_CODE_CLASS (code1))
    7594                 :            :     {
    7595                 :            :     case tcc_unary:
    7596                 :            :     case tcc_binary:
    7597                 :            :     case tcc_comparison:
    7598                 :            :     case tcc_expression:
    7599                 :            :     case tcc_reference:
    7600                 :            :     case tcc_statement:
    7601                 :            :       cmp = 1;
    7602                 :        504 :       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
    7603                 :            :         {
    7604                 :        406 :           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
    7605                 :        406 :           if (cmp <= 0)
    7606                 :        293 :             return cmp;
    7607                 :            :         }
    7608                 :            : 
    7609                 :            :       return cmp;
    7610                 :            : 
    7611                 :            :     default:
    7612                 :            :       return -1;
    7613                 :            :     }
    7614                 :            : }
    7615                 :            : 
    7616                 :            : /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
    7617                 :            :    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
    7618                 :            :    than U, respectively.  */
    7619                 :            : 
    7620                 :            : int
    7621                 :  342719000 : compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
    7622                 :            : {
    7623                 :  342719000 :   if (tree_int_cst_sgn (t) < 0)
    7624                 :            :     return -1;
    7625                 :  342719000 :   else if (!tree_fits_uhwi_p (t))
    7626                 :            :     return 1;
    7627                 :  342719000 :   else if (TREE_INT_CST_LOW (t) == u)
    7628                 :            :     return 0;
    7629                 :  309005000 :   else if (TREE_INT_CST_LOW (t) < u)
    7630                 :            :     return -1;
    7631                 :            :   else
    7632                 :    4424840 :     return 1;
    7633                 :            : }
    7634                 :            : 
    7635                 :            : /* Return true if SIZE represents a constant size that is in bounds of
    7636                 :            :    what the middle-end and the backend accepts (covering not more than
    7637                 :            :    half of the address-space).
    7638                 :            :    When PERR is non-null, set *PERR on failure to the description of
    7639                 :            :    why SIZE is not valid.  */
    7640                 :            : 
    7641                 :            : bool
    7642                 :   20679000 : valid_constant_size_p (const_tree size, cst_size_error *perr /* = NULL */)
    7643                 :            : {
    7644                 :   20679000 :   if (POLY_INT_CST_P (size))
    7645                 :            :     {
    7646                 :            :       if (TREE_OVERFLOW (size))
    7647                 :            :         return false;
    7648                 :            :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    7649                 :            :         if (!valid_constant_size_p (POLY_INT_CST_COEFF (size, i)))
    7650                 :            :           return false;
    7651                 :            :       return true;
    7652                 :            :     }
    7653                 :            : 
    7654                 :   20679000 :   cst_size_error error;
    7655                 :   20679000 :   if (!perr)
    7656                 :   19333500 :     perr = &error;
    7657                 :            : 
    7658                 :   20679000 :   if (TREE_CODE (size) != INTEGER_CST)
    7659                 :            :     {
    7660                 :          0 :       *perr = cst_size_not_constant;
    7661                 :          0 :       return false;
    7662                 :            :     }
    7663                 :            : 
    7664                 :   20679000 :   if (TREE_OVERFLOW_P (size))
    7665                 :            :     {
    7666                 :         84 :       *perr = cst_size_overflow;
    7667                 :         84 :       return false;
    7668                 :            :     }
    7669                 :            : 
    7670                 :   20678900 :   if (tree_int_cst_sgn (size) < 0)
    7671                 :            :     {
    7672                 :        416 :       *perr = cst_size_negative;
    7673                 :        416 :       return false;
    7674                 :            :     }
    7675                 :   20678500 :   if (!tree_fits_uhwi_p (size)
    7676                 :   41357100 :       || (wi::to_widest (TYPE_MAX_VALUE (sizetype))
    7677                 :   41357100 :           < wi::to_widest (size) * 2))
    7678                 :            :     {
    7679                 :        808 :       *perr = cst_size_too_big;
    7680                 :        808 :       return false;
    7681                 :            :     }
    7682                 :            : 
    7683                 :            :   return true;
    7684                 :            : }
    7685                 :            : 
    7686                 :            : /* Return the precision of the type, or for a complex or vector type the
    7687                 :            :    precision of the type of its elements.  */
    7688                 :            : 
    7689                 :            : unsigned int
    7690                 : 2509220000 : element_precision (const_tree type)
    7691                 :            : {
    7692                 : 2509220000 :   if (!TYPE_P (type))
    7693                 :    2260520 :     type = TREE_TYPE (type);
    7694                 : 2509220000 :   enum tree_code code = TREE_CODE (type);
    7695                 : 2509220000 :   if (code == COMPLEX_TYPE || code == VECTOR_TYPE)
    7696                 :   23578800 :     type = TREE_TYPE (type);
    7697                 :            : 
    7698                 : 2509220000 :   return TYPE_PRECISION (type);
    7699                 :            : }
    7700                 :            : 
    7701                 :            : /* Return true if CODE represents an associative tree code.  Otherwise
    7702                 :            :    return false.  */
    7703                 :            : bool
    7704                 :    3333640 : associative_tree_code (enum tree_code code)
    7705                 :            : {
    7706                 :    3333640 :   switch (code)
    7707                 :            :     {
    7708                 :            :     case BIT_IOR_EXPR:
    7709                 :            :     case BIT_AND_EXPR:
    7710                 :            :     case BIT_XOR_EXPR:
    7711                 :            :     case PLUS_EXPR:
    7712                 :            :     case MULT_EXPR:
    7713                 :            :     case MIN_EXPR:
    7714                 :            :     case MAX_EXPR:
    7715                 :            :       return true;
    7716                 :            : 
    7717                 :     637202 :     default:
    7718                 :     637202 :       break;
    7719                 :            :     }
    7720                 :     637202 :   return false;
    7721                 :            : }
    7722                 :            : 
    7723                 :            : /* Return true if CODE represents a commutative tree code.  Otherwise
    7724                 :            :    return false.  */
    7725                 :            : bool
    7726                 :  898150000 : commutative_tree_code (enum tree_code code)
    7727                 :            : {
    7728                 :  898150000 :   switch (code)
    7729                 :            :     {
    7730                 :            :     case PLUS_EXPR:
    7731                 :            :     case MULT_EXPR:
    7732                 :            :     case MULT_HIGHPART_EXPR:
    7733                 :            :     case MIN_EXPR:
    7734                 :            :     case MAX_EXPR:
    7735                 :            :     case BIT_IOR_EXPR:
    7736                 :            :     case BIT_XOR_EXPR:
    7737                 :            :     case BIT_AND_EXPR:
    7738                 :            :     case NE_EXPR:
    7739                 :            :     case EQ_EXPR:
    7740                 :            :     case UNORDERED_EXPR:
    7741                 :            :     case ORDERED_EXPR:
    7742                 :            :     case UNEQ_EXPR:
    7743                 :            :     case LTGT_EXPR:
    7744                 :            :     case TRUTH_AND_EXPR:
    7745                 :            :     case TRUTH_XOR_EXPR:
    7746                 :            :     case TRUTH_OR_EXPR:
    7747                 :            :     case WIDEN_MULT_EXPR:
    7748                 :            :     case VEC_WIDEN_MULT_HI_EXPR:
    7749                 :            :     case VEC_WIDEN_MULT_LO_EXPR:
    7750                 :            :     case VEC_WIDEN_MULT_EVEN_EXPR:
    7751                 :            :     case VEC_WIDEN_MULT_ODD_EXPR:
    7752                 :            :       return true;
    7753                 :            : 
    7754                 :  466692000 :     default:
    7755                 :  466692000 :       break;
    7756                 :            :     }
    7757                 :  466692000 :   return false;
    7758                 :            : }
    7759                 :            : 
    7760                 :            : /* Return true if CODE represents a ternary tree code for which the
    7761                 :            :    first two operands are commutative.  Otherwise return false.  */
    7762                 :            : bool
    7763                 :   52926600 : commutative_ternary_tree_code (enum tree_code code)
    7764                 :            : {
    7765                 :   52926600 :   switch (code)
    7766                 :            :     {
    7767                 :            :     case WIDEN_MULT_PLUS_EXPR:
    7768                 :            :     case WIDEN_MULT_MINUS_EXPR:
    7769                 :            :     case DOT_PROD_EXPR:
    7770                 :            :       return true;
    7771                 :            : 
    7772                 :   52926000 :     default:
    7773                 :   52926000 :       break;
    7774                 :            :     }
    7775                 :   52926000 :   return false;
    7776                 :            : }
    7777                 :            : 
    7778                 :            : /* Returns true if CODE can overflow.  */
    7779                 :            : 
    7780                 :            : bool
    7781                 :         24 : operation_can_overflow (enum tree_code code)
    7782                 :            : {
    7783                 :         24 :   switch (code)
    7784                 :            :     {
    7785                 :            :     case PLUS_EXPR:
    7786                 :            :     case MINUS_EXPR:
    7787                 :            :     case MULT_EXPR:
    7788                 :            :     case LSHIFT_EXPR:
    7789                 :            :       /* Can overflow in various ways.  */
    7790                 :            :       return true;
    7791                 :            :     case TRUNC_DIV_EXPR:
    7792                 :            :     case EXACT_DIV_EXPR:
    7793                 :            :     case FLOOR_DIV_EXPR:
    7794                 :            :     case CEIL_DIV_EXPR:
    7795                 :            :       /* For INT_MIN / -1.  */
    7796                 :            :       return true;
    7797                 :            :     case NEGATE_EXPR:
    7798                 :            :     case ABS_EXPR:
    7799                 :            :       /* For -INT_MIN.  */
    7800                 :            :       return true;
    7801                 :          8 :     default:
    7802                 :            :       /* These operators cannot overflow.  */
    7803                 :          8 :       return false;
    7804                 :            :     }
    7805                 :            : }
    7806                 :            : 
    7807                 :            : /* Returns true if CODE operating on operands of type TYPE doesn't overflow, or
    7808                 :            :    ftrapv doesn't generate trapping insns for CODE.  */
    7809                 :            : 
    7810                 :            : bool
    7811                 :      27819 : operation_no_trapping_overflow (tree type, enum tree_code code)
    7812                 :            : {
    7813                 :      27819 :   gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type));
    7814                 :            : 
    7815                 :            :   /* We don't generate instructions that trap on overflow for complex or vector
    7816                 :            :      types.  */
    7817                 :      27819 :   if (!INTEGRAL_TYPE_P (type))
    7818                 :            :     return true;
    7819                 :            : 
    7820                 :      27819 :   if (!TYPE_OVERFLOW_TRAPS (type))
    7821                 :            :     return true;
    7822                 :            : 
    7823                 :         95 :   switch (code)
    7824                 :            :     {
    7825                 :            :     case PLUS_EXPR:
    7826                 :            :     case MINUS_EXPR:
    7827                 :            :     case MULT_EXPR:
    7828                 :            :     case NEGATE_EXPR:
    7829                 :            :     case ABS_EXPR:
    7830                 :            :       /* These operators can overflow, and -ftrapv generates trapping code for
    7831                 :            :          these.  */
    7832                 :            :       return false;
    7833                 :          0 :     case TRUNC_DIV_EXPR:
    7834                 :          0 :     case EXACT_DIV_EXPR:
    7835                 :          0 :     case FLOOR_DIV_EXPR:
    7836                 :          0 :     case CEIL_DIV_EXPR:
    7837                 :          0 :     case LSHIFT_EXPR:
    7838                 :            :       /* These operators can overflow, but -ftrapv does not generate trapping
    7839                 :            :          code for these.  */
    7840                 :          0 :       return true;
    7841                 :          3 :     default:
    7842                 :            :       /* These operators cannot overflow.  */
    7843                 :          3 :       return true;
    7844                 :            :     }
    7845                 :            : }
    7846                 :            : 
    7847                 :            : /* Constructors for pointer, array and function types.
    7848                 :            :    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
    7849                 :            :    constructed by language-dependent code, not here.)  */
    7850                 :            : 
    7851                 :            : /* Construct, lay out and return the type of pointers to TO_TYPE with
    7852                 :            :    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
    7853                 :            :    reference all of memory. If such a type has already been
    7854                 :            :    constructed, reuse it.  */
    7855                 :            : 
    7856                 :            : tree
    7857                 :  431757000 : build_pointer_type_for_mode (tree to_type, machine_mode mode,
    7858                 :            :                              bool can_alias_all)
    7859                 :            : {
    7860                 :  431757000 :   tree t;
    7861                 :  431757000 :   bool could_alias = can_alias_all;
    7862                 :            : 
    7863                 :  431757000 :   if (to_type == error_mark_node)
    7864                 :            :     return error_mark_node;
    7865                 :            : 
    7866                 :            :   /* If the pointed-to type has the may_alias attribute set, force
    7867                 :            :      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
    7868                 :  431757000 :   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
    7869                 :    2968630 :     can_alias_all = true;
    7870                 :            : 
    7871                 :            :   /* In some cases, languages will have things that aren't a POINTER_TYPE
    7872                 :            :      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
    7873                 :            :      In that case, return that type without regard to the rest of our
    7874                 :            :      operands.
    7875                 :            : 
    7876                 :            :      ??? This is a kludge, but consistent with the way this function has
    7877                 :            :      always operated and there doesn't seem to be a good way to avoid this
    7878                 :            :      at the moment.  */
    7879                 :  431757000 :   if (TYPE_POINTER_TO (to_type) != 0
    7880                 :  431757000 :       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
    7881                 :  431757000 :     return TYPE_POINTER_TO (to_type);
    7882                 :            : 
    7883                 :            :   /* First, if we already have a type for pointers to TO_TYPE and it's
    7884                 :            :      the proper mode, use it.  */
    7885                 :  431814000 :   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
    7886                 :  795325000 :     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
    7887                 :  397454000 :       return t;
    7888                 :            : 
    7889                 :   34151100 :   t = make_node (POINTER_TYPE);
    7890                 :            : 
    7891                 :   34151100 :   TREE_TYPE (t) = to_type;
    7892                 :   34151100 :   SET_TYPE_MODE (t, mode);
    7893                 :   34151100 :   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
    7894                 :   34151100 :   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
    7895                 :   34151100 :   TYPE_POINTER_TO (to_type) = t;
    7896                 :            : 
    7897                 :            :   /* During LTO we do not set TYPE_CANONICAL of pointers and references.  */
    7898                 :   34151100 :   if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
    7899                 :    1956580 :     SET_TYPE_STRUCTURAL_EQUALITY (t);
    7900                 :   32194500 :   else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
    7901                 :    8966900 :     TYPE_CANONICAL (t)
    7902                 :    8966900 :       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
    7903                 :            :                                      mode, false);
    7904                 :            : 
    7905                 :            :   /* Lay out the type.  This function has many callers that are concerned
    7906                 :            :      with expression-construction, and this simplifies them all.  */
    7907                 :   34151100 :   layout_type (t);
    7908                 :            : 
    7909                 :   34151100 :   return t;
    7910                 :            : }
    7911                 :            : 
    7912                 :            : /* By default build pointers in ptr_mode.  */
    7913                 :            : 
    7914                 :            : tree
    7915                 :  409054000 : build_pointer_type (tree to_type)
    7916                 :            : {
    7917                 :  409054000 :   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
    7918                 :  818109000 :                                               : TYPE_ADDR_SPACE (to_type);
    7919                 :  409054000 :   machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
    7920                 :  409054000 :   return build_pointer_type_for_mode (to_type, pointer_mode, false);
    7921                 :            : }
    7922                 :            : 
    7923                 :            : /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
    7924                 :            : 
    7925                 :            : tree
    7926                 :   80021900 : build_reference_type_for_mode (tree to_type, machine_mode mode,
    7927                 :            :                                bool can_alias_all)
    7928                 :            : {
    7929                 :   80021900 :   tree t;
    7930                 :   80021900 :   bool could_alias = can_alias_all;
    7931                 :            : 
    7932                 :   80021900 :   if (to_type == error_mark_node)
    7933                 :            :     return error_mark_node;
    7934                 :            : 
    7935                 :            :   /* If the pointed-to type has the may_alias attribute set, force
    7936                 :            :      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
    7937                 :   80021900 :   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
    7938                 :     540866 :     can_alias_all = true;
    7939                 :            : 
    7940                 :            :   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
    7941                 :            :      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
    7942                 :            :      In that case, return that type without regard to the rest of our
    7943                 :            :      operands.
    7944                 :            : 
    7945                 :            :      ??? This is a kludge, but consistent with the way this function has
    7946                 :            :      always operated and there doesn't seem to be a good way to avoid this
    7947                 :            :      at the moment.  */
    7948                 :   80021900 :   if (TYPE_REFERENCE_TO (to_type) != 0
    7949                 :   80021900 :       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
    7950                 :   80021900 :     return TYPE_REFERENCE_TO (to_type);
    7951                 :            : 
    7952                 :            :   /* First, if we already have a type for pointers to TO_TYPE and it's
    7953                 :            :      the proper mode, use it.  */
    7954                 :   80021900 :   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
    7955                 :  144669000 :     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
    7956                 :   72334700 :       return t;
    7957                 :            : 
    7958                 :    7687200 :   t = make_node (REFERENCE_TYPE);
    7959                 :            : 
    7960                 :    7687200 :   TREE_TYPE (t) = to_type;
    7961                 :    7687200 :   SET_TYPE_MODE (t, mode);
    7962                 :    7687200 :   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
    7963                 :    7687200 :   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
    7964                 :    7687200 :   TYPE_REFERENCE_TO (to_type) = t;
    7965                 :            : 
    7966                 :            :   /* During LTO we do not set TYPE_CANONICAL of pointers and references.  */
    7967                 :    7687200 :   if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p)
    7968                 :     467352 :     SET_TYPE_STRUCTURAL_EQUALITY (t);
    7969                 :    7219850 :   else if (TYPE_CANONICAL (to_type) != to_type || could_alias)
    7970                 :    3673980 :     TYPE_CANONICAL (t)
    7971                 :    3673980 :       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
    7972                 :            :                                        mode, false);
    7973                 :            : 
    7974                 :    7687200 :   layout_type (t);
    7975                 :            : 
    7976                 :    7687200 :   return t;
    7977                 :            : }
    7978                 :            : 
    7979                 :            : 
    7980                 :            : /* Build the node for the type of references-to-TO_TYPE by default
    7981                 :            :    in ptr_mode.  */
    7982                 :            : 
    7983                 :            : tree
    7984                 :   76319200 : build_reference_type (tree to_type)
    7985                 :            : {
    7986                 :   76319200 :   addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
    7987                 :  152638000 :                                               : TYPE_ADDR_SPACE (to_type);
    7988                 :   76319200 :   machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
    7989                 :   76319200 :   return build_reference_type_for_mode (to_type, pointer_mode, false);
    7990                 :            : }
    7991                 :            : 
    7992                 :            : #define MAX_INT_CACHED_PREC \
    7993                 :            :   (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64)
    7994                 :            : static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2];
    7995                 :            : 
    7996                 :            : /* Builds a signed or unsigned integer type of precision PRECISION.
    7997                 :            :    Used for C bitfields whose precision does not match that of
    7998                 :            :    built-in target types.  */
    7999                 :            : tree
    8000                 :   29182800 : build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
    8001                 :            :                                 int unsignedp)
    8002                 :            : {
    8003                 :   29182800 :   tree itype, ret;
    8004                 :            : 
    8005                 :   29182800 :   if (unsignedp)
    8006                 :   24630900 :     unsignedp = MAX_INT_CACHED_PREC + 1;
    8007                 :            :     
    8008                 :   29182800 :   if (precision <= MAX_INT_CACHED_PREC)
    8009                 :            :     {
    8010                 :   29048000 :       itype = nonstandard_integer_type_cache[precision + unsignedp];
    8011                 :   29048000 :       if (itype)
    8012                 :            :         return itype;
    8013                 :            :     }
    8014                 :            : 
    8015                 :     469806 :   itype = make_node (INTEGER_TYPE);
    8016                 :     469806 :   TYPE_PRECISION (itype) = precision;
    8017                 :            : 
    8018                 :     469806 :   if (unsignedp)
    8019                 :     366325 :     fixup_unsigned_type (itype);
    8020                 :            :   else
    8021                 :     103481 :     fixup_signed_type (itype);
    8022                 :            : 
    8023                 :     469806 :   inchash::hash hstate;
    8024                 :     469806 :   inchash::add_expr (TYPE_MAX_VALUE (itype), hstate);</